@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

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

@@ -0,0 +1,72 @@
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { asArray } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+function getInstanceHoverInfo(instance) {
+    let statusString = '';
+    const statuses = instance.statusList.statuses;
+    const actions = [];
+    for (const status of statuses) {
+        statusString += `\n\n---\n\n${status.icon ? `$(${status.icon?.id}) ` : ''}${status.tooltip || status.id}`;
+        if (status.hoverActions) {
+            actions.push(...status.hoverActions);
+        }
+    }
+    const shellProcessString = getShellProcessTooltip(instance, true);
+    const shellIntegrationString = getShellIntegrationTooltip(instance, true);
+    const content = ( (new MarkdownString(
+        instance.title + shellProcessString + shellIntegrationString + statusString,
+        { supportThemeIcons: true }
+    )));
+    return { content, actions };
+}
+function getShellIntegrationTooltip(instance, markdown) {
+    const shellIntegrationCapabilities = [];
+    if (( (instance.capabilities.has(2 )))) {
+        shellIntegrationCapabilities.push(2 );
+    }
+    if (( (instance.capabilities.has(0 )))) {
+        shellIntegrationCapabilities.push(0 );
+    }
+    let shellIntegrationString = '';
+    if (shellIntegrationCapabilities.length > 0) {
+        shellIntegrationString += `${markdown ? '\n\n---\n\n' : '\n\n'}${( ( localize('shellIntegration.enabled', "Shell integration activated")))}`;
+    }
+    else {
+        if (instance.shellLaunchConfig.ignoreShellIntegration) {
+            shellIntegrationString += `${markdown ? '\n\n---\n\n' : '\n\n'}${( ( localize(
+                'launchFailed.exitCodeOnlyShellIntegration',
+                "The terminal process failed to launch. Disabling shell integration with terminal.integrated.shellIntegration.enabled might help."
+            )))}`;
+        }
+        else {
+            if (instance.usedShellIntegrationInjection) {
+                shellIntegrationString += `${markdown ? '\n\n---\n\n' : '\n\n'}${( ( localize(
+                    'shellIntegration.activationFailed',
+                    "Shell integration failed to activate"
+                )))}`;
+            }
+        }
+    }
+    return shellIntegrationString;
+}
+function getShellProcessTooltip(instance, markdown) {
+    const lines = [];
+    if (instance.processId) {
+        lines.push(( (localize(
+            { key: 'shellProcessTooltip.processId', comment: ['The first arg is "PID" which shouldn\'t be translated'] },
+            "Process ID ({0}): {1}",
+            'PID',
+            instance.processId
+        ))) + '\n');
+    }
+    if (instance.shellLaunchConfig.executable) {
+        let commandLine = instance.shellLaunchConfig.executable;
+        const args = ( (asArray(instance.injectedArgs || instance.shellLaunchConfig.args || []).map(x => `'${x}'`))).join(' ');
+        if (args) {
+            commandLine += ` ${args}`;
+        }
+        lines.push(( (localize('shellProcessTooltip.commandLine', 'Command line: {0}', commandLine))));
+    }
+    return lines.length ? `${markdown ? '\n\n---\n\n' : '\n\n'}${lines.join('\n')}` : '';
+}
+export { getInstanceHoverInfo, getShellIntegrationTooltip, getShellProcessTooltip };

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

@@ -0,0 +1,39 @@
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+function parseTerminalUri(resource) {
+    const [, workspaceId, instanceId] = resource.path.split('/');
+    if (!workspaceId || !Number.parseInt(instanceId)) {
+        throw new Error(`Could not parse terminal uri for resource ${resource}`);
+    }
+    return { workspaceId, instanceId: Number.parseInt(instanceId) };
+}
+function getTerminalUri(workspaceId, instanceId, title) {
+    return ( URI.from({
+        scheme: Schemas.vscodeTerminal,
+        path: `/${workspaceId}/${instanceId}`,
+        fragment: title || undefined,
+    }));
+}
+function getTerminalResourcesFromDragEvent(event) {
+    const resources = event.dataTransfer?.getData("Terminals" );
+    if (resources) {
+        const json = JSON.parse(resources);
+        const result = [];
+        for (const entry of json) {
+            result.push(( URI.parse(entry)));
+        }
+        return result.length === 0 ? undefined : result;
+    }
+    return undefined;
+}
+function getInstanceFromResource(instances, resource) {
+    if (resource) {
+        for (const instance of instances) {
+            if (instance.resource.path === resource.path) {
+                return instance;
+            }
+        }
+    }
+    return undefined;
+}
+export { getInstanceFromResource, getTerminalResourcesFromDragEvent, getTerminalUri, parseTerminalUri };

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

@@ -0,0 +1,535 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextMenuService, IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.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 { switchTerminalActionViewItemSeparator, switchTerminalShowTabsTitle } from './terminalActions.js';
+import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { ITerminalService, ITerminalGroupService } from './terminal.js';
+import { ViewPane } from '../../../browser/parts/views/viewPane.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { MenuId, MenuItemAction, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ITerminalProfileResolverService, ITerminalProfileService } from '../common/terminal.js';
+import { TerminalLocation } from '../../../../platform/terminal/common/terminal.js';
+import { ActionViewItem, SelectActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionViewItems.js';
+import { asCssVariable, selectBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { TerminalTabbedView } from './terminalTabbedView.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { renderLabelWithIcons } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabels.js';
+import { getColorForSeverity } from './terminalStatusList.js';
+import { createAndFillInContextMenuActions, MenuEntryActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { DropdownWithPrimaryActionViewItem } from '../../../../platform/actions/browser/dropdownWithPrimaryActionViewItem.js';
+import { toDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ColorScheme } from 'monaco-editor/esm/vs/platform/theme/common/theme.js';
+import { getColorClass, getUriClasses } from './terminalIcon.js';
+import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { getTerminalActionBarArgs } from './terminalMenus.js';
+import { TerminalContextKeys } from '../common/terminalContextKey.js';
+import { getShellProcessTooltip, getShellIntegrationTooltip } from './terminalTooltip.js';
+import { defaultSelectBoxStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+let TerminalViewPane = class TerminalViewPane extends ViewPane {
+    get terminalTabbedView() { return this._terminalTabbedView; }
+    constructor(options, keybindingService, _contextKeyService, viewDescriptorService, _configurationService, _contextMenuService, _instantiationService, _terminalService, _terminalGroupService, themeService, telemetryService, _notificationService, _keybindingService, openerService, _menuService, _terminalProfileService, _terminalProfileResolverService, _themeService) {
+        super(options, keybindingService, _contextMenuService, _configurationService, _contextKeyService, viewDescriptorService, _instantiationService, openerService, themeService, telemetryService);
+        this._contextKeyService = _contextKeyService;
+        this._configurationService = _configurationService;
+        this._contextMenuService = _contextMenuService;
+        this._instantiationService = _instantiationService;
+        this._terminalService = _terminalService;
+        this._terminalGroupService = _terminalGroupService;
+        this._notificationService = _notificationService;
+        this._keybindingService = _keybindingService;
+        this._menuService = _menuService;
+        this._terminalProfileService = _terminalProfileService;
+        this._terminalProfileResolverService = _terminalProfileResolverService;
+        this._themeService = _themeService;
+        this._isWelcomeShowing = false;
+        this._register(this._terminalService.onDidRegisterProcessSupport(() => {
+            this._onDidChangeViewWelcomeState.fire();
+        }));
+        this._register(this._terminalService.onDidChangeInstances(() => {
+            if (!this._isWelcomeShowing) {
+                return;
+            }
+            this._isWelcomeShowing = true;
+            this._onDidChangeViewWelcomeState.fire();
+            if (!this._terminalTabbedView && this._parentDomElement) {
+                this._createTabsView();
+                this.layoutBody(this._parentDomElement.offsetHeight, this._parentDomElement.offsetWidth);
+            }
+        }));
+        this._dropdownMenu = this._register(this._menuService.createMenu(MenuId.TerminalNewDropdownContext, this._contextKeyService));
+        this._singleTabMenu = this._register(this._menuService.createMenu(MenuId.TerminalInlineTabContext, this._contextKeyService));
+        this._register(this._terminalProfileService.onDidChangeAvailableProfiles(profiles => this._updateTabActionBar(profiles)));
+        this._viewShowing = TerminalContextKeys.viewShowing.bindTo(this._contextKeyService);
+        this._register(this.onDidChangeBodyVisibility(e => {
+            if (e) {
+                this._terminalTabbedView?.rerenderTabs();
+            }
+        }));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (this._parentDomElement && (e.affectsConfiguration("terminal.integrated.shellIntegration.decorationsEnabled" ) || e.affectsConfiguration("terminal.integrated.shellIntegration.enabled" ))) {
+                this._updateForShellIntegration(this._parentDomElement);
+            }
+        }));
+        this._register(this._terminalService.onDidCreateInstance((i) => {
+            i.capabilities.onDidAddCapability(c => {
+                if (c === 2  && this._gutterDecorationsEnabled()) {
+                    this._parentDomElement?.classList.add('shell-integration');
+                }
+            });
+        }));
+    }
+    _updateForShellIntegration(container) {
+        container.classList.toggle('shell-integration', this._gutterDecorationsEnabled());
+    }
+    _gutterDecorationsEnabled() {
+        const decorationsEnabled = this._configurationService.getValue("terminal.integrated.shellIntegration.decorationsEnabled" );
+        return (decorationsEnabled === 'both' || decorationsEnabled === 'gutter') && this._configurationService.getValue("terminal.integrated.shellIntegration.enabled" );
+    }
+    _initializeTerminal() {
+        if (this.isBodyVisible() && this._terminalService.isProcessSupportRegistered && this._terminalService.connectionState === 1  && !this._terminalGroupService.groups.length) {
+            this._terminalService.createTerminal({ location: TerminalLocation.Panel });
+        }
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        if (!this._parentDomElement) {
+            this._updateForShellIntegration(container);
+        }
+        this._parentDomElement = container;
+        this._parentDomElement.classList.add('integrated-terminal');
+        this._fontStyleElement = document.createElement('style');
+        this._instantiationService.createInstance(TerminalThemeIconStyle, this._parentDomElement);
+        if (!this.shouldShowWelcome()) {
+            this._createTabsView();
+        }
+        this._parentDomElement.appendChild(this._fontStyleElement);
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("terminal.integrated.fontFamily" ) || e.affectsConfiguration('editor.fontFamily')) {
+                const configHelper = this._terminalService.configHelper;
+                if (!configHelper.configFontIsMonospace()) {
+                    const choices = [{
+                            label: ( nls.localize('terminal.useMonospace', "Use 'monospace'")),
+                            run: () => this.configurationService.updateValue("terminal.integrated.fontFamily" , 'monospace'),
+                        }];
+                    this._notificationService.prompt(Severity.Warning, ( nls.localize(
+                        'terminal.monospaceOnly',
+                        "The terminal only supports monospace fonts. Be sure to restart VS Code if this is a newly installed font."
+                    )), choices);
+                }
+            }
+        }));
+        this._register(this.onDidChangeBodyVisibility(async (visible) => {
+            this._viewShowing.set(visible);
+            if (visible) {
+                if (!this._terminalService.isProcessSupportRegistered) {
+                    this._onDidChangeViewWelcomeState.fire();
+                }
+                this._initializeTerminal();
+                this._terminalGroupService.showPanel(false);
+            }
+            else {
+                for (const instance of this._terminalGroupService.instances) {
+                    instance.resetFocusContextKey();
+                }
+            }
+            this._terminalGroupService.updateVisibility();
+        }));
+        this._register(this._terminalService.onDidChangeConnectionState(() => this._initializeTerminal()));
+        this.layoutBody(this._parentDomElement.offsetHeight, this._parentDomElement.offsetWidth);
+    }
+    _createTabsView() {
+        if (!this._parentDomElement) {
+            return;
+        }
+        this._terminalTabbedView = this.instantiationService.createInstance(TerminalTabbedView, this._parentDomElement);
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this._terminalTabbedView?.layout(width, height);
+    }
+    getActionViewItem(action) {
+        switch (action.id) {
+            case "workbench.action.terminal.split" : {
+                const that = this;
+                const panelOnlySplitAction = new (class extends Action {
+                    constructor() {
+                        super(action.id, action.label, action.class, action.enabled);
+                        this.checked = action.checked;
+                        this.tooltip = action.tooltip;
+                    }
+                    dispose() {
+                        action.dispose();
+                    }
+                    async run() {
+                        const instance = that._terminalGroupService.activeInstance;
+                        if (instance) {
+                            const newInstance = await that._terminalService.createTerminal({ location: { parentTerminal: instance } });
+                            return newInstance?.focusWhenReady();
+                        }
+                        return;
+                    }
+                });
+                return ( new ActionViewItem(
+                    action,
+                    panelOnlySplitAction,
+                    { icon: true, label: false, keybinding: this._getKeybindingLabel(action) }
+                ));
+            }
+            case "workbench.action.terminal.switchTerminal" : {
+                return this._instantiationService.createInstance(SwitchTerminalActionViewItem, action);
+            }
+            case "workbench.action.terminal.focus" : {
+                if (action instanceof MenuItemAction) {
+                    const actions = [];
+                    createAndFillInContextMenuActions(this._singleTabMenu, undefined, actions);
+                    return this._instantiationService.createInstance(SingleTerminalTabActionViewItem, action, actions);
+                }
+            }
+            case "workbench.action.terminal.new" : {
+                if (action instanceof MenuItemAction) {
+                    const actions = getTerminalActionBarArgs(TerminalLocation.Panel, this._terminalProfileService.availableProfiles, this._getDefaultProfileName(), this._terminalProfileService.contributedProfiles, this._terminalService, this._dropdownMenu);
+                    this._newDropdown?.dispose();
+                    this._newDropdown = ( new DropdownWithPrimaryActionViewItem(
+                        action,
+                        actions.dropdownAction,
+                        actions.dropdownMenuActions,
+                        actions.className,
+                        this._contextMenuService,
+                        {},
+                        this._keybindingService,
+                        this._notificationService,
+                        this._contextKeyService,
+                        this._themeService
+                    ));
+                    this._updateTabActionBar(this._terminalProfileService.availableProfiles);
+                    return this._newDropdown;
+                }
+            }
+        }
+        return super.getActionViewItem(action);
+    }
+    _getDefaultProfileName() {
+        let defaultProfileName;
+        try {
+            defaultProfileName = this._terminalProfileService.getDefaultProfileName();
+        }
+        catch (e) {
+            defaultProfileName = this._terminalProfileResolverService.defaultProfileName;
+        }
+        return defaultProfileName;
+    }
+    _getKeybindingLabel(action) {
+        return withNullAsUndefined(this._keybindingService.lookupKeybinding(action.id)?.getLabel());
+    }
+    _updateTabActionBar(profiles) {
+        const actions = getTerminalActionBarArgs(TerminalLocation.Panel, profiles, this._getDefaultProfileName(), this._terminalProfileService.contributedProfiles, this._terminalService, this._dropdownMenu);
+        this._newDropdown?.update(actions.dropdownAction, actions.dropdownMenuActions);
+    }
+    focus() {
+        if (this._terminalService.connectionState === 0 ) {
+            const activeElement = document.activeElement;
+            this._register(this._terminalService.onDidChangeConnectionState(() => {
+                if (document.activeElement === activeElement) {
+                    this._terminalGroupService.showPanel(true);
+                }
+            }));
+            return;
+        }
+        this._terminalGroupService.showPanel(true);
+    }
+    shouldShowWelcome() {
+        this._isWelcomeShowing = !this._terminalService.isProcessSupportRegistered && this._terminalService.instances.length === 0;
+        return this._isWelcomeShowing;
+    }
+};
+TerminalViewPane = ( __decorate([
+    ( __param(1, IKeybindingService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IViewDescriptorService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IContextMenuService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, ITerminalService)),
+    ( __param(8, ITerminalGroupService)),
+    ( __param(9, IThemeService)),
+    ( __param(10, ITelemetryService)),
+    ( __param(11, INotificationService)),
+    ( __param(12, IKeybindingService)),
+    ( __param(13, IOpenerService)),
+    ( __param(14, IMenuService)),
+    ( __param(15, ITerminalProfileService)),
+    ( __param(16, ITerminalProfileResolverService)),
+    ( __param(17, IThemeService))
+], TerminalViewPane));
+let SwitchTerminalActionViewItem = class SwitchTerminalActionViewItem extends SelectActionViewItem {
+    constructor(action, _terminalService, _terminalGroupService, contextViewService, terminalProfileService) {
+        super(null, action, getTerminalSelectOpenItems(_terminalService, _terminalGroupService), _terminalGroupService.activeGroupIndex, contextViewService, defaultSelectBoxStyles, { ariaLabel: ( nls.localize('terminals', 'Open Terminals.')), optionsAsChildren: true });
+        this._terminalService = _terminalService;
+        this._terminalGroupService = _terminalGroupService;
+        this._register(_terminalService.onDidChangeInstances(() => this._updateItems(), this));
+        this._register(_terminalService.onDidChangeActiveGroup(() => this._updateItems(), this));
+        this._register(_terminalService.onDidChangeActiveInstance(() => this._updateItems(), this));
+        this._register(_terminalService.onDidChangeInstanceTitle(() => this._updateItems(), this));
+        this._register(_terminalGroupService.onDidChangeGroups(() => this._updateItems(), this));
+        this._register(_terminalService.onDidChangeConnectionState(() => this._updateItems(), this));
+        this._register(terminalProfileService.onDidChangeAvailableProfiles(() => this._updateItems(), this));
+        this._register(_terminalService.onDidChangeInstancePrimaryStatus(() => this._updateItems(), this));
+    }
+    render(container) {
+        super.render(container);
+        container.classList.add('switch-terminal');
+        container.style.borderColor = asCssVariable(selectBorder);
+    }
+    _updateItems() {
+        const options = getTerminalSelectOpenItems(this._terminalService, this._terminalGroupService);
+        this.setOptions(options, this._terminalGroupService.activeGroupIndex);
+    }
+};
+SwitchTerminalActionViewItem = ( __decorate([
+    ( __param(1, ITerminalService)),
+    ( __param(2, ITerminalGroupService)),
+    ( __param(3, IContextViewService)),
+    ( __param(4, ITerminalProfileService))
+], SwitchTerminalActionViewItem));
+function getTerminalSelectOpenItems(terminalService, terminalGroupService) {
+    let items;
+    if (terminalService.connectionState === 1 ) {
+        items = ( terminalGroupService.getGroupLabels().map(label => {
+            return { text: label };
+        }));
+    }
+    else {
+        items = [{ text: ( nls.localize('terminalConnectingLabel', "Starting...")) }];
+    }
+    items.push({ text: switchTerminalActionViewItemSeparator, isDisabled: true });
+    items.push({ text: switchTerminalShowTabsTitle });
+    return items;
+}
+let SingleTerminalTabActionViewItem = class SingleTerminalTabActionViewItem extends MenuEntryActionViewItem {
+    constructor(action, _actions, keybindingService, notificationService, contextKeyService, themeService, _terminalService, _terminalGroupService, contextMenuService, _commandService, _instantiationService) {
+        super(action, { draggable: true }, keybindingService, notificationService, contextKeyService, themeService, contextMenuService);
+        this._actions = _actions;
+        this._terminalService = _terminalService;
+        this._terminalGroupService = _terminalGroupService;
+        this._commandService = _commandService;
+        this._instantiationService = _instantiationService;
+        this._elementDisposables = [];
+        this._register(Event.debounce(Event.any(this._terminalService.onDidChangeInstancePrimaryStatus, this._terminalGroupService.onDidChangeActiveInstance, ( Event.map(this._terminalService.onDidChangeInstanceIcon, e => e.instance)), ( Event.map(this._terminalService.onDidChangeInstanceColor, e => e.instance)), this._terminalService.onDidChangeInstanceTitle, this._terminalService.onDidChangeInstanceCapability), (last, e) => {
+            if (!last) {
+                last = ( new Set());
+            }
+            if (e) {
+                last.add(e);
+            }
+            return last;
+        })(merged => {
+            for (const e of merged) {
+                this.updateLabel(e);
+            }
+        }));
+        this._register(toDisposable(() => dispose(this._elementDisposables)));
+    }
+    async onClick(event) {
+        if (event.altKey && this._menuItemAction.alt) {
+            this._commandService.executeCommand(this._menuItemAction.alt.id, { target: TerminalLocation.Panel });
+        }
+        else {
+            this._openContextMenu();
+        }
+    }
+    updateLabel(e) {
+        if (e && e !== this._terminalGroupService.activeInstance) {
+            return;
+        }
+        if (this._elementDisposables.length === 0 && this.element && this.label) {
+            this._elementDisposables.push(dom.addDisposableListener(this.element, dom.EventType.CONTEXT_MENU, e => {
+                if (e.button === 2) {
+                    this._openContextMenu();
+                    e.preventDefault();
+                }
+            }));
+            this._elementDisposables.push(dom.addDisposableListener(this.element, dom.EventType.AUXCLICK, e => {
+                if (e.button === 1) {
+                    const instance = this._terminalGroupService.activeInstance;
+                    if (instance) {
+                        this._terminalService.safeDisposeTerminal(instance);
+                    }
+                    e.preventDefault();
+                }
+            }));
+            this._elementDisposables.push(dom.addDisposableListener(this.element, dom.EventType.DRAG_START, e => {
+                const instance = this._terminalGroupService.activeInstance;
+                if (e.dataTransfer && instance) {
+                    e.dataTransfer.setData("Terminals" , JSON.stringify([( instance.resource.toString())]));
+                }
+            }));
+        }
+        if (this.label) {
+            const label = this.label;
+            const instance = this._terminalGroupService.activeInstance;
+            if (!instance) {
+                dom.reset(label, '');
+                return;
+            }
+            label.classList.add('single-terminal-tab');
+            let colorStyle = '';
+            const primaryStatus = instance.statusList.primary;
+            if (primaryStatus) {
+                const colorKey = getColorForSeverity(primaryStatus.severity);
+                this._themeService.getColorTheme();
+                const foundColor = this._themeService.getColorTheme().getColor(colorKey);
+                if (foundColor) {
+                    colorStyle = ( foundColor.toString());
+                }
+            }
+            label.style.color = colorStyle;
+            dom.reset(label, ...renderLabelWithIcons(this._instantiationService.invokeFunction(getSingleTabLabel, instance, this._terminalService.configHelper.config.tabs.separator, ThemeIcon.isThemeIcon(this._commandAction.item.icon) ? this._commandAction.item.icon : undefined)));
+            if (this._altCommand) {
+                label.classList.remove(this._altCommand);
+                this._altCommand = undefined;
+            }
+            if (this._color) {
+                label.classList.remove(this._color);
+                this._color = undefined;
+            }
+            if (this._class) {
+                label.classList.remove(this._class);
+                label.classList.remove('terminal-uri-icon');
+                this._class = undefined;
+            }
+            const colorClass = getColorClass(instance);
+            if (colorClass) {
+                this._color = colorClass;
+                label.classList.add(colorClass);
+            }
+            const uriClasses = getUriClasses(instance, this._themeService.getColorTheme().type);
+            if (uriClasses) {
+                this._class = uriClasses?.[0];
+                label.classList.add(...uriClasses);
+            }
+            if (this._commandAction.item.icon) {
+                this._altCommand = `alt-command`;
+                label.classList.add(this._altCommand);
+            }
+            this._action.tooltip = getSingleTabTooltip(instance, this._terminalService.configHelper.config.tabs.separator);
+            this.updateTooltip();
+        }
+    }
+    _openContextMenu() {
+        this._contextMenuService.showContextMenu({
+            getAnchor: () => this.element,
+            getActions: () => this._actions,
+            getActionsContext: () => this.label
+        });
+    }
+};
+SingleTerminalTabActionViewItem = ( __decorate([
+    ( __param(2, IKeybindingService)),
+    ( __param(3, INotificationService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IThemeService)),
+    ( __param(6, ITerminalService)),
+    ( __param(7, ITerminalGroupService)),
+    ( __param(8, IContextMenuService)),
+    ( __param(9, ICommandService)),
+    ( __param(10, IInstantiationService))
+], SingleTerminalTabActionViewItem));
+function getSingleTabLabel(accessor, instance, separator, icon) {
+    if (!instance || !instance.title) {
+        return '';
+    }
+    const iconClass = ThemeIcon.isThemeIcon(instance.icon) ? instance.icon.id : accessor.get(ITerminalProfileResolverService).getDefaultIcon();
+    const label = `$(${icon?.id || iconClass}) ${getSingleTabTitle(instance, separator)}`;
+    const primaryStatus = instance.statusList.primary;
+    if (!primaryStatus?.icon) {
+        return label;
+    }
+    return `${label} $(${primaryStatus.icon.id})`;
+}
+function getSingleTabTooltip(instance, separator) {
+    if (!instance) {
+        return '';
+    }
+    const parts = [];
+    parts.push(getSingleTabTitle(instance, separator) + getShellProcessTooltip(instance, false) + getShellIntegrationTooltip(instance, false));
+    parts.push(instance.statusList.primary?.tooltip || '');
+    return parts.filter(e => e).join('\n\n');
+}
+function getSingleTabTitle(instance, separator) {
+    if (!instance) {
+        return '';
+    }
+    return !instance.description ? instance.title : `${instance.title} ${separator} ${instance.description}`;
+}
+let TerminalThemeIconStyle = class TerminalThemeIconStyle extends Themable {
+    constructor(container, _themeService, _terminalService, _terminalGroupService) {
+        super(_themeService);
+        this._themeService = _themeService;
+        this._terminalService = _terminalService;
+        this._terminalGroupService = _terminalGroupService;
+        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.onDidChangeInstances(() => this.updateStyles()));
+        this._register(this._terminalGroupService.onDidChangeGroups(() => this.updateStyles()));
+    }
+    updateStyles() {
+        super.updateStyles();
+        const colorTheme = this._themeService.getColorTheme();
+        let css = '';
+        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 .${iconClasses[0]} .monaco-highlighted-label .codicon, .monaco-action-bar .terminal-uri-icon.single-terminal-tab.action-label:not(.alt-command) .codicon` +
+                    `{background-image: ${dom.asCSSUrl(uri)};}`);
+            }
+        }
+        for (const instance of this._terminalService.instances) {
+            const colorClass = getColorClass(instance);
+            if (!colorClass || !instance.color) {
+                continue;
+            }
+            const color = colorTheme.getColor(instance.color);
+            if (color) {
+                css += (`.monaco-workbench .${colorClass} .codicon:first-child:not(.codicon-split-horizontal):not(.codicon-trashcan):not(.file-icon)` +
+                    `{ color: ${color} !important; }`);
+            }
+        }
+        this._styleElement.textContent = css;
+    }
+};
+TerminalThemeIconStyle = ( __decorate([
+    ( __param(1, IThemeService)),
+    ( __param(2, ITerminalService)),
+    ( __param(3, ITerminalGroupService))
+], TerminalThemeIconStyle));
+export { TerminalViewPane };