@codingame/monaco-vscode-api 1.82.4-next.1 → 1.82.5-next.0

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

@@ -1,413 +0,0 @@
-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 '../common/debug.js';
-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 '../../../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 { 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

@@ -1,100 +0,0 @@
-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 '../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 { ViewContentGroups, Extensions, IViewDescriptorService } from '../../../common/views.js';
-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

@@ -1,19 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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 './debug.js';
-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 };