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

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

@@ -1,1002 +0,0 @@
-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 };