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

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

@@ -0,0 +1,734 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { append, $ as $$1 } from 'vscode/vscode/vs/base/browser/dom';
+import { HighlightedLabel } from 'vscode/vscode/vs/base/browser/ui/highlightedlabel/highlightedLabel';
+import { Action } from 'vscode/vscode/vs/base/common/actions';
+import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
+import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { createMatches } from 'vscode/vscode/vs/base/common/filters';
+import { toDisposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { createAndFillInContextMenuActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { MenuId, registerAction2, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService';
+import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextMenuService, IContextViewService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { WorkbenchAsyncDataTree } from 'vscode/vscode/vs/platform/list/browser/listService';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { ViewAction, ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { AbstractExpressionsRenderer, renderExpressionValue, renderVariable, renderViewTree, AbstractExpressionDataSource } from 'vscode/vscode/vs/workbench/contrib/debug/browser/baseDebugView';
+import { LinkDetector } from './linkDetector.js';
+import { IDebugService, VARIABLES_VIEW_ID, CONTEXT_VARIABLES_FOCUSED, CONTEXT_BREAK_WHEN_VALUE_CHANGES_SUPPORTED, CONTEXT_BREAK_WHEN_VALUE_IS_ACCESSED_SUPPORTED, CONTEXT_BREAK_WHEN_VALUE_IS_READ_SUPPORTED } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { getContextForVariable } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugContext';
+import { VisualizedExpression, Variable, getUriForDebugMemory, Expression, ErrorScope, Scope, StackFrame } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugModel';
+import { IDebugVisualizerService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugVisualizers';
+import { IExtensionsWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { IEditorService, SIDE_GROUP } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+
+var VisualizedVariableRenderer_1, VariablesRenderer_1;
+const $ = $$1;
+let forgetScopes = true;
+let variableInternalContext;
+let dataBreakpointInfoResponse;
+let VariablesView = class VariablesView extends ViewPane {
+    constructor(options, contextMenuService, debugService, keybindingService, configurationService, instantiationService, viewDescriptorService, contextKeyService, openerService, themeService, telemetryService, menuService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.debugService = debugService;
+        this.menuService = menuService;
+        this.needsRefresh = false;
+        this.savedViewState = ( new Map());
+        this.autoExpandedScopes = ( new Set());
+        this.updateTreeScheduler = ( new RunOnceScheduler(async () => {
+            const stackFrame = this.debugService.getViewModel().focusedStackFrame;
+            this.needsRefresh = false;
+            const input = this.tree.getInput();
+            if (input) {
+                this.savedViewState.set(input.getId(), this.tree.getViewState());
+            }
+            if (!stackFrame) {
+                await this.tree.setInput(null);
+                return;
+            }
+            const viewState = this.savedViewState.get(stackFrame.getId());
+            await this.tree.setInput(stackFrame, viewState);
+            const scopes = await stackFrame.getScopes();
+            const toExpand = scopes.find(s => !s.expensive);
+            if (toExpand && this.tree.hasNode(toExpand)) {
+                this.autoExpandedScopes.add(toExpand.getId());
+                await this.tree.expand(toExpand);
+            }
+        }, 400));
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        this.element.classList.add('debug-pane');
+        container.classList.add('debug-variables');
+        const treeContainer = renderViewTree(container);
+        const linkDetector = this.instantiationService.createInstance(LinkDetector);
+        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'VariablesView', treeContainer, ( new VariablesDelegate()), [
+            this.instantiationService.createInstance(VariablesRenderer, linkDetector),
+            this.instantiationService.createInstance(VisualizedVariableRenderer, linkDetector),
+            ( new ScopesRenderer()),
+            ( new ScopeErrorRenderer()),
+        ], this.instantiationService.createInstance(VariablesDataSource), {
+            accessibilityProvider: ( new VariablesAccessibilityProvider()),
+            identityProvider: { getId: (element) => element.getId() },
+            keyboardNavigationLabelProvider: { getKeyboardNavigationLabel: (e) => e.name },
+            overrideStyles: {
+                listBackground: this.getBackgroundColor()
+            }
+        });
+        this._register(VisualizedVariableRenderer.rendererOnVisualizationRange(this.debugService.getViewModel(), this.tree));
+        this.tree.setInput(this.debugService.getViewModel().focusedStackFrame ?? null);
+        CONTEXT_VARIABLES_FOCUSED.bindTo(this.tree.contextKeyService);
+        this._register(this.debugService.getViewModel().onDidFocusStackFrame(sf => {
+            if (!this.isBodyVisible()) {
+                this.needsRefresh = true;
+                return;
+            }
+            const timeout = sf.explicit ? 0 : undefined;
+            this.updateTreeScheduler.schedule(timeout);
+        }));
+        this._register(this.debugService.getViewModel().onWillUpdateViews(() => {
+            const stackFrame = this.debugService.getViewModel().focusedStackFrame;
+            if (stackFrame && forgetScopes) {
+                stackFrame.forgetScopes();
+            }
+            forgetScopes = true;
+            this.tree.updateChildren();
+        }));
+        this._register(this.tree);
+        this._register(this.tree.onMouseDblClick(e => this.onMouseDblClick(e)));
+        this._register(this.tree.onContextMenu(async (e) => await this.onContextMenu(e)));
+        this._register(this.onDidChangeBodyVisibility(visible => {
+            if (visible && this.needsRefresh) {
+                this.updateTreeScheduler.schedule();
+            }
+        }));
+        let horizontalScrolling;
+        this._register(this.debugService.getViewModel().onDidSelectExpression(e => {
+            const variable = e?.expression;
+            if (variable && this.tree.hasNode(variable)) {
+                horizontalScrolling = this.tree.options.horizontalScrolling;
+                if (horizontalScrolling) {
+                    this.tree.updateOptions({ horizontalScrolling: false });
+                }
+                this.tree.rerender(variable);
+            }
+            else if (!e && horizontalScrolling !== undefined) {
+                this.tree.updateOptions({ horizontalScrolling: horizontalScrolling });
+                horizontalScrolling = undefined;
+            }
+        }));
+        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.onDidEndSession(() => {
+            this.savedViewState.clear();
+            this.autoExpandedScopes.clear();
+        }));
+    }
+    layoutBody(width, height) {
+        super.layoutBody(height, width);
+        this.tree.layout(width, height);
+    }
+    focus() {
+        super.focus();
+        this.tree.domFocus();
+    }
+    collapseAll() {
+        this.tree.collapseAll();
+    }
+    onMouseDblClick(e) {
+        if (this.canSetExpressionValue(e.element)) {
+            this.debugService.getViewModel().setSelectedExpression(e.element, false);
+        }
+    }
+    canSetExpressionValue(e) {
+        const session = this.debugService.getViewModel().focusedSession;
+        if (!session) {
+            return false;
+        }
+        if (e instanceof VisualizedExpression) {
+            return !!e.treeItem.canEdit;
+        }
+        return e instanceof Variable && !e.presentationHint?.attributes?.includes('readOnly') && !e.presentationHint?.lazy;
+    }
+    async onContextMenu(e) {
+        const variable = e.element;
+        if (!(variable instanceof Variable) || !variable.value) {
+            return;
+        }
+        return openContextMenuForVariableTreeElement(this.contextKeyService, this.menuService, this.contextMenuService, MenuId.DebugVariablesContext, e);
+    }
+};
+VariablesView = ( __decorate([
+    ( __param(1, IContextMenuService)),
+    ( __param(2, IDebugService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IViewDescriptorService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, IOpenerService)),
+    ( __param(9, IThemeService)),
+    ( __param(10, ITelemetryService)),
+    ( __param(11, IMenuService))
+], VariablesView));
+async function openContextMenuForVariableTreeElement(parentContextKeyService, menuService, contextMenuService, menuId, e) {
+    const variable = e.element;
+    if (!(variable instanceof Variable) || !variable.value) {
+        return;
+    }
+    const toDispose = ( new DisposableStore());
+    try {
+        const contextKeyService = await getContextForVariableMenuWithDataAccess(parentContextKeyService, variable);
+        const menu = toDispose.add(menuService.createMenu(menuId, contextKeyService));
+        const context = getVariablesContext(variable);
+        const secondary = [];
+        createAndFillInContextMenuActions(menu, { arg: context, shouldForwardArgs: false }, { primary: [], secondary }, 'inline');
+        contextMenuService.showContextMenu({
+            getAnchor: () => e.anchor,
+            getActions: () => secondary
+        });
+    }
+    finally {
+        toDispose.dispose();
+    }
+}
+const getVariablesContext = (variable) => ({
+    sessionId: variable.getSession()?.getId(),
+    container: variable.parent instanceof Expression
+        ? { expression: variable.parent.name }
+        : variable.parent.toDebugProtocolObject(),
+    variable: variable.toDebugProtocolObject()
+});
+async function getContextForVariableMenuWithDataAccess(parentContext, variable) {
+    const session = variable.getSession();
+    if (!session || !session.capabilities.supportsDataBreakpoints) {
+        return getContextForVariableMenuBase(parentContext, variable);
+    }
+    const contextKeys = [];
+    dataBreakpointInfoResponse = await session.dataBreakpointInfo(variable.name, variable.parent.reference);
+    const dataBreakpointId = dataBreakpointInfoResponse?.dataId;
+    const dataBreakpointAccessTypes = dataBreakpointInfoResponse?.accessTypes;
+    if (!dataBreakpointAccessTypes) {
+        contextKeys.push([CONTEXT_BREAK_WHEN_VALUE_CHANGES_SUPPORTED.key, !!dataBreakpointId]);
+    }
+    else {
+        for (const accessType of dataBreakpointAccessTypes) {
+            switch (accessType) {
+                case 'read':
+                    contextKeys.push([CONTEXT_BREAK_WHEN_VALUE_IS_READ_SUPPORTED.key, !!dataBreakpointId]);
+                    break;
+                case 'write':
+                    contextKeys.push([CONTEXT_BREAK_WHEN_VALUE_CHANGES_SUPPORTED.key, !!dataBreakpointId]);
+                    break;
+                case 'readWrite':
+                    contextKeys.push([CONTEXT_BREAK_WHEN_VALUE_IS_ACCESSED_SUPPORTED.key, !!dataBreakpointId]);
+                    break;
+            }
+        }
+    }
+    return getContextForVariableMenuBase(parentContext, variable, contextKeys);
+}
+function getContextForVariableMenuBase(parentContext, variable, additionalContext = []) {
+    variableInternalContext = variable;
+    return getContextForVariable(parentContext, variable, additionalContext);
+}
+function isStackFrame(obj) {
+    return obj instanceof StackFrame;
+}
+class VariablesDataSource extends AbstractExpressionDataSource {
+    hasChildren(element) {
+        if (!element) {
+            return false;
+        }
+        if (isStackFrame(element)) {
+            return true;
+        }
+        return element.hasChildren;
+    }
+    doGetChildren(element) {
+        if (isStackFrame(element)) {
+            return element.getScopes();
+        }
+        return element.getChildren();
+    }
+}
+class VariablesDelegate {
+    getHeight(element) {
+        return 22;
+    }
+    getTemplateId(element) {
+        if (element instanceof ErrorScope) {
+            return ScopeErrorRenderer.ID;
+        }
+        if (element instanceof Scope) {
+            return ScopesRenderer.ID;
+        }
+        if (element instanceof VisualizedExpression) {
+            return VisualizedVariableRenderer.ID;
+        }
+        return VariablesRenderer.ID;
+    }
+}
+class ScopesRenderer {
+    static { this.ID = 'scope'; }
+    get templateId() {
+        return ScopesRenderer.ID;
+    }
+    renderTemplate(container) {
+        const name = append(container, $('.scope'));
+        const label = ( new HighlightedLabel(name));
+        return { name, label };
+    }
+    renderElement(element, index, templateData) {
+        templateData.label.set(element.element.name, createMatches(element.filterData));
+    }
+    disposeTemplate(templateData) {
+        templateData.label.dispose();
+    }
+}
+class ScopeErrorRenderer {
+    static { this.ID = 'scopeError'; }
+    get templateId() {
+        return ScopeErrorRenderer.ID;
+    }
+    renderTemplate(container) {
+        const wrapper = append(container, $('.scope'));
+        const error = append(wrapper, $('.error'));
+        return { error };
+    }
+    renderElement(element, index, templateData) {
+        templateData.error.innerText = element.element.name;
+    }
+    disposeTemplate() {
+    }
+}
+let VisualizedVariableRenderer = class VisualizedVariableRenderer extends AbstractExpressionsRenderer {
+    static { VisualizedVariableRenderer_1 = this; }
+    static { this.ID = 'viz'; }
+    static rendererOnVisualizationRange(model, tree) {
+        return model.onDidChangeVisualization(({ original }) => {
+            if (!tree.hasNode(original)) {
+                return;
+            }
+            const parent = tree.getParentElement(original);
+            tree.updateChildren(parent, false, false);
+        });
+    }
+    constructor(linkDetector, debugService, contextViewService, menuService, contextKeyService) {
+        super(debugService, contextViewService);
+        this.linkDetector = linkDetector;
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+    }
+    get templateId() {
+        return VisualizedVariableRenderer_1.ID;
+    }
+    renderElement(node, index, data) {
+        super.renderExpressionElement(node.element, node, data);
+    }
+    renderExpression(expression, data, highlights) {
+        const viz = expression;
+        let text = viz.name;
+        if (viz.value && typeof viz.name === 'string') {
+            text += ':';
+        }
+        data.label.set(text, highlights, viz.name);
+        renderExpressionValue(viz, data.value, {
+            showChanged: false,
+            maxValueLength: 1024,
+            showHover: true,
+            colorize: true,
+            linkDetector: this.linkDetector
+        });
+    }
+    getInputBoxOptions(expression) {
+        const viz = expression;
+        return {
+            initialValue: expression.value,
+            ariaLabel: ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/variablesView',
+                'variableValueAriaLabel',
+                "Type new variable value"
+            )),
+            validationOptions: {
+                validation: () => viz.errorMessage ? ({ content: viz.errorMessage }) : null
+            },
+            onFinish: (value, success) => {
+                viz.errorMessage = undefined;
+                if (success) {
+                    viz.edit(value).then(() => {
+                        forgetScopes = false;
+                        this.debugService.getViewModel().updateViews();
+                    });
+                }
+            }
+        };
+    }
+    renderActionBar(actionBar, expression, _data) {
+        const viz = expression;
+        const contextKeyService = viz.original ? getContextForVariableMenuBase(this.contextKeyService, viz.original) : this.contextKeyService;
+        const menu = this.menuService.createMenu(MenuId.DebugVariablesContext, contextKeyService);
+        const primary = [];
+        const context = viz.original ? getVariablesContext(viz.original) : undefined;
+        createAndFillInContextMenuActions(menu, { arg: context, shouldForwardArgs: false }, { primary, secondary: [] }, 'inline');
+        if (viz.original) {
+            const action = ( new Action('debugViz', ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/variablesView',
+                'removeVisualizer',
+                'Remove Visualizer'
+            )), ThemeIcon.asClassName(Codicon.eye), true, () => this.debugService.getViewModel().setVisualizedExpression(viz.original, undefined)));
+            action.checked = true;
+            primary.push(action);
+            actionBar.domNode.style.display = 'initial';
+        }
+        actionBar.clear();
+        actionBar.context = context;
+        actionBar.push(primary, { icon: true, label: false });
+    }
+};
+VisualizedVariableRenderer = VisualizedVariableRenderer_1 = ( __decorate([
+    ( __param(1, IDebugService)),
+    ( __param(2, IContextViewService)),
+    ( __param(3, IMenuService)),
+    ( __param(4, IContextKeyService))
+], VisualizedVariableRenderer));
+let VariablesRenderer = class VariablesRenderer extends AbstractExpressionsRenderer {
+    static { VariablesRenderer_1 = this; }
+    static { this.ID = 'variable'; }
+    constructor(linkDetector, menuService, contextKeyService, visualization, contextMenuService, debugService, contextViewService) {
+        super(debugService, contextViewService);
+        this.linkDetector = linkDetector;
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+        this.visualization = visualization;
+        this.contextMenuService = contextMenuService;
+    }
+    get templateId() {
+        return VariablesRenderer_1.ID;
+    }
+    renderExpression(expression, data, highlights) {
+        renderVariable(expression, data, true, highlights, this.linkDetector);
+    }
+    renderElement(node, index, data) {
+        super.renderExpressionElement(node.element, node, data);
+    }
+    getInputBoxOptions(expression) {
+        const variable = expression;
+        return {
+            initialValue: expression.value,
+            ariaLabel: ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/variablesView',
+                'variableValueAriaLabel',
+                "Type new variable value"
+            )),
+            validationOptions: {
+                validation: () => variable.errorMessage ? ({ content: variable.errorMessage }) : null
+            },
+            onFinish: (value, success) => {
+                variable.errorMessage = undefined;
+                const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
+                if (success && variable.value !== value && focusedStackFrame) {
+                    variable.setVariable(value, focusedStackFrame)
+                        .then(() => {
+                        forgetScopes = false;
+                        this.debugService.getViewModel().updateViews();
+                    });
+                }
+            }
+        };
+    }
+    renderActionBar(actionBar, expression, data) {
+        const variable = expression;
+        const contextKeyService = getContextForVariableMenuBase(this.contextKeyService, variable);
+        const menu = this.menuService.createMenu(MenuId.DebugVariablesContext, contextKeyService);
+        const primary = [];
+        const context = getVariablesContext(variable);
+        createAndFillInContextMenuActions(menu, { arg: context, shouldForwardArgs: false }, { primary, secondary: [] }, 'inline');
+        actionBar.clear();
+        actionBar.context = context;
+        actionBar.push(primary, { icon: true, label: false });
+        const cts = ( new CancellationTokenSource());
+        data.elementDisposable.add(toDisposable(() => cts.dispose(true)));
+        this.visualization.getApplicableFor(expression, cts.token).then(result => {
+            data.elementDisposable.add(result);
+            const originalExpression = (expression instanceof VisualizedExpression && expression.original) || expression;
+            const actions = ( result.object.map(v => ( new Action(
+                'debugViz',
+                v.name,
+                v.iconClass || 'debug-viz-icon',
+                undefined,
+                this.useVisualizer(v, originalExpression, cts.token)
+            ))));
+            if (actions.length === 0) ;
+            else if (actions.length === 1) {
+                actionBar.push(actions[0], { icon: true, label: false });
+            }
+            else {
+                actionBar.push(( new Action('debugViz', ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/variablesView',
+                    'useVisualizer',
+                    'Visualize Variable...'
+                )), ThemeIcon.asClassName(Codicon.eye), undefined, () => this.pickVisualizer(actions, originalExpression, data))), { icon: true, label: false });
+            }
+        });
+    }
+    pickVisualizer(actions, expression, data) {
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => data.actionBar.getContainer(),
+            getActions: () => actions,
+        });
+    }
+    useVisualizer(viz, expression, token) {
+        return async () => {
+            const resolved = await viz.resolve(token);
+            if (token.isCancellationRequested) {
+                return;
+            }
+            if (resolved.type === 0 ) {
+                viz.execute();
+            }
+            else {
+                const replacement = await this.visualization.getVisualizedNodeFor(resolved.id, expression);
+                if (replacement) {
+                    this.debugService.getViewModel().setVisualizedExpression(expression, replacement);
+                }
+            }
+        };
+    }
+};
+VariablesRenderer = VariablesRenderer_1 = ( __decorate([
+    ( __param(1, IMenuService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IDebugVisualizerService)),
+    ( __param(4, IContextMenuService)),
+    ( __param(5, IDebugService)),
+    ( __param(6, IContextViewService))
+], VariablesRenderer));
+class VariablesAccessibilityProvider {
+    getWidgetAriaLabel() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/variablesView',
+            'variablesAriaTreeLabel',
+            "Debug Variables"
+        ));
+    }
+    getAriaLabel(element) {
+        if (element instanceof Scope) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/variablesView',
+                'variableScopeAriaLabel',
+                "Scope {0}",
+                element.name
+            ));
+        }
+        if (element instanceof Variable) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/variablesView',
+                { key: 'variableAriaLabel', comment: ['Placeholders are variable name and variable value respectivly. They should not be translated.'] },
+                "{0}, value {1}",
+                element.name,
+                element.value
+            ));
+        }
+        return null;
+    }
+}
+const SET_VARIABLE_ID = 'debug.setVariable';
+CommandsRegistry.registerCommand({
+    id: SET_VARIABLE_ID,
+    handler: (accessor) => {
+        const debugService = accessor.get(IDebugService);
+        debugService.getViewModel().setSelectedExpression(variableInternalContext, false);
+    }
+});
+const COPY_VALUE_ID = 'workbench.debug.viewlet.action.copyValue';
+CommandsRegistry.registerCommand({
+    id: COPY_VALUE_ID,
+    handler: async (accessor, arg, ctx) => {
+        const debugService = accessor.get(IDebugService);
+        const clipboardService = accessor.get(IClipboardService);
+        let elementContext = '';
+        let elements;
+        if (arg instanceof Variable || arg instanceof Expression) {
+            elementContext = 'watch';
+            elements = ctx ? ctx : [];
+        }
+        else {
+            elementContext = 'variables';
+            elements = variableInternalContext ? [variableInternalContext] : [];
+        }
+        const stackFrame = debugService.getViewModel().focusedStackFrame;
+        const session = debugService.getViewModel().focusedSession;
+        if (!stackFrame || !session || elements.length === 0) {
+            return;
+        }
+        const evalContext = session.capabilities.supportsClipboardContext ? 'clipboard' : elementContext;
+        const toEvaluate = ( elements.map(
+            element => element instanceof Variable ? (element.evaluateName || element.value) : element.name
+        ));
+        try {
+            const evaluations = await Promise.all(( toEvaluate.map(expr => session.evaluate(expr, stackFrame.frameId, evalContext))));
+            const result = ( coalesce(evaluations).map(evaluation => evaluation.body.result));
+            if (result.length) {
+                clipboardService.writeText(result.join('\n'));
+            }
+        }
+        catch (e) {
+            const result = ( elements.map(element => element.value));
+            clipboardService.writeText(result.join('\n'));
+        }
+    }
+});
+const VIEW_MEMORY_ID = 'workbench.debug.viewlet.action.viewMemory';
+const HEX_EDITOR_EXTENSION_ID = 'ms-vscode.hexeditor';
+const HEX_EDITOR_EDITOR_ID = 'hexEditor.hexedit';
+CommandsRegistry.registerCommand({
+    id: VIEW_MEMORY_ID,
+    handler: async (accessor, arg, ctx) => {
+        const debugService = accessor.get(IDebugService);
+        let sessionId;
+        let memoryReference;
+        if ('sessionId' in arg) {
+            if (!arg.sessionId || !arg.variable.memoryReference) {
+                return;
+            }
+            sessionId = arg.sessionId;
+            memoryReference = arg.variable.memoryReference;
+        }
+        else {
+            if (!arg.memoryReference) {
+                return;
+            }
+            const focused = debugService.getViewModel().focusedSession;
+            if (!focused) {
+                return;
+            }
+            sessionId = focused.getId();
+            memoryReference = arg.memoryReference;
+        }
+        const extensionsWorkbenchService = accessor.get(IExtensionsWorkbenchService);
+        const editorService = accessor.get(IEditorService);
+        const notificationService = accessor.get(INotificationService);
+        const extensionService = accessor.get(IExtensionService);
+        const telemetryService = accessor.get(ITelemetryService);
+        const ext = await extensionService.getExtension(HEX_EDITOR_EXTENSION_ID);
+        if (ext || (await tryInstallHexEditor(extensionsWorkbenchService, notificationService))) {
+            telemetryService.publicLog('debug/didViewMemory', {
+                debugType: debugService.getModel().getSession(sessionId)?.configuration.type,
+            });
+            await editorService.openEditor({
+                resource: getUriForDebugMemory(sessionId, memoryReference),
+                options: {
+                    revealIfOpened: true,
+                    override: HEX_EDITOR_EDITOR_ID,
+                },
+            }, SIDE_GROUP);
+        }
+    }
+});
+async function tryInstallHexEditor(extensionsWorkbenchService, notificationService) {
+    try {
+        await extensionsWorkbenchService.install(HEX_EDITOR_EXTENSION_ID, {
+            justification: ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/variablesView',
+                "viewMemory.prompt",
+                "Inspecting binary data requires this extension."
+            )),
+            enable: true
+        }, 15 );
+        return true;
+    }
+    catch (error) {
+        notificationService.error(error);
+        return false;
+    }
+}
+const BREAK_WHEN_VALUE_CHANGES_ID = 'debug.breakWhenValueChanges';
+CommandsRegistry.registerCommand({
+    id: BREAK_WHEN_VALUE_CHANGES_ID,
+    handler: async (accessor) => {
+        const debugService = accessor.get(IDebugService);
+        if (dataBreakpointInfoResponse) {
+            await debugService.addDataBreakpoint({ description: dataBreakpointInfoResponse.description, src: { type: 0 , dataId: dataBreakpointInfoResponse.dataId }, canPersist: !!dataBreakpointInfoResponse.canPersist, accessTypes: dataBreakpointInfoResponse.accessTypes, accessType: 'write' });
+        }
+    }
+});
+const BREAK_WHEN_VALUE_IS_ACCESSED_ID = 'debug.breakWhenValueIsAccessed';
+CommandsRegistry.registerCommand({
+    id: BREAK_WHEN_VALUE_IS_ACCESSED_ID,
+    handler: async (accessor) => {
+        const debugService = accessor.get(IDebugService);
+        if (dataBreakpointInfoResponse) {
+            await debugService.addDataBreakpoint({ description: dataBreakpointInfoResponse.description, src: { type: 0 , dataId: dataBreakpointInfoResponse.dataId }, canPersist: !!dataBreakpointInfoResponse.canPersist, accessTypes: dataBreakpointInfoResponse.accessTypes, accessType: 'readWrite' });
+        }
+    }
+});
+const BREAK_WHEN_VALUE_IS_READ_ID = 'debug.breakWhenValueIsRead';
+CommandsRegistry.registerCommand({
+    id: BREAK_WHEN_VALUE_IS_READ_ID,
+    handler: async (accessor) => {
+        const debugService = accessor.get(IDebugService);
+        if (dataBreakpointInfoResponse) {
+            await debugService.addDataBreakpoint({ description: dataBreakpointInfoResponse.description, src: { type: 0 , dataId: dataBreakpointInfoResponse.dataId }, canPersist: !!dataBreakpointInfoResponse.canPersist, accessTypes: dataBreakpointInfoResponse.accessTypes, accessType: 'read' });
+        }
+    }
+});
+const COPY_EVALUATE_PATH_ID = 'debug.copyEvaluatePath';
+CommandsRegistry.registerCommand({
+    id: COPY_EVALUATE_PATH_ID,
+    handler: async (accessor, context) => {
+        const clipboardService = accessor.get(IClipboardService);
+        await clipboardService.writeText(context.variable.evaluateName);
+    }
+});
+const ADD_TO_WATCH_ID = 'debug.addToWatchExpressions';
+CommandsRegistry.registerCommand({
+    id: ADD_TO_WATCH_ID,
+    handler: async (accessor, context) => {
+        const debugService = accessor.get(IDebugService);
+        debugService.addWatchExpression(context.variable.evaluateName);
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: 'variables.collapse',
+            viewId: VARIABLES_VIEW_ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/variablesView',
+                'collapse',
+                "Collapse All"
+            )),
+            f1: false,
+            icon: Codicon.collapseAll,
+            menu: {
+                id: MenuId.ViewTitle,
+                group: 'navigation',
+                when: ( ContextKeyExpr.equals('view', VARIABLES_VIEW_ID))
+            }
+        });
+    }
+    runInView(_accessor, view) {
+        view.collapseAll();
+    }
+});
+
+export { ADD_TO_WATCH_ID, BREAK_WHEN_VALUE_CHANGES_ID, BREAK_WHEN_VALUE_IS_ACCESSED_ID, BREAK_WHEN_VALUE_IS_READ_ID, COPY_EVALUATE_PATH_ID, COPY_VALUE_ID, SET_VARIABLE_ID, VIEW_MEMORY_ID, VariablesRenderer, VariablesView, VisualizedVariableRenderer, openContextMenuForVariableTreeElement };