@codingame/monaco-vscode-debug-service-override 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/contrib/debug/browser/repl.js

@@ -0,0 +1,1002 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { clearNode, Dimension, isActiveElement, append, getWindow, createStyleSheet, addStandardDisposableListener, EventType, getActiveWindow, $ as $$1 } from 'vscode/vscode/vs/base/browser/dom';
+import { status } from 'vscode/vscode/vs/base/browser/ui/aria/aria';
+import { MOUSE_CURSOR_TEXT_CSS_CLASS_NAME } from 'vscode/vscode/vs/base/browser/ui/mouseCursor/mouseCursor';
+import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
+import { memoize } from 'vscode/vscode/vs/base/common/decorators';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { HistoryNavigator } from 'vscode/vscode/vs/base/common/history';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { removeAnsiEscapeCodes } from 'vscode/vscode/vs/base/common/strings';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import './media/repl.css.js';
+import { isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
+import { registerEditorAction, EditorAction } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
+import { CodeEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/codeEditor/codeEditorWidget';
+import { EDITOR_FONT_DEFAULTS } from 'vscode/vscode/vs/editor/common/config/editorOptions';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
+import { CompletionItemKinds } from 'vscode/vscode/vs/editor/common/languages';
+import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
+import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
+import { ITextResourcePropertiesService } from 'vscode/vscode/vs/editor/common/services/textResourceConfiguration';
+import { SuggestController } from 'vscode/vscode/vs/editor/contrib/suggest/browser/suggestController';
+import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
+import { createAndFillInContextMenuActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { MenuId, registerAction2, Action2, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IContextKeyService, ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
+import { registerAndCreateHistoryNavigationContext } from 'vscode/vscode/vs/platform/history/browser/contextScopedHistoryWidget';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/common/serviceCollection';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { WorkbenchAsyncDataTree } from 'vscode/vscode/vs/platform/list/browser/listService';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { resolveColorValue } from 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
+import { editorForeground } from 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { FilterViewPane, ViewAction } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
+import { getSimpleEditorOptions, getSimpleCodeEditorWidgetOptions } from 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/simpleEditorOptions';
+import { FocusSessionActionViewItem } from './debugActionViewItems.js';
+import { debugConsoleEvaluationPrompt, debugConsoleClearAll } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugIcons';
+import { LinkDetector } from './linkDetector.js';
+import { ReplFilter } from './replFilter.js';
+import { ReplDelegate, ReplVariablesRenderer, ReplOutputElementRenderer, ReplEvaluationInputsRenderer, ReplGroupRenderer, ReplEvaluationResultsRenderer, ReplRawObjectsRenderer, ReplDataSource, ReplAccessibilityProvider } from './replViewer.js';
+import { DEBUG_SCHEME, CONTEXT_MULTI_SESSION_REPL, CONTEXT_IN_DEBUG_REPL, REPL_VIEW_ID, IDebugService, CONTEXT_DEBUG_STATE, getStateLabel } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { Variable } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugModel';
+import { ReplEvaluationResult, ReplGroup } from 'vscode/vscode/vs/workbench/contrib/debug/common/replModel';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { registerNavigableContainer } from 'vscode/vscode/vs/workbench/browser/actions/widgetNavigationCommands';
+import { IAccessibilitySignalService, AccessibilitySignal } from 'vscode/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
+
+var Repl_1, ReplOptions_1;
+const $ = $$1;
+const HISTORY_STORAGE_KEY = 'debug.repl.history';
+const FILTER_HISTORY_STORAGE_KEY = 'debug.repl.filterHistory';
+const FILTER_VALUE_STORAGE_KEY = 'debug.repl.filterValue';
+const DECORATION_KEY = 'replinputdecoration';
+function revealLastElement(tree) {
+    tree.scrollTop = tree.scrollHeight - tree.renderHeight;
+}
+const sessionsToIgnore = ( (new Set()));
+const identityProvider = { getId: (element) => element.getId() };
+let Repl = class Repl extends FilterViewPane {
+    static { Repl_1 = this; }
+    static { this.REFRESH_DELAY = 50; }
+    static { this.URI = ( URI.parse(`${DEBUG_SCHEME}:replinput`)); }
+    constructor(options, debugService, instantiationService, storageService, themeService, modelService, contextKeyService, codeEditorService, viewDescriptorService, contextMenuService, configurationService, textResourcePropertiesService, editorService, keybindingService, openerService, telemetryService, menuService, languageFeaturesService, logService) {
+        const filterText = storageService.get(FILTER_VALUE_STORAGE_KEY, 1 , '');
+        super({
+            ...options,
+            filterOptions: {
+                placeholder: ( (localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/repl',
+                    { key: 'workbench.debug.filter.placeholder', comment: ['Text in the brackets after e.g. is not localizable'] },
+                    "Filter (e.g. text, !exclude)"
+                ))),
+                text: filterText,
+                history: JSON.parse(storageService.get(FILTER_HISTORY_STORAGE_KEY, 1 , '[]')),
+            }
+        }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.debugService = debugService;
+        this.storageService = storageService;
+        this.modelService = modelService;
+        this.textResourcePropertiesService = textResourcePropertiesService;
+        this.editorService = editorService;
+        this.languageFeaturesService = languageFeaturesService;
+        this.logService = logService;
+        this.previousTreeScrollHeight = 0;
+        this.replInputLineCount = 1;
+        this.styleChangedWhenInvisible = false;
+        this.modelChangeListener = Disposable.None;
+        this.menu = menuService.createMenu(MenuId.DebugConsoleContext, contextKeyService);
+        this._register(this.menu);
+        this.history = ( (new HistoryNavigator(
+            JSON.parse(this.storageService.get(HISTORY_STORAGE_KEY, 1 , '[]')),
+            50
+        )));
+        this.filter = ( (new ReplFilter()));
+        this.filter.filterQuery = filterText;
+        this.multiSessionRepl = CONTEXT_MULTI_SESSION_REPL.bindTo(contextKeyService);
+        this.replOptions = this._register(this.instantiationService.createInstance(ReplOptions, this.id, () => this.getBackgroundColor()));
+        this._register(this.replOptions.onDidChange(() => this.onDidStyleChange()));
+        codeEditorService.registerDecorationType('repl-decoration', DECORATION_KEY, {});
+        this.multiSessionRepl.set(this.isMultiSessionView);
+        this.registerListeners();
+    }
+    registerListeners() {
+        if (this.debugService.getViewModel().focusedSession) {
+            this.onDidFocusSession(this.debugService.getViewModel().focusedSession);
+        }
+        this._register(this.debugService.getViewModel().onDidFocusSession(async (session) => this.onDidFocusSession(session)));
+        this._register(this.debugService.getViewModel().onDidEvaluateLazyExpression(async (e) => {
+            if (e instanceof Variable && this.tree?.hasNode(e)) {
+                await this.tree.updateChildren(e, false, true);
+                await this.tree.expand(e);
+            }
+        }));
+        this._register(this.debugService.onWillNewSession(async (newSession) => {
+            const input = this.tree?.getInput();
+            if (!input || input.state === 0 ) {
+                await this.selectSession(newSession);
+            }
+            this.multiSessionRepl.set(this.isMultiSessionView);
+        }));
+        this._register(this.debugService.onDidEndSession(async () => {
+            await Promise.resolve();
+            this.multiSessionRepl.set(this.isMultiSessionView);
+        }));
+        this._register(this.themeService.onDidColorThemeChange(() => {
+            this.refreshReplElements(false);
+            if (this.isVisible()) {
+                this.updateInputDecoration();
+            }
+        }));
+        this._register(this.onDidChangeBodyVisibility(visible => {
+            if (visible) {
+                if (!this.model) {
+                    this.model = this.modelService.getModel(Repl_1.URI) || this.modelService.createModel('', null, Repl_1.URI, true);
+                }
+                this.setMode();
+                this.replInput.setModel(this.model);
+                this.updateInputDecoration();
+                this.refreshReplElements(true);
+                if (this.styleChangedWhenInvisible) {
+                    this.styleChangedWhenInvisible = false;
+                    this.onDidStyleChange();
+                }
+            }
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('debug.console.wordWrap') && this.tree) {
+                this.tree.dispose();
+                this.treeContainer.innerText = '';
+                clearNode(this.treeContainer);
+                this.createReplTree();
+            }
+            if (e.affectsConfiguration('debug.console.acceptSuggestionOnEnter')) {
+                const config = this.configurationService.getValue('debug');
+                this.replInput.updateOptions({
+                    acceptSuggestionOnEnter: config.console.acceptSuggestionOnEnter === 'on' ? 'on' : 'off'
+                });
+            }
+        }));
+        this._register(this.editorService.onDidActiveEditorChange(() => {
+            this.setMode();
+        }));
+        this._register(this.filterWidget.onDidChangeFilterText(() => {
+            this.filter.filterQuery = this.filterWidget.getFilterText();
+            if (this.tree) {
+                this.tree.refilter();
+                revealLastElement(this.tree);
+            }
+        }));
+    }
+    async onDidFocusSession(session) {
+        if (session) {
+            sessionsToIgnore.delete(session);
+            this.completionItemProvider?.dispose();
+            if (session.capabilities.supportsCompletionsRequest) {
+                this.completionItemProvider = this.languageFeaturesService.completionProvider.register({ scheme: DEBUG_SCHEME, pattern: '**/replinput', hasAccessToAllModels: true }, {
+                    _debugDisplayName: 'debugConsole',
+                    triggerCharacters: session.capabilities.completionTriggerCharacters || ['.'],
+                    provideCompletionItems: async (_, position, _context, token) => {
+                        this.setHistoryNavigationEnablement(false);
+                        const model = this.replInput.getModel();
+                        if (model) {
+                            const word = model.getWordAtPosition(position);
+                            const overwriteBefore = word ? word.word.length : 0;
+                            const text = model.getValue();
+                            const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
+                            const frameId = focusedStackFrame ? focusedStackFrame.frameId : undefined;
+                            const response = await session.completions(frameId, focusedStackFrame?.thread.threadId || 0, text, position, overwriteBefore, token);
+                            const suggestions = [];
+                            const computeRange = (length) => Range.fromPositions(position.delta(0, -length), position);
+                            if (response && response.body && response.body.targets) {
+                                response.body.targets.forEach(item => {
+                                    if (item && item.label) {
+                                        let insertTextRules = undefined;
+                                        let insertText = item.text || item.label;
+                                        if (typeof item.selectionStart === 'number') {
+                                            insertTextRules = 4 ;
+                                            const selectionLength = typeof item.selectionLength === 'number' ? item.selectionLength : 0;
+                                            const placeholder = selectionLength > 0 ? '${1:' + insertText.substring(item.selectionStart, item.selectionStart + selectionLength) + '}$0' : '$0';
+                                            insertText = insertText.substring(0, item.selectionStart) + placeholder + insertText.substring(item.selectionStart + selectionLength);
+                                        }
+                                        suggestions.push({
+                                            label: item.label,
+                                            insertText,
+                                            detail: item.detail,
+                                            kind: CompletionItemKinds.fromString(item.type || 'property'),
+                                            filterText: (item.start && item.length) ? text.substring(item.start, item.start + item.length).concat(item.label) : undefined,
+                                            range: computeRange(item.length || overwriteBefore),
+                                            sortText: item.sortText,
+                                            insertTextRules
+                                        });
+                                    }
+                                });
+                            }
+                            if (this.configurationService.getValue('debug').console.historySuggestions) {
+                                const history = this.history.getHistory();
+                                const idxLength = String(history.length).length;
+                                history.forEach((h, i) => suggestions.push({
+                                    label: h,
+                                    insertText: h,
+                                    kind: 18 ,
+                                    range: computeRange(h.length),
+                                    sortText: 'ZZZ' + String(history.length - i).padStart(idxLength, '0')
+                                }));
+                            }
+                            return { suggestions };
+                        }
+                        return Promise.resolve({ suggestions: [] });
+                    }
+                });
+            }
+        }
+        await this.selectSession();
+    }
+    getFilterStats() {
+        return {
+            total: this.tree?.getNode().children.length ?? 0,
+            filtered: this.tree?.getNode().children.filter(c => c.visible).length ?? 0
+        };
+    }
+    get isReadonly() {
+        const session = this.tree?.getInput();
+        if (session && session.state !== 0 ) {
+            return false;
+        }
+        return true;
+    }
+    showPreviousValue() {
+        if (!this.isReadonly) {
+            this.navigateHistory(true);
+        }
+    }
+    showNextValue() {
+        if (!this.isReadonly) {
+            this.navigateHistory(false);
+        }
+    }
+    focusFilter() {
+        this.filterWidget.focus();
+    }
+    setMode() {
+        if (!this.isVisible()) {
+            return;
+        }
+        const activeEditorControl = this.editorService.activeTextEditorControl;
+        if (isCodeEditor(activeEditorControl)) {
+            this.modelChangeListener.dispose();
+            this.modelChangeListener = activeEditorControl.onDidChangeModelLanguage(() => this.setMode());
+            if (this.model && activeEditorControl.hasModel()) {
+                this.model.setLanguage(activeEditorControl.getModel().getLanguageId());
+            }
+        }
+    }
+    onDidStyleChange() {
+        if (!this.isVisible()) {
+            this.styleChangedWhenInvisible = true;
+            return;
+        }
+        if (this.styleElement) {
+            this.replInput.updateOptions({
+                fontSize: this.replOptions.replConfiguration.fontSize,
+                lineHeight: this.replOptions.replConfiguration.lineHeight,
+                fontFamily: this.replOptions.replConfiguration.fontFamily === 'default' ? EDITOR_FONT_DEFAULTS.fontFamily : this.replOptions.replConfiguration.fontFamily
+            });
+            const replInputLineHeight = this.replInput.getOption(67 );
+            this.styleElement.textContent = `
+				.repl .repl-input-wrapper .repl-input-chevron {
+					line-height: ${replInputLineHeight}px
+				}
+
+				.repl .repl-input-wrapper .monaco-editor .lines-content {
+					background-color: ${this.replOptions.replConfiguration.backgroundColor};
+				}
+			`;
+            const cssFontFamily = this.replOptions.replConfiguration.fontFamily === 'default' ? 'var(--monaco-monospace-font)' : this.replOptions.replConfiguration.fontFamily;
+            this.container.style.setProperty(`--vscode-repl-font-family`, cssFontFamily);
+            this.container.style.setProperty(`--vscode-repl-font-size`, `${this.replOptions.replConfiguration.fontSize}px`);
+            this.container.style.setProperty(`--vscode-repl-font-size-for-twistie`, `${this.replOptions.replConfiguration.fontSizeForTwistie}px`);
+            this.container.style.setProperty(`--vscode-repl-line-height`, this.replOptions.replConfiguration.cssLineHeight);
+            this.tree?.rerender();
+            if (this.bodyContentDimension) {
+                this.layoutBodyContent(this.bodyContentDimension.height, this.bodyContentDimension.width);
+            }
+        }
+    }
+    navigateHistory(previous) {
+        const historyInput = (previous ?
+            (this.history.previous() ?? this.history.first()) : this.history.next())
+            ?? '';
+        this.replInput.setValue(historyInput);
+        status(historyInput);
+        this.replInput.setPosition({ lineNumber: 1, column: historyInput.length + 1 });
+        this.setHistoryNavigationEnablement(true);
+    }
+    async selectSession(session) {
+        const treeInput = this.tree?.getInput();
+        if (!session) {
+            const focusedSession = this.debugService.getViewModel().focusedSession;
+            if (focusedSession) {
+                session = focusedSession;
+            }
+            else if (!treeInput || ( (sessionsToIgnore.has(treeInput)))) {
+                session = this.debugService.getModel().getSessions(true).find(s => !( (sessionsToIgnore.has(s))));
+            }
+        }
+        if (session) {
+            this.replElementsChangeListener?.dispose();
+            this.replElementsChangeListener = session.onDidChangeReplElements(() => {
+                this.refreshReplElements(session.getReplElements().length === 0);
+            });
+            if (this.tree && treeInput !== session) {
+                try {
+                    await this.tree.setInput(session);
+                }
+                catch (err) {
+                    this.logService.error(err);
+                }
+                revealLastElement(this.tree);
+            }
+        }
+        this.replInput?.updateOptions({ readOnly: this.isReadonly });
+        this.updateInputDecoration();
+    }
+    async clearRepl() {
+        const session = this.tree?.getInput();
+        if (session) {
+            session.removeReplExpressions();
+            if (session.state === 0 ) {
+                sessionsToIgnore.add(session);
+                await this.selectSession();
+                this.multiSessionRepl.set(this.isMultiSessionView);
+            }
+        }
+        this.replInput.focus();
+    }
+    acceptReplInput() {
+        const session = this.tree?.getInput();
+        if (session && !this.isReadonly) {
+            session.addReplExpression(this.debugService.getViewModel().focusedStackFrame, this.replInput.getValue());
+            revealLastElement(this.tree);
+            this.history.add(this.replInput.getValue());
+            this.replInput.setValue('');
+            const shouldRelayout = this.replInputLineCount > 1;
+            this.replInputLineCount = 1;
+            if (shouldRelayout && this.bodyContentDimension) {
+                this.layoutBodyContent(this.bodyContentDimension.height, this.bodyContentDimension.width);
+            }
+        }
+    }
+    getVisibleContent() {
+        let text = '';
+        if (this.model && this.tree) {
+            const lineDelimiter = this.textResourcePropertiesService.getEOL(this.model.uri);
+            const traverseAndAppend = (node) => {
+                node.children.forEach(child => {
+                    if (child.visible) {
+                        text += ( (child.element.toString())).trimRight() + lineDelimiter;
+                        if (!child.collapsed && child.children.length) {
+                            traverseAndAppend(child);
+                        }
+                    }
+                });
+            };
+            traverseAndAppend(this.tree.getNode());
+        }
+        return removeAnsiEscapeCodes(text);
+    }
+    layoutBodyContent(height, width) {
+        this.bodyContentDimension = new Dimension(width, height);
+        const replInputHeight = Math.min(this.replInput.getContentHeight(), height);
+        if (this.tree) {
+            const lastElementVisible = this.tree.scrollTop + this.tree.renderHeight >= this.tree.scrollHeight;
+            const treeHeight = height - replInputHeight;
+            this.tree.getHTMLElement().style.height = `${treeHeight}px`;
+            this.tree.layout(treeHeight, width);
+            if (lastElementVisible) {
+                revealLastElement(this.tree);
+            }
+        }
+        this.replInputContainer.style.height = `${replInputHeight}px`;
+        this.replInput.layout({ width: width - 30, height: replInputHeight });
+    }
+    collapseAll() {
+        this.tree?.collapseAll();
+    }
+    getReplInput() {
+        return this.replInput;
+    }
+    focus() {
+        super.focus();
+        setTimeout(() => this.replInput.focus(), 0);
+    }
+    getActionViewItem(action) {
+        if (action.id === selectReplCommandId) {
+            const session = (this.tree ? this.tree.getInput() : undefined) ?? this.debugService.getViewModel().focusedSession;
+            return this.instantiationService.createInstance(SelectReplActionViewItem, action, session);
+        }
+        return super.getActionViewItem(action);
+    }
+    get isMultiSessionView() {
+        return this.debugService.getModel().getSessions(true).filter(s => s.hasSeparateRepl() && !( (sessionsToIgnore.has(s)))).length > 1;
+    }
+    get refreshScheduler() {
+        const autoExpanded = ( (new Set()));
+        return (
+             (new RunOnceScheduler(async () => {
+                if (!this.tree) {
+                    return;
+                }
+                if (!this.tree.getInput()) {
+                    return;
+                }
+                await this.tree.updateChildren(undefined, true, false, { diffIdentityProvider: identityProvider });
+                const session = this.tree.getInput();
+                if (session) {
+                    const autoExpandElements = async (elements) => {
+                        for (const element of elements) {
+                            if (element instanceof ReplGroup) {
+                                if (element.autoExpand && !( (autoExpanded.has(element.getId())))) {
+                                    autoExpanded.add(element.getId());
+                                    await this.tree.expand(element);
+                                }
+                                if (!this.tree.isCollapsed(element)) {
+                                    await autoExpandElements(element.getChildren());
+                                }
+                            }
+                        }
+                    };
+                    await autoExpandElements(session.getReplElements());
+                }
+                const { total, filtered } = this.getFilterStats();
+                this.filterWidget.updateBadge(total === filtered || total === 0 ? undefined : ( (localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/repl',
+                    'showing filtered repl lines',
+                    "Showing {0} of {1}",
+                    filtered,
+                    total
+                ))));
+            }, Repl_1.REFRESH_DELAY))
+        );
+    }
+    render() {
+        super.render();
+        this._register(registerNavigableContainer({
+            focusNotifiers: [this, this.filterWidget],
+            focusNextWidget: () => {
+                const element = this.tree?.getHTMLElement();
+                if (this.filterWidget.hasFocus()) {
+                    this.tree?.domFocus();
+                }
+                else if (element && isActiveElement(element)) {
+                    this.focus();
+                }
+            },
+            focusPreviousWidget: () => {
+                const element = this.tree?.getHTMLElement();
+                if (this.replInput.hasTextFocus()) {
+                    this.tree?.domFocus();
+                }
+                else if (element && isActiveElement(element)) {
+                    this.focusFilter();
+                }
+            }
+        }));
+    }
+    renderBody(parent) {
+        super.renderBody(parent);
+        this.container = append(parent, $('.repl'));
+        this.treeContainer = append(this.container, $(`.repl-tree.${MOUSE_CURSOR_TEXT_CSS_CLASS_NAME}`));
+        this.createReplInput(this.container);
+        this.createReplTree();
+    }
+    createReplTree() {
+        this.replDelegate = ( (new ReplDelegate(this.configurationService, this.replOptions)));
+        const wordWrap = this.configurationService.getValue('debug').console.wordWrap;
+        this.treeContainer.classList.toggle('word-wrap', wordWrap);
+        const linkDetector = this.instantiationService.createInstance(LinkDetector);
+        const tree = this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'DebugRepl', this.treeContainer, this.replDelegate, [
+            this.instantiationService.createInstance(ReplVariablesRenderer, linkDetector),
+            this.instantiationService.createInstance(ReplOutputElementRenderer, linkDetector),
+            ( (new ReplEvaluationInputsRenderer())),
+            this.instantiationService.createInstance(ReplGroupRenderer, linkDetector),
+            ( (new ReplEvaluationResultsRenderer(linkDetector))),
+            ( (new ReplRawObjectsRenderer(linkDetector))),
+        ],
+        (
+        (new ReplDataSource())), {
+            filter: this.filter,
+            accessibilityProvider: ( (new ReplAccessibilityProvider())),
+            identityProvider,
+            mouseSupport: false,
+            findWidgetEnabled: false,
+            keyboardNavigationLabelProvider: { getKeyboardNavigationLabel: (e) => ( (e.toString(true))) },
+            horizontalScrolling: !wordWrap,
+            setRowLineHeight: false,
+            supportDynamicHeights: wordWrap,
+            overrideStyles: {
+                listBackground: this.getBackgroundColor()
+            }
+        });
+        this._register(tree.onDidChangeContentHeight(() => {
+            if (tree.scrollHeight !== this.previousTreeScrollHeight) {
+                const lastElementWasVisible = tree.scrollTop + tree.renderHeight >= this.previousTreeScrollHeight - 2;
+                if (lastElementWasVisible) {
+                    setTimeout(() => {
+                        revealLastElement(tree);
+                    }, 0);
+                }
+            }
+            this.previousTreeScrollHeight = tree.scrollHeight;
+        }));
+        this._register(tree.onContextMenu(e => this.onContextMenu(e)));
+        let lastSelectedString;
+        this._register(tree.onMouseClick(() => {
+            const selection = getWindow(this.treeContainer).getSelection();
+            if (!selection || selection.type !== 'Range' || lastSelectedString === ( (selection.toString()))) {
+                this.replInput.focus();
+            }
+            lastSelectedString = selection ? ( (selection.toString())) : '';
+        }));
+        this.selectSession();
+        this.styleElement = createStyleSheet(this.container);
+        this.onDidStyleChange();
+    }
+    createReplInput(container) {
+        this.replInputContainer = append(container, $('.repl-input-wrapper'));
+        append(this.replInputContainer, $('.repl-input-chevron' + ThemeIcon.asCSSSelector(debugConsoleEvaluationPrompt)));
+        const { historyNavigationBackwardsEnablement, historyNavigationForwardsEnablement } = this._register(registerAndCreateHistoryNavigationContext(this.scopedContextKeyService, this));
+        this.setHistoryNavigationEnablement = enabled => {
+            historyNavigationBackwardsEnablement.set(enabled);
+            historyNavigationForwardsEnablement.set(enabled);
+        };
+        CONTEXT_IN_DEBUG_REPL.bindTo(this.scopedContextKeyService).set(true);
+        this.scopedInstantiationService = this.instantiationService.createChild(( (new ServiceCollection([IContextKeyService, this.scopedContextKeyService]))));
+        const options = getSimpleEditorOptions(this.configurationService);
+        options.readOnly = true;
+        options.suggest = { showStatusBar: true };
+        const config = this.configurationService.getValue('debug');
+        options.acceptSuggestionOnEnter = config.console.acceptSuggestionOnEnter === 'on' ? 'on' : 'off';
+        options.ariaLabel = ( (localizeWithPath('vs/workbench/contrib/debug/browser/repl', 'debugConsole', "Debug Console")));
+        this.replInput = this.scopedInstantiationService.createInstance(CodeEditorWidget, this.replInputContainer, options, getSimpleCodeEditorWidgetOptions());
+        this._register(this.replInput.onDidChangeModelContent(() => {
+            const model = this.replInput.getModel();
+            this.setHistoryNavigationEnablement(!!model && model.getValue() === '');
+            const lineCount = model ? Math.min(10, model.getLineCount()) : 1;
+            if (lineCount !== this.replInputLineCount) {
+                this.replInputLineCount = lineCount;
+                if (this.bodyContentDimension) {
+                    this.layoutBodyContent(this.bodyContentDimension.height, this.bodyContentDimension.width);
+                }
+            }
+        }));
+        this._register(this.replInput.onDidFocusEditorText(() => this.updateInputDecoration()));
+        this._register(this.replInput.onDidBlurEditorText(() => this.updateInputDecoration()));
+        this._register(addStandardDisposableListener(this.replInputContainer, EventType.FOCUS, () => this.replInputContainer.classList.add('synthetic-focus')));
+        this._register(addStandardDisposableListener(this.replInputContainer, EventType.BLUR, () => this.replInputContainer.classList.remove('synthetic-focus')));
+    }
+    onContextMenu(e) {
+        const actions = [];
+        createAndFillInContextMenuActions(this.menu, { arg: e.element, shouldForwardArgs: false }, actions);
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => e.anchor,
+            getActions: () => actions,
+            getActionsContext: () => e.element
+        });
+    }
+    refreshReplElements(noDelay) {
+        if (this.tree && this.isVisible()) {
+            if (this.refreshScheduler.isScheduled()) {
+                return;
+            }
+            this.refreshScheduler.schedule(noDelay ? 0 : undefined);
+        }
+    }
+    updateInputDecoration() {
+        if (!this.replInput) {
+            return;
+        }
+        const decorations = [];
+        if (this.isReadonly && this.replInput.hasTextFocus() && !this.replInput.getValue()) {
+            const transparentForeground = resolveColorValue(editorForeground, this.themeService.getColorTheme())?.transparent(0.4);
+            decorations.push({
+                range: {
+                    startLineNumber: 0,
+                    endLineNumber: 0,
+                    startColumn: 0,
+                    endColumn: 1
+                },
+                renderOptions: {
+                    after: {
+                        contentText: ( (localizeWithPath(
+                            'vs/workbench/contrib/debug/browser/repl',
+                            'startDebugFirst',
+                            "Please start a debug session to evaluate expressions"
+                        ))),
+                        color: transparentForeground ? ( (transparentForeground.toString())) : undefined
+                    }
+                }
+            });
+        }
+        this.replInput.setDecorationsByType('repl-decoration', DECORATION_KEY, decorations);
+    }
+    saveState() {
+        const replHistory = this.history.getHistory();
+        if (replHistory.length) {
+            this.storageService.store(HISTORY_STORAGE_KEY, JSON.stringify(replHistory), 1 , 1 );
+        }
+        else {
+            this.storageService.remove(HISTORY_STORAGE_KEY, 1 );
+        }
+        const filterHistory = this.filterWidget.getHistory();
+        if (filterHistory.length) {
+            this.storageService.store(FILTER_HISTORY_STORAGE_KEY, JSON.stringify(filterHistory), 1 , 1 );
+        }
+        else {
+            this.storageService.remove(FILTER_HISTORY_STORAGE_KEY, 1 );
+        }
+        const filterValue = this.filterWidget.getFilterText();
+        if (filterValue) {
+            this.storageService.store(FILTER_VALUE_STORAGE_KEY, filterValue, 1 , 1 );
+        }
+        else {
+            this.storageService.remove(FILTER_VALUE_STORAGE_KEY, 1 );
+        }
+        super.saveState();
+    }
+    dispose() {
+        this.replInput?.dispose();
+        this.replElementsChangeListener?.dispose();
+        this.refreshScheduler.dispose();
+        this.modelChangeListener.dispose();
+        super.dispose();
+    }
+};
+Repl.__decorator = ( (__decorate([
+    memoize
+], Repl.prototype, "refreshScheduler", null)));
+Repl = Repl_1 = ( (__decorate([
+    ( (__param(1, IDebugService))),
+    ( (__param(2, IInstantiationService))),
+    ( (__param(3, IStorageService))),
+    ( (__param(4, IThemeService))),
+    ( (__param(5, IModelService))),
+    ( (__param(6, IContextKeyService))),
+    ( (__param(7, ICodeEditorService))),
+    ( (__param(8, IViewDescriptorService))),
+    ( (__param(9, IContextMenuService))),
+    ( (__param(10, IConfigurationService))),
+    ( (__param(11, ITextResourcePropertiesService))),
+    ( (__param(12, IEditorService))),
+    ( (__param(13, IKeybindingService))),
+    ( (__param(14, IOpenerService))),
+    ( (__param(15, ITelemetryService))),
+    ( (__param(16, IMenuService))),
+    ( (__param(17, ILanguageFeaturesService))),
+    ( (__param(18, ILogService)))
+], Repl)));
+let ReplOptions = class ReplOptions extends Disposable {
+    static { ReplOptions_1 = this; }
+    static { this.lineHeightEm = 1.4; }
+    get replConfiguration() {
+        return this._replConfig;
+    }
+    constructor(viewId, backgroundColorDelegate, configurationService, themeService, viewDescriptorService) {
+        super();
+        this.backgroundColorDelegate = backgroundColorDelegate;
+        this.configurationService = configurationService;
+        this.themeService = themeService;
+        this.viewDescriptorService = viewDescriptorService;
+        this._onDidChange = this._register(( (new Emitter())));
+        this.onDidChange = this._onDidChange.event;
+        this._register(this.themeService.onDidColorThemeChange(e => this.update()));
+        this._register(this.viewDescriptorService.onDidChangeLocation(e => {
+            if (( (e.views.some(v => v.id === viewId)))) {
+                this.update();
+            }
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('debug.console.lineHeight') || e.affectsConfiguration('debug.console.fontSize') || e.affectsConfiguration('debug.console.fontFamily')) {
+                this.update();
+            }
+        }));
+        this.update();
+    }
+    update() {
+        const debugConsole = this.configurationService.getValue('debug').console;
+        this._replConfig = {
+            fontSize: debugConsole.fontSize,
+            fontFamily: debugConsole.fontFamily,
+            lineHeight: debugConsole.lineHeight ? debugConsole.lineHeight : ReplOptions_1.lineHeightEm * debugConsole.fontSize,
+            cssLineHeight: debugConsole.lineHeight ? `${debugConsole.lineHeight}px` : `${ReplOptions_1.lineHeightEm}em`,
+            backgroundColor: this.themeService.getColorTheme().getColor(this.backgroundColorDelegate()),
+            fontSizeForTwistie: debugConsole.fontSize * ReplOptions_1.lineHeightEm / 2 - 8
+        };
+        this._onDidChange.fire();
+    }
+};
+ReplOptions = ReplOptions_1 = ( (__decorate([
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, IThemeService))),
+    ( (__param(4, IViewDescriptorService)))
+], ReplOptions)));
+class AcceptReplInputAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'repl.action.acceptInput',
+            label: ( (localizeWithPath(
+                'vs/workbench/contrib/debug/browser/repl',
+                { key: 'actions.repl.acceptInput', comment: ['Apply input from the debug console input box'] },
+                "REPL Accept Input"
+            ))),
+            alias: 'REPL Accept Input',
+            precondition: CONTEXT_IN_DEBUG_REPL,
+            kbOpts: {
+                kbExpr: EditorContextKeys.textInputFocus,
+                primary: 3 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor, editor) {
+        SuggestController.get(editor)?.cancelSuggestWidget();
+        const repl = getReplView(accessor.get(IViewsService));
+        repl?.acceptReplInput();
+    }
+}
+class FilterReplAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'repl.action.filter',
+            label: ( (localizeWithPath(
+                'vs/workbench/contrib/debug/browser/repl',
+                'repl.action.filter',
+                "REPL Focus Content to Filter"
+            ))),
+            alias: 'REPL Filter',
+            precondition: CONTEXT_IN_DEBUG_REPL,
+            kbOpts: {
+                kbExpr: EditorContextKeys.textInputFocus,
+                primary: 2048  | 36 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor, editor) {
+        const repl = getReplView(accessor.get(IViewsService));
+        repl?.focusFilter();
+    }
+}
+class ReplCopyAllAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'repl.action.copyAll',
+            label: ( (localizeWithPath(
+                'vs/workbench/contrib/debug/browser/repl',
+                'actions.repl.copyAll',
+                "Debug: Console Copy All"
+            ))),
+            alias: 'Debug Console Copy All',
+            precondition: CONTEXT_IN_DEBUG_REPL,
+        });
+    }
+    run(accessor, editor) {
+        const clipboardService = accessor.get(IClipboardService);
+        const repl = getReplView(accessor.get(IViewsService));
+        if (repl) {
+            return clipboardService.writeText(repl.getVisibleContent());
+        }
+    }
+}
+registerEditorAction(AcceptReplInputAction);
+registerEditorAction(ReplCopyAllAction);
+registerEditorAction(FilterReplAction);
+class SelectReplActionViewItem extends FocusSessionActionViewItem {
+    getSessions() {
+        return this.debugService.getModel().getSessions(true).filter(s => s.hasSeparateRepl() && !( (sessionsToIgnore.has(s))));
+    }
+    mapFocusedSessionToSelected(focusedSession) {
+        while (focusedSession.parentSession && !focusedSession.hasSeparateRepl()) {
+            focusedSession = focusedSession.parentSession;
+        }
+        return focusedSession;
+    }
+}
+function getReplView(viewsService) {
+    return viewsService.getActiveViewWithId(REPL_VIEW_ID) ?? undefined;
+}
+const selectReplCommandId = 'workbench.action.debug.selectRepl';
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: selectReplCommandId,
+            viewId: REPL_VIEW_ID,
+            title: ( (localizeWithPath(
+                'vs/workbench/contrib/debug/browser/repl',
+                'selectRepl',
+                "Select Debug Console"
+            ))),
+            f1: false,
+            menu: {
+                id: MenuId.ViewTitle,
+                group: 'navigation',
+                when: ( (ContextKeyExpr.and(
+                     (ContextKeyExpr.equals('view', REPL_VIEW_ID)),
+                    CONTEXT_MULTI_SESSION_REPL
+                ))),
+                order: 20
+            }
+        });
+    }
+    async runInView(accessor, view, session) {
+        const debugService = accessor.get(IDebugService);
+        if (session && session.state !== 0  && session !== debugService.getViewModel().focusedSession) {
+            if (session.state !== 2 ) {
+                const stopppedChildSession = debugService.getModel().getSessions().find(s => s.parentSession === session && s.state === 2 );
+                if (stopppedChildSession) {
+                    session = stopppedChildSession;
+                }
+            }
+            await debugService.focusStackFrame(undefined, undefined, session, { explicit: true });
+        }
+        await view.selectSession(session);
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: 'workbench.debug.panel.action.clearReplAction',
+            viewId: REPL_VIEW_ID,
+            title: ( (localize2WithPath('vs/workbench/contrib/debug/browser/repl', 'clearRepl', 'Clear Console'))),
+            f1: true,
+            icon: debugConsoleClearAll,
+            menu: [{
+                    id: MenuId.ViewTitle,
+                    group: 'navigation',
+                    when: ( (ContextKeyExpr.equals('view', REPL_VIEW_ID))),
+                    order: 30
+                }, {
+                    id: MenuId.DebugConsoleContext,
+                    group: 'z_commands',
+                    order: 20
+                }]
+        });
+    }
+    runInView(_accessor, view) {
+        const accessibilitySignalService = _accessor.get(IAccessibilitySignalService);
+        view.clearRepl();
+        accessibilitySignalService.playSignal(AccessibilitySignal.clear);
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: 'debug.collapseRepl',
+            title: ( (localizeWithPath('vs/workbench/contrib/debug/browser/repl', 'collapse', "Collapse All"))),
+            viewId: REPL_VIEW_ID,
+            menu: {
+                id: MenuId.DebugConsoleContext,
+                group: 'z_commands',
+                order: 10
+            }
+        });
+    }
+    runInView(_accessor, view) {
+        view.collapseAll();
+        view.focus();
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: 'debug.replPaste',
+            title: ( (localizeWithPath('vs/workbench/contrib/debug/browser/repl', 'paste', "Paste"))),
+            viewId: REPL_VIEW_ID,
+            precondition: ( (CONTEXT_DEBUG_STATE.notEqualsTo(getStateLabel(0 )))),
+            menu: {
+                id: MenuId.DebugConsoleContext,
+                group: '2_cutcopypaste',
+                order: 30
+            }
+        });
+    }
+    async runInView(accessor, view) {
+        const clipboardService = accessor.get(IClipboardService);
+        const clipboardText = await clipboardService.readText();
+        if (clipboardText) {
+            const replInput = view.getReplInput();
+            replInput.setValue(replInput.getValue().concat(clipboardText));
+            view.focus();
+            const model = replInput.getModel();
+            const lineNumber = model ? model.getLineCount() : 0;
+            const column = model?.getLineMaxColumn(lineNumber);
+            if (typeof lineNumber === 'number' && typeof column === 'number') {
+                replInput.setPosition({ lineNumber, column });
+            }
+        }
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: 'workbench.debug.action.copyAll',
+            title: ( (localizeWithPath('vs/workbench/contrib/debug/browser/repl', 'copyAll', "Copy All"))),
+            viewId: REPL_VIEW_ID,
+            menu: {
+                id: MenuId.DebugConsoleContext,
+                group: '2_cutcopypaste',
+                order: 20
+            }
+        });
+    }
+    async runInView(accessor, view) {
+        const clipboardService = accessor.get(IClipboardService);
+        await clipboardService.writeText(view.getVisibleContent());
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'debug.replCopy',
+            title: ( (localizeWithPath('vs/workbench/contrib/debug/browser/repl', 'copy', "Copy"))),
+            menu: {
+                id: MenuId.DebugConsoleContext,
+                group: '2_cutcopypaste',
+                order: 10
+            }
+        });
+    }
+    async run(accessor, element) {
+        const clipboardService = accessor.get(IClipboardService);
+        const debugService = accessor.get(IDebugService);
+        const nativeSelection = getActiveWindow().getSelection();
+        const selectedText = nativeSelection?.toString();
+        if (selectedText && selectedText.length > 0) {
+            return clipboardService.writeText(selectedText);
+        }
+        else if (element) {
+            return clipboardService.writeText((await this.tryEvaluateAndCopy(debugService, element)) || ( (element.toString())));
+        }
+    }
+    async tryEvaluateAndCopy(debugService, element) {
+        if (!(element instanceof ReplEvaluationResult)) {
+            return;
+        }
+        const stackFrame = debugService.getViewModel().focusedStackFrame;
+        const session = debugService.getViewModel().focusedSession;
+        if (!stackFrame || !session || !session.capabilities.supportsClipboardContext) {
+            return;
+        }
+        try {
+            const evaluation = await session.evaluate(element.originalExpression, stackFrame.frameId, 'clipboard');
+            return evaluation?.body.result;
+        }
+        catch (e) {
+            return;
+        }
+    }
+});
+
+export { Repl };