@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/vscode/vs/workbench/contrib/debug/browser/watchExpressionsView.js

@@ -0,0 +1,411 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { WATCH_VIEW_ID, CONTEXT_WATCH_EXPRESSIONS_EXIST, IDebugService, CONTEXT_VARIABLE_IS_READONLY, CONTEXT_WATCH_ITEM_TYPE, CONTEXT_WATCH_EXPRESSIONS_FOCUSED, CONTEXT_CAN_VIEW_MEMORY } from '../common/debug.js';
+import { Expression, Variable } from '../common/debugModel.js';
+import { IContextMenuService, IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { renderViewTree, AbstractExpressionsRenderer, renderExpressionValue } from './baseDebugView.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ViewAction, ViewPane } from '../../../browser/parts/views/viewPane.js';
+import { WorkbenchAsyncDataTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { ElementsDragAndDropData } from 'monaco-editor/esm/vs/base/browser/ui/list/listView.js';
+import { VariablesRenderer } from './variablesView.js';
+import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { watchExpressionsAdd, watchExpressionsRemoveAll } from './debugIcons.js';
+import { registerAction2, MenuId, Action2, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { createAndFillInContextMenuActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { LinkDetector } from './linkDetector.js';
+const MAX_VALUE_RENDER_LENGTH_IN_VIEWLET = 1024;
+let ignoreViewUpdates = false;
+let useCachedEvaluation = false;
+let WatchExpressionsView = class WatchExpressionsView extends ViewPane {
+    constructor(options, contextMenuService, debugService, keybindingService, instantiationService, viewDescriptorService, configurationService, contextKeyService, openerService, themeService, telemetryService, menuService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.debugService = debugService;
+        this.needsRefresh = false;
+        this.menu = menuService.createMenu(MenuId.DebugWatchContext, contextKeyService);
+        this._register(this.menu);
+        this.watchExpressionsUpdatedScheduler = ( new RunOnceScheduler(() => {
+            this.needsRefresh = false;
+            this.tree.updateChildren();
+        }, 50));
+        this.watchExpressionsExist = CONTEXT_WATCH_EXPRESSIONS_EXIST.bindTo(contextKeyService);
+        this.variableReadonly = CONTEXT_VARIABLE_IS_READONLY.bindTo(contextKeyService);
+        this.watchExpressionsExist.set(this.debugService.getModel().getWatchExpressions().length > 0);
+        this.watchItemType = CONTEXT_WATCH_ITEM_TYPE.bindTo(contextKeyService);
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        this.element.classList.add('debug-pane');
+        container.classList.add('debug-watch');
+        const treeContainer = renderViewTree(container);
+        const expressionsRenderer = this.instantiationService.createInstance(WatchExpressionsRenderer);
+        const linkeDetector = this.instantiationService.createInstance(LinkDetector);
+        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'WatchExpressions', treeContainer, ( new WatchExpressionsDelegate()), [expressionsRenderer, this.instantiationService.createInstance(VariablesRenderer, linkeDetector)], ( new WatchExpressionsDataSource()), {
+            accessibilityProvider: ( new WatchExpressionsAccessibilityProvider()),
+            identityProvider: { getId: (element) => element.getId() },
+            keyboardNavigationLabelProvider: {
+                getKeyboardNavigationLabel: (e) => {
+                    if (e === this.debugService.getViewModel().getSelectedExpression()?.expression) {
+                        return undefined;
+                    }
+                    return e.name;
+                }
+            },
+            dnd: ( new WatchExpressionsDragAndDrop(this.debugService)),
+            overrideStyles: {
+                listBackground: this.getBackgroundColor()
+            }
+        });
+        this.tree.setInput(this.debugService);
+        CONTEXT_WATCH_EXPRESSIONS_FOCUSED.bindTo(this.tree.contextKeyService);
+        this._register(this.tree.onContextMenu(e => this.onContextMenu(e)));
+        this._register(this.tree.onMouseDblClick(e => this.onMouseDblClick(e)));
+        this._register(this.debugService.getModel().onDidChangeWatchExpressions(async (we) => {
+            this.watchExpressionsExist.set(this.debugService.getModel().getWatchExpressions().length > 0);
+            if (!this.isBodyVisible()) {
+                this.needsRefresh = true;
+            }
+            else {
+                if (we && !we.name) {
+                    useCachedEvaluation = true;
+                }
+                await this.tree.updateChildren();
+                useCachedEvaluation = false;
+                if (we instanceof Expression) {
+                    this.tree.reveal(we);
+                }
+            }
+        }));
+        this._register(this.debugService.getViewModel().onDidFocusStackFrame(() => {
+            if (!this.isBodyVisible()) {
+                this.needsRefresh = true;
+                return;
+            }
+            if (!this.watchExpressionsUpdatedScheduler.isScheduled()) {
+                this.watchExpressionsUpdatedScheduler.schedule();
+            }
+        }));
+        this._register(this.debugService.getViewModel().onWillUpdateViews(() => {
+            if (!ignoreViewUpdates) {
+                this.tree.updateChildren();
+            }
+        }));
+        this._register(this.onDidChangeBodyVisibility(visible => {
+            if (visible && this.needsRefresh) {
+                this.watchExpressionsUpdatedScheduler.schedule();
+            }
+        }));
+        let horizontalScrolling;
+        this._register(this.debugService.getViewModel().onDidSelectExpression(e => {
+            const expression = e?.expression;
+            if (expression instanceof Expression || (expression instanceof Variable && e?.settingWatch)) {
+                horizontalScrolling = this.tree.options.horizontalScrolling;
+                if (horizontalScrolling) {
+                    this.tree.updateOptions({ horizontalScrolling: false });
+                }
+                if (expression.name) {
+                    this.tree.rerender(expression);
+                }
+            }
+            else if (!expression && 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);
+            }
+        }));
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this.tree.layout(height, width);
+    }
+    focus() {
+        this.tree.domFocus();
+    }
+    collapseAll() {
+        this.tree.collapseAll();
+    }
+    onMouseDblClick(e) {
+        if (e.browserEvent.target.className.indexOf('twistie') >= 0) {
+            return;
+        }
+        const element = e.element;
+        const selectedExpression = this.debugService.getViewModel().getSelectedExpression();
+        if (element instanceof Expression && element !== selectedExpression?.expression) {
+            this.debugService.getViewModel().setSelectedExpression(element, false);
+        }
+        else if (!element) {
+            this.debugService.addWatchExpression();
+        }
+    }
+    onContextMenu(e) {
+        const element = e.element;
+        const selection = this.tree.getSelection();
+        this.watchItemType.set(element instanceof Expression ? 'expression' : element instanceof Variable ? 'variable' : undefined);
+        const actions = [];
+        const attributes = element instanceof Variable ? element.presentationHint?.attributes : undefined;
+        this.variableReadonly.set(!!attributes && attributes.indexOf('readOnly') >= 0 || !!element?.presentationHint?.lazy);
+        createAndFillInContextMenuActions(this.menu, { arg: element, shouldForwardArgs: true }, actions);
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => e.anchor,
+            getActions: () => actions,
+            getActionsContext: () => element && selection.includes(element) ? selection : element ? [element] : [],
+        });
+    }
+};
+WatchExpressionsView = ( __decorate([
+    ( __param(1, IContextMenuService)),
+    ( __param(2, IDebugService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IViewDescriptorService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, IOpenerService)),
+    ( __param(9, IThemeService)),
+    ( __param(10, ITelemetryService)),
+    ( __param(11, IMenuService))
+], WatchExpressionsView));
+class WatchExpressionsDelegate {
+    getHeight(_element) {
+        return 22;
+    }
+    getTemplateId(element) {
+        if (element instanceof Expression) {
+            return WatchExpressionsRenderer.ID;
+        }
+        return VariablesRenderer.ID;
+    }
+}
+function isDebugService(element) {
+    return typeof element.getConfigurationManager === 'function';
+}
+class WatchExpressionsDataSource {
+    hasChildren(element) {
+        return isDebugService(element) || element.hasChildren;
+    }
+    getChildren(element) {
+        if (isDebugService(element)) {
+            const debugService = element;
+            const watchExpressions = debugService.getModel().getWatchExpressions();
+            const viewModel = debugService.getViewModel();
+            return Promise.all(( watchExpressions.map(we => !!we.name && !useCachedEvaluation
+                ? we.evaluate(viewModel.focusedSession, viewModel.focusedStackFrame, 'watch').then(() => we)
+                : Promise.resolve(we))));
+        }
+        return element.getChildren();
+    }
+}
+let WatchExpressionsRenderer = class WatchExpressionsRenderer extends AbstractExpressionsRenderer {
+    constructor(menuService, contextKeyService, debugService, contextViewService) {
+        super(debugService, contextViewService);
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+    }
+    get templateId() {
+        return WatchExpressionsRenderer.ID;
+    }
+    renderElement(node, index, data) {
+        super.renderExpressionElement(node.element, node, data);
+    }
+    renderExpression(expression, data, highlights) {
+        const text = typeof expression.value === 'string' ? `${expression.name}:` : expression.name;
+        let title;
+        if (expression.type) {
+            title = expression.type === expression.value ?
+                expression.type :
+                `${expression.type}: ${expression.value}`;
+        }
+        else {
+            title = expression.value;
+        }
+        data.label.set(text, highlights, title);
+        renderExpressionValue(expression, data.value, {
+            showChanged: true,
+            maxValueLength: MAX_VALUE_RENDER_LENGTH_IN_VIEWLET,
+            showHover: true,
+            colorize: true
+        });
+    }
+    getInputBoxOptions(expression, settingValue) {
+        if (settingValue) {
+            return {
+                initialValue: expression.value,
+                ariaLabel: ( localize('typeNewValue', "Type new value")),
+                onFinish: async (value, success) => {
+                    if (success && value) {
+                        const focusedFrame = this.debugService.getViewModel().focusedStackFrame;
+                        if (focusedFrame && (expression instanceof Variable || expression instanceof Expression)) {
+                            await expression.setExpression(value, focusedFrame);
+                            this.debugService.getViewModel().updateViews();
+                        }
+                    }
+                }
+            };
+        }
+        return {
+            initialValue: expression.name ? expression.name : '',
+            ariaLabel: ( localize('watchExpressionInputAriaLabel', "Type watch expression")),
+            placeholder: ( localize('watchExpressionPlaceholder', "Expression to watch")),
+            onFinish: (value, success) => {
+                if (success && value) {
+                    this.debugService.renameWatchExpression(expression.getId(), value);
+                    ignoreViewUpdates = true;
+                    this.debugService.getViewModel().updateViews();
+                    ignoreViewUpdates = false;
+                }
+                else if (!expression.name) {
+                    this.debugService.removeWatchExpressions(expression.getId());
+                }
+            }
+        };
+    }
+    renderActionBar(actionBar, expression) {
+        const contextKeyService = getContextForWatchExpressionMenu(this.contextKeyService, expression);
+        const menu = this.menuService.createMenu(MenuId.DebugWatchContext, contextKeyService);
+        const primary = [];
+        const context = expression;
+        createAndFillInContextMenuActions(menu, { arg: context, shouldForwardArgs: false }, { primary, secondary: [] }, 'inline');
+        actionBar.clear();
+        actionBar.context = context;
+        actionBar.push(primary, { icon: true, label: false });
+    }
+};
+WatchExpressionsRenderer.ID = 'watchexpression';
+WatchExpressionsRenderer = ( __decorate([
+    ( __param(0, IMenuService)),
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IDebugService)),
+    ( __param(3, IContextViewService))
+], WatchExpressionsRenderer));
+function getContextForWatchExpressionMenu(parentContext, expression) {
+    return parentContext.createOverlay([
+        [CONTEXT_CAN_VIEW_MEMORY.key, expression.memoryReference !== undefined],
+        [CONTEXT_WATCH_ITEM_TYPE.key, 'expression']
+    ]);
+}
+class WatchExpressionsAccessibilityProvider {
+    getWidgetAriaLabel() {
+        return ( localize(
+            { comment: ['Debug is a noun in this context, not a verb.'], key: 'watchAriaTreeLabel' },
+            "Debug Watch Expressions"
+        ));
+    }
+    getAriaLabel(element) {
+        if (element instanceof Expression) {
+            return ( localize('watchExpressionAriaLabel', "{0}, value {1}", element.name, element.value));
+        }
+        return ( localize('watchVariableAriaLabel', "{0}, value {1}", element.name, element.value));
+    }
+}
+class WatchExpressionsDragAndDrop {
+    constructor(debugService) {
+        this.debugService = debugService;
+    }
+    onDragOver(data) {
+        if (!(data instanceof ElementsDragAndDropData)) {
+            return false;
+        }
+        const expressions = data.elements;
+        return expressions.length > 0 && expressions[0] instanceof Expression;
+    }
+    getDragURI(element) {
+        if (!(element instanceof Expression) || element === this.debugService.getViewModel().getSelectedExpression()?.expression) {
+            return null;
+        }
+        return element.getId();
+    }
+    getDragLabel(elements) {
+        if (elements.length === 1) {
+            return elements[0].name;
+        }
+        return undefined;
+    }
+    drop(data, targetElement) {
+        if (!(data instanceof ElementsDragAndDropData)) {
+            return;
+        }
+        const draggedElement = data.elements[0];
+        const watches = this.debugService.getModel().getWatchExpressions();
+        const position = targetElement instanceof Expression ? watches.indexOf(targetElement) : watches.length - 1;
+        this.debugService.moveWatchExpression(draggedElement.getId(), position);
+    }
+}
+registerAction2(class Collapse extends ViewAction {
+    constructor() {
+        super({
+            id: 'watch.collapse',
+            viewId: WATCH_VIEW_ID,
+            title: ( localize('collapse', "Collapse All")),
+            f1: false,
+            icon: Codicon.collapseAll,
+            precondition: CONTEXT_WATCH_EXPRESSIONS_EXIST,
+            menu: {
+                id: MenuId.ViewTitle,
+                order: 30,
+                group: 'navigation',
+                when: ( ContextKeyExpr.equals('view', WATCH_VIEW_ID))
+            }
+        });
+    }
+    runInView(_accessor, view) {
+        view.collapseAll();
+    }
+});
+const ADD_WATCH_ID = 'workbench.debug.viewlet.action.addWatchExpression';
+const ADD_WATCH_LABEL = ( localize('addWatchExpression', "Add Expression"));
+registerAction2(class AddWatchExpressionAction extends Action2 {
+    constructor() {
+        super({
+            id: ADD_WATCH_ID,
+            title: ADD_WATCH_LABEL,
+            f1: false,
+            icon: watchExpressionsAdd,
+            menu: {
+                id: MenuId.ViewTitle,
+                group: 'navigation',
+                when: ( ContextKeyExpr.equals('view', WATCH_VIEW_ID))
+            }
+        });
+    }
+    run(accessor) {
+        const debugService = accessor.get(IDebugService);
+        debugService.addWatchExpression();
+    }
+});
+const REMOVE_WATCH_EXPRESSIONS_COMMAND_ID = 'workbench.debug.viewlet.action.removeAllWatchExpressions';
+const REMOVE_WATCH_EXPRESSIONS_LABEL = ( localize('removeAllWatchExpressions', "Remove All Expressions"));
+registerAction2(class RemoveAllWatchExpressionsAction extends Action2 {
+    constructor() {
+        super({
+            id: REMOVE_WATCH_EXPRESSIONS_COMMAND_ID,
+            title: REMOVE_WATCH_EXPRESSIONS_LABEL,
+            f1: false,
+            icon: watchExpressionsRemoveAll,
+            precondition: CONTEXT_WATCH_EXPRESSIONS_EXIST,
+            menu: {
+                id: MenuId.ViewTitle,
+                order: 20,
+                group: 'navigation',
+                when: ( ContextKeyExpr.equals('view', WATCH_VIEW_ID))
+            }
+        });
+    }
+    run(accessor) {
+        const debugService = accessor.get(IDebugService);
+        debugService.removeWatchExpressions();
+    }
+});
+export { ADD_WATCH_ID, ADD_WATCH_LABEL, REMOVE_WATCH_EXPRESSIONS_COMMAND_ID, REMOVE_WATCH_EXPRESSIONS_LABEL, WatchExpressionsView };

package/dist/vscode/vs/workbench/contrib/debug/browser/welcomeView.js

@@ -0,0 +1,85 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IDebugService } from '../common/debug.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { ViewPane } from '../../../browser/parts/views/viewPane.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { isCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { DEBUG_START_COMMAND_ID } from './debugCommands.js';
+const debugStartLanguageKey = 'debugStartLanguage';
+const CONTEXT_DEBUG_START_LANGUAGE = ( new RawContextKey(debugStartLanguageKey, undefined));
+const CONTEXT_DEBUGGER_INTERESTED_IN_ACTIVE_EDITOR = ( new RawContextKey('debuggerInterestedInActiveEditor', false));
+let WelcomeView = class WelcomeView extends ViewPane {
+    constructor(options, themeService, keybindingService, contextMenuService, configurationService, contextKeyService, debugService, editorService, instantiationService, viewDescriptorService, openerService, storageSevice, telemetryService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.debugService = debugService;
+        this.editorService = editorService;
+        this.debugStartLanguageContext = CONTEXT_DEBUG_START_LANGUAGE.bindTo(contextKeyService);
+        this.debuggerInterestedContext = CONTEXT_DEBUGGER_INTERESTED_IN_ACTIVE_EDITOR.bindTo(contextKeyService);
+        const lastSetLanguage = storageSevice.get(debugStartLanguageKey, 1 );
+        this.debugStartLanguageContext.set(lastSetLanguage);
+        const setContextKey = () => {
+            const editorControl = this.editorService.activeTextEditorControl;
+            if (isCodeEditor(editorControl)) {
+                const model = editorControl.getModel();
+                const language = model ? model.getLanguageId() : undefined;
+                if (language && this.debugService.getAdapterManager().someDebuggerInterestedInLanguage(language)) {
+                    this.debugStartLanguageContext.set(language);
+                    this.debuggerInterestedContext.set(true);
+                    storageSevice.store(debugStartLanguageKey, language, 1 , 1 );
+                    return;
+                }
+            }
+            this.debuggerInterestedContext.set(false);
+        };
+        const disposables = ( new DisposableStore());
+        this._register(disposables);
+        this._register(editorService.onDidActiveEditorChange(() => {
+            disposables.clear();
+            const editorControl = this.editorService.activeTextEditorControl;
+            if (isCodeEditor(editorControl)) {
+                disposables.add(editorControl.onDidChangeModelLanguage(setContextKey));
+            }
+            setContextKey();
+        }));
+        this._register(this.debugService.getAdapterManager().onDidRegisterDebugger(setContextKey));
+        this._register(this.onDidChangeBodyVisibility(visible => {
+            if (visible) {
+                setContextKey();
+            }
+        }));
+        setContextKey();
+        const debugKeybinding = this.keybindingService.lookupKeybinding(DEBUG_START_COMMAND_ID);
+        debugKeybinding ? ` (${debugKeybinding.getLabel()})` : '';
+    }
+    shouldShowWelcome() {
+        return true;
+    }
+};
+WelcomeView.ID = 'workbench.debug.welcome';
+WelcomeView.LABEL = ( localize('run', "Run"));
+WelcomeView = ( __decorate([
+    ( __param(1, IThemeService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IDebugService)),
+    ( __param(7, IEditorService)),
+    ( __param(8, IInstantiationService)),
+    ( __param(9, IViewDescriptorService)),
+    ( __param(10, IOpenerService)),
+    ( __param(11, IStorageService)),
+    ( __param(12, ITelemetryService))
+], WelcomeView));
+export { WelcomeView };

package/dist/vscode/vs/workbench/contrib/debug/common/debug.js

@@ -3,8 +3,11 @@ import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/c
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const VIEWLET_ID = 'workbench.view.debug';
 const VARIABLES_VIEW_ID = 'workbench.debug.variablesView';
+const WATCH_VIEW_ID = 'workbench.debug.watchExpressionsView';
 const CALLSTACK_VIEW_ID = 'workbench.debug.callStackView';
+const LOADED_SCRIPTS_VIEW_ID = 'workbench.debug.loadedScriptsView';
 const BREAKPOINTS_VIEW_ID = 'workbench.debug.breakPointsView';
+const DEBUG_PANEL_ID = 'workbench.panel.repl';
 const REPL_VIEW_ID = 'workbench.panel.repl.view';
 const CONTEXT_DEBUG_TYPE = ( new RawContextKey('debugType', undefined, { type: 'string', description: ( nls.localize(
     'debugType',
@@ -36,6 +39,7 @@ const CONTEXT_HAS_DEBUGGED = ( new RawContextKey('hasDebugged', false, { type: '
     "True when a debug session has been started at least once, false otherwise."
 )) }));
 const CONTEXT_IN_DEBUG_MODE = ( new RawContextKey('inDebugMode', false, { type: 'boolean', description: ( nls.localize('inDebugMode', "True when debugging, false otherwise.")) }));
+const CONTEXT_IN_DEBUG_REPL = ( new RawContextKey('inDebugRepl', false, { type: 'boolean', description: ( nls.localize('inDebugRepl', "True when focus is in the debug console, false otherwise.")) }));
 const CONTEXT_BREAKPOINT_WIDGET_VISIBLE = ( new RawContextKey(
     'breakpointWidgetVisible',
     false,
@@ -64,6 +68,14 @@ const CONTEXT_WATCH_EXPRESSIONS_FOCUSED = ( new RawContextKey(
         "True when the WATCH view is focused, false otherwsie."
     )) }
 ));
+const CONTEXT_WATCH_EXPRESSIONS_EXIST = ( new RawContextKey(
+    'watchExpressionsExist',
+    false,
+    { type: 'boolean', description: ( nls.localize(
+        'watchExpressionsExist',
+        "True when at least one watch expression exists, false otherwise."
+    )) }
+));
 const CONTEXT_VARIABLES_FOCUSED = ( new RawContextKey('variablesFocused', true, { type: 'boolean', description: ( nls.localize(
     'variablesFocused',
     "True when the VARIABLES views is focused, false otherwsie"
@@ -84,6 +96,42 @@ const CONTEXT_BREAKPOINT_INPUT_FOCUSED = ( new RawContextKey(
         "True when the input box has focus in the BREAKPOINTS view."
     )) }
 ));
+const CONTEXT_CALLSTACK_ITEM_TYPE = ( new RawContextKey(
+    'callStackItemType',
+    undefined,
+    { type: 'string', description: ( nls.localize(
+        'callStackItemType',
+        "Represents the item type of the focused element in the CALL STACK view. For example: 'session', 'thread', 'stackFrame'"
+    )) }
+));
+const CONTEXT_CALLSTACK_SESSION_IS_ATTACH = ( new RawContextKey(
+    'callStackSessionIsAttach',
+    false,
+    { type: 'boolean', description: ( nls.localize(
+        'callStackSessionIsAttach',
+        "True when the session in the CALL STACK view is attach, false otherwise. Used internally for inline menus in the CALL STACK view."
+    )) }
+));
+const CONTEXT_CALLSTACK_ITEM_STOPPED = ( new RawContextKey(
+    'callStackItemStopped',
+    false,
+    { type: 'boolean', description: ( nls.localize(
+        'callStackItemStopped',
+        "True when the focused item in the CALL STACK is stopped. Used internaly for inline menus in the CALL STACK view."
+    )) }
+));
+const CONTEXT_CALLSTACK_SESSION_HAS_ONE_THREAD = ( new RawContextKey(
+    'callStackSessionHasOneThread',
+    false,
+    { type: 'boolean', description: ( nls.localize(
+        'callStackSessionHasOneThread',
+        "True when the focused session in the CALL STACK view has exactly one thread. Used internally for inline menus in the CALL STACK view."
+    )) }
+));
+const CONTEXT_WATCH_ITEM_TYPE = ( new RawContextKey('watchItemType', undefined, { type: 'string', description: ( nls.localize(
+    'watchItemType',
+    "Represents the item type of the focused element in the WATCH view. For example: 'expression', 'variable'"
+)) }));
 const CONTEXT_CAN_VIEW_MEMORY = ( new RawContextKey('canViewMemory', undefined, { type: 'boolean', description: ( nls.localize(
     'canViewMemory',
     "Indicates whether the item in the view has an associated memory refrence."
@@ -112,6 +160,14 @@ const CONTEXT_LOADED_SCRIPTS_SUPPORTED = ( new RawContextKey(
         "True when the focused sessions supports the LOADED SCRIPTS view"
     )) }
 ));
+const CONTEXT_LOADED_SCRIPTS_ITEM_TYPE = ( new RawContextKey(
+    'loadedScriptsItemType',
+    undefined,
+    { type: 'string', description: ( nls.localize(
+        'loadedScriptsItemType',
+        "Represents the item type of the focused element in the LOADED SCRIPTS view."
+    )) }
+));
 const CONTEXT_FOCUSED_SESSION_IS_ATTACH = ( new RawContextKey(
     'focusedSessionIsAttach',
     false,
@@ -129,6 +185,14 @@ const CONTEXT_RESTART_FRAME_SUPPORTED = ( new RawContextKey(
         "True when the focused session supports 'restartFrame' requests."
     )) }
 ));
+const CONTEXT_STACK_FRAME_SUPPORTS_RESTART = ( new RawContextKey(
+    'stackFrameSupportsRestart',
+    false,
+    { type: 'boolean', description: ( nls.localize(
+        'stackFrameSupportsRestart',
+        "True when the focused stack frame suppots 'restartFrame'."
+    )) }
+));
 const CONTEXT_JUMP_TO_CURSOR_SUPPORTED = ( new RawContextKey(
     'jumpToCursorSupported',
     false,
@@ -186,6 +250,30 @@ const CONTEXT_SET_EXPRESSION_SUPPORTED = ( new RawContextKey(
         "True when the focused session supports 'setExpression' request."
     )) }
 ));
+const CONTEXT_BREAK_WHEN_VALUE_CHANGES_SUPPORTED = ( new RawContextKey(
+    'breakWhenValueChangesSupported',
+    false,
+    { type: 'boolean', description: ( nls.localize(
+        'breakWhenValueChangesSupported',
+        "True when the focused session supports to break when value changes."
+    )) }
+));
+const CONTEXT_BREAK_WHEN_VALUE_IS_ACCESSED_SUPPORTED = ( new RawContextKey(
+    'breakWhenValueIsAccessedSupported',
+    false,
+    { type: 'boolean', description: ( nls.localize(
+        'breakWhenValueIsAccessedSupported',
+        "True when the focused breakpoint supports to break when value is accessed."
+    )) }
+));
+const CONTEXT_BREAK_WHEN_VALUE_IS_READ_SUPPORTED = ( new RawContextKey(
+    'breakWhenValueIsReadSupported',
+    false,
+    { type: 'boolean', description: ( nls.localize(
+        'breakWhenValueIsReadSupported',
+        "True when the focused breakpoint supports to break when value is read."
+    )) }
+));
 const CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED = ( new RawContextKey(
     'terminateDebuggeeSupported',
     false,
@@ -220,6 +308,7 @@ const CONTEXT_EXCEPTION_WIDGET_VISIBLE = ( new RawContextKey(
     false,
     { type: 'boolean', description: ( nls.localize('exceptionWidgetVisible', "True when the exception widget is visible.")) }
 ));
+const CONTEXT_MULTI_SESSION_REPL = ( new RawContextKey('multiSessionRepl', false, { type: 'boolean', description: ( nls.localize('multiSessionRepl', "True when there is more than 1 debug console.")) }));
 const CONTEXT_MULTI_SESSION_DEBUG = ( new RawContextKey('multiSessionDebug', false, { type: 'boolean', description: ( nls.localize(
     'multiSessionDebug',
     "True when there is more than 1 active debug session."
@@ -237,6 +326,14 @@ const CONTEXT_DISASSEMBLY_VIEW_FOCUS = ( new RawContextKey(
     false,
     { type: 'boolean', description: ( nls.localize('disassemblyViewFocus', "True when the Disassembly View is focused.")) }
 ));
+const CONTEXT_LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST = ( new RawContextKey(
+    'languageSupportsDisassembleRequest',
+    false,
+    { type: 'boolean', description: ( nls.localize(
+        'languageSupportsDisassembleRequest',
+        "True when the language in the current editor supports disassemble request."
+    )) }
+));
 const CONTEXT_FOCUSED_STACK_FRAME_HAS_INSTRUCTION_POINTER_REFERENCE = ( new RawContextKey(
     'focusedStackFrameHasInstructionReference',
     false,
@@ -282,4 +379,4 @@ var DebuggerString;
     DebuggerString["UnverifiedBreakpoints"] = "unverifiedBreakpoints";
 })(DebuggerString || (DebuggerString = {})));
 const IDebugService = ( createDecorator('debugService'));
-export { BREAKPOINTS_VIEW_ID, BREAKPOINT_EDITOR_CONTRIBUTION_ID, CALLSTACK_VIEW_ID, CONTEXT_BREAKPOINTS_EXIST, CONTEXT_BREAKPOINTS_FOCUSED, CONTEXT_BREAKPOINT_INPUT_FOCUSED, CONTEXT_BREAKPOINT_ITEM_TYPE, CONTEXT_BREAKPOINT_SUPPORTS_CONDITION, CONTEXT_BREAKPOINT_WIDGET_VISIBLE, CONTEXT_CAN_VIEW_MEMORY, CONTEXT_DEBUGGERS_AVAILABLE, CONTEXT_DEBUG_CONFIGURATION_TYPE, CONTEXT_DEBUG_EXTENSION_AVAILABLE, CONTEXT_DEBUG_PROTOCOL_VARIABLE_MENU_CONTEXT, CONTEXT_DEBUG_STATE, CONTEXT_DEBUG_TYPE, CONTEXT_DEBUG_UX, CONTEXT_DEBUG_UX_KEY, CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED, CONTEXT_DISASSEMBLY_VIEW_FOCUS, CONTEXT_EXCEPTION_WIDGET_VISIBLE, CONTEXT_EXPRESSION_SELECTED, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_FOCUSED_STACK_FRAME_HAS_INSTRUCTION_POINTER_REFERENCE, CONTEXT_HAS_DEBUGGED, CONTEXT_IN_BREAKPOINT_WIDGET, CONTEXT_IN_DEBUG_MODE, CONTEXT_JUMP_TO_CURSOR_SUPPORTED, CONTEXT_LOADED_SCRIPTS_SUPPORTED, CONTEXT_MULTI_SESSION_DEBUG, CONTEXT_RESTART_FRAME_SUPPORTED, CONTEXT_SET_EXPRESSION_SUPPORTED, CONTEXT_SET_VARIABLE_SUPPORTED, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_STEP_INTO_TARGETS_SUPPORTED, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, CONTEXT_VARIABLES_FOCUSED, CONTEXT_VARIABLE_EVALUATE_NAME_PRESENT, CONTEXT_VARIABLE_IS_READONLY, CONTEXT_WATCH_EXPRESSIONS_FOCUSED, DEBUG_MEMORY_SCHEME, DEBUG_SCHEME, DebugConfigurationProviderTriggerKind, DebuggerString, EDITOR_CONTRIBUTION_ID, IDebugService, INTERNAL_CONSOLE_OPTIONS_SCHEMA, REPL_VIEW_ID, VARIABLES_VIEW_ID, VIEWLET_ID, debuggerDisabledMessage, getStateLabel };
+export { BREAKPOINTS_VIEW_ID, BREAKPOINT_EDITOR_CONTRIBUTION_ID, CALLSTACK_VIEW_ID, CONTEXT_BREAKPOINTS_EXIST, CONTEXT_BREAKPOINTS_FOCUSED, CONTEXT_BREAKPOINT_INPUT_FOCUSED, CONTEXT_BREAKPOINT_ITEM_TYPE, CONTEXT_BREAKPOINT_SUPPORTS_CONDITION, CONTEXT_BREAKPOINT_WIDGET_VISIBLE, CONTEXT_BREAK_WHEN_VALUE_CHANGES_SUPPORTED, CONTEXT_BREAK_WHEN_VALUE_IS_ACCESSED_SUPPORTED, CONTEXT_BREAK_WHEN_VALUE_IS_READ_SUPPORTED, CONTEXT_CALLSTACK_ITEM_STOPPED, CONTEXT_CALLSTACK_ITEM_TYPE, CONTEXT_CALLSTACK_SESSION_HAS_ONE_THREAD, CONTEXT_CALLSTACK_SESSION_IS_ATTACH, CONTEXT_CAN_VIEW_MEMORY, CONTEXT_DEBUGGERS_AVAILABLE, CONTEXT_DEBUG_CONFIGURATION_TYPE, CONTEXT_DEBUG_EXTENSION_AVAILABLE, CONTEXT_DEBUG_PROTOCOL_VARIABLE_MENU_CONTEXT, CONTEXT_DEBUG_STATE, CONTEXT_DEBUG_TYPE, CONTEXT_DEBUG_UX, CONTEXT_DEBUG_UX_KEY, CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED, CONTEXT_DISASSEMBLY_VIEW_FOCUS, CONTEXT_EXCEPTION_WIDGET_VISIBLE, CONTEXT_EXPRESSION_SELECTED, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_FOCUSED_STACK_FRAME_HAS_INSTRUCTION_POINTER_REFERENCE, CONTEXT_HAS_DEBUGGED, CONTEXT_IN_BREAKPOINT_WIDGET, CONTEXT_IN_DEBUG_MODE, CONTEXT_IN_DEBUG_REPL, CONTEXT_JUMP_TO_CURSOR_SUPPORTED, CONTEXT_LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST, CONTEXT_LOADED_SCRIPTS_ITEM_TYPE, CONTEXT_LOADED_SCRIPTS_SUPPORTED, CONTEXT_MULTI_SESSION_DEBUG, CONTEXT_MULTI_SESSION_REPL, CONTEXT_RESTART_FRAME_SUPPORTED, CONTEXT_SET_EXPRESSION_SUPPORTED, CONTEXT_SET_VARIABLE_SUPPORTED, CONTEXT_STACK_FRAME_SUPPORTS_RESTART, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_STEP_INTO_TARGETS_SUPPORTED, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, CONTEXT_VARIABLES_FOCUSED, CONTEXT_VARIABLE_EVALUATE_NAME_PRESENT, CONTEXT_VARIABLE_IS_READONLY, CONTEXT_WATCH_EXPRESSIONS_EXIST, CONTEXT_WATCH_EXPRESSIONS_FOCUSED, CONTEXT_WATCH_ITEM_TYPE, DEBUG_MEMORY_SCHEME, DEBUG_PANEL_ID, DEBUG_SCHEME, DebugConfigurationProviderTriggerKind, DebuggerString, EDITOR_CONTRIBUTION_ID, IDebugService, INTERNAL_CONSOLE_OPTIONS_SCHEMA, LOADED_SCRIPTS_VIEW_ID, REPL_VIEW_ID, VARIABLES_VIEW_ID, VIEWLET_ID, WATCH_VIEW_ID, debuggerDisabledMessage, getStateLabel };