@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,1156 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { createStyleSheet, asCSSUrl, asCSSPropertyValue } from '../../../../base/browser/dom.js';
+import { DeferredPromise, timeout } from '../../../../base/common/async.js';
+import { memoize, debounce } from '../../../../base/common/decorators.js';
+import { Event, Emitter, DynamicListEventMultiplexer } from '../../../../base/common/event.js';
+import { Disposable, dispose, toDisposable } from '../../../../base/common/lifecycle.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { isWeb, isMacintosh } from '../../../../base/common/platform.js';
+import { URI } from '../../../../base/common/uri.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { TerminalLocation, TerminalExtensions, TerminalExitReason, TitleEventSource, ITerminalLogService } from '../../../../platform/terminal/common/terminal.js';
+import { formatMessageForTerminal } from '../../../../platform/terminal/common/terminalStrings.js';
+import '../../../../platform/theme/common/colorUtils.js';
+import { iconForeground } from '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { getIconRegistry } from '../../../../platform/theme/common/iconRegistry.js';
+import { ColorScheme } from '../../../../platform/theme/common/theme.js';
+import { Themable, IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { VirtualWorkspaceContext } from '../../../common/contextkeys.js';
+import { IViewsService } from '../../../services/views/common/viewsService.js';
+import { ITerminalEditorService, ITerminalGroupService, ITerminalInstanceService, ITerminalService } from './terminal.js';
+import { getCwdForSplit } from './terminalActions.js';
+import { TerminalConfigHelper } from './terminalConfigHelper.js';
+import { TerminalEditorInput } from './terminalEditorInput.js';
+import { getUriClasses, getColorStyleContent } from './terminalIcon.js';
+import { TerminalProfileQuickpick } from './terminalProfileQuickpick.js';
+import { getTerminalUri, getInstanceFromResource, parseTerminalUri } from './terminalUri.js';
+import { TERMINAL_VIEW_ID, ITerminalProfileService } from '../common/terminal.js';
+import { TerminalContextKeys } from '../common/terminalContextKey.js';
+import { columnToEditorGroup } from '../../../services/editor/common/editorGroupColumn.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { AUX_WINDOW_GROUP, SIDE_GROUP, IEditorService } from '../../../services/editor/common/editorService.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.js';
+import { XtermTerminal } from './xterm/xtermTerminal.js';
+import { TerminalInstance } from './terminalInstance.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { TerminalCapabilityStore } from '../../../../platform/terminal/common/capabilities/terminalCapabilityStore.js';
+import { ITimerService } from '../../../services/timer/browser/timerService.js';
+import { mark } from '../../../../base/common/performance.js';
+import { DetachedTerminal } from './detachedTerminal.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { createInstanceCapabilityEventMultiplexer } from './terminalEvents.js';
+import { mainWindow } from '../../../../base/browser/window.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+let TerminalService = class TerminalService extends Disposable {
+    get isProcessSupportRegistered() { return !!this._processSupportContextKey.get(); }
+    get connectionState() { return this._connectionState; }
+    get whenConnected() { return this._whenConnected.p; }
+    get restoredGroupCount() { return this._restoredGroupCount; }
+    get configHelper() { return this._configHelper; }
+    get instances() {
+        return this._terminalGroupService.instances.concat(this._terminalEditorService.instances);
+    }
+    get detachedInstances() {
+        return this._detachedXterms;
+    }
+    getReconnectedTerminals(reconnectionOwner) {
+        return this._reconnectedTerminals.get(reconnectionOwner);
+    }
+    get defaultLocation() { return this.configHelper.config.defaultLocation === "editor"  ? TerminalLocation.Editor : TerminalLocation.Panel; }
+    get activeInstance() {
+        for (const activeHostTerminal of ( this._hostActiveTerminals.values())) {
+            if (activeHostTerminal?.hasFocus) {
+                return activeHostTerminal;
+            }
+        }
+        return this._activeInstance;
+    }
+    get onDidCreateInstance() { return this._onDidCreateInstance.event; }
+    get onDidChangeInstanceDimensions() { return this._onDidChangeInstanceDimensions.event; }
+    get onDidRegisterProcessSupport() { return this._onDidRegisterProcessSupport.event; }
+    get onDidChangeConnectionState() { return this._onDidChangeConnectionState.event; }
+    get onDidRequestStartExtensionTerminal() { return this._onDidRequestStartExtensionTerminal.event; }
+    get onDidDisposeInstance() { return this._onDidDisposeInstance.event; }
+    get onDidFocusInstance() { return this._onDidFocusInstance.event; }
+    get onDidChangeActiveInstance() { return this._onDidChangeActiveInstance.event; }
+    get onDidChangeInstances() { return this._onDidChangeInstances.event; }
+    get onDidChangeInstanceCapability() { return this._onDidChangeInstanceCapability.event; }
+    get onDidChangeActiveGroup() { return this._onDidChangeActiveGroup.event; }
+    get onAnyInstanceData() { return this.createOnInstanceEvent(instance => ( Event.map(instance.onData, data => ({ instance, data })))); }
+    get onAnyInstanceDataInput() { return this.createOnInstanceEvent(e => e.onDidInputData); }
+    get onAnyInstanceIconChange() { return this.createOnInstanceEvent(e => e.onIconChanged); }
+    get onAnyInstanceMaximumDimensionsChange() { return this.createOnInstanceEvent(e => ( Event.map(e.onMaximumDimensionsChanged, () => e, e.store))); }
+    get onAnyInstancePrimaryStatusChange() { return this.createOnInstanceEvent(e => ( Event.map(e.statusList.onDidChangePrimaryStatus, () => e, e.store))); }
+    get onAnyInstanceProcessIdReady() { return this.createOnInstanceEvent(e => e.onProcessIdReady); }
+    get onAnyInstanceSelectionChange() { return this.createOnInstanceEvent(e => e.onDidChangeSelection); }
+    get onAnyInstanceTitleChange() { return this.createOnInstanceEvent(e => e.onTitleChanged); }
+    constructor(_contextKeyService, _lifecycleService, _logService, _dialogService, _instantiationService, _remoteAgentService, _viewsService, _configurationService, _environmentService, _terminalEditorService, _terminalGroupService, _terminalInstanceService, _editorGroupsService, _terminalProfileService, _extensionService, _notificationService, _workspaceContextService, _commandService, _keybindingService, _timerService) {
+        super();
+        this._contextKeyService = _contextKeyService;
+        this._lifecycleService = _lifecycleService;
+        this._logService = _logService;
+        this._dialogService = _dialogService;
+        this._instantiationService = _instantiationService;
+        this._remoteAgentService = _remoteAgentService;
+        this._viewsService = _viewsService;
+        this._configurationService = _configurationService;
+        this._environmentService = _environmentService;
+        this._terminalEditorService = _terminalEditorService;
+        this._terminalGroupService = _terminalGroupService;
+        this._terminalInstanceService = _terminalInstanceService;
+        this._editorGroupsService = _editorGroupsService;
+        this._terminalProfileService = _terminalProfileService;
+        this._extensionService = _extensionService;
+        this._notificationService = _notificationService;
+        this._workspaceContextService = _workspaceContextService;
+        this._commandService = _commandService;
+        this._keybindingService = _keybindingService;
+        this._timerService = _timerService;
+        this._hostActiveTerminals = ( new Map());
+        this._detachedXterms = ( new Set());
+        this._isShuttingDown = false;
+        this._backgroundedTerminalInstances = [];
+        this._backgroundedTerminalDisposables = ( new Map());
+        this._connectionState = 0 ;
+        this._whenConnected = ( new DeferredPromise());
+        this._restoredGroupCount = 0;
+        this._reconnectedTerminals = ( new Map());
+        this._onDidCreateInstance = this._register(( new Emitter()));
+        this._onDidChangeInstanceDimensions = this._register(( new Emitter()));
+        this._onDidRegisterProcessSupport = this._register(( new Emitter()));
+        this._onDidChangeConnectionState = this._register(( new Emitter()));
+        this._onDidRequestStartExtensionTerminal = this._register(( new Emitter()));
+        this._onDidDisposeInstance = this._register(( new Emitter()));
+        this._onDidFocusInstance = this._register(( new Emitter()));
+        this._onDidChangeActiveInstance = this._register(( new Emitter()));
+        this._onDidChangeInstances = this._register(( new Emitter()));
+        this._onDidChangeInstanceCapability = this._register(( new Emitter()));
+        this._onDidChangeActiveGroup = this._register(( new Emitter()));
+        this._configHelper = this._register(this._instantiationService.createInstance(TerminalConfigHelper));
+        this._register(this.onDidCreateInstance(() => this._terminalProfileService.refreshAvailableProfiles()));
+        this._forwardInstanceHostEvents(this._terminalGroupService);
+        this._forwardInstanceHostEvents(this._terminalEditorService);
+        this._register(this._terminalGroupService.onDidChangeActiveGroup(this._onDidChangeActiveGroup.fire, this._onDidChangeActiveGroup));
+        this._register(this._terminalInstanceService.onDidCreateInstance(instance => {
+            this._initInstanceListeners(instance);
+            this._onDidCreateInstance.fire(instance);
+        }));
+        this._register(this._terminalGroupService.onDidChangeActiveInstance(instance => {
+            if (!instance && !this._isShuttingDown) {
+                this._terminalGroupService.hidePanel();
+            }
+            if (instance?.shellType) {
+                this._terminalShellTypeContextKey.set(( instance.shellType.toString()));
+            }
+            else if (!instance) {
+                this._terminalShellTypeContextKey.reset();
+            }
+        }));
+        this._handleInstanceContextKeys();
+        this._terminalShellTypeContextKey = TerminalContextKeys.shellType.bindTo(this._contextKeyService);
+        this._processSupportContextKey = TerminalContextKeys.processSupported.bindTo(this._contextKeyService);
+        this._processSupportContextKey.set(!isWeb || this._remoteAgentService.getConnection() !== null || ( Registry.as(TerminalExtensions.Backend)).getTerminalBackend() !== undefined);
+        this._terminalHasBeenCreated = TerminalContextKeys.terminalHasBeenCreated.bindTo(this._contextKeyService);
+        this._terminalCountContextKey = TerminalContextKeys.count.bindTo(this._contextKeyService);
+        this._terminalEditorActive = TerminalContextKeys.terminalEditorActive.bindTo(this._contextKeyService);
+        this.onDidChangeActiveInstance(instance => {
+            this._terminalEditorActive.set(!!instance?.target && instance.target === TerminalLocation.Editor);
+        });
+        _lifecycleService.onBeforeShutdown(async (e) => e.veto(this._onBeforeShutdown(e.reason), 'veto.terminal'));
+        _lifecycleService.onWillShutdown(e => this._onWillShutdown(e));
+        this._initializePrimaryBackend();
+        timeout(0).then(() => this._register(this._instantiationService.createInstance(TerminalEditorStyle, mainWindow.document.head)));
+    }
+    async showProfileQuickPick(type, cwd) {
+        const quickPick = this._instantiationService.createInstance(TerminalProfileQuickpick);
+        const result = await quickPick.showAndGetResult(type);
+        if (!result) {
+            return;
+        }
+        if (typeof result === 'string') {
+            return;
+        }
+        const keyMods = result.keyMods;
+        if (type === 'createInstance') {
+            const activeInstance = this.getDefaultInstanceHost().activeInstance;
+            let instance;
+            if (result.config && 'id' in result?.config) {
+                await this.createContributedTerminalProfile(result.config.extensionIdentifier, result.config.id, {
+                    icon: result.config.options?.icon,
+                    color: result.config.options?.color,
+                    location: !!(keyMods?.alt && activeInstance) ? { splitActiveTerminal: true } : this.defaultLocation
+                });
+                return;
+            }
+            else if (result.config && 'profileName' in result.config) {
+                if (keyMods?.alt && activeInstance) {
+                    instance = await this.createTerminal({ location: { parentTerminal: activeInstance }, config: result.config, cwd });
+                }
+                else {
+                    instance = await this.createTerminal({ location: this.defaultLocation, config: result.config, cwd });
+                }
+            }
+            if (instance && this.defaultLocation !== TerminalLocation.Editor) {
+                this._terminalGroupService.showPanel(true);
+                this.setActiveInstance(instance);
+                return instance;
+            }
+        }
+        return undefined;
+    }
+    async _initializePrimaryBackend() {
+        mark('code/terminal/willGetTerminalBackend');
+        this._primaryBackend = await this._terminalInstanceService.getBackend(this._environmentService.remoteAuthority);
+        mark('code/terminal/didGetTerminalBackend');
+        const enableTerminalReconnection = this.configHelper.config.enablePersistentSessions;
+        this._connectionState = 0 ;
+        const isPersistentRemote = !!this._environmentService.remoteAuthority && enableTerminalReconnection;
+        this._primaryBackend?.onDidRequestDetach(async (e) => {
+            const instanceToDetach = this.getInstanceFromResource(getTerminalUri(e.workspaceId, e.instanceId));
+            if (instanceToDetach) {
+                const persistentProcessId = instanceToDetach?.persistentProcessId;
+                if (persistentProcessId && !instanceToDetach.shellLaunchConfig.isFeatureTerminal && !instanceToDetach.shellLaunchConfig.customPtyImplementation) {
+                    if (instanceToDetach.target === TerminalLocation.Editor) {
+                        this._terminalEditorService.detachInstance(instanceToDetach);
+                    }
+                    else {
+                        this._terminalGroupService.getGroupForInstance(instanceToDetach)?.removeInstance(instanceToDetach);
+                    }
+                    await instanceToDetach.detachProcessAndDispose(TerminalExitReason.User);
+                    await this._primaryBackend?.acceptDetachInstanceReply(e.requestId, persistentProcessId);
+                }
+                else {
+                    await this._primaryBackend?.acceptDetachInstanceReply(e.requestId, undefined);
+                }
+            }
+        });
+        mark('code/terminal/willReconnect');
+        let reconnectedPromise;
+        if (isPersistentRemote) {
+            reconnectedPromise = this._reconnectToRemoteTerminals();
+        }
+        else if (enableTerminalReconnection) {
+            reconnectedPromise = this._reconnectToLocalTerminals();
+        }
+        else {
+            reconnectedPromise = Promise.resolve();
+        }
+        reconnectedPromise.then(async () => {
+            this._setConnected();
+            mark('code/terminal/didReconnect');
+            mark('code/terminal/willReplay');
+            const instances = (await this._reconnectedTerminalGroups?.then(groups => ( groups.map(e => e.terminalInstances)).flat())) ?? [];
+            await Promise.all(( instances.map(e => ( new Promise(r => Event.once(e.onProcessReplayComplete)(r))))));
+            mark('code/terminal/didReplay');
+            mark('code/terminal/willGetPerformanceMarks');
+            await Promise.all(( Array.from(this._terminalInstanceService.getRegisteredBackends()).map(async (backend) => {
+                this._timerService.setPerformanceMarks(backend.remoteAuthority === undefined ? 'localPtyHost' : 'remotePtyHost', await backend.getPerformanceMarks());
+                backend.setReady();
+            })));
+            mark('code/terminal/didGetPerformanceMarks');
+            this._whenConnected.complete();
+        });
+    }
+    getPrimaryBackend() {
+        return this._primaryBackend;
+    }
+    _forwardInstanceHostEvents(host) {
+        host.onDidChangeInstances(this._onDidChangeInstances.fire, this._onDidChangeInstances);
+        host.onDidDisposeInstance(this._onDidDisposeInstance.fire, this._onDidDisposeInstance);
+        host.onDidChangeActiveInstance(instance => this._evaluateActiveInstance(host, instance));
+        host.onDidFocusInstance(instance => {
+            this._onDidFocusInstance.fire(instance);
+            this._evaluateActiveInstance(host, instance);
+        });
+        host.onDidChangeInstanceCapability((instance) => {
+            this._onDidChangeInstanceCapability.fire(instance);
+        });
+        this._hostActiveTerminals.set(host, undefined);
+    }
+    _evaluateActiveInstance(host, instance) {
+        this._hostActiveTerminals.set(host, instance);
+        if (instance === undefined) {
+            for (const active of ( this._hostActiveTerminals.values())) {
+                if (active) {
+                    instance = active;
+                }
+            }
+        }
+        this._activeInstance = instance;
+        this._onDidChangeActiveInstance.fire(instance);
+    }
+    setActiveInstance(value) {
+        if (value.shellLaunchConfig.hideFromUser) {
+            this._showBackgroundTerminal(value);
+        }
+        if (value.target === TerminalLocation.Editor) {
+            this._terminalEditorService.setActiveInstance(value);
+        }
+        else {
+            this._terminalGroupService.setActiveInstance(value);
+        }
+    }
+    async focusActiveInstance() {
+        if (!this._activeInstance) {
+            return;
+        }
+        if (this._activeInstance.target === TerminalLocation.Editor) {
+            return this._terminalEditorService.focusActiveInstance();
+        }
+        return this._terminalGroupService.focusActiveInstance();
+    }
+    async createContributedTerminalProfile(extensionIdentifier, id, options) {
+        await this._extensionService.activateByEvent(`onTerminalProfile:${id}`);
+        const profileProvider = this._terminalProfileService.getContributedProfileProvider(extensionIdentifier, id);
+        if (!profileProvider) {
+            this._notificationService.error(`No terminal profile provider registered for id "${id}"`);
+            return;
+        }
+        try {
+            await profileProvider.createContributedTerminalProfile(options);
+            this._terminalGroupService.setActiveInstanceByIndex(this._terminalGroupService.instances.length - 1);
+            await this._terminalGroupService.activeInstance?.focusWhenReady();
+        }
+        catch (e) {
+            this._notificationService.error(e.message);
+        }
+    }
+    async safeDisposeTerminal(instance) {
+        if (instance.target !== TerminalLocation.Editor &&
+            instance.hasChildProcesses &&
+            (this.configHelper.config.confirmOnKill === 'panel' || this.configHelper.config.confirmOnKill === 'always')) {
+            const veto = await this._showTerminalCloseConfirmation(true);
+            if (veto) {
+                return;
+            }
+        }
+        return ( new Promise(r => {
+            Event.once(instance.onExit)(() => r());
+            instance.dispose(TerminalExitReason.User);
+        }));
+    }
+    _setConnected() {
+        this._connectionState = 1 ;
+        this._onDidChangeConnectionState.fire();
+        this._logService.trace('Pty host ready');
+    }
+    async _reconnectToRemoteTerminals() {
+        const remoteAuthority = this._environmentService.remoteAuthority;
+        if (!remoteAuthority) {
+            return;
+        }
+        const backend = await this._terminalInstanceService.getBackend(remoteAuthority);
+        if (!backend) {
+            return;
+        }
+        mark('code/terminal/willGetTerminalLayoutInfo');
+        const layoutInfo = await backend.getTerminalLayoutInfo();
+        mark('code/terminal/didGetTerminalLayoutInfo');
+        backend.reduceConnectionGraceTime();
+        mark('code/terminal/willRecreateTerminalGroups');
+        await this._recreateTerminalGroups(layoutInfo);
+        mark('code/terminal/didRecreateTerminalGroups');
+        this._attachProcessLayoutListeners();
+        this._logService.trace('Reconnected to remote terminals');
+    }
+    async _reconnectToLocalTerminals() {
+        const localBackend = await this._terminalInstanceService.getBackend();
+        if (!localBackend) {
+            return;
+        }
+        mark('code/terminal/willGetTerminalLayoutInfo');
+        const layoutInfo = await localBackend.getTerminalLayoutInfo();
+        mark('code/terminal/didGetTerminalLayoutInfo');
+        if (layoutInfo && layoutInfo.tabs.length > 0) {
+            mark('code/terminal/willRecreateTerminalGroups');
+            this._reconnectedTerminalGroups = this._recreateTerminalGroups(layoutInfo);
+            mark('code/terminal/didRecreateTerminalGroups');
+        }
+        this._attachProcessLayoutListeners();
+        this._logService.trace('Reconnected to local terminals');
+    }
+    _recreateTerminalGroups(layoutInfo) {
+        const groupPromises = [];
+        let activeGroup;
+        if (layoutInfo) {
+            for (const tabLayout of layoutInfo.tabs) {
+                const terminalLayouts = tabLayout.terminals.filter(t => t.terminal && t.terminal.isOrphan);
+                if (terminalLayouts.length) {
+                    this._restoredGroupCount += terminalLayouts.length;
+                    const promise = this._recreateTerminalGroup(tabLayout, terminalLayouts);
+                    groupPromises.push(promise);
+                    if (tabLayout.isActive) {
+                        activeGroup = promise;
+                    }
+                    const activeInstance = this.instances.find(t => t.shellLaunchConfig.attachPersistentProcess?.id === tabLayout.activePersistentProcessId);
+                    if (activeInstance) {
+                        this.setActiveInstance(activeInstance);
+                    }
+                }
+            }
+            if (layoutInfo.tabs.length) {
+                activeGroup?.then(group => this._terminalGroupService.activeGroup = group);
+            }
+        }
+        return Promise.all(groupPromises).then(result => result.filter(e => !!e));
+    }
+    async _recreateTerminalGroup(tabLayout, terminalLayouts) {
+        let lastInstance;
+        for (const terminalLayout of terminalLayouts) {
+            const attachPersistentProcess = terminalLayout.terminal;
+            if (this._lifecycleService.startupKind !== 3  && attachPersistentProcess.type === 'Task') {
+                continue;
+            }
+            mark(`code/terminal/willRecreateTerminal/${attachPersistentProcess.id}-${attachPersistentProcess.pid}`);
+            lastInstance = this.createTerminal({
+                config: { attachPersistentProcess },
+                location: lastInstance ? { parentTerminal: lastInstance } : TerminalLocation.Panel
+            });
+            lastInstance.then(() => mark(`code/terminal/didRecreateTerminal/${attachPersistentProcess.id}-${attachPersistentProcess.pid}`));
+        }
+        const group = lastInstance?.then(instance => {
+            const g = this._terminalGroupService.getGroupForInstance(instance);
+            g?.resizePanes(( tabLayout.terminals.map(terminal => terminal.relativeSize)));
+            return g;
+        });
+        return group;
+    }
+    _attachProcessLayoutListeners() {
+        this._register(this.onDidChangeActiveGroup(() => this._saveState()));
+        this._register(this.onDidChangeActiveInstance(() => this._saveState()));
+        this._register(this.onDidChangeInstances(() => this._saveState()));
+        this._register(this.onAnyInstanceProcessIdReady(() => this._saveState()));
+        this._register(this.onAnyInstanceTitleChange(instance => this._updateTitle(instance)));
+        this._register(this.onAnyInstanceIconChange(e => this._updateIcon(e.instance, e.userInitiated)));
+    }
+    _handleInstanceContextKeys() {
+        const terminalIsOpenContext = TerminalContextKeys.isOpen.bindTo(this._contextKeyService);
+        const updateTerminalContextKeys = () => {
+            terminalIsOpenContext.set(this.instances.length > 0);
+            this._terminalCountContextKey.set(this.instances.length);
+        };
+        this.onDidChangeInstances(() => updateTerminalContextKeys());
+    }
+    async getActiveOrCreateInstance(options) {
+        const activeInstance = this.activeInstance;
+        if (!activeInstance) {
+            return this.createTerminal();
+        }
+        if (!options?.acceptsInput || activeInstance.xterm?.isStdinDisabled !== true) {
+            return activeInstance;
+        }
+        const instance = await this.createTerminal();
+        this.setActiveInstance(instance);
+        await this.revealActiveTerminal();
+        return instance;
+    }
+    async revealActiveTerminal(preserveFocus) {
+        const instance = this.activeInstance;
+        if (!instance) {
+            return;
+        }
+        if (instance.target === TerminalLocation.Editor) {
+            await this._terminalEditorService.revealActiveEditor(preserveFocus);
+        }
+        else {
+            await this._terminalGroupService.showPanel();
+        }
+    }
+    setEditable(instance, data) {
+        if (!data) {
+            this._editable = undefined;
+        }
+        else {
+            this._editable = { instance: instance, data };
+        }
+        const pane = this._viewsService.getActiveViewWithId(TERMINAL_VIEW_ID);
+        const isEditing = this.isEditable(instance);
+        pane?.terminalTabbedView?.setEditable(isEditing);
+    }
+    isEditable(instance) {
+        return !!this._editable && (this._editable.instance === instance || !instance);
+    }
+    getEditableData(instance) {
+        return this._editable && this._editable.instance === instance ? this._editable.data : undefined;
+    }
+    requestStartExtensionTerminal(proxy, cols, rows) {
+        return ( new Promise(callback => {
+            this._onDidRequestStartExtensionTerminal.fire({ proxy, cols, rows, callback });
+        }));
+    }
+    _onBeforeShutdown(reason) {
+        if (isWeb) {
+            this._isShuttingDown = true;
+            return false;
+        }
+        return this._onBeforeShutdownAsync(reason);
+    }
+    async _onBeforeShutdownAsync(reason) {
+        if (this.instances.length === 0) {
+            return false;
+        }
+        try {
+            this._shutdownWindowCount = await this._nativeDelegate?.getWindowCount();
+            const shouldReviveProcesses = this._shouldReviveProcesses(reason);
+            if (shouldReviveProcesses) {
+                await Promise.race([
+                    this._primaryBackend?.persistTerminalState(),
+                    timeout(2000)
+                ]);
+            }
+            const shouldPersistProcesses = this._configHelper.config.enablePersistentSessions && reason === 3 ;
+            if (!shouldPersistProcesses) {
+                const hasDirtyInstances = ((this.configHelper.config.confirmOnExit === 'always' && this.instances.length > 0) ||
+                    (this.configHelper.config.confirmOnExit === 'hasChildProcesses' && ( this.instances.some(e => e.hasChildProcesses))));
+                if (hasDirtyInstances) {
+                    return this._onBeforeShutdownConfirmation(reason);
+                }
+            }
+        }
+        catch (err) {
+            this._logService.warn('Exception occurred during terminal shutdown', err);
+        }
+        this._isShuttingDown = true;
+        return false;
+    }
+    setNativeDelegate(nativeDelegate) {
+        this._nativeDelegate = nativeDelegate;
+    }
+    _shouldReviveProcesses(reason) {
+        if (!this._configHelper.config.enablePersistentSessions) {
+            return false;
+        }
+        switch (this.configHelper.config.persistentSessionReviveProcess) {
+            case 'onExit': {
+                if (reason === 1  && (this._shutdownWindowCount === 1 && !isMacintosh)) {
+                    return true;
+                }
+                return reason === 4  || reason === 2 ;
+            }
+            case 'onExitAndWindowClose': return reason !== 3 ;
+            default: return false;
+        }
+    }
+    async _onBeforeShutdownConfirmation(reason) {
+        const veto = await this._showTerminalCloseConfirmation();
+        if (!veto) {
+            this._isShuttingDown = true;
+        }
+        return veto;
+    }
+    _onWillShutdown(e) {
+        const shouldPersistTerminals = this._configHelper.config.enablePersistentSessions && e.reason === 3 ;
+        for (const instance of [...this._terminalGroupService.instances, ...this._backgroundedTerminalInstances]) {
+            if (shouldPersistTerminals && instance.shouldPersist) {
+                instance.detachProcessAndDispose(TerminalExitReason.Shutdown);
+            }
+            else {
+                instance.dispose(TerminalExitReason.Shutdown);
+            }
+        }
+        if (!shouldPersistTerminals && !this._shouldReviveProcesses(e.reason)) {
+            this._primaryBackend?.setTerminalLayoutInfo(undefined);
+        }
+    }
+    _saveState() {
+        if (this._isShuttingDown) {
+            return;
+        }
+        if (!this.configHelper.config.enablePersistentSessions) {
+            return;
+        }
+        const tabs = ( this._terminalGroupService.groups.map(g => g.getLayoutInfo(g === this._terminalGroupService.activeGroup)));
+        const state = { tabs };
+        this._primaryBackend?.setTerminalLayoutInfo(state);
+    }
+    _updateTitle(instance) {
+        if (!this.configHelper.config.enablePersistentSessions || !instance || !instance.persistentProcessId || !instance.title || instance.isDisposed) {
+            return;
+        }
+        if (instance.staticTitle) {
+            this._primaryBackend?.updateTitle(instance.persistentProcessId, instance.staticTitle, TitleEventSource.Api);
+        }
+        else {
+            this._primaryBackend?.updateTitle(instance.persistentProcessId, instance.title, instance.titleSource);
+        }
+    }
+    _updateIcon(instance, userInitiated) {
+        if (!this.configHelper.config.enablePersistentSessions || !instance || !instance.persistentProcessId || !instance.icon || instance.isDisposed) {
+            return;
+        }
+        this._primaryBackend?.updateIcon(instance.persistentProcessId, userInitiated, instance.icon, instance.color);
+    }
+    refreshActiveGroup() {
+        this._onDidChangeActiveGroup.fire(this._terminalGroupService.activeGroup);
+    }
+    getInstanceFromId(terminalId) {
+        let bgIndex = -1;
+        this._backgroundedTerminalInstances.forEach((terminalInstance, i) => {
+            if (terminalInstance.instanceId === terminalId) {
+                bgIndex = i;
+            }
+        });
+        if (bgIndex !== -1) {
+            return this._backgroundedTerminalInstances[bgIndex];
+        }
+        try {
+            return this.instances[this._getIndexFromId(terminalId)];
+        }
+        catch {
+            return undefined;
+        }
+    }
+    getInstanceFromIndex(terminalIndex) {
+        return this.instances[terminalIndex];
+    }
+    getInstanceFromResource(resource) {
+        return getInstanceFromResource(this.instances, resource);
+    }
+    isAttachedToTerminal(remoteTerm) {
+        return ( this.instances.some(term => term.processId === remoteTerm.pid));
+    }
+    moveToEditor(source, group) {
+        if (source.target === TerminalLocation.Editor) {
+            return;
+        }
+        const sourceGroup = this._terminalGroupService.getGroupForInstance(source);
+        if (!sourceGroup) {
+            return;
+        }
+        sourceGroup.removeInstance(source);
+        this._terminalEditorService.openEditor(source, group ? { viewColumn: group } : undefined);
+    }
+    moveIntoNewEditor(source) {
+        this.moveToEditor(source, AUX_WINDOW_GROUP);
+    }
+    async moveToTerminalView(source, target, side) {
+        if (URI.isUri(source)) {
+            source = this.getInstanceFromResource(source);
+        }
+        if (!source) {
+            return;
+        }
+        this._terminalEditorService.detachInstance(source);
+        if (source.target !== TerminalLocation.Editor) {
+            await this._terminalGroupService.showPanel(true);
+            return;
+        }
+        source.target = TerminalLocation.Panel;
+        let group;
+        if (target) {
+            group = this._terminalGroupService.getGroupForInstance(target);
+        }
+        if (!group) {
+            group = this._terminalGroupService.createGroup();
+        }
+        group.addInstance(source);
+        this.setActiveInstance(source);
+        await this._terminalGroupService.showPanel(true);
+        if (target && side) {
+            const index = group.terminalInstances.indexOf(target) + (side === 'after' ? 1 : 0);
+            group.moveInstance(source, index);
+        }
+        this._onDidChangeInstances.fire();
+        this._onDidChangeActiveGroup.fire(this._terminalGroupService.activeGroup);
+    }
+    _initInstanceListeners(instance) {
+        const instanceDisposables = [
+            instance.onDimensionsChanged(() => {
+                this._onDidChangeInstanceDimensions.fire(instance);
+                if (this.configHelper.config.enablePersistentSessions && this.isProcessSupportRegistered) {
+                    this._saveState();
+                }
+            }),
+            instance.onDidFocus(this._onDidChangeActiveInstance.fire, this._onDidChangeActiveInstance),
+            instance.onRequestAddInstanceToGroup(async (e) => await this._addInstanceToGroup(instance, e))
+        ];
+        instance.onDisposed(() => dispose(instanceDisposables));
+    }
+    async _addInstanceToGroup(instance, e) {
+        const terminalIdentifier = parseTerminalUri(e.uri);
+        if (terminalIdentifier.instanceId === undefined) {
+            return;
+        }
+        let sourceInstance = this.getInstanceFromResource(e.uri);
+        if (!sourceInstance) {
+            const attachPersistentProcess = await this._primaryBackend?.requestDetachInstance(terminalIdentifier.workspaceId, terminalIdentifier.instanceId);
+            if (attachPersistentProcess) {
+                sourceInstance = await this.createTerminal({ config: { attachPersistentProcess }, resource: e.uri });
+                this._terminalGroupService.moveInstance(sourceInstance, instance, e.side);
+                return;
+            }
+        }
+        sourceInstance = this._terminalGroupService.getInstanceFromResource(e.uri);
+        if (sourceInstance) {
+            this._terminalGroupService.moveInstance(sourceInstance, instance, e.side);
+            return;
+        }
+        sourceInstance = this._terminalEditorService.getInstanceFromResource(e.uri);
+        if (sourceInstance) {
+            this.moveToTerminalView(sourceInstance, instance, e.side);
+            return;
+        }
+        return;
+    }
+    registerProcessSupport(isSupported) {
+        if (!isSupported) {
+            return;
+        }
+        this._processSupportContextKey.set(isSupported);
+        this._onDidRegisterProcessSupport.fire();
+    }
+    _getIndexFromId(terminalId) {
+        let terminalIndex = -1;
+        this.instances.forEach((terminalInstance, i) => {
+            if (terminalInstance.instanceId === terminalId) {
+                terminalIndex = i;
+            }
+        });
+        if (terminalIndex === -1) {
+            throw new Error(`Terminal with ID ${terminalId} does not exist (has it already been disposed?)`);
+        }
+        return terminalIndex;
+    }
+    async _showTerminalCloseConfirmation(singleTerminal) {
+        let message;
+        if (this.instances.length === 1 || singleTerminal) {
+            message = ( localizeWithPath(
+                'vs/workbench/contrib/terminal/browser/terminalService',
+                'terminalService.terminalCloseConfirmationSingular',
+                "Do you want to terminate the active terminal session?"
+            ));
+        }
+        else {
+            message = ( localizeWithPath(
+                'vs/workbench/contrib/terminal/browser/terminalService',
+                'terminalService.terminalCloseConfirmationPlural',
+                "Do you want to terminate the {0} active terminal sessions?",
+                this.instances.length
+            ));
+        }
+        const { confirmed } = await this._dialogService.confirm({
+            type: 'warning',
+            message,
+            primaryButton: ( localizeWithPath(
+                'vs/workbench/contrib/terminal/browser/terminalService',
+                { key: 'terminate', comment: ['&& denotes a mnemonic'] },
+                "&&Terminate"
+            ))
+        });
+        return !confirmed;
+    }
+    getDefaultInstanceHost() {
+        if (this.defaultLocation === TerminalLocation.Editor) {
+            return this._terminalEditorService;
+        }
+        return this._terminalGroupService;
+    }
+    async getInstanceHost(location) {
+        if (location) {
+            if (location === TerminalLocation.Editor) {
+                return this._terminalEditorService;
+            }
+            else if (typeof location === 'object') {
+                if ('viewColumn' in location) {
+                    return this._terminalEditorService;
+                }
+                else if ('parentTerminal' in location) {
+                    return (await location.parentTerminal).target === TerminalLocation.Editor ? this._terminalEditorService : this._terminalGroupService;
+                }
+            }
+            else {
+                return this._terminalGroupService;
+            }
+        }
+        return this;
+    }
+    async createTerminal(options) {
+        if (this._terminalProfileService.availableProfiles.length === 0) {
+            const isPtyTerminal = options?.config && 'customPtyImplementation' in options.config;
+            const isLocalInRemoteTerminal = this._remoteAgentService.getConnection() && URI.isUri(options?.cwd) && options?.cwd.scheme === Schemas.vscodeFileResource;
+            if (!isPtyTerminal && !isLocalInRemoteTerminal) {
+                if (this._connectionState === 0 ) {
+                    mark(`code/terminal/willGetProfiles`);
+                }
+                await this._terminalProfileService.profilesReady;
+                if (this._connectionState === 0 ) {
+                    mark(`code/terminal/didGetProfiles`);
+                }
+            }
+        }
+        const config = options?.config || this._terminalProfileService.getDefaultProfile();
+        const shellLaunchConfig = config && 'extensionIdentifier' in config ? {} : this._terminalInstanceService.convertProfileToShellLaunchConfig(config || {});
+        const contributedProfile = await this._getContributedProfile(shellLaunchConfig, options);
+        const splitActiveTerminal = typeof options?.location === 'object' && 'splitActiveTerminal' in options.location ? options.location.splitActiveTerminal : typeof options?.location === 'object' ? 'parentTerminal' in options.location : false;
+        await this._resolveCwd(shellLaunchConfig, splitActiveTerminal, options);
+        if (contributedProfile) {
+            const resolvedLocation = await this.resolveLocation(options?.location);
+            let location;
+            if (splitActiveTerminal) {
+                location = resolvedLocation === TerminalLocation.Editor ? { viewColumn: SIDE_GROUP } : { splitActiveTerminal: true };
+            }
+            else {
+                location = typeof options?.location === 'object' && 'viewColumn' in options.location ? options.location : resolvedLocation;
+            }
+            await this.createContributedTerminalProfile(contributedProfile.extensionIdentifier, contributedProfile.id, {
+                icon: contributedProfile.icon,
+                color: contributedProfile.color,
+                location,
+                cwd: shellLaunchConfig.cwd,
+            });
+            const instanceHost = resolvedLocation === TerminalLocation.Editor ? this._terminalEditorService : this._terminalGroupService;
+            const instance = instanceHost.instances[instanceHost.instances.length - 1];
+            await instance?.focusWhenReady();
+            this._terminalHasBeenCreated.set(true);
+            return instance;
+        }
+        if (!shellLaunchConfig.customPtyImplementation && !this.isProcessSupportRegistered) {
+            throw new Error('Could not create terminal when process support is not registered');
+        }
+        if (shellLaunchConfig.hideFromUser) {
+            const instance = this._terminalInstanceService.createInstance(shellLaunchConfig, TerminalLocation.Panel);
+            this._backgroundedTerminalInstances.push(instance);
+            this._backgroundedTerminalDisposables.set(instance.instanceId, [
+                instance.onDisposed(this._onDidDisposeInstance.fire, this._onDidDisposeInstance)
+            ]);
+            this._terminalHasBeenCreated.set(true);
+            return instance;
+        }
+        this._evaluateLocalCwd(shellLaunchConfig);
+        const location = (await this.resolveLocation(options?.location)) || this.defaultLocation;
+        const parent = await this._getSplitParent(options?.location);
+        this._terminalHasBeenCreated.set(true);
+        if (parent) {
+            return this._splitTerminal(shellLaunchConfig, location, parent);
+        }
+        return this._createTerminal(shellLaunchConfig, location, options);
+    }
+    async _getContributedProfile(shellLaunchConfig, options) {
+        if (options?.config && 'extensionIdentifier' in options.config) {
+            return options.config;
+        }
+        return this._terminalProfileService.getContributedDefaultProfile(shellLaunchConfig);
+    }
+    async createDetachedTerminal(options) {
+        const ctor = await TerminalInstance.getXtermConstructor(this._keybindingService, this._contextKeyService);
+        const xterm = this._instantiationService.createInstance(XtermTerminal, ctor, this._configHelper, options.cols, options.rows, options.colorProvider, options.capabilities || ( new TerminalCapabilityStore()), '', false);
+        if (options.readonly) {
+            xterm.raw.attachCustomKeyEventHandler(() => false);
+        }
+        const instance = ( new DetachedTerminal(xterm, options, this._instantiationService));
+        this._detachedXterms.add(instance);
+        const l = xterm.onDidDispose(() => {
+            this._detachedXterms.delete(instance);
+            l.dispose();
+        });
+        return instance;
+    }
+    async _resolveCwd(shellLaunchConfig, splitActiveTerminal, options) {
+        const cwd = shellLaunchConfig.cwd;
+        if (!cwd) {
+            if (options?.cwd) {
+                shellLaunchConfig.cwd = options.cwd;
+            }
+            else if (splitActiveTerminal && options?.location) {
+                let parent = this.activeInstance;
+                if (typeof options.location === 'object' && 'parentTerminal' in options.location) {
+                    parent = await options.location.parentTerminal;
+                }
+                if (!parent) {
+                    throw new Error('Cannot split without an active instance');
+                }
+                shellLaunchConfig.cwd = await getCwdForSplit(this.configHelper, parent, this._workspaceContextService.getWorkspace().folders, this._commandService);
+            }
+        }
+    }
+    _splitTerminal(shellLaunchConfig, location, parent) {
+        let instance;
+        if (typeof shellLaunchConfig.cwd !== 'object' && typeof parent.shellLaunchConfig.cwd === 'object') {
+            shellLaunchConfig.cwd = ( URI.from({
+                scheme: parent.shellLaunchConfig.cwd.scheme,
+                authority: parent.shellLaunchConfig.cwd.authority,
+                path: shellLaunchConfig.cwd || parent.shellLaunchConfig.cwd.path
+            }));
+        }
+        if (location === TerminalLocation.Editor || parent.target === TerminalLocation.Editor) {
+            instance = this._terminalEditorService.splitInstance(parent, shellLaunchConfig);
+        }
+        else {
+            const group = this._terminalGroupService.getGroupForInstance(parent);
+            if (!group) {
+                throw new Error(`Cannot split a terminal without a group ${parent}`);
+            }
+            shellLaunchConfig.parentTerminalId = parent.instanceId;
+            instance = group.split(shellLaunchConfig);
+        }
+        this._addToReconnected(instance);
+        return instance;
+    }
+    _addToReconnected(instance) {
+        if (!instance.reconnectionProperties?.ownerId) {
+            return;
+        }
+        const reconnectedTerminals = this._reconnectedTerminals.get(instance.reconnectionProperties.ownerId);
+        if (reconnectedTerminals) {
+            reconnectedTerminals.push(instance);
+        }
+        else {
+            this._reconnectedTerminals.set(instance.reconnectionProperties.ownerId, [instance]);
+        }
+    }
+    _createTerminal(shellLaunchConfig, location, options) {
+        let instance;
+        const editorOptions = this._getEditorOptions(options?.location);
+        if (location === TerminalLocation.Editor) {
+            instance = this._terminalInstanceService.createInstance(shellLaunchConfig, TerminalLocation.Editor);
+            this._terminalEditorService.openEditor(instance, editorOptions);
+        }
+        else {
+            const group = this._terminalGroupService.createGroup(shellLaunchConfig);
+            instance = group.terminalInstances[0];
+        }
+        this._addToReconnected(instance);
+        return instance;
+    }
+    async resolveLocation(location) {
+        if (location && typeof location === 'object') {
+            if ('parentTerminal' in location) {
+                const parentTerminal = await location.parentTerminal;
+                return !parentTerminal.target ? TerminalLocation.Panel : parentTerminal.target;
+            }
+            else if ('viewColumn' in location) {
+                return TerminalLocation.Editor;
+            }
+            else if ('splitActiveTerminal' in location) {
+                return !this._activeInstance?.target ? TerminalLocation.Panel : this._activeInstance?.target;
+            }
+        }
+        return location;
+    }
+    async _getSplitParent(location) {
+        if (location && typeof location === 'object' && 'parentTerminal' in location) {
+            return location.parentTerminal;
+        }
+        else if (location && typeof location === 'object' && 'splitActiveTerminal' in location) {
+            return this.activeInstance;
+        }
+        return undefined;
+    }
+    _getEditorOptions(location) {
+        if (location && typeof location === 'object' && 'viewColumn' in location) {
+            location.viewColumn = columnToEditorGroup(this._editorGroupsService, this._configurationService, location.viewColumn);
+            return location;
+        }
+        return undefined;
+    }
+    _evaluateLocalCwd(shellLaunchConfig) {
+        if (typeof shellLaunchConfig.cwd !== 'string' && shellLaunchConfig.cwd?.scheme === Schemas.file) {
+            if (VirtualWorkspaceContext.getValue(this._contextKeyService)) {
+                shellLaunchConfig.initialText = formatMessageForTerminal(( localizeWithPath(
+                    'vs/workbench/contrib/terminal/browser/terminalService',
+                    'localTerminalVirtualWorkspace',
+                    "This shell is open to a {0}local{1} folder, NOT to the virtual folder",
+                    '\x1b[3m',
+                    '\x1b[23m'
+                )), { excludeLeadingNewLine: true, loudFormatting: true });
+                shellLaunchConfig.type = 'Local';
+            }
+            else if (this._remoteAgentService.getConnection()) {
+                shellLaunchConfig.initialText = formatMessageForTerminal(( localizeWithPath(
+                    'vs/workbench/contrib/terminal/browser/terminalService',
+                    'localTerminalRemote',
+                    "This shell is running on your {0}local{1} machine, NOT on the connected remote machine",
+                    '\x1b[3m',
+                    '\x1b[23m'
+                )), { excludeLeadingNewLine: true, loudFormatting: true });
+                shellLaunchConfig.type = 'Local';
+            }
+        }
+    }
+    _showBackgroundTerminal(instance) {
+        this._backgroundedTerminalInstances.splice(this._backgroundedTerminalInstances.indexOf(instance), 1);
+        const disposables = this._backgroundedTerminalDisposables.get(instance.instanceId);
+        if (disposables) {
+            dispose(disposables);
+        }
+        this._backgroundedTerminalDisposables.delete(instance.instanceId);
+        instance.shellLaunchConfig.hideFromUser = false;
+        this._terminalGroupService.createGroup(instance);
+        if (this.instances.length === 1) {
+            this._terminalGroupService.setActiveInstanceByIndex(0);
+        }
+        this._onDidChangeInstances.fire();
+    }
+    async setContainers(panelContainer, terminalContainer) {
+        this._configHelper.panelContainer = panelContainer;
+        this._terminalGroupService.setContainer(terminalContainer);
+    }
+    getEditingTerminal() {
+        return this._editingTerminal;
+    }
+    setEditingTerminal(instance) {
+        this._editingTerminal = instance;
+    }
+    createOnInstanceEvent(getEvent) {
+        return this._register(( new DynamicListEventMultiplexer(
+            this.instances,
+            this.onDidCreateInstance,
+            this.onDidDisposeInstance,
+            getEvent
+        ))).event;
+    }
+    createOnInstanceCapabilityEvent(capabilityId, getEvent) {
+        return createInstanceCapabilityEventMultiplexer(this.instances, this.onDidCreateInstance, this.onDidDisposeInstance, capabilityId, getEvent);
+    }
+};
+TerminalService.__decorator = ( __decorate([
+    memoize
+], TerminalService.prototype, "onAnyInstanceData", null));
+TerminalService.__decorator = ( __decorate([
+    memoize
+], TerminalService.prototype, "onAnyInstanceDataInput", null));
+TerminalService.__decorator = ( __decorate([
+    memoize
+], TerminalService.prototype, "onAnyInstanceIconChange", null));
+TerminalService.__decorator = ( __decorate([
+    memoize
+], TerminalService.prototype, "onAnyInstanceMaximumDimensionsChange", null));
+TerminalService.__decorator = ( __decorate([
+    memoize
+], TerminalService.prototype, "onAnyInstancePrimaryStatusChange", null));
+TerminalService.__decorator = ( __decorate([
+    memoize
+], TerminalService.prototype, "onAnyInstanceProcessIdReady", null));
+TerminalService.__decorator = ( __decorate([
+    memoize
+], TerminalService.prototype, "onAnyInstanceSelectionChange", null));
+TerminalService.__decorator = ( __decorate([
+    memoize
+], TerminalService.prototype, "onAnyInstanceTitleChange", null));
+TerminalService.__decorator = ( __decorate([
+    debounce(500)
+], TerminalService.prototype, "_saveState", null));
+TerminalService.__decorator = ( __decorate([
+    debounce(500)
+], TerminalService.prototype, "_updateTitle", null));
+TerminalService.__decorator = ( __decorate([
+    debounce(500)
+], TerminalService.prototype, "_updateIcon", null));
+TerminalService = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, ILifecycleService)),
+    ( __param(2, ITerminalLogService)),
+    ( __param(3, IDialogService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IRemoteAgentService)),
+    ( __param(6, IViewsService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IWorkbenchEnvironmentService)),
+    ( __param(9, ITerminalEditorService)),
+    ( __param(10, ITerminalGroupService)),
+    ( __param(11, ITerminalInstanceService)),
+    ( __param(12, IEditorGroupsService)),
+    ( __param(13, ITerminalProfileService)),
+    ( __param(14, IExtensionService)),
+    ( __param(15, INotificationService)),
+    ( __param(16, IWorkspaceContextService)),
+    ( __param(17, ICommandService)),
+    ( __param(18, IKeybindingService)),
+    ( __param(19, ITimerService))
+], TerminalService));
+let TerminalEditorStyle = class TerminalEditorStyle extends Themable {
+    constructor(container, _terminalService, _themeService, _terminalProfileService, _editorService) {
+        super(_themeService);
+        this._terminalService = _terminalService;
+        this._themeService = _themeService;
+        this._terminalProfileService = _terminalProfileService;
+        this._editorService = _editorService;
+        this._registerListeners();
+        this._styleElement = createStyleSheet(container);
+        this._register(toDisposable(() => container.removeChild(this._styleElement)));
+        this.updateStyles();
+    }
+    _registerListeners() {
+        this._register(this._terminalService.onAnyInstanceIconChange(() => this.updateStyles()));
+        this._register(this._terminalService.onDidCreateInstance(() => this.updateStyles()));
+        this._register(this._editorService.onDidActiveEditorChange(() => {
+            if (this._editorService.activeEditor instanceof TerminalEditorInput) {
+                this.updateStyles();
+            }
+        }));
+        this._register(this._editorService.onDidCloseEditor(() => {
+            if (this._editorService.activeEditor instanceof TerminalEditorInput) {
+                this.updateStyles();
+            }
+        }));
+        this._register(this._terminalProfileService.onDidChangeAvailableProfiles(() => this.updateStyles()));
+    }
+    updateStyles() {
+        super.updateStyles();
+        const colorTheme = this._themeService.getColorTheme();
+        let css = '';
+        const productIconTheme = this._themeService.getProductIconTheme();
+        for (const instance of this._terminalService.instances) {
+            const icon = instance.icon;
+            if (!icon) {
+                continue;
+            }
+            let uri = undefined;
+            if (icon instanceof URI) {
+                uri = icon;
+            }
+            else if (icon instanceof Object && 'light' in icon && 'dark' in icon) {
+                uri = colorTheme.type === ColorScheme.LIGHT ? icon.light : icon.dark;
+            }
+            const iconClasses = getUriClasses(instance, colorTheme.type);
+            if (uri instanceof URI && iconClasses && iconClasses.length > 1) {
+                css += (`.monaco-workbench .terminal-tab.${iconClasses[0]}::before` +
+                    `{content: ''; background-image: ${asCSSUrl(uri)};}`);
+            }
+            if (ThemeIcon.isThemeIcon(icon)) {
+                const iconRegistry = getIconRegistry();
+                const iconContribution = iconRegistry.getIcon(icon.id);
+                if (iconContribution) {
+                    const def = productIconTheme.getIcon(iconContribution);
+                    if (def) {
+                        css += (`.monaco-workbench .terminal-tab.codicon-${icon.id}::before` +
+                            `{content: '${def.fontCharacter}' !important; font-family: ${asCSSPropertyValue(def.font?.id ?? 'codicon')} !important;}`);
+                    }
+                }
+            }
+        }
+        const iconForegroundColor = colorTheme.getColor(iconForeground);
+        if (iconForegroundColor) {
+            css += `.monaco-workbench .show-file-icons .file-icon.terminal-tab::before { color: ${iconForegroundColor}; }`;
+        }
+        css += getColorStyleContent(colorTheme, true);
+        this._styleElement.textContent = css;
+    }
+};
+TerminalEditorStyle = ( __decorate([
+    ( __param(1, ITerminalService)),
+    ( __param(2, IThemeService)),
+    ( __param(3, ITerminalProfileService)),
+    ( __param(4, IEditorService))
+], TerminalEditorStyle));
+export { TerminalService };