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

package/dist/vscode/vs/workbench/contrib/terminal/browser/widgets/widgetManager.js

@@ -0,0 +1,36 @@
+class TerminalWidgetManager {
+    constructor() {
+        this._attached = ( new Map());
+    }
+    attachToElement(terminalWrapper) {
+        if (!this._container) {
+            this._container = document.createElement('div');
+            this._container.classList.add('terminal-widget-container');
+            terminalWrapper.appendChild(this._container);
+        }
+    }
+    dispose() {
+        if (this._container && this._container.parentElement) {
+            this._container.parentElement.removeChild(this._container);
+            this._container = undefined;
+        }
+    }
+    attachWidget(widget) {
+        if (!this._container) {
+            return;
+        }
+        this._attached.get(widget.id)?.dispose();
+        widget.attach(this._container);
+        this._attached.set(widget.id, widget);
+        return {
+            dispose: () => {
+                const current = this._attached.get(widget.id);
+                if (current === widget) {
+                    this._attached.delete(widget.id);
+                    widget.dispose();
+                }
+            }
+        };
+    }
+}
+export { TerminalWidgetManager };

package/dist/vscode/vs/workbench/contrib/terminal/browser/xterm/decorationAddon.js

@@ -0,0 +1,469 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Separator } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, toDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.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 { terminalDecorationMark, terminalDecorationIncomplete, terminalDecorationError, terminalDecorationSuccess } from '../terminalIcons.js';
+import { TerminalDecorationHoverManager, updateLayout } from './decorationStyles.js';
+import { TERMINAL_COMMAND_DECORATION_DEFAULT_BACKGROUND_COLOR, TERMINAL_COMMAND_DECORATION_ERROR_BACKGROUND_COLOR, TERMINAL_COMMAND_DECORATION_SUCCESS_BACKGROUND_COLOR } from '../../common/terminalColorRegistry.js';
+import { ILifecycleService } from '../../../../services/lifecycle/common/lifecycle.js';
+import { AudioCue, IAudioCueService } from 'monaco-editor/esm/vs/platform/audioCues/browser/audioCueService.js';
+import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+let DecorationAddon = class DecorationAddon extends Disposable {
+    constructor(_capabilities, _clipboardService, _contextMenuService, _configurationService, _themeService, _openerService, _quickInputService, lifecycleService, _commandService, instantiationService, _audioCueService, _notificationService) {
+        super();
+        this._capabilities = _capabilities;
+        this._clipboardService = _clipboardService;
+        this._contextMenuService = _contextMenuService;
+        this._configurationService = _configurationService;
+        this._themeService = _themeService;
+        this._openerService = _openerService;
+        this._quickInputService = _quickInputService;
+        this._commandService = _commandService;
+        this._audioCueService = _audioCueService;
+        this._notificationService = _notificationService;
+        this._capabilityDisposables = ( new Map());
+        this._decorations = ( new Map());
+        this._onDidRequestRunCommand = this._register(( new Emitter()));
+        this.onDidRequestRunCommand = this._onDidRequestRunCommand.event;
+        this._register(toDisposable(() => this._dispose()));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("terminal.integrated.fontSize" ) || e.affectsConfiguration("terminal.integrated.lineHeight" )) {
+                this.refreshLayouts();
+            }
+            else if (e.affectsConfiguration('workbench.colorCustomizations')) {
+                this._refreshStyles(true);
+            }
+            else if (e.affectsConfiguration("terminal.integrated.shellIntegration.decorationsEnabled" )) {
+                this._removeCapabilityDisposables(2 );
+                this._updateDecorationVisibility();
+            }
+        }));
+        this._register(this._themeService.onDidColorThemeChange(() => this._refreshStyles(true)));
+        this._updateDecorationVisibility();
+        this._register(this._capabilities.onDidAddCapability(c => this._createCapabilityDisposables(c)));
+        this._register(this._capabilities.onDidRemoveCapability(c => this._removeCapabilityDisposables(c)));
+        this._register(lifecycleService.onWillShutdown(() => this._disposeAllDecorations()));
+        this._terminalDecorationHoverService = instantiationService.createInstance(TerminalDecorationHoverManager);
+    }
+    _removeCapabilityDisposables(c) {
+        const disposables = this._capabilityDisposables.get(c);
+        if (disposables) {
+            dispose(disposables);
+        }
+        this._capabilityDisposables.delete(c);
+    }
+    _createCapabilityDisposables(c) {
+        let disposables = [];
+        const capability = this._capabilities.get(c);
+        if (!capability || ( this._capabilityDisposables.has(c))) {
+            return;
+        }
+        switch (capability.type) {
+            case 4 :
+                disposables = [capability.onMarkAdded(mark => this.registerMarkDecoration(mark))];
+                break;
+            case 2 :
+                disposables = this._getCommandDetectionListeners(capability);
+                break;
+        }
+        this._capabilityDisposables.set(c, disposables);
+    }
+    registerMarkDecoration(mark) {
+        if (!this._terminal || (!this._showGutterDecorations && !this._showOverviewRulerDecorations)) {
+            return undefined;
+        }
+        if (mark.hidden) {
+            return undefined;
+        }
+        return this.registerCommandDecoration(undefined, undefined, mark);
+    }
+    _updateDecorationVisibility() {
+        const showDecorations = this._configurationService.getValue("terminal.integrated.shellIntegration.decorationsEnabled" );
+        this._showGutterDecorations = (showDecorations === 'both' || showDecorations === 'gutter');
+        this._showOverviewRulerDecorations = (showDecorations === 'both' || showDecorations === 'overviewRuler');
+        this._disposeAllDecorations();
+        if (this._showGutterDecorations || this._showOverviewRulerDecorations) {
+            this._attachToCommandCapability();
+            this._updateGutterDecorationVisibility();
+        }
+        const currentCommand = this._capabilities.get(2 )?.executingCommandObject;
+        if (currentCommand) {
+            this.registerCommandDecoration(currentCommand, true);
+        }
+    }
+    _disposeAllDecorations() {
+        this._placeholderDecoration?.dispose();
+        for (const value of ( this._decorations.values())) {
+            value.decoration.dispose();
+            dispose(value.disposables);
+        }
+    }
+    _updateGutterDecorationVisibility() {
+        const commandDecorationElements = document.querySelectorAll("terminal-command-decoration" );
+        for (const commandDecorationElement of commandDecorationElements) {
+            this._updateCommandDecorationVisibility(commandDecorationElement);
+        }
+    }
+    _updateCommandDecorationVisibility(commandDecorationElement) {
+        if (this._showGutterDecorations) {
+            commandDecorationElement.classList.remove("hide" );
+        }
+        else {
+            commandDecorationElement.classList.add("hide" );
+        }
+    }
+    refreshLayouts() {
+        updateLayout(this._configurationService, this._placeholderDecoration?.element);
+        for (const decoration of this._decorations) {
+            updateLayout(this._configurationService, decoration[1].decoration.element);
+        }
+    }
+    _refreshStyles(refreshOverviewRulerColors) {
+        if (refreshOverviewRulerColors) {
+            for (const decoration of ( this._decorations.values())) {
+                const color = this._getDecorationCssColor(decoration)?.toString() ?? '';
+                if (decoration.decoration.options?.overviewRulerOptions) {
+                    decoration.decoration.options.overviewRulerOptions.color = color;
+                }
+                else if (decoration.decoration.options) {
+                    decoration.decoration.options.overviewRulerOptions = { color };
+                }
+            }
+        }
+        this._updateClasses(this._placeholderDecoration?.element);
+        for (const decoration of ( this._decorations.values())) {
+            this._updateClasses(decoration.decoration.element, decoration.exitCode, decoration.markProperties);
+        }
+    }
+    _dispose() {
+        this._terminalDecorationHoverService.dispose();
+        for (const disposable of ( this._capabilityDisposables.values())) {
+            dispose(disposable);
+        }
+        this.clearDecorations();
+    }
+    _clearPlaceholder() {
+        this._placeholderDecoration?.dispose();
+        this._placeholderDecoration = undefined;
+    }
+    clearDecorations() {
+        this._placeholderDecoration?.marker.dispose();
+        this._clearPlaceholder();
+        this._disposeAllDecorations();
+        this._decorations.clear();
+    }
+    _attachToCommandCapability() {
+        if (( this._capabilities.has(2 ))) {
+            this._getCommandDetectionListeners(this._capabilities.get(2 ));
+        }
+    }
+    _getCommandDetectionListeners(capability) {
+        if (( this._capabilityDisposables.has(2 ))) {
+            const disposables = this._capabilityDisposables.get(2 );
+            dispose(disposables);
+            this._capabilityDisposables.delete(capability.type);
+        }
+        const commandDetectionListeners = [];
+        if (capability.executingCommandObject?.marker) {
+            this.registerCommandDecoration(capability.executingCommandObject, true);
+        }
+        commandDetectionListeners.push(capability.onCommandStarted(command => this.registerCommandDecoration(command, true)));
+        for (const command of capability.commands) {
+            this.registerCommandDecoration(command);
+        }
+        commandDetectionListeners.push(capability.onCommandFinished(command => {
+            this.registerCommandDecoration(command);
+            if (command.exitCode) {
+                this._audioCueService.playAudioCue(AudioCue.terminalCommandFailed);
+            }
+        }));
+        commandDetectionListeners.push(capability.onCommandInvalidated(commands => {
+            for (const command of commands) {
+                const id = command.marker?.id;
+                if (id) {
+                    const match = this._decorations.get(id);
+                    if (match) {
+                        match.decoration.dispose();
+                        dispose(match.disposables);
+                    }
+                }
+            }
+        }));
+        commandDetectionListeners.push(capability.onCurrentCommandInvalidated((request) => {
+            if (request.reason === "noProblemsReported" ) {
+                const lastDecoration = Array.from(this._decorations.entries())[this._decorations.size - 1];
+                lastDecoration?.[1].decoration.dispose();
+            }
+            else if (request.reason === "windows" ) {
+                this._clearPlaceholder();
+            }
+        }));
+        return commandDetectionListeners;
+    }
+    activate(terminal) {
+        this._terminal = terminal;
+        this._attachToCommandCapability();
+    }
+    registerCommandDecoration(command, beforeCommandExecution, markProperties) {
+        if (!this._terminal || (beforeCommandExecution && !command) || (!this._showGutterDecorations && !this._showOverviewRulerDecorations)) {
+            return undefined;
+        }
+        const marker = command?.marker || markProperties?.marker;
+        if (!marker) {
+            throw new Error(`cannot add a decoration for a command ${JSON.stringify(command)} with no marker`);
+        }
+        this._clearPlaceholder();
+        const color = this._getDecorationCssColor(command)?.toString() ?? '';
+        const decoration = this._terminal.registerDecoration({
+            marker,
+            overviewRulerOptions: this._showOverviewRulerDecorations ? (beforeCommandExecution
+                ? { color, position: 'left' }
+                : { color, position: command?.exitCode ? 'right' : 'left' }) : undefined
+        });
+        if (!decoration) {
+            return undefined;
+        }
+        if (beforeCommandExecution) {
+            this._placeholderDecoration = decoration;
+        }
+        decoration.onRender(element => {
+            if (element.classList.contains(".xterm-decoration-overview-ruler" )) {
+                return;
+            }
+            if (!this._decorations.get(decoration.marker.id)) {
+                decoration.onDispose(() => this._decorations.delete(decoration.marker.id));
+                this._decorations.set(decoration.marker.id, {
+                    decoration,
+                    disposables: this._createDisposables(element, command, markProperties),
+                    exitCode: command?.exitCode,
+                    markProperties: command?.markProperties
+                });
+            }
+            if (!element.classList.contains("codicon" ) || command?.marker?.line === 0) {
+                updateLayout(this._configurationService, element);
+                this._updateClasses(element, command?.exitCode, command?.markProperties || markProperties);
+            }
+        });
+        return decoration;
+    }
+    _createDisposables(element, command, markProperties) {
+        if (command?.exitCode === undefined && !command?.markProperties) {
+            return [];
+        }
+        else if (command?.markProperties || markProperties) {
+            return [this._terminalDecorationHoverService.createHover(element, command || markProperties, markProperties?.hoverMessage)];
+        }
+        return [this._createContextMenu(element, command), this._terminalDecorationHoverService.createHover(element, command)];
+    }
+    _updateClasses(element, exitCode, markProperties) {
+        if (!element) {
+            return;
+        }
+        for (const classes of element.classList) {
+            element.classList.remove(classes);
+        }
+        element.classList.add("terminal-command-decoration" , "codicon" , "xterm-decoration" );
+        if (markProperties) {
+            element.classList.add("default-color" , ...ThemeIcon.asClassNameArray(terminalDecorationMark));
+            if (!markProperties.hoverMessage) {
+                element.classList.add("default" );
+            }
+        }
+        else {
+            this._updateCommandDecorationVisibility(element);
+            if (exitCode === undefined) {
+                element.classList.add("default-color" , "default" );
+                element.classList.add(...ThemeIcon.asClassNameArray(terminalDecorationIncomplete));
+            }
+            else if (exitCode) {
+                element.classList.add("error" );
+                element.classList.add(...ThemeIcon.asClassNameArray(terminalDecorationError));
+            }
+            else {
+                element.classList.add(...ThemeIcon.asClassNameArray(terminalDecorationSuccess));
+            }
+        }
+    }
+    _createContextMenu(element, command) {
+        return dom.addDisposableListener(element, dom.EventType.CLICK, async () => {
+            this._terminalDecorationHoverService.hideHover();
+            const actions = await this._getCommandActions(command);
+            this._contextMenuService.showContextMenu({ getAnchor: () => element, getActions: () => actions });
+        });
+    }
+    async _getCommandActions(command) {
+        const actions = [];
+        if (command.command !== '') {
+            const labelRun = ( localize("terminal.rerunCommand", 'Rerun Command'));
+            actions.push({
+                class: undefined, tooltip: labelRun, id: 'terminal.rerunCommand', label: labelRun, enabled: true,
+                run: async () => {
+                    if (command.command === '') {
+                        return;
+                    }
+                    if (!command.isTrusted) {
+                        const shouldRun = await ( new Promise(r => {
+                            this._notificationService.prompt(Severity.Info, ( localize('rerun', 'Do you want to run the command: {0}', command.command)), [{
+                                    label: ( localize('yes', 'Yes')),
+                                    run: () => r(true)
+                                }, {
+                                    label: ( localize('no', 'No')),
+                                    run: () => r(false)
+                                }]);
+                        }));
+                        if (!shouldRun) {
+                            return;
+                        }
+                    }
+                    this._onDidRequestRunCommand.fire({ command });
+                }
+            });
+            const labelCopy = ( localize("terminal.copyCommand", 'Copy Command'));
+            actions.push({
+                class: undefined, tooltip: labelCopy, id: 'terminal.copyCommand', label: labelCopy, enabled: true,
+                run: () => this._clipboardService.writeText(command.command)
+            });
+        }
+        if (command.hasOutput()) {
+            if (actions.length > 0) {
+                actions.push(( new Separator()));
+            }
+            const labelText = ( localize("terminal.copyOutput", 'Copy Output'));
+            actions.push({
+                class: undefined, tooltip: labelText, id: 'terminal.copyOutput', label: labelText, enabled: true,
+                run: () => {
+                    const text = command.getOutput();
+                    if (typeof text === 'string') {
+                        this._clipboardService.writeText(text);
+                    }
+                }
+            });
+            const labelHtml = ( localize("terminal.copyOutputAsHtml", 'Copy Output as HTML'));
+            actions.push({
+                class: undefined, tooltip: labelHtml, id: 'terminal.copyOutputAsHtml', label: labelHtml, enabled: true,
+                run: () => this._onDidRequestRunCommand.fire({ command, copyAsHtml: true })
+            });
+        }
+        if (actions.length > 0) {
+            actions.push(( new Separator()));
+        }
+        const labelRunRecent = ( localize('workbench.action.terminal.runRecentCommand', "Run Recent Command"));
+        actions.push({
+            class: undefined, tooltip: labelRunRecent, id: 'workbench.action.terminal.runRecentCommand', label: labelRunRecent, enabled: true,
+            run: () => this._commandService.executeCommand('workbench.action.terminal.runRecentCommand')
+        });
+        const labelGoToRecent = ( localize('workbench.action.terminal.goToRecentDirectory', "Go To Recent Directory"));
+        actions.push({
+            class: undefined, tooltip: labelRunRecent, id: 'workbench.action.terminal.goToRecentDirectory', label: labelGoToRecent, enabled: true,
+            run: () => this._commandService.executeCommand('workbench.action.terminal.goToRecentDirectory')
+        });
+        actions.push(( new Separator()));
+        const labelConfigure = ( localize("terminal.configureCommandDecorations", 'Configure Command Decorations'));
+        actions.push({
+            class: undefined, tooltip: labelConfigure, id: 'terminal.configureCommandDecorations', label: labelConfigure, enabled: true,
+            run: () => this._showConfigureCommandDecorationsQuickPick()
+        });
+        const labelAbout = ( localize("terminal.learnShellIntegration", 'Learn About Shell Integration'));
+        actions.push({
+            class: undefined, tooltip: labelAbout, id: 'terminal.learnShellIntegration', label: labelAbout, enabled: true,
+            run: () => this._openerService.open('https://code.visualstudio.com/docs/terminal/shell-integration')
+        });
+        return actions;
+    }
+    async _showConfigureCommandDecorationsQuickPick() {
+        const quickPick = this._quickInputService.createQuickPick();
+        quickPick.items = [
+            { id: 'a', label: ( localize('toggleVisibility', 'Toggle visibility')) },
+        ];
+        quickPick.canSelectMany = false;
+        quickPick.onDidAccept(async (e) => {
+            quickPick.hide();
+            const result = quickPick.activeItems[0];
+            switch (result.id) {
+                case 'a':
+                    this._showToggleVisibilityQuickPick();
+                    break;
+            }
+        });
+        quickPick.show();
+    }
+    _showToggleVisibilityQuickPick() {
+        const quickPick = this._quickInputService.createQuickPick();
+        quickPick.hideInput = true;
+        quickPick.hideCheckAll = true;
+        quickPick.canSelectMany = true;
+        quickPick.title = ( localize('toggleVisibility', 'Toggle visibility'));
+        const configValue = this._configurationService.getValue("terminal.integrated.shellIntegration.decorationsEnabled" );
+        const gutterIcon = {
+            label: ( localize('gutter', 'Gutter command decorations')),
+            picked: configValue !== 'never' && configValue !== 'overviewRuler'
+        };
+        const overviewRulerIcon = {
+            label: ( localize('overviewRuler', 'Overview ruler command decorations')),
+            picked: configValue !== 'never' && configValue !== 'gutter'
+        };
+        quickPick.items = [gutterIcon, overviewRulerIcon];
+        const selectedItems = [];
+        if (configValue !== 'never') {
+            if (configValue !== 'gutter') {
+                selectedItems.push(gutterIcon);
+            }
+            if (configValue !== 'overviewRuler') {
+                selectedItems.push(overviewRulerIcon);
+            }
+        }
+        quickPick.selectedItems = selectedItems;
+        quickPick.onDidChangeSelection(async (e) => {
+            let newValue = 'never';
+            if (e.includes(gutterIcon)) {
+                if (e.includes(overviewRulerIcon)) {
+                    newValue = 'both';
+                }
+                else {
+                    newValue = 'gutter';
+                }
+            }
+            else if (e.includes(overviewRulerIcon)) {
+                newValue = 'overviewRuler';
+            }
+            await this._configurationService.updateValue("terminal.integrated.shellIntegration.decorationsEnabled" , newValue);
+        });
+        quickPick.ok = false;
+        quickPick.show();
+    }
+    _getDecorationCssColor(decorationOrCommand) {
+        let colorId;
+        if (decorationOrCommand?.exitCode === undefined) {
+            colorId = TERMINAL_COMMAND_DECORATION_DEFAULT_BACKGROUND_COLOR;
+        }
+        else {
+            colorId = decorationOrCommand.exitCode ? TERMINAL_COMMAND_DECORATION_ERROR_BACKGROUND_COLOR : TERMINAL_COMMAND_DECORATION_SUCCESS_BACKGROUND_COLOR;
+        }
+        return this._themeService.getColorTheme().getColor(colorId)?.toString();
+    }
+};
+DecorationAddon = ( __decorate([
+    ( __param(1, IClipboardService)),
+    ( __param(2, IContextMenuService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IThemeService)),
+    ( __param(5, IOpenerService)),
+    ( __param(6, IQuickInputService)),
+    ( __param(7, ILifecycleService)),
+    ( __param(8, ICommandService)),
+    ( __param(9, IInstantiationService)),
+    ( __param(10, IAudioCueService)),
+    ( __param(11, INotificationService))
+], DecorationAddon));
+export { DecorationAddon };

package/dist/vscode/vs/workbench/contrib/terminal/browser/xterm/decorationStyles.js

@@ -0,0 +1,97 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Delayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { fromNow } from '../../../../../base/common/date.js';
+import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { Disposable, combinedDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IHoverService } from '../../../../services/hover/browser/hover.js';
+let TerminalDecorationHoverManager = class TerminalDecorationHoverManager extends Disposable {
+    constructor(_hoverService, configurationService, contextMenuService) {
+        super();
+        this._hoverService = _hoverService;
+        this._contextMenuVisible = false;
+        this._register(contextMenuService.onDidShowContextMenu(() => this._contextMenuVisible = true));
+        this._register(contextMenuService.onDidHideContextMenu(() => this._contextMenuVisible = false));
+        this._hoverDelayer = this._register(( (new Delayer(configurationService.getValue('workbench.hover.delay')))));
+    }
+    hideHover() {
+        this._hoverDelayer.cancel();
+        this._hoverService.hideHover();
+    }
+    createHover(element, command, hoverMessage) {
+        return combinedDisposable(dom.addDisposableListener(element, dom.EventType.MOUSE_ENTER, () => {
+            if (this._contextMenuVisible) {
+                return;
+            }
+            this._hoverDelayer.trigger(() => {
+                let hoverContent = `${( ( localize('terminalPromptContextMenu', "Show Command Actions")))}`;
+                hoverContent += '\n\n---\n\n';
+                if (!command) {
+                    if (hoverMessage) {
+                        hoverContent = hoverMessage;
+                    }
+                    else {
+                        return;
+                    }
+                }
+                else if (command.markProperties || hoverMessage) {
+                    if (command.markProperties?.hoverMessage || hoverMessage) {
+                        hoverContent = command.markProperties?.hoverMessage || hoverMessage || '';
+                    }
+                    else {
+                        return;
+                    }
+                }
+                else if (command.exitCode) {
+                    if (command.exitCode === -1) {
+                        hoverContent += ( (localize(
+                            'terminalPromptCommandFailed',
+                            'Command executed {0} and failed',
+                            fromNow(command.timestamp, true)
+                        )));
+                    }
+                    else {
+                        hoverContent += ( (localize(
+                            'terminalPromptCommandFailedWithExitCode',
+                            'Command executed {0} and failed (Exit Code {1})',
+                            fromNow(command.timestamp, true),
+                            command.exitCode
+                        )));
+                    }
+                }
+                else {
+                    hoverContent += ( (localize(
+                        'terminalPromptCommandSuccess',
+                        'Command executed {0}',
+                        fromNow(command.timestamp, true)
+                    )));
+                }
+                this._hoverService.showHover({ content: ( (new MarkdownString(hoverContent))), target: element });
+            });
+        }), dom.addDisposableListener(element, dom.EventType.MOUSE_LEAVE, () => this.hideHover()), dom.addDisposableListener(element, dom.EventType.MOUSE_OUT, () => this.hideHover()));
+    }
+};
+TerminalDecorationHoverManager = ( (__decorate([
+    ( (__param(0, IHoverService))),
+    ( (__param(1, IConfigurationService))),
+    ( (__param(2, IContextMenuService)))
+], TerminalDecorationHoverManager)));
+function updateLayout(configurationService, element) {
+    if (!element) {
+        return;
+    }
+    const fontSize = configurationService.inspect("terminal.integrated.fontSize" ).value;
+    const defaultFontSize = configurationService.inspect("terminal.integrated.fontSize" ).defaultValue;
+    const lineHeight = configurationService.inspect("terminal.integrated.lineHeight" ).value;
+    if (typeof fontSize === 'number' && typeof defaultFontSize === 'number' && typeof lineHeight === 'number') {
+        const scalar = (fontSize / defaultFontSize) <= 1 ? (fontSize / defaultFontSize) : 1;
+        element.style.width = `${scalar * 16 }px`;
+        element.style.height = `${scalar * 16  * lineHeight}px`;
+        element.style.fontSize = `${scalar * 16 }px`;
+        element.style.marginLeft = `${scalar * -17 }px`;
+    }
+}
+export { TerminalDecorationHoverManager, updateLayout };

package/dist/vscode/vs/workbench/contrib/terminal/browser/xterm/lineDataEventAddon.js

@@ -0,0 +1,56 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class LineDataEventAddon extends Disposable {
+    constructor(_initializationPromise) {
+        super();
+        this._initializationPromise = _initializationPromise;
+        this._isOsSet = false;
+        this._onLineData = this._register(( new Emitter()));
+        this.onLineData = this._onLineData.event;
+    }
+    async activate(xterm) {
+        this._xterm = xterm;
+        await this._initializationPromise;
+        this._register(xterm.onLineFeed(() => {
+            const buffer = xterm.buffer;
+            const newLine = buffer.active.getLine(buffer.active.baseY + buffer.active.cursorY);
+            if (newLine && !newLine.isWrapped) {
+                this._sendLineData(buffer.active, buffer.active.baseY + buffer.active.cursorY - 1);
+            }
+        }));
+        this._register(toDisposable(() => {
+            const buffer = xterm.buffer;
+            this._sendLineData(buffer.active, buffer.active.baseY + buffer.active.cursorY);
+        }));
+    }
+    setOperatingSystem(os) {
+        if (this._isOsSet || !this._xterm) {
+            return;
+        }
+        this._isOsSet = true;
+        if (os === 1 ) {
+            const xterm = this._xterm;
+            this._register(xterm.parser.registerCsiHandler({ final: 'H' }, () => {
+                const buffer = xterm.buffer;
+                this._sendLineData(buffer.active, buffer.active.baseY + buffer.active.cursorY);
+                return false;
+            }));
+        }
+    }
+    _sendLineData(buffer, lineIndex) {
+        let line = buffer.getLine(lineIndex);
+        if (!line) {
+            return;
+        }
+        let lineData = line.translateToString(true);
+        while (lineIndex > 0 && line.isWrapped) {
+            line = buffer.getLine(--lineIndex);
+            if (!line) {
+                break;
+            }
+            lineData = line.translateToString(false) + lineData;
+        }
+        this._onLineData.fire(lineData);
+    }
+}
+export { LineDataEventAddon };