@codingame/monaco-vscode-debug-service-override 1.82.4 → 1.82.5-next.1

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

@@ -0,0 +1,415 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CONTEXT_CAN_VIEW_MEMORY, CONTEXT_WATCH_ITEM_TYPE, WATCH_VIEW_ID, CONTEXT_WATCH_EXPRESSIONS_EXIST, IDebugService, CONTEXT_VARIABLE_IS_READONLY, CONTEXT_WATCH_EXPRESSIONS_FOCUSED } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { Variable, Expression } 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 { AbstractExpressionsRenderer, renderExpressionValue, renderViewTree } from './baseDebugView.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ViewAction, ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+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 'vscode/vscode/vs/workbench/common/views';
+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 'vscode/vscode/vs/workbench/contrib/debug/browser/debugIcons';
+import { MenuId, registerAction2, 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';
+
+var WatchExpressionsRenderer_1;
+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 {
+    static { WatchExpressionsRenderer_1 = this; }
+    static { this.ID = 'watchexpression'; }
+    constructor(menuService, contextKeyService, debugService, contextViewService) {
+        super(debugService, contextViewService);
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+    }
+    get templateId() {
+        return WatchExpressionsRenderer_1.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 = WatchExpressionsRenderer_1 = ( __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/vscode/src/vs/workbench/contrib/debug/browser/welcomeView.js

@@ -0,0 +1,102 @@
+import { __decorate, __param } from '../../../../../../../external/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 { CONTEXT_DEBUGGERS_AVAILABLE, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Extensions, ViewContentGroups, IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.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, SELECT_AND_START_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 {
+    static { this.ID = 'workbench.debug.welcome'; }
+    static { this.LABEL = ( (localize('run', "Run"))); }
+    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);
+        debugKeybindingLabel = debugKeybinding ? ` (${debugKeybinding.getLabel()})` : '';
+    }
+    shouldShowWelcome() {
+        return true;
+    }
+};
+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)));
+const viewsRegistry = ( (Registry.as(Extensions.ViewsRegistry)));
+let debugKeybindingLabel = '';
+( (viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
+    content: `[${( ( localize('runAndDebugAction', "Run and Debug")))}${debugKeybindingLabel}](command:${DEBUG_START_COMMAND_ID})`,
+    when: CONTEXT_DEBUGGERS_AVAILABLE,
+    group: ViewContentGroups.Debug,
+    order: 1
+})));
+( (viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
+    content: `[${( ( localize('detectThenRunAndDebug', "Show all automatic debug configurations")))}](command:${SELECT_AND_START_ID}).`,
+    when: CONTEXT_DEBUGGERS_AVAILABLE,
+    group: ViewContentGroups.Debug,
+    order: 10
+})));
+
+export { WelcomeView };

package/vscode/src/vs/workbench/contrib/debug/common/breakpoints.js

@@ -0,0 +1,21 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+
+let Breakpoints = class Breakpoints {
+    constructor(breakpointContribution, contextKeyService) {
+        this.breakpointContribution = breakpointContribution;
+        this.contextKeyService = contextKeyService;
+        this.breakpointsWhen = typeof breakpointContribution.when === 'string' ? ContextKeyExpr.deserialize(breakpointContribution.when) : undefined;
+    }
+    get language() {
+        return this.breakpointContribution.language;
+    }
+    get enabled() {
+        return !this.breakpointsWhen || this.contextKeyService.contextMatchesRules(this.breakpointsWhen);
+    }
+};
+Breakpoints = ( __decorate([
+    ( __param(1, IContextKeyService))
+], Breakpoints));
+
+export { Breakpoints };

package/vscode/src/vs/workbench/contrib/debug/common/debugCompoundRoot.js

@@ -0,0 +1,17 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+
+class DebugCompoundRoot {
+    constructor() {
+        this.stopped = false;
+        this.stopEmitter = ( new Emitter());
+        this.onDidSessionStop = this.stopEmitter.event;
+    }
+    sessionStopped() {
+        if (!this.stopped) {
+            this.stopped = true;
+            this.stopEmitter.fire();
+        }
+    }
+}
+
+export { DebugCompoundRoot };

package/vscode/src/vs/workbench/contrib/debug/common/debugContentProvider.js

@@ -0,0 +1,100 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { getMimeTypes } from 'monaco-editor/esm/vs/editor/common/services/languagesAssociations.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { DEBUG_SCHEME, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { Source } from './debugSource.js';
+import { IEditorWorkerService } from 'monaco-editor/esm/vs/editor/common/services/editorWorker.js';
+import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { ErrorNoTelemetry } from 'monaco-editor/esm/vs/base/common/errors.js';
+
+var DebugContentProvider_1;
+let DebugContentProvider = class DebugContentProvider {
+    static { DebugContentProvider_1 = this; }
+    constructor(textModelResolverService, debugService, modelService, languageService, editorWorkerService) {
+        this.debugService = debugService;
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this.editorWorkerService = editorWorkerService;
+        this.pendingUpdates = ( new Map());
+        textModelResolverService.registerTextModelContentProvider(DEBUG_SCHEME, this);
+        DebugContentProvider_1.INSTANCE = this;
+    }
+    dispose() {
+        this.pendingUpdates.forEach(cancellationSource => cancellationSource.dispose());
+    }
+    provideTextContent(resource) {
+        return this.createOrUpdateContentModel(resource, true);
+    }
+    static refreshDebugContent(resource) {
+        DebugContentProvider_1.INSTANCE?.createOrUpdateContentModel(resource, false);
+    }
+    createOrUpdateContentModel(resource, createIfNotExists) {
+        const model = this.modelService.getModel(resource);
+        if (!model && !createIfNotExists) {
+            return null;
+        }
+        let session;
+        if (resource.query) {
+            const data = Source.getEncodedDebugData(resource);
+            session = this.debugService.getModel().getSession(data.sessionId);
+        }
+        if (!session) {
+            session = this.debugService.getViewModel().focusedSession;
+        }
+        if (!session) {
+            return Promise.reject(( new ErrorNoTelemetry(( localize('unable', "Unable to resolve the resource without a debug session")))));
+        }
+        const createErrModel = (errMsg) => {
+            this.debugService.sourceIsNotAvailable(resource);
+            const languageSelection = this.languageService.createById(PLAINTEXT_LANGUAGE_ID);
+            const message = errMsg
+                ? ( localize(
+                'canNotResolveSourceWithError',
+                "Could not load source '{0}': {1}.",
+                resource.path,
+                errMsg
+            ))
+                : ( localize('canNotResolveSource', "Could not load source '{0}'.", resource.path));
+            return this.modelService.createModel(message, languageSelection, resource);
+        };
+        return session.loadSource(resource).then(response => {
+            if (response && response.body) {
+                if (model) {
+                    const newContent = response.body.content;
+                    const cancellationSource = this.pendingUpdates.get(model.id);
+                    cancellationSource?.cancel();
+                    const myToken = ( new CancellationTokenSource());
+                    this.pendingUpdates.set(model.id, myToken);
+                    return this.editorWorkerService.computeMoreMinimalEdits(model.uri, [{ text: newContent, range: model.getFullModelRange() }]).then(edits => {
+                        this.pendingUpdates.delete(model.id);
+                        if (!myToken.token.isCancellationRequested && edits && edits.length > 0) {
+                            model.applyEdits(( edits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text))));
+                        }
+                        return model;
+                    });
+                }
+                else {
+                    const mime = response.body.mimeType || getMimeTypes(resource)[0];
+                    const languageSelection = this.languageService.createByMimeType(mime);
+                    return this.modelService.createModel(response.body.content, languageSelection, resource);
+                }
+            }
+            return createErrModel();
+        }, (err) => createErrModel(err.message));
+    }
+};
+DebugContentProvider = DebugContentProvider_1 = ( __decorate([
+    ( __param(0, ITextModelService)),
+    ( __param(1, IDebugService)),
+    ( __param(2, IModelService)),
+    ( __param(3, ILanguageService)),
+    ( __param(4, IEditorWorkerService))
+], DebugContentProvider));
+
+export { DebugContentProvider };