@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollOverlay.js

@@ -0,0 +1,379 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { addStandardDisposableListener, $, addDisposableListener, getWindow } from '../../../../../base/browser/dom.js';
+import { createCancelablePromise } from '../../../../../base/common/async.js';
+import { throttle, memoize } from '../../../../../base/common/decorators.js';
+import { Event } from '../../../../../base/common/event.js';
+import { Disposable, MutableDisposable, combinedDisposable, toDisposable } from '../../../../../base/common/lifecycle.js';
+import { removeAnsiEscapeCodes } from '../../../../../base/common/strings.js';
+import './media/stickyScroll.css.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { MenuId, IMenuService } from '../../../../../platform/actions/common/actions.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from '../../../../../platform/contextview/browser/contextView.js';
+import { IKeybindingService } from '../../../../../platform/keybinding/common/keybinding.js';
+import { IThemeService } from '../../../../../platform/theme/common/themeService.js';
+import { openContextMenu } from '../../../terminal/browser/terminalContextMenu.js';
+import { TERMINAL_CONFIG_SECTION } from '../../../terminal/common/terminal.js';
+import { terminalStrings } from '../../../terminal/common/terminalStrings.js';
+import { terminalStickyScrollHoverBackground, terminalStickyScrollBackground } from './terminalStickyScrollColorRegistry.js';
+let TerminalStickyScrollOverlay = class TerminalStickyScrollOverlay extends Disposable {
+    constructor(_instance, _xterm, _xtermColorProvider, _commandDetection, xtermCtor, configurationService, contextKeyService, _contextMenuService, _keybindingService, menuService, _themeService) {
+        super();
+        this._instance = _instance;
+        this._xterm = _xterm;
+        this._xtermColorProvider = _xtermColorProvider;
+        this._commandDetection = _commandDetection;
+        this._contextMenuService = _contextMenuService;
+        this._keybindingService = _keybindingService;
+        this._themeService = _themeService;
+        this._canvasAddon = this._register(( new MutableDisposable()));
+        this._refreshListeners = this._register(( new MutableDisposable()));
+        this._state = 0 ;
+        this._isRefreshQueued = false;
+        this._rawMaxLineCount = 5;
+        this._contextMenu = this._register(menuService.createMenu(MenuId.TerminalStickyScrollContext, contextKeyService));
+        this._register(Event.runAndSubscribe(this._xterm.raw.buffer.onBufferChange, buffer => {
+            this._setState((buffer ?? this._xterm.raw.buffer.active).type === 'normal' ? 1  : 0 );
+        }));
+        this._register(Event.runAndSubscribe(configurationService.onDidChangeConfiguration, e => {
+            if (!e || e.affectsConfiguration("terminal.integrated.stickyScroll.maxLineCount" )) {
+                this._rawMaxLineCount = configurationService.getValue("terminal.integrated.stickyScroll.maxLineCount" );
+            }
+        }));
+        this._register(this._instance.onDidChangeTarget(() => this._syncOptions()));
+        xtermCtor.then(ctor => {
+            if (this._store.isDisposed) {
+                return;
+            }
+            this._stickyScrollOverlay = this._register(( new ctor({
+                rows: 1,
+                cols: this._xterm.raw.cols,
+                allowProposedApi: true,
+                ...this._getOptions()
+            })));
+            this._register(configurationService.onDidChangeConfiguration(e => {
+                if (e.affectsConfiguration(TERMINAL_CONFIG_SECTION)) {
+                    this._syncOptions();
+                }
+            }));
+            this._register(this._themeService.onDidColorThemeChange(() => {
+                this._syncOptions();
+            }));
+            this._register(this._xterm.raw.onResize(() => {
+                this._syncOptions();
+                this._refresh();
+            }));
+            this._getSerializeAddonConstructor().then(SerializeAddon => {
+                this._serializeAddon = this._register(( new SerializeAddon()));
+                this._xterm.raw.loadAddon(this._serializeAddon);
+                this._refresh();
+            });
+            this._syncGpuAccelerationState();
+        });
+    }
+    _setState(state) {
+        if (this._state === state) {
+            return;
+        }
+        switch (state) {
+            case 0 : {
+                this._setVisible(false);
+                this._uninstallRefreshListeners();
+                break;
+            }
+            case 1 : {
+                this._refresh();
+                this._installRefreshListeners();
+                break;
+            }
+        }
+    }
+    _installRefreshListeners() {
+        if (!this._refreshListeners.value) {
+            this._refreshListeners.value = combinedDisposable(Event.any(this._xterm.raw.onScroll, this._xterm.raw.onLineFeed,
+            this._xterm.raw.onCursorMove)(() => this._refresh()), addStandardDisposableListener(this._xterm.raw.element.querySelector('.xterm-viewport'), 'scroll', () => this._refresh()));
+        }
+    }
+    _uninstallRefreshListeners() {
+        this._refreshListeners.clear();
+    }
+    _setVisible(isVisible) {
+        if (isVisible) {
+            this._ensureElement();
+            this._syncGpuAccelerationState();
+        }
+        this._element?.classList.toggle("visible" , isVisible);
+    }
+    _refresh() {
+        if (this._isRefreshQueued) {
+            return;
+        }
+        this._isRefreshQueued = true;
+        queueMicrotask(() => {
+            this._refreshNow();
+            this._isRefreshQueued = false;
+        });
+    }
+    _refreshNow() {
+        const command = this._commandDetection.getCommandForLine(this._xterm.raw.buffer.active.viewportY);
+        this._currentStickyCommand = undefined;
+        if (!command) {
+            this._setVisible(false);
+            return;
+        }
+        if (!('marker' in command)) {
+            const partialCommand = this._commandDetection.currentCommand;
+            if (partialCommand?.commandStartMarker && partialCommand.commandExecutedMarker) {
+                this._updateContent(partialCommand, partialCommand.commandStartMarker);
+                return;
+            }
+            this._setVisible(false);
+            return;
+        }
+        const marker = command.marker;
+        if (!marker || marker.line === -1) {
+            this._setVisible(false);
+            return;
+        }
+        this._updateContent(command, marker);
+    }
+    _updateContent(command, startMarker) {
+        const xterm = this._xterm.raw;
+        if (!xterm.element?.parentElement || !this._stickyScrollOverlay || !this._serializeAddon) {
+            return;
+        }
+        if (command.promptStartMarker?.line === -1) {
+            this._setVisible(false);
+            return;
+        }
+        const buffer = xterm.buffer.active;
+        const promptRowCount = command.getPromptRowCount();
+        const commandRowCount = command.getCommandRowCount();
+        const stickyScrollLineStart = startMarker.line - (promptRowCount - 1);
+        const isPartialCommand = !('getOutput' in command);
+        const rowOffset = !isPartialCommand && command.endMarker ? Math.max(buffer.viewportY - command.endMarker.line + 1, 0) : 0;
+        const maxLineCount = Math.min(this._rawMaxLineCount, Math.floor(xterm.rows * 0.4 ));
+        const stickyScrollLineCount = Math.min(promptRowCount + commandRowCount - 1, maxLineCount) - rowOffset;
+        if (buffer.viewportY <= stickyScrollLineStart) {
+            this._setVisible(false);
+            return;
+        }
+        if (isPartialCommand && buffer.viewportY === buffer.baseY && buffer.cursorY === xterm.rows - 1) {
+            const line = buffer.getLine(buffer.baseY + xterm.rows - 1);
+            if ((buffer.cursorX === 1 && lineStartsWith(line, ':')) ||
+                (buffer.cursorX === 5 && lineStartsWith(line, '(END)'))) {
+                this._setVisible(false);
+                return;
+            }
+        }
+        const content = this._serializeAddon.serialize({
+            range: {
+                start: stickyScrollLineStart + rowOffset,
+                end: stickyScrollLineStart + rowOffset + Math.max(stickyScrollLineCount - 1, 0)
+            }
+        });
+        if (isPartialCommand && removeAnsiEscapeCodes(content).length === 0) {
+            this._setVisible(false);
+            return;
+        }
+        if (content && this._currentContent !== content ||
+            this._stickyScrollOverlay.cols !== xterm.cols ||
+            this._stickyScrollOverlay.rows !== stickyScrollLineCount) {
+            this._stickyScrollOverlay.resize(this._stickyScrollOverlay.cols, stickyScrollLineCount);
+            this._stickyScrollOverlay.write('\x1b[0m\x1b[H\x1b[2J');
+            this._stickyScrollOverlay.write(content);
+            this._currentContent = content;
+        }
+        if (content) {
+            this._currentStickyCommand = command;
+            this._setVisible(true);
+            if (this._element) {
+                const termBox = xterm.element.getBoundingClientRect();
+                const rowHeight = termBox.height / xterm.rows;
+                const overlayHeight = stickyScrollLineCount * rowHeight;
+                let endMarkerOffset = 0;
+                if (!isPartialCommand && command.endMarker && command.endMarker.line !== -1) {
+                    if (buffer.viewportY + stickyScrollLineCount > command.endMarker.line) {
+                        const diff = buffer.viewportY + stickyScrollLineCount - command.endMarker.line;
+                        endMarkerOffset = diff * rowHeight;
+                    }
+                }
+                this._element.style.bottom = `${termBox.height - overlayHeight + 1 + endMarkerOffset}px`;
+            }
+        }
+        else {
+            this._setVisible(false);
+        }
+    }
+    _ensureElement() {
+        if (
+        this._element ||
+            !this._stickyScrollOverlay ||
+            !this._xterm?.raw.element?.parentElement) {
+            return;
+        }
+        const overlay = this._stickyScrollOverlay;
+        const hoverOverlay = $('.hover-overlay');
+        this._element = $('.terminal-sticky-scroll', undefined, hoverOverlay);
+        this._xterm.raw.element.parentElement.append(this._element);
+        this._register(toDisposable(() => this._element?.remove()));
+        let hoverTitle = ( localizeWithPath(
+            'vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollOverlay',
+            'stickyScrollHoverTitle',
+            'Navigate to Command'
+        ));
+        const scrollToPreviousCommandKeybinding = this._keybindingService.lookupKeybinding("workbench.action.terminal.scrollToPreviousCommand" );
+        if (scrollToPreviousCommandKeybinding) {
+            const label = scrollToPreviousCommandKeybinding.getLabel();
+            if (label) {
+                hoverTitle += '\n' + ( localizeWithPath(
+                    'vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollOverlay',
+                    'labelWithKeybinding',
+                    "{0} ({1})",
+                    terminalStrings.scrollToPreviousCommand.value,
+                    label
+                ));
+            }
+        }
+        const scrollToNextCommandKeybinding = this._keybindingService.lookupKeybinding("workbench.action.terminal.scrollToNextCommand" );
+        if (scrollToNextCommandKeybinding) {
+            const label = scrollToNextCommandKeybinding.getLabel();
+            if (label) {
+                hoverTitle += '\n' + ( localizeWithPath(
+                    'vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollOverlay',
+                    'labelWithKeybinding',
+                    "{0} ({1})",
+                    terminalStrings.scrollToNextCommand.value,
+                    label
+                ));
+            }
+        }
+        hoverOverlay.title = hoverTitle;
+        const scrollBarWidth = this._xterm.raw._core.viewport?.scrollBarWidth;
+        if (scrollBarWidth !== undefined) {
+            this._element.style.right = `${scrollBarWidth}px`;
+        }
+        this._stickyScrollOverlay.open(this._element);
+        this._register(addStandardDisposableListener(hoverOverlay, 'click', () => {
+            if (this._xterm && this._currentStickyCommand) {
+                this._xterm.markTracker.revealCommand(this._currentStickyCommand);
+                this._instance.focus();
+            }
+        }));
+        this._register(addStandardDisposableListener(hoverOverlay, 'wheel', e => this._xterm?.raw.element?.dispatchEvent(( new WheelEvent(e.type, e)))));
+        this._register(addDisposableListener(hoverOverlay, 'mousedown', e => {
+            e.stopImmediatePropagation();
+            e.preventDefault();
+        }));
+        this._register(addDisposableListener(hoverOverlay, 'contextmenu', e => {
+            e.stopImmediatePropagation();
+            e.preventDefault();
+            openContextMenu(getWindow(hoverOverlay), e, this._instance, this._contextMenu, this._contextMenuService);
+        }));
+        this._register(addStandardDisposableListener(hoverOverlay, 'mouseover', () => overlay.options.theme = this._getTheme(true)));
+        this._register(addStandardDisposableListener(hoverOverlay, 'mouseleave', () => overlay.options.theme = this._getTheme(false)));
+    }
+    _syncOptions() {
+        if (!this._stickyScrollOverlay) {
+            return;
+        }
+        this._stickyScrollOverlay.resize(this._xterm.raw.cols, this._stickyScrollOverlay.rows);
+        this._stickyScrollOverlay.options = this._getOptions();
+        this._syncGpuAccelerationState();
+    }
+    _syncGpuAccelerationState() {
+        if (!this._stickyScrollOverlay) {
+            return;
+        }
+        const overlay = this._stickyScrollOverlay;
+        if (this._xterm.isGpuAccelerated) {
+            if (!this._canvasAddon.value && !this._pendingCanvasAddon) {
+                this._pendingCanvasAddon = createCancelablePromise(async (token) => {
+                    const CanvasAddon = await this._getCanvasAddonConstructor();
+                    if (!token.isCancellationRequested && !this._store.isDisposed) {
+                        this._canvasAddon.value = ( new CanvasAddon());
+                        if (this._canvasAddon.value) {
+                            overlay.loadAddon(this._canvasAddon.value);
+                        }
+                    }
+                    this._pendingCanvasAddon = undefined;
+                });
+            }
+        }
+        else {
+            this._canvasAddon.clear();
+            this._pendingCanvasAddon?.cancel();
+            this._pendingCanvasAddon = undefined;
+        }
+    }
+    _getOptions() {
+        const o = this._xterm.raw.options;
+        return {
+            allowTransparency: true,
+            cursorInactiveStyle: 'none',
+            scrollback: 0,
+            logLevel: 'off',
+            theme: this._getTheme(false),
+            documentOverride: o.documentOverride,
+            fontFamily: o.fontFamily,
+            fontWeight: o.fontWeight,
+            fontWeightBold: o.fontWeightBold,
+            fontSize: o.fontSize,
+            letterSpacing: o.letterSpacing,
+            lineHeight: o.lineHeight,
+            drawBoldTextInBrightColors: o.drawBoldTextInBrightColors,
+            minimumContrastRatio: o.minimumContrastRatio,
+            tabStopWidth: o.tabStopWidth,
+            overviewRulerWidth: o.overviewRulerWidth,
+        };
+    }
+    _getTheme(isHovering) {
+        const theme = this._themeService.getColorTheme();
+        return {
+            ...this._xterm.getXtermTheme(),
+            background: isHovering
+                ? theme.getColor(terminalStickyScrollHoverBackground)?.toString() ?? this._xtermColorProvider.getBackgroundColor(theme)?.toString()
+                : theme.getColor(terminalStickyScrollBackground)?.toString() ?? this._xtermColorProvider.getBackgroundColor(theme)?.toString(),
+            selectionBackground: undefined,
+            selectionInactiveBackground: undefined
+        };
+    }
+    async _getCanvasAddonConstructor() {
+        const m = await import('@xterm/addon-canvas').then(module => module.default ?? module);
+        return m.CanvasAddon;
+    }
+    async _getSerializeAddonConstructor() {
+        const m = await import('@xterm/addon-serialize').then(module => module.default ?? module);
+        return m.SerializeAddon;
+    }
+};
+TerminalStickyScrollOverlay.__decorator = ( __decorate([
+    throttle(0)
+], TerminalStickyScrollOverlay.prototype, "_syncOptions", null));
+TerminalStickyScrollOverlay.__decorator = ( __decorate([
+    memoize
+], TerminalStickyScrollOverlay.prototype, "_getCanvasAddonConstructor", null));
+TerminalStickyScrollOverlay.__decorator = ( __decorate([
+    memoize
+], TerminalStickyScrollOverlay.prototype, "_getSerializeAddonConstructor", null));
+TerminalStickyScrollOverlay = ( __decorate([
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IContextMenuService)),
+    ( __param(8, IKeybindingService)),
+    ( __param(9, IMenuService)),
+    ( __param(10, IThemeService))
+], TerminalStickyScrollOverlay));
+function lineStartsWith(line, text) {
+    if (!line) {
+        return false;
+    }
+    for (let i = 0; i < text.length; i++) {
+        if (line.getCell(i)?.getChars() !== text[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+export { TerminalStickyScrollOverlay };

package/vscode/src/vs/workbench/contrib/terminalContrib/suggest/browser/terminal.suggest.contribution.js

@@ -0,0 +1,181 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { findParentWithClass } from '../../../../../base/browser/dom.js';
+import { DisposableStore, MutableDisposable, toDisposable } from '../../../../../base/common/lifecycle.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { registerTerminalContribution } from '../../../terminal/browser/terminalExtensions.js';
+import { SuggestAddon } from './terminalSuggestAddon.js';
+import { TERMINAL_CONFIG_SECTION } from '../../../terminal/common/terminal.js';
+import { ContextKeyExpr, IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.js';
+import { TerminalContextKeys } from '../../../terminal/common/terminalContextKey.js';
+import { registerActiveInstanceAction } from '../../../terminal/browser/terminalActions.js';
+import { localize2WithPath } from '../../../../../nls.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
+var TerminalSuggestContribution_1;
+let TerminalSuggestContribution = class TerminalSuggestContribution extends DisposableStore {
+    static { TerminalSuggestContribution_1 = this; }
+    static { this.ID = 'terminal.suggest'; }
+    static get(instance) {
+        return instance.getContribution(TerminalSuggestContribution_1.ID);
+    }
+    get addon() { return this._addon.value; }
+    constructor(_instance, _processManager, widgetManager, _contextKeyService, _configurationService, _instantiationService) {
+        super();
+        this._instance = _instance;
+        this._contextKeyService = _contextKeyService;
+        this._configurationService = _configurationService;
+        this._instantiationService = _instantiationService;
+        this._addon = ( new MutableDisposable());
+        this._terminalSuggestWidgetContextKeys = ( new Set(TerminalContextKeys.suggestWidgetVisible.key));
+        this.add(toDisposable(() => this._addon?.dispose()));
+        this._terminalSuggestWidgetVisibleContextKey = TerminalContextKeys.suggestWidgetVisible.bindTo(this._contextKeyService);
+    }
+    xtermOpen(xterm) {
+        this._loadSuggestAddon(xterm.raw);
+        this.add(this._contextKeyService.onDidChangeContext(e => {
+            if (e.affectsSome(this._terminalSuggestWidgetContextKeys)) {
+                this._loadSuggestAddon(xterm.raw);
+            }
+        }));
+        this.add(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("terminal.integrated.sendKeybindingsToShell" )) {
+                this._loadSuggestAddon(xterm.raw);
+            }
+        }));
+    }
+    _loadSuggestAddon(xterm) {
+        const sendingKeybindingsToShell = this._configurationService.getValue(TERMINAL_CONFIG_SECTION).sendKeybindingsToShell;
+        if (sendingKeybindingsToShell) {
+            this._addon.dispose();
+            return;
+        }
+        if (this._terminalSuggestWidgetVisibleContextKey) {
+            this._addon.value = this._instantiationService.createInstance(SuggestAddon, this._terminalSuggestWidgetVisibleContextKey);
+            xterm.loadAddon(this._addon.value);
+            this._addon.value.setPanel(findParentWithClass(xterm.element, 'panel'));
+            this._addon.value.setScreen(xterm.element.querySelector('.xterm-screen'));
+            this.add(this._instance.onDidBlur(() => this._addon.value?.hideSuggestWidget()));
+            this.add(this._addon.value.onAcceptedCompletion(async (text) => {
+                this._instance.focus();
+                this._instance.sendText(text, false);
+            }));
+            this.add(this._instance.onDidSendText((text) => {
+                this._addon.value?.handleNonXtermData(text);
+            }));
+        }
+    }
+};
+TerminalSuggestContribution = TerminalSuggestContribution_1 = ( __decorate([
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IInstantiationService))
+], TerminalSuggestContribution));
+registerTerminalContribution(TerminalSuggestContribution.ID, TerminalSuggestContribution);
+registerActiveInstanceAction({
+    id: "workbench.action.terminal.selectPrevSuggestion" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/suggest/browser/terminal.suggest.contribution',
+        'workbench.action.terminal.selectPrevSuggestion',
+        'Select the Previous Suggestion'
+    )),
+    f1: false,
+    precondition: ( ContextKeyExpr.and(( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )), TerminalContextKeys.focus, TerminalContextKeys.isOpen, TerminalContextKeys.suggestWidgetVisible)),
+    keybinding: {
+        primary: 16 ,
+        weight: 200  + 1
+    },
+    run: (activeInstance) => TerminalSuggestContribution.get(activeInstance)?.addon?.selectPreviousSuggestion()
+});
+registerActiveInstanceAction({
+    id: "workbench.action.terminal.selectPrevPageSuggestion" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/suggest/browser/terminal.suggest.contribution',
+        'workbench.action.terminal.selectPrevPageSuggestion',
+        'Select the Previous Page Suggestion'
+    )),
+    f1: false,
+    precondition: ( ContextKeyExpr.and(( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )), TerminalContextKeys.focus, TerminalContextKeys.isOpen, TerminalContextKeys.suggestWidgetVisible)),
+    keybinding: {
+        primary: 11 ,
+        weight: 200  + 1
+    },
+    run: (activeInstance) => TerminalSuggestContribution.get(activeInstance)?.addon?.selectPreviousPageSuggestion()
+});
+registerActiveInstanceAction({
+    id: "workbench.action.terminal.selectNextSuggestion" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/suggest/browser/terminal.suggest.contribution',
+        'workbench.action.terminal.selectNextSuggestion',
+        'Select the Next Suggestion'
+    )),
+    f1: false,
+    precondition: ( ContextKeyExpr.and(( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )), TerminalContextKeys.focus, TerminalContextKeys.isOpen, TerminalContextKeys.suggestWidgetVisible)),
+    keybinding: {
+        primary: 18 ,
+        weight: 200  + 1
+    },
+    run: (activeInstance) => TerminalSuggestContribution.get(activeInstance)?.addon?.selectNextSuggestion()
+});
+registerActiveInstanceAction({
+    id: "workbench.action.terminal.selectNextPageSuggestion" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/suggest/browser/terminal.suggest.contribution',
+        'workbench.action.terminal.selectNextPageSuggestion',
+        'Select the Next Page Suggestion'
+    )),
+    f1: false,
+    precondition: ( ContextKeyExpr.and(( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )), TerminalContextKeys.focus, TerminalContextKeys.isOpen, TerminalContextKeys.suggestWidgetVisible)),
+    keybinding: {
+        primary: 12 ,
+        weight: 200  + 1
+    },
+    run: (activeInstance) => TerminalSuggestContribution.get(activeInstance)?.addon?.selectNextPageSuggestion()
+});
+registerActiveInstanceAction({
+    id: "workbench.action.terminal.acceptSelectedSuggestion" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/suggest/browser/terminal.suggest.contribution',
+        'workbench.action.terminal.acceptSelectedSuggestion',
+        'Accept Selected Suggestion'
+    )),
+    f1: false,
+    precondition: ( ContextKeyExpr.and(( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )), TerminalContextKeys.focus, TerminalContextKeys.isOpen, TerminalContextKeys.suggestWidgetVisible)),
+    keybinding: {
+        primary: 3 ,
+        secondary: [2 ],
+        weight: 200  + 1
+    },
+    run: (activeInstance) => TerminalSuggestContribution.get(activeInstance)?.addon?.acceptSelectedSuggestion()
+});
+registerActiveInstanceAction({
+    id: "workbench.action.terminal.hideSuggestWidget" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/suggest/browser/terminal.suggest.contribution',
+        'workbench.action.terminal.hideSuggestWidget',
+        'Hide Suggest Widget'
+    )),
+    f1: false,
+    precondition: ( ContextKeyExpr.and(( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )), TerminalContextKeys.focus, TerminalContextKeys.isOpen, TerminalContextKeys.suggestWidgetVisible)),
+    keybinding: {
+        primary: 9 ,
+        weight: 200  + 1
+    },
+    run: (activeInstance) => TerminalSuggestContribution.get(activeInstance)?.addon?.hideSuggestWidget()
+});