@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.1

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

@@ -0,0 +1,2123 @@
+import { __decorate, __param } from '../../../../../../node_modules/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, timeout, Promises } 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, 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 { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.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 { 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 { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { containsDragType, CodeDataTransfers } from 'monaco-editor/esm/vs/platform/dnd/browser/dnd.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 { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.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 { TitleEventSource, TerminalLocation, TerminalExitReason } from '../../../../platform/terminal/common/terminal.js';
+import { formatMessageForTerminal } from '../../../../platform/terminal/common/terminalStrings.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 { IViewsService, IViewDescriptorService } from '../../../common/views.js';
+import { TerminalLaunchHelpAction } from './terminalActions.js';
+import { TerminalEditorInput } from './terminalEditorInput.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 } from './xterm/xtermTerminal.js';
+import { deserializeEnvironmentVariableCollections } from '../../../../platform/terminal/common/environmentVariableShared.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 { TerminalContextKeys } from '../common/terminalContextKey.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 { AudioCue, IAudioCueService } from 'monaco-editor/esm/vs/platform/audioCues/browser/audioCueService.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { preparePathForShell, getWorkspaceForTerminal } from '../common/terminalEnvironment.js';
+import { TERMINAL_BACKGROUND_COLOR } from '../common/terminalColorRegistry.js';
+import { editorBackground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { PANEL_BACKGROUND, SIDE_BAR_BACKGROUND } from '../../../common/theme.js';
+import { TerminalExtensionsRegistry } from './terminalExtensions.js';
+let xtermConstructor;
+function getXtermConstructor(keybinding) {
+    if (xtermConstructor) {
+        return xtermConstructor;
+    }
+    xtermConstructor = Promises.withAsyncBody(async (resolve) => {
+        const Terminal = (await import('xterm').then(module => module.default ?? module)).Terminal;
+        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;
+}
+const shellIntegrationSupportedShellTypes = [
+    "bash" ,
+    "zsh" ,
+    "pwsh" ,
+    "pwsh"
+];
+let TerminalInstance = class TerminalInstance extends Disposable {
+    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; }
+    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._widgetManager = ( new TerminalWidgetManager());
+        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._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._onRequestAddInstanceToGroup = this._register(( new Emitter()));
+        this.onRequestAddInstanceToGroup = this._onRequestAddInstanceToGroup.event;
+        this._onDidChangeHasChildProcesses = this._register(( new Emitter()));
+        this.onDidChangeHasChildProcesses = this._onDidChangeHasChildProcesses.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._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 = withNullAsUndefined(this._workspaceContextService.getWorkspaceFolder(cwdUri));
+            }
+        }
+        if (!this._workspaceFolder) {
+            const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot();
+            this._workspaceFolder = activeWorkspaceRootUri ? withNullAsUndefined(this._workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri)) : 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.onDidAddCapability(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.onDidRemoveCapability(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._register(toDisposable(() => this._dndObserver?.dispose()));
+        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._register(this._workspaceContextService.onDidChangeWorkspaceFolders(() => this._labelComputer?.refreshLabel()));
+        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();
+            });
+        }
+    }
+    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();
+        if (!font.charWidth || !font.charHeight) {
+            this._setLastKnownColsAndRows();
+            return null;
+        }
+        const scaledWidthAvailable = dimension.width * window.devicePixelRatio;
+        const scaledCharWidth = font.charWidth * window.devicePixelRatio + font.letterSpacing;
+        const newCols = Math.max(Math.floor(scaledWidthAvailable / scaledCharWidth), 1);
+        const scaledHeightAvailable = dimension.height * window.devicePixelRatio;
+        const scaledCharHeight = Math.ceil(font.charHeight * window.devicePixelRatio);
+        const scaledLineHeight = Math.floor(scaledCharHeight * font.lineHeight);
+        const newRows = Math.max(Math.floor(scaledHeightAvailable / scaledLineHeight), 1);
+        if (this._cols !== newCols || this._rows !== newRows) {
+            this._cols = newCols;
+            this._rows = newRows;
+            this._fireMaximumDimensionsChanged();
+        }
+        return dimension.width;
+    }
+    _setLastKnownColsAndRows() {
+        if (TerminalInstance._lastKnownGridDimensions) {
+            this._cols = TerminalInstance._lastKnownGridDimensions.cols;
+            this._rows = TerminalInstance._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._lastKnownCanvasDimensions = new dom.Dimension(Math.min(8000 , width - horizontalPadding), height + (this._hasScrollBar && !this._horizontalScrollbar ? -5  : 0) - 2  - verticalPadding);
+        return TerminalInstance._lastKnownCanvasDimensions;
+    }
+    get persistentProcessId() { return this._processManager.persistentProcessId; }
+    get shouldPersist() { return this._processManager.shouldPersist && !this.shellLaunchConfig.isTransient && (!this.reconnectionProperties || this._configurationService.getValue("task.reconnection" ) === true); }
+    async _createXterm() {
+        const Terminal = await getXtermConstructor(this._keybindingService.lookupKeybinding("workbench.action.terminal.focusAccessibleBuffer" , 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 = ( new LineDataEventAddon(initialTextWrittenPromise));
+        lineDataEventAddon.onLineData(e => this._onLineData.fire(e));
+        this._lineDataEventAddon = lineDataEventAddon;
+        setTimeout(() => {
+            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);
+                }
+            });
+        }, 1000);
+        xterm.raw.onSelectionChange(async () => this._onSelectionChange());
+        xterm.raw.buffer.onBufferChange(() => this._refreshAltBufferContextKey());
+        this._processManager.onProcessData(e => this._onProcessData(e));
+        xterm.raw.onData(async (data) => {
+            await this._processManager.write(data);
+            this._onDidInputData.fire(this);
+        });
+        xterm.raw.onBinary(data => this._processManager.processBinary(data));
+        this._processManager.onProcessReady(async (processTraits) => {
+            if (this._processManager.os) {
+                lineDataEventAddon.setOperatingSystem(this._processManager.os);
+            }
+            if (this._processManager.os === 1 ) {
+                xterm.raw.options.windowsMode = processTraits.requiresWindowsMode || false;
+            }
+        });
+        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.onDidAddCapability(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 (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) {
+        this._dndObserver?.dispose();
+        const dndController = 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 = new dom.DragAndDropObserver(container, dndController);
+    }
+    hasSelection() {
+        return this.xterm ? this.xterm.raw.hasSelection() : false;
+    }
+    async copySelection(asHtml, command) {
+        const xterm = await this._xtermReadyPromise;
+        if (this.hasSelection() || (asHtml && command)) {
+            if (asHtml) {
+                const textAsHtml = await xterm.getSelectionAsHtml(command);
+                function listener(e) {
+                    if (!e.clipboardData.types.includes('text/plain')) {
+                        e.clipboardData.setData('text/plain', command?.getOutput() ?? '');
+                    }
+                    e.clipboardData.setData('text/html', textAsHtml);
+                    e.preventDefault();
+                }
+                document.addEventListener('copy', listener);
+                document.execCommand('copy');
+                document.removeEventListener('copy', listener);
+            }
+            else {
+                await this._clipboardService.writeText(xterm.raw.getSelection());
+            }
+        }
+        else {
+            this._notificationService.warn(( nls.localize(
+                'terminal.integrated.copySelection.noSelection',
+                'The terminal has no selection to copy'
+            )));
+        }
+    }
+    get selection() {
+        return this.xterm && this.hasSelection() ? this.xterm.raw.getSelection() : undefined;
+    }
+    clearSelection() {
+        this.xterm?.raw.clearSelection();
+    }
+    selectAll() {
+        this.xterm?.raw.focus();
+        this.xterm?.raw.selectAll();
+    }
+    _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();
+    }
+    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.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));
+                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 = 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();
+                    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.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._logService.debug(`Terminal process exit (instanceId: ${this.instanceId}) with code ${this._exitCode}`);
+        this._exitCode = parsedExitResult?.code;
+        const exitMessage = parsedExitResult?.message;
+        this._logService.debug(`Terminal process exit (instanceId: ${this.instanceId}) state ${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;
+                }
+            }
+        });
+    }
+    async setEscapeSequenceLogging(enable) {
+        const xterm = await this._xtermReadyPromise;
+        xterm.raw.options.logLevel = enable ? 'debug' : 'info';
+    }
+    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() {
+        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._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("workbench.action.terminal.showAccessibilityHelp" )?.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;
+                dispose(this._messageTitleDisposable);
+                this._messageTitleDisposable = 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._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();
+        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.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);
+    }
+    _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.relaunch();
+            return;
+        }
+        const workspaceFolder = getWorkspaceForTerminal(this.shellLaunchConfig.cwd, this._workspaceContextService, this._historyService);
+        this.statusList.add(info.getStatus({ workspaceFolder }));
+    }
+    async toggleEscapeSequenceLogging() {
+        const xterm = await this._xtermReadyPromise;
+        xterm.raw.options.logLevel = xterm.raw.options.logLevel === 'debug' ? 'info' : 'debug';
+        return xterm.raw.options.logLevel === 'debug';
+    }
+    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(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._instanceIdCounter = 1;
+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 = ( __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, ILogService)),
+    ( __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 = ( new Emitter());
+        this._onDropTerminal = ( 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, _instance, _fileService, _workspaceContextService) {
+        super();
+        this._configHelper = _configHelper;
+        this._instance = _instance;
+        this._fileService = _fileService;
+        this._workspaceContextService = _workspaceContextService;
+        this._title = '';
+        this._description = '';
+        this._onDidChangeLabel = this._register(( new Emitter()));
+        this.onDidChangeLabel = this._onDidChangeLabel.event;
+    }
+    refreshLabel(reset) {
+        this._title = this.computeLabel(this._configHelper.config.tabs.title, "title" , reset);
+        this._description = this.computeLabel(this._configHelper.config.tabs.description, "description" );
+        if (this._title !== this._instance.title || this._description !== this._instance.description || reset) {
+            this._onDidChangeLabel.fire({ title: this._title, description: this._description });
+        }
+    }
+    computeLabel(labelTemplate, labelType, reset) {
+        const type = this._instance.shellLaunchConfig.attachPersistentProcess?.type || this._instance.shellLaunchConfig.type;
+        const templateProperties = {
+            cwd: this._instance.cwd || this._instance.initialCwd || '',
+            cwdFolder: '',
+            workspaceFolder: this._instance.workspaceFolder ? path.basename(this._instance.workspaceFolder.uri.fsPath) : undefined,
+            local: type === 'Local' ? type : undefined,
+            process: this._instance.processName,
+            sequence: this._instance.sequence,
+            task: type === 'Task' ? type : undefined,
+            fixedDimensions: this._instance.fixedCols
+                ? (this._instance.fixedRows ? `\u2194${this._instance.fixedCols} \u2195${this._instance.fixedRows}` : `\u2194${this._instance.fixedCols}`)
+                : (this._instance.fixedRows ? `\u2195${this._instance.fixedRows}` : ''),
+            separator: { label: this._configHelper.config.tabs.separator }
+        };
+        labelTemplate = labelTemplate.trim();
+        if (!labelTemplate) {
+            return labelType === "title"  ? (this._instance.processName || '') : '';
+        }
+        if (!reset && this._instance.staticTitle && labelType === "title" ) {
+            return this._instance.staticTitle.replace(/[\n\r\t]/g, '') || templateProperties.process?.replace(/[\n\r\t]/g, '') || '';
+        }
+        const detection = ( this._instance.capabilities.has(0 )) || ( this._instance.capabilities.has(1 ));
+        const folders = this._workspaceContextService.getWorkspace().folders;
+        const multiRootWorkspace = folders.length > 1;
+        if (templateProperties.cwd && detection && ((!this._instance.shellLaunchConfig.isFeatureTerminal || labelType === "title") )) {
+            const cwdUri = ( URI.from({
+                scheme: this._instance.workspaceFolder?.uri.scheme || Schemas.file,
+                path: this._instance.cwd ? path.resolve(this._instance.cwd) : undefined
+            }));
+            let showCwd = false;
+            if (multiRootWorkspace) {
+                showCwd = true;
+            }
+            else if (this._instance.workspaceFolder?.uri) {
+                const caseSensitive = this._fileService.hasCapability(this._instance.workspaceFolder.uri, 1024 );
+                showCwd = cwdUri.fsPath.localeCompare(this._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"  ? (this._instance.processName || '') : label;
+    }
+};
+TerminalLabelComputer = ( __decorate([
+    ( __param(2, IFileService)),
+    ( __param(3, 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 };