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

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

@@ -0,0 +1,22 @@
+import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
+import { ITerminalGroupService } from './terminal.js';
+function setupTerminalCommands() {
+    registerOpenTerminalAtIndexCommands();
+}
+function registerOpenTerminalAtIndexCommands() {
+    for (let i = 0; i < 9; i++) {
+        const terminalIndex = i;
+        const visibleIndex = i + 1;
+        KeybindingsRegistry.registerCommandAndKeybindingRule({
+            id: `workbench.action.terminal.focusAtIndex${visibleIndex}`,
+            weight: 200 ,
+            when: undefined,
+            primary: 0,
+            handler: accessor => {
+                accessor.get(ITerminalGroupService).setActiveInstanceByIndex(terminalIndex);
+                return accessor.get(ITerminalGroupService).showPanel(true);
+            }
+        });
+    }
+}
+export { setupTerminalCommands };

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

@@ -0,0 +1,213 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { EDITOR_FONT_DEFAULTS } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { TERMINAL_CONFIG_SECTION, DEFAULT_FONT_WEIGHT, DEFAULT_BOLD_FONT_WEIGHT, MINIMUM_FONT_WEIGHT, MAXIMUM_FONT_WEIGHT, MINIMUM_LETTER_SPACING, DEFAULT_LETTER_SPACING, DEFAULT_LINE_HEIGHT } from '../common/terminal.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { NeverShowAgainScope, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { basename } from 'monaco-editor/esm/vs/base/common/path.js';
+import { IExtensionManagementService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { InstallRecommendedExtensionAction } from '../../extensions/browser/extensionsActions.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { isLinux, isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
+let TerminalConfigHelper = class TerminalConfigHelper {
+    get onConfigChanged() { return this._onConfigChanged.event; }
+    constructor(_configurationService, _extensionManagementService, _notificationService, _instantiationService, _productService) {
+        this._configurationService = _configurationService;
+        this._extensionManagementService = _extensionManagementService;
+        this._notificationService = _notificationService;
+        this._instantiationService = _instantiationService;
+        this._productService = _productService;
+        this._linuxDistro = 1 ;
+        this._onConfigChanged = ( new Emitter());
+        this._recommendationsShown = false;
+        this._updateConfig();
+        this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(TERMINAL_CONFIG_SECTION)) {
+                this._updateConfig();
+            }
+        });
+        if (isLinux) {
+            if (navigator.userAgent.includes('Ubuntu')) {
+                this._linuxDistro = 3 ;
+            }
+            else if (navigator.userAgent.includes('Fedora')) {
+                this._linuxDistro = 2 ;
+            }
+        }
+    }
+    _updateConfig() {
+        const configValues = this._configurationService.getValue(TERMINAL_CONFIG_SECTION);
+        configValues.fontWeight = this._normalizeFontWeight(configValues.fontWeight, DEFAULT_FONT_WEIGHT);
+        configValues.fontWeightBold = this._normalizeFontWeight(configValues.fontWeightBold, DEFAULT_BOLD_FONT_WEIGHT);
+        this.config = configValues;
+        this._onConfigChanged.fire();
+    }
+    configFontIsMonospace() {
+        const fontSize = 15;
+        const fontFamily = this.config.fontFamily || this._configurationService.getValue('editor').fontFamily || EDITOR_FONT_DEFAULTS.fontFamily;
+        const iRect = this._getBoundingRectFor('i', fontFamily, fontSize);
+        const wRect = this._getBoundingRectFor('w', fontFamily, fontSize);
+        if (!iRect || !wRect || !iRect.width || !wRect.width) {
+            return true;
+        }
+        return iRect.width === wRect.width;
+    }
+    _createCharMeasureElementIfNecessary() {
+        if (!this.panelContainer) {
+            throw new Error('Cannot measure element when terminal is not attached');
+        }
+        if (!this._charMeasureElement || !this._charMeasureElement.parentElement) {
+            this._charMeasureElement = document.createElement('div');
+            this.panelContainer.appendChild(this._charMeasureElement);
+        }
+        return this._charMeasureElement;
+    }
+    _getBoundingRectFor(char, fontFamily, fontSize) {
+        let charMeasureElement;
+        try {
+            charMeasureElement = this._createCharMeasureElementIfNecessary();
+        }
+        catch {
+            return undefined;
+        }
+        const style = charMeasureElement.style;
+        style.display = 'inline-block';
+        style.fontFamily = fontFamily;
+        style.fontSize = fontSize + 'px';
+        style.lineHeight = 'normal';
+        charMeasureElement.innerText = char;
+        const rect = charMeasureElement.getBoundingClientRect();
+        style.display = 'none';
+        return rect;
+    }
+    _measureFont(fontFamily, fontSize, letterSpacing, lineHeight) {
+        const rect = this._getBoundingRectFor('X', fontFamily, fontSize);
+        if (this._lastFontMeasurement && (!rect || !rect.width || !rect.height)) {
+            return this._lastFontMeasurement;
+        }
+        this._lastFontMeasurement = {
+            fontFamily,
+            fontSize,
+            letterSpacing,
+            lineHeight,
+            charWidth: 0,
+            charHeight: 0
+        };
+        if (rect && rect.width && rect.height) {
+            this._lastFontMeasurement.charHeight = Math.ceil(rect.height);
+            if (this.config.gpuAcceleration === 'off') {
+                this._lastFontMeasurement.charWidth = rect.width;
+            }
+            else {
+                const deviceCharWidth = Math.floor(rect.width * window.devicePixelRatio);
+                const deviceCellWidth = deviceCharWidth + Math.round(letterSpacing);
+                const cssCellWidth = deviceCellWidth / window.devicePixelRatio;
+                this._lastFontMeasurement.charWidth = cssCellWidth - Math.round(letterSpacing) / window.devicePixelRatio;
+            }
+        }
+        return this._lastFontMeasurement;
+    }
+    getFont(xtermCore, excludeDimensions) {
+        const editorConfig = this._configurationService.getValue('editor');
+        let fontFamily = this.config.fontFamily || editorConfig.fontFamily || EDITOR_FONT_DEFAULTS.fontFamily;
+        let fontSize = this._clampInt(this.config.fontSize, 6 , 100 , EDITOR_FONT_DEFAULTS.fontSize);
+        if (!this.config.fontFamily) {
+            if (this._linuxDistro === 2 ) {
+                fontFamily = '\'DejaVu Sans Mono\'';
+            }
+            if (this._linuxDistro === 3 ) {
+                fontFamily = '\'Ubuntu Mono\'';
+                fontSize = this._clampInt(fontSize + 2, 6 , 100 , EDITOR_FONT_DEFAULTS.fontSize);
+            }
+        }
+        fontFamily += ', monospace';
+        const letterSpacing = this.config.letterSpacing ? Math.max(Math.floor(this.config.letterSpacing), MINIMUM_LETTER_SPACING) : DEFAULT_LETTER_SPACING;
+        const lineHeight = this.config.lineHeight ? Math.max(this.config.lineHeight, 1) : DEFAULT_LINE_HEIGHT;
+        if (excludeDimensions) {
+            return {
+                fontFamily,
+                fontSize,
+                letterSpacing,
+                lineHeight
+            };
+        }
+        if (xtermCore) {
+            if (xtermCore._renderService && xtermCore._renderService.dimensions?.css.cell.width && xtermCore._renderService.dimensions?.css.cell.height) {
+                return {
+                    fontFamily,
+                    fontSize,
+                    letterSpacing,
+                    lineHeight,
+                    charHeight: xtermCore._renderService.dimensions.css.cell.height / lineHeight,
+                    charWidth: xtermCore._renderService.dimensions.css.cell.width - Math.round(letterSpacing) / window.devicePixelRatio
+                };
+            }
+        }
+        return this._measureFont(fontFamily, fontSize, letterSpacing, lineHeight);
+    }
+    _clampInt(source, minimum, maximum, fallback) {
+        let r = parseInt(source, 10);
+        if (isNaN(r)) {
+            return fallback;
+        }
+        if (typeof minimum === 'number') {
+            r = Math.max(minimum, r);
+        }
+        if (typeof maximum === 'number') {
+            r = Math.min(maximum, r);
+        }
+        return r;
+    }
+    async showRecommendations(shellLaunchConfig) {
+        if (this._recommendationsShown) {
+            return;
+        }
+        this._recommendationsShown = true;
+        if (isWindows && shellLaunchConfig.executable && basename(shellLaunchConfig.executable).toLowerCase() === 'wsl.exe') {
+            const exeBasedExtensionTips = this._productService.exeBasedExtensionTips;
+            if (!exeBasedExtensionTips || !exeBasedExtensionTips.wsl) {
+                return;
+            }
+            const extId = ( Object.keys(exeBasedExtensionTips.wsl.recommendations)).find(extId => exeBasedExtensionTips.wsl.recommendations[extId].important);
+            if (extId && !(await this._isExtensionInstalled(extId))) {
+                this._notificationService.prompt(Severity.Info, ( nls.localize(
+                    'useWslExtension.title',
+                    "The '{0}' extension is recommended for opening a terminal in WSL.",
+                    exeBasedExtensionTips.wsl.friendlyName
+                )), [
+                    {
+                        label: ( nls.localize('install', 'Install')),
+                        run: () => {
+                            this._instantiationService.createInstance(InstallRecommendedExtensionAction, extId).run();
+                        }
+                    }
+                ], {
+                    sticky: true,
+                    neverShowAgain: { id: 'terminalConfigHelper/launchRecommendationsIgnore', scope: NeverShowAgainScope.APPLICATION },
+                    onCancel: () => { }
+                });
+            }
+        }
+    }
+    async _isExtensionInstalled(id) {
+        const extensions = await this._extensionManagementService.getInstalled();
+        return ( extensions.some(e => e.identifier.id === id));
+    }
+    _normalizeFontWeight(input, defaultWeight) {
+        if (input === 'normal' || input === 'bold') {
+            return input;
+        }
+        return this._clampInt(input, MINIMUM_FONT_WEIGHT, MAXIMUM_FONT_WEIGHT, defaultWeight);
+    }
+};
+TerminalConfigHelper = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IExtensionManagementService)),
+    ( __param(2, INotificationService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IProductService))
+], TerminalConfigHelper));
+export { TerminalConfigHelper };

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

@@ -0,0 +1,17 @@
+import { StandardMouseEvent } from 'monaco-editor/esm/vs/base/browser/mouseEvent.js';
+import { createAndFillInContextMenuActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+function openContextMenu(event, parent, menu, contextMenuService, extraActions) {
+    const standardEvent = ( new StandardMouseEvent(event));
+    const anchor = { x: standardEvent.posx, y: standardEvent.posy };
+    const actions = [];
+    createAndFillInContextMenuActions(menu, undefined, actions);
+    if (extraActions) {
+        actions.push(...extraActions);
+    }
+    contextMenuService.showContextMenu({
+        getAnchor: () => anchor,
+        getActions: () => actions,
+        getActionsContext: () => parent,
+    });
+}
+export { openContextMenu };

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

@@ -0,0 +1,186 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { DropdownWithPrimaryActionViewItem } from '../../../../platform/actions/browser/dropdownWithPrimaryActionViewItem.js';
+import { MenuId, MenuItemAction, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { EditorPane } from '../../../browser/parts/editor/editorPane.js';
+import { terminalEditorId, ITerminalEditorService, ITerminalService } from './terminal.js';
+import { getTerminalActionBarArgs } from './terminalMenus.js';
+import { ITerminalProfileResolverService, ITerminalProfileService } from '../common/terminal.js';
+import { isLinux, isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { BrowserFeatures } from 'monaco-editor/esm/vs/base/browser/canIUse.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { openContextMenu } from './terminalContextMenu.js';
+import { ACTIVE_GROUP } from '../../../services/editor/common/editorService.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+let TerminalEditor = class TerminalEditor extends EditorPane {
+    constructor(telemetryService, themeService, storageService, _terminalEditorService, _terminalProfileResolverService, _terminalService, contextKeyService, menuService, _instantiationService, _contextMenuService, _notificationService, _terminalProfileService, _workbenchLayoutService) {
+        super(terminalEditorId, telemetryService, themeService, storageService);
+        this._terminalEditorService = _terminalEditorService;
+        this._terminalProfileResolverService = _terminalProfileResolverService;
+        this._terminalService = _terminalService;
+        this._instantiationService = _instantiationService;
+        this._contextMenuService = _contextMenuService;
+        this._notificationService = _notificationService;
+        this._terminalProfileService = _terminalProfileService;
+        this._workbenchLayoutService = _workbenchLayoutService;
+        this._editorInput = undefined;
+        this._cancelContextMenu = false;
+        this._dropdownMenu = this._register(menuService.createMenu(MenuId.TerminalNewDropdownContext, contextKeyService));
+        this._instanceMenu = this._register(menuService.createMenu(MenuId.TerminalEditorInstanceContext, contextKeyService));
+    }
+    async setInput(newInput, options, context, token) {
+        this._editorInput?.terminalInstance?.detachFromElement();
+        this._editorInput = newInput;
+        await super.setInput(newInput, options, context, token);
+        this._editorInput.terminalInstance?.attachToElement(this._overflowGuardElement);
+        if (this._lastDimension) {
+            this.layout(this._lastDimension);
+        }
+        this._editorInput.terminalInstance?.setVisible(this.isVisible() && this._workbenchLayoutService.isVisible("workbench.parts.editor" ));
+        if (this._editorInput.terminalInstance) {
+            this._register(this._editorInput.terminalInstance.onDidFocus(() => this._setActiveInstance()));
+            this._editorInput.setCopyLaunchConfig(this._editorInput.terminalInstance.shellLaunchConfig);
+        }
+    }
+    clearInput() {
+        super.clearInput();
+        this._editorInput?.terminalInstance?.detachFromElement();
+        this._editorInput = undefined;
+    }
+    _setActiveInstance() {
+        if (!this._editorInput?.terminalInstance) {
+            return;
+        }
+        this._terminalEditorService.setActiveInstance(this._editorInput.terminalInstance);
+    }
+    focus() {
+        this._editorInput?.terminalInstance?.focus();
+    }
+    createEditor(parent) {
+        this._editorInstanceElement = parent;
+        this._overflowGuardElement = dom.$('.terminal-overflow-guard');
+        this._editorInstanceElement.appendChild(this._overflowGuardElement);
+        this._registerListeners();
+    }
+    _registerListeners() {
+        if (!this._editorInstanceElement) {
+            return;
+        }
+        this._register(dom.addDisposableListener(this._editorInstanceElement, 'mousedown', async (event) => {
+            if (this._terminalEditorService.instances.length === 0) {
+                return;
+            }
+            if (event.which === 2 && isLinux) {
+                const terminal = this._terminalEditorService.activeInstance;
+                terminal?.focus();
+            }
+            else if (event.which === 3) {
+                const rightClickBehavior = this._terminalService.configHelper.config.rightClickBehavior;
+                if (rightClickBehavior === 'nothing') {
+                    if (!event.shiftKey) {
+                        this._cancelContextMenu = true;
+                    }
+                    return;
+                }
+                else if (rightClickBehavior === 'copyPaste' || rightClickBehavior === 'paste') {
+                    const terminal = this._terminalEditorService.activeInstance;
+                    if (!terminal) {
+                        return;
+                    }
+                    if (rightClickBehavior === 'copyPaste' && event.shiftKey) {
+                        openContextMenu(event, this._editorInstanceElement, this._instanceMenu, this._contextMenuService);
+                        return;
+                    }
+                    if (rightClickBehavior === 'copyPaste' && terminal.hasSelection()) {
+                        await terminal.copySelection();
+                        terminal.clearSelection();
+                    }
+                    else {
+                        if (BrowserFeatures.clipboard.readText) {
+                            terminal.paste();
+                        }
+                        else {
+                            this._notificationService.info(`This browser doesn't support the clipboard.readText API needed to trigger a paste, try ${isMacintosh ? '⌘' : 'Ctrl'}+V instead.`);
+                        }
+                    }
+                    if (isMacintosh) {
+                        setTimeout(() => {
+                            terminal.clearSelection();
+                        }, 0);
+                    }
+                    this._cancelContextMenu = true;
+                }
+            }
+        }));
+        this._register(dom.addDisposableListener(this._editorInstanceElement, 'contextmenu', (event) => {
+            const rightClickBehavior = this._terminalService.configHelper.config.rightClickBehavior;
+            if (rightClickBehavior === 'nothing' && !event.shiftKey) {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                this._cancelContextMenu = false;
+                return;
+            }
+            else if (!this._cancelContextMenu && rightClickBehavior !== 'copyPaste' && rightClickBehavior !== 'paste') {
+                if (!this._cancelContextMenu) {
+                    openContextMenu(event, this._editorInstanceElement, this._instanceMenu, this._contextMenuService);
+                }
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                this._cancelContextMenu = false;
+            }
+        }));
+    }
+    layout(dimension) {
+        this._editorInput?.terminalInstance?.layout(dimension);
+        this._lastDimension = dimension;
+    }
+    setVisible(visible, group) {
+        super.setVisible(visible, group);
+        this._editorInput?.terminalInstance?.setVisible(visible && this._workbenchLayoutService.isVisible("workbench.parts.editor" ));
+    }
+    getActionViewItem(action) {
+        switch (action.id) {
+            case "workbench.action.createTerminalEditor" : {
+                if (action instanceof MenuItemAction) {
+                    const location = { viewColumn: ACTIVE_GROUP };
+                    const actions = getTerminalActionBarArgs(location, this._terminalProfileService.availableProfiles, this._getDefaultProfileName(), this._terminalProfileService.contributedProfiles, this._terminalService, this._dropdownMenu);
+                    const button = this._instantiationService.createInstance(DropdownWithPrimaryActionViewItem, action, actions.dropdownAction, actions.dropdownMenuActions, actions.className, this._contextMenuService, {});
+                    return button;
+                }
+            }
+        }
+        return super.getActionViewItem(action);
+    }
+    _getDefaultProfileName() {
+        let defaultProfileName;
+        try {
+            defaultProfileName = this._terminalProfileService.getDefaultProfileName();
+        }
+        catch (e) {
+            defaultProfileName = this._terminalProfileResolverService.defaultProfileName;
+        }
+        return defaultProfileName;
+    }
+};
+TerminalEditor = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, IThemeService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, ITerminalEditorService)),
+    ( __param(4, ITerminalProfileResolverService)),
+    ( __param(5, ITerminalService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IMenuService)),
+    ( __param(8, IInstantiationService)),
+    ( __param(9, IContextMenuService)),
+    ( __param(10, INotificationService)),
+    ( __param(11, ITerminalProfileService)),
+    ( __param(12, IWorkbenchLayoutService))
+], TerminalEditor));
+export { TerminalEditor };

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

@@ -0,0 +1,199 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { toDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { EditorInput } from '../../../common/editor/editorInput.js';
+import { terminalEditorId, ITerminalInstanceService } from './terminal.js';
+import { getColorClass, getUriClasses } from './terminalIcon.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { TerminalLocation, TerminalExitReason } from '../../../../platform/terminal/common/terminal.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { TerminalContextKeys } from '../common/terminalContextKey.js';
+import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+let TerminalEditorInput = class TerminalEditorInput extends EditorInput {
+    setGroup(group) {
+        this._group = group;
+    }
+    get group() {
+        return this._group;
+    }
+    get typeId() {
+        return TerminalEditorInput.ID;
+    }
+    get editorId() {
+        return terminalEditorId;
+    }
+    get capabilities() {
+        return 2  | 8  | 128 ;
+    }
+    setTerminalInstance(instance) {
+        if (this._terminalInstance) {
+            throw new Error('cannot set instance that has already been set');
+        }
+        this._terminalInstance = instance;
+        this._setupInstanceListeners();
+    }
+    copy() {
+        const instance = this._terminalInstanceService.createInstance(this._copyLaunchConfig || {}, TerminalLocation.Editor);
+        instance.focusWhenReady();
+        this._copyLaunchConfig = undefined;
+        return this._instantiationService.createInstance(TerminalEditorInput, instance.resource, instance);
+    }
+    setCopyLaunchConfig(launchConfig) {
+        this._copyLaunchConfig = launchConfig;
+    }
+    get terminalInstance() {
+        return this._isDetached ? undefined : this._terminalInstance;
+    }
+    showConfirm() {
+        if (this._isReverted) {
+            return false;
+        }
+        const confirmOnKill = this._configurationService.getValue("terminal.integrated.confirmOnKill" );
+        if (confirmOnKill === 'editor' || confirmOnKill === 'always') {
+            return this._terminalInstance?.hasChildProcesses || false;
+        }
+        return false;
+    }
+    async confirm(terminals) {
+        const { confirmed } = await this._dialogService.confirm({
+            type: Severity.Warning,
+            message: ( localize(
+                'confirmDirtyTerminal.message',
+                "Do you want to terminate running processes?"
+            )),
+            primaryButton: ( localize(
+                { key: 'confirmDirtyTerminal.button', comment: ['&& denotes a mnemonic'] },
+                "&&Terminate"
+            )),
+            detail: terminals.length > 1 ?
+                ( terminals.map(terminal => terminal.editor.getName())).join('\n') + '\n\n' + ( localize(
+                    'confirmDirtyTerminals.detail',
+                    "Closing will terminate the running processes in the terminals."
+                )) :
+                ( localize(
+                    'confirmDirtyTerminal.detail',
+                    "Closing will terminate the running processes in this terminal."
+                ))
+        });
+        return confirmed ? 1  : 2 ;
+    }
+    async revert() {
+        this._isReverted = true;
+    }
+    constructor(resource, _terminalInstance, _themeService, _terminalInstanceService, _instantiationService, _configurationService, _lifecycleService, _contextKeyService, _dialogService) {
+        super();
+        this.resource = resource;
+        this._terminalInstance = _terminalInstance;
+        this._themeService = _themeService;
+        this._terminalInstanceService = _terminalInstanceService;
+        this._instantiationService = _instantiationService;
+        this._configurationService = _configurationService;
+        this._lifecycleService = _lifecycleService;
+        this._dialogService = _dialogService;
+        this.closeHandler = this;
+        this._isDetached = false;
+        this._isShuttingDown = false;
+        this._isReverted = false;
+        this._onDidRequestAttach = this._register(( new Emitter()));
+        this.onDidRequestAttach = this._onDidRequestAttach.event;
+        this._terminalEditorFocusContextKey = TerminalContextKeys.editorFocus.bindTo(_contextKeyService);
+        if (_terminalInstance) {
+            this._setupInstanceListeners();
+        }
+    }
+    _setupInstanceListeners() {
+        const instance = this._terminalInstance;
+        if (!instance) {
+            return;
+        }
+        const instanceOnDidFocusListener = instance.onDidFocus(() => this._terminalEditorFocusContextKey.set(true));
+        const instanceOnDidBlurListener = instance.onDidBlur(() => this._terminalEditorFocusContextKey.reset());
+        this._register(toDisposable(() => {
+            if (!this._isDetached && !this._isShuttingDown) {
+                instance.dispose(TerminalExitReason.User);
+            }
+            dispose([instanceOnDidFocusListener, instanceOnDidBlurListener]);
+        }));
+        const disposeListeners = [
+            instance.onExit((e) => {
+                if (!instance.waitOnExit) {
+                    this.dispose();
+                }
+            }),
+            instance.onDisposed(() => this.dispose()),
+            instance.onTitleChanged(() => this._onDidChangeLabel.fire()),
+            instance.onIconChanged(() => this._onDidChangeLabel.fire()),
+            instanceOnDidFocusListener,
+            instanceOnDidBlurListener,
+            instance.statusList.onDidChangePrimaryStatus(() => this._onDidChangeLabel.fire())
+        ];
+        this._lifecycleService.onWillShutdown((e) => {
+            this._isShuttingDown = true;
+            dispose(disposeListeners);
+            const shouldPersistTerminals = this._configurationService.getValue("terminal.integrated.enablePersistentSessions" ) && e.reason === 3 ;
+            if (shouldPersistTerminals) {
+                instance.detachProcessAndDispose(TerminalExitReason.Shutdown);
+            }
+            else {
+                instance.dispose(TerminalExitReason.Shutdown);
+            }
+        });
+    }
+    getName() {
+        return this._terminalInstance?.title || this.resource.fragment;
+    }
+    getLabelExtraClasses() {
+        if (!this._terminalInstance) {
+            return [];
+        }
+        const extraClasses = ['terminal-tab'];
+        const colorClass = getColorClass(this._terminalInstance);
+        if (colorClass) {
+            extraClasses.push(colorClass);
+        }
+        const uriClasses = getUriClasses(this._terminalInstance, this._themeService.getColorTheme().type);
+        if (uriClasses) {
+            extraClasses.push(...uriClasses);
+        }
+        if (ThemeIcon.isThemeIcon(this._terminalInstance.icon)) {
+            extraClasses.push(`codicon-${this._terminalInstance.icon.id}`);
+        }
+        return extraClasses;
+    }
+    detachInstance() {
+        if (!this._isShuttingDown) {
+            this._terminalInstance?.detachFromElement();
+            this._isDetached = true;
+        }
+    }
+    getDescription() {
+        return this._terminalInstance?.description;
+    }
+    toUntyped() {
+        return {
+            resource: this.resource,
+            options: {
+                override: terminalEditorId,
+                pinned: true,
+                forceReload: true
+            }
+        };
+    }
+};
+TerminalEditorInput.ID = 'workbench.editors.terminal';
+TerminalEditorInput = ( __decorate([
+    ( __param(2, IThemeService)),
+    ( __param(3, ITerminalInstanceService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, ILifecycleService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, IDialogService))
+], TerminalEditorInput));
+export { TerminalEditorInput };