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

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

@@ -1,1134 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { DeferredPromise, timeout } from 'monaco-editor/esm/vs/base/common/async.js';
-import { debounce } from 'monaco-editor/esm/vs/base/common/decorators.js';
-import { Emitter, Event, DynamicListEventMultiplexer } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable, dispose, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { isWeb, isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { INotificationService } from 'monaco-editor/esm/vs/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 { iconForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
-import { getIconRegistry } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-import { ColorScheme } from 'monaco-editor/esm/vs/platform/theme/common/theme.js';
-import { Themable, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { VirtualWorkspaceContext } from '../../../common/contextkeys.js';
-import { IViewsService } from '../../../common/views.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 { 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 'monaco-editor/esm/vs/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 'monaco-editor/esm/vs/base/common/performance.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { DeatachedTerminal } from './detachedTerminal.js';
-import { createInstanceCapabilityEventMultiplexer } from './terminalEvents.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 detachedXterms() {
-        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 onDidChangeActiveGroup() { return this._onDidChangeActiveGroup.event; }
-    get onDidCreateInstance() { return this._onDidCreateInstance.event; }
-    get onDidDisposeInstance() { return this._onDidDisposeInstance.event; }
-    get onDidFocusInstance() { return this._onDidFocusInstance.event; }
-    get onDidReceiveProcessId() { return this._onDidReceiveProcessId.event; }
-    get onDidRequestStartExtensionTerminal() { return this._onDidRequestStartExtensionTerminal.event; }
-    get onDidChangeInstanceDimensions() { return this._onDidChangeInstanceDimensions.event; }
-    get onDidMaximumDimensionsChange() { return this._onDidMaxiumumDimensionsChange.event; }
-    get onDidChangeInstanceCapability() { return this._onDidChangeInstanceCapability.event; }
-    get onDidChangeInstances() { return this._onDidChangeInstances.event; }
-    get onDidChangeInstanceTitle() { return this._onDidChangeInstanceTitle.event; }
-    get onDidChangeInstanceIcon() { return this._onDidChangeInstanceIcon.event; }
-    get onDidChangeInstanceColor() { return this._onDidChangeInstanceColor.event; }
-    get onDidChangeActiveInstance() { return this._onDidChangeActiveInstance.event; }
-    get onDidChangeInstancePrimaryStatus() { return this._onDidChangeInstancePrimaryStatus.event; }
-    get onDidInputInstanceData() { return this._onDidInputInstanceData.event; }
-    get onDidChangeSelection() { return this._onDidChangeSelection.event; }
-    get onDidDisposeGroup() { return this._onDidDisposeGroup.event; }
-    get onDidChangeGroups() { return this._onDidChangeGroups.event; }
-    get onDidRegisterProcessSupport() { return this._onDidRegisterProcessSupport.event; }
-    get onDidChangeConnectionState() { return this._onDidChangeConnectionState.event; }
-    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._onDidChangeActiveGroup = this._register(( new Emitter()));
-        this._onDidCreateInstance = this._register(( new Emitter()));
-        this._onDidDisposeInstance = this._register(( new Emitter()));
-        this._onDidFocusInstance = this._register(( new Emitter()));
-        this._onDidReceiveProcessId = this._register(( new Emitter()));
-        this._onDidRequestStartExtensionTerminal = this._register(( new Emitter()));
-        this._onDidChangeInstanceDimensions = this._register(( new Emitter()));
-        this._onDidMaxiumumDimensionsChange = this._register(( new Emitter()));
-        this._onDidChangeInstanceCapability = this._register(( new Emitter()));
-        this._onDidChangeInstances = this._register(( new Emitter()));
-        this._onDidChangeInstanceTitle = this._register(( new Emitter()));
-        this._onDidChangeInstanceIcon = this._register(( new Emitter()));
-        this._onDidChangeInstanceColor = this._register(( new Emitter()));
-        this._onDidChangeActiveInstance = this._register(( new Emitter()));
-        this._onDidChangeInstancePrimaryStatus = this._register(( new Emitter()));
-        this._onDidInputInstanceData = this._register(( new Emitter()));
-        this._onDidChangeSelection = this._register(( new Emitter()));
-        this._onDidDisposeGroup = this._register(( new Emitter()));
-        this._onDidChangeGroups = this._register(( new Emitter()));
-        this._onDidRegisterProcessSupport = this._register(( new Emitter()));
-        this._onDidChangeConnectionState = this._register(( new Emitter()));
-        this._configHelper = this._register(this._instantiationService.createInstance(TerminalConfigHelper));
-        this.onDidCreateInstance(() => this._terminalProfileService.refreshAvailableProfiles());
-        this._forwardInstanceHostEvents(this._terminalGroupService);
-        this._forwardInstanceHostEvents(this._terminalEditorService);
-        this._terminalGroupService.onDidChangeActiveGroup(this._onDidChangeActiveGroup.fire, this._onDidChangeActiveGroup);
-        this._terminalInstanceService.onDidCreateInstance(instance => {
-            this._initInstanceListeners(instance);
-            this._onDidCreateInstance.fire(instance);
-        });
-        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._instantiationService.createInstance(TerminalEditorStyle, 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 => {
-            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;
-        let group;
-        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}`);
-            if (!lastInstance) {
-                lastInstance = this.createTerminal({
-                    config: { attachPersistentProcess },
-                    location: TerminalLocation.Panel
-                });
-                group = lastInstance.then(instance => this._terminalGroupService.getGroupForInstance(instance));
-            }
-            else {
-                lastInstance = this.createTerminal({
-                    config: { attachPersistentProcess },
-                    location: { parentTerminal: lastInstance }
-                });
-            }
-            mark(`code/terminal/didRecreateTerminal/${attachPersistentProcess.id}-${attachPersistentProcess.pid}`);
-        }
-        group?.then(g => g?.resizePanes(( tabLayout.terminals.map(terminal => terminal.relativeSize))));
-        return group;
-    }
-    _attachProcessLayoutListeners() {
-        this.onDidChangeActiveGroup(() => this._saveState());
-        this.onDidChangeActiveInstance(() => this._saveState());
-        this.onDidChangeInstances(() => this._saveState());
-        this.onDidReceiveProcessId(() => this._saveState());
-        this.onDidChangeInstanceTitle(instance => this._updateTitle(instance));
-        this.onDidChangeInstanceIcon(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() {
-        const instance = this.activeInstance;
-        if (!instance) {
-            return;
-        }
-        if (instance.target === TerminalLocation.Editor) {
-            await this._terminalEditorService.revealActiveEditor();
-        }
-        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) {
-        if (source.target === TerminalLocation.Editor) {
-            return;
-        }
-        const sourceGroup = this._terminalGroupService.getGroupForInstance(source);
-        if (!sourceGroup) {
-            return;
-        }
-        sourceGroup.removeInstance(source);
-        this._terminalEditorService.openEditor(source);
-    }
-    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.onTitleChanged(this._onDidChangeInstanceTitle.fire, this._onDidChangeInstanceTitle),
-            instance.onIconChanged(this._onDidChangeInstanceIcon.fire, this._onDidChangeInstanceIcon),
-            instance.onIconChanged(this._onDidChangeInstanceColor.fire, this._onDidChangeInstanceColor),
-            instance.onProcessIdReady(this._onDidReceiveProcessId.fire, this._onDidReceiveProcessId),
-            instance.statusList.onDidChangePrimaryStatus(() => this._onDidChangeInstancePrimaryStatus.fire(instance)),
-            instance.onDimensionsChanged(() => {
-                this._onDidChangeInstanceDimensions.fire(instance);
-                if (this.configHelper.config.enablePersistentSessions && this.isProcessSupportRegistered) {
-                    this._saveState();
-                }
-            }),
-            instance.onMaximumDimensionsChanged(() => this._onDidMaxiumumDimensionsChange.fire(instance)),
-            instance.onDidInputData(this._onDidInputInstanceData.fire, this._onDidInputInstanceData),
-            instance.onDidFocus(this._onDidChangeActiveInstance.fire, this._onDidChangeActiveInstance),
-            instance.onRequestAddInstanceToGroup(async (e) => await this._addInstanceToGroup(instance, e)),
-            instance.onDidChangeSelection(this._onDidChangeSelection.fire, this._onDidChangeSelection)
-        ];
-        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 = ( nls.localize(
-                'terminalService.terminalCloseConfirmationSingular',
-                "Do you want to terminate the active terminal session?"
-            ));
-        }
-        else {
-            message = ( nls.localize(
-                '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: ( nls.localize({ 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 || {});
-        let contributedProfile = config && 'extensionIdentifier' in config ? config : undefined;
-        if (!contributedProfile && (!options || !options.config)) {
-            contributedProfile = await this._terminalProfileService.getContributedDefaultProfile(shellLaunchConfig);
-        }
-        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
-            });
-            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 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()), '', undefined, false);
-        if (options.readonly) {
-            xterm.raw.attachCustomKeyEventHandler(() => false);
-        }
-        this._detachedXterms.add(xterm);
-        const l = xterm.onDidDispose(() => {
-            this._detachedXterms.delete(xterm);
-            l.dispose();
-        });
-        return ( new DeatachedTerminal(xterm, options, this._instantiationService));
-    }
-    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(( nls.localize(
-                    '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(( nls.localize(
-                    '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();
-        this._onDidChangeGroups.fire();
-    }
-    async setContainers(panelContainer, terminalContainer) {
-        this._configHelper.panelContainer = panelContainer;
-        this._terminalGroupService.setContainer(terminalContainer);
-    }
-    getEditingTerminal() {
-        return this._editingTerminal;
-    }
-    setEditingTerminal(instance) {
-        this._editingTerminal = instance;
-    }
-    onInstanceEvent(getEvent) {
-        return ( new DynamicListEventMultiplexer(
-            this.instances,
-            this.onDidCreateInstance,
-            this.onDidDisposeInstance,
-            getEvent
-        ));
-    }
-    onInstanceCapabilityEvent(capabilityId, getEvent) {
-        return createInstanceCapabilityEventMultiplexer(this.instances, this.onDidCreateInstance, this.onDidDisposeInstance, capabilityId, getEvent);
-    }
-};
-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 = document.createElement('style');
-        container.appendChild(this._styleElement);
-        this._register(toDisposable(() => container.removeChild(this._styleElement)));
-        this.updateStyles();
-    }
-    _registerListeners() {
-        this._register(this._terminalService.onDidChangeInstanceIcon(() => this.updateStyles()));
-        this._register(this._terminalService.onDidChangeInstanceColor(() => 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` +
-                    `{background-image: ${dom.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: ${dom.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 };