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

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

@@ -1,501 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { ElementsDragAndDropData } from 'vscode/vscode/vs/base/browser/ui/list/listView';
-import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
-import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { createAndFillInContextMenuActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
-import { MenuId, registerAction2, Action2, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { IContextMenuService, IContextViewService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
-import { WorkbenchAsyncDataTree } from 'vscode/vscode/vs/platform/list/browser/listService';
-import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { ViewAction, ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
-import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
-import { AbstractExpressionsRenderer, renderExpressionValue, renderViewTree, AbstractExpressionDataSource } from 'vscode/vscode/vs/workbench/contrib/debug/browser/baseDebugView';
-import { watchExpressionsAdd, watchExpressionsRemoveAll } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugIcons';
-import { LinkDetector } from './linkDetector.js';
-import { VariablesRenderer, VisualizedVariableRenderer } from './variablesView.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, VisualizedExpression } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugModel';
-
-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 linkDetector = this.instantiationService.createInstance(LinkDetector);
-        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'WatchExpressions', treeContainer, ( new WatchExpressionsDelegate()), [
-            expressionsRenderer,
-            this.instantiationService.createInstance(VariablesRenderer, linkDetector),
-            this.instantiationService.createInstance(VisualizedVariableRenderer, linkDetector),
-        ], this.instantiationService.createInstance(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(VisualizedVariableRenderer.rendererOnVisualizationRange(this.debugService.getViewModel(), this.tree));
-        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 && this.tree.hasElement(expression)) {
-                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() {
-        super.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) || (element instanceof VisualizedExpression && element.treeItem.canEdit)) {
-            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;
-        }
-        if (element instanceof VisualizedExpression) {
-            return VisualizedVariableRenderer.ID;
-        }
-        return VariablesRenderer.ID;
-    }
-}
-function isDebugService(element) {
-    return typeof element.getConfigurationManager === 'function';
-}
-class WatchExpressionsDataSource extends AbstractExpressionDataSource {
-    hasChildren(element) {
-        return isDebugService(element) || element.hasChildren;
-    }
-    doGetChildren(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: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/watchExpressionsView',
-                    '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: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/watchExpressionsView',
-                'watchExpressionInputAriaLabel',
-                "Type watch expression"
-            )),
-            placeholder: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/watchExpressionsView',
-                '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 ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/watchExpressionsView',
-            { comment: ['Debug is a noun in this context, not a verb.'], key: 'watchAriaTreeLabel' },
-            "Debug Watch Expressions"
-        ));
-    }
-    getAriaLabel(element) {
-        if (element instanceof Expression) {
-            return ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/watchExpressionsView',
-                'watchExpressionAriaLabel',
-                "{0}, value {1}",
-                element.name,
-                element.value
-            ));
-        }
-        return ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/watchExpressionsView',
-            'watchVariableAriaLabel',
-            "{0}, value {1}",
-            element.name,
-            element.value
-        ));
-    }
-}
-class WatchExpressionsDragAndDrop {
-    constructor(debugService) {
-        this.debugService = debugService;
-    }
-    onDragOver(data, targetElement, targetIndex, targetSector, originalEvent) {
-        if (!(data instanceof ElementsDragAndDropData)) {
-            return false;
-        }
-        const expressions = data.elements;
-        if (!(expressions.length > 0 && expressions[0] instanceof Expression)) {
-            return false;
-        }
-        let dropEffectPosition = undefined;
-        if (targetIndex === undefined) {
-            dropEffectPosition = "drop-target-after" ;
-            targetIndex = -1;
-        }
-        else {
-            switch (targetSector) {
-                case 0 :
-                case 1 :
-                    dropEffectPosition = "drop-target-before" ;
-                    break;
-                case 2 :
-                case 3 :
-                    dropEffectPosition = "drop-target-after" ;
-                    break;
-            }
-        }
-        return { accept: true, effect: { type: 1 , position: dropEffectPosition }, feedback: [targetIndex] };
-    }
-    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, targetIndex, targetSector, originalEvent) {
-        if (!(data instanceof ElementsDragAndDropData)) {
-            return;
-        }
-        const draggedElement = data.elements[0];
-        if (!(draggedElement instanceof Expression)) {
-            throw new Error('Invalid dragged element');
-        }
-        const watches = this.debugService.getModel().getWatchExpressions();
-        const sourcePosition = watches.indexOf(draggedElement);
-        let targetPosition;
-        if (targetElement instanceof Expression) {
-            targetPosition = watches.indexOf(targetElement);
-            switch (targetSector) {
-                case 3 :
-                case 2 :
-                    targetPosition++;
-                    break;
-            }
-            if (sourcePosition < targetPosition) {
-                targetPosition--;
-            }
-        }
-        else {
-            targetPosition = watches.length - 1;
-        }
-        this.debugService.moveWatchExpression(draggedElement.getId(), targetPosition);
-    }
-    dispose() { }
-}
-registerAction2(class Collapse extends ViewAction {
-    constructor() {
-        super({
-            id: 'watch.collapse',
-            viewId: WATCH_VIEW_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/watchExpressionsView',
-                '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 = ( localizeWithPath(
-    'vs/workbench/contrib/debug/browser/watchExpressionsView',
-    '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 = ( localizeWithPath(
-    'vs/workbench/contrib/debug/browser/watchExpressionsView',
-    '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,162 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
-import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { localize2WithPath, localizeWithPath } from 'vscode/vscode/vs/nls';
-import { CONTEXT_DEBUGGERS_AVAILABLE, CONTEXT_DEBUG_EXTENSION_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 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { Extensions, ViewContentGroups, IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
-import { WorkbenchStateContext } from 'vscode/vscode/vs/workbench/common/contextkeys';
-import { OpenFileFolderAction, OpenFileAction, OpenFolderAction } from 'vscode/vscode/vs/workbench/browser/actions/workspaceActions';
-import { isMacintosh, isWeb } from 'vscode/vscode/vs/base/common/platform';
-import { isDiffEditor, isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { DEBUG_START_COMMAND_ID, SELECT_AND_START_ID, DEBUG_CONFIGURE_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 {
-    static { this.ID = 'workbench.debug.welcome'; }
-    static { this.LABEL = ( localize2WithPath('vs/workbench/contrib/debug/browser/welcomeView', '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 = () => {
-            let editorControl = this.editorService.activeTextEditorControl;
-            if (isDiffEditor(editorControl)) {
-                editorControl = editorControl.getModifiedEditor();
-            }
-            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();
-            let editorControl = this.editorService.activeTextEditorControl;
-            if (isDiffEditor(editorControl)) {
-                editorControl = editorControl.getModifiedEditor();
-            }
-            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));
-viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
-    content: ( localizeWithPath('vs/workbench/contrib/debug/browser/welcomeView', {
-        key: 'openAFileWhichCanBeDebugged',
-        comment: [
-            'Please do not translate the word "command", it is part of our internal syntax which must not change',
-            '{Locked="](command:{0})"}'
-        ]
-    }, "[Open a file](command:{0}) which can be debugged or run.", (isMacintosh && !isWeb) ? OpenFileFolderAction.ID : OpenFileAction.ID)),
-    when: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( CONTEXT_DEBUGGER_INTERESTED_IN_ACTIVE_EDITOR.toNegated()))),
-    group: ViewContentGroups.Open,
-});
-let debugKeybindingLabel = '';
-viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
-    content: `[${( localizeWithPath(
-        'vs/workbench/contrib/debug/browser/welcomeView',
-        'runAndDebugAction',
-        "Run and Debug"
-    ))}${debugKeybindingLabel}](command:${DEBUG_START_COMMAND_ID})`,
-    when: CONTEXT_DEBUGGERS_AVAILABLE,
-    group: ViewContentGroups.Debug,
-    order: 1
-});
-viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
-    content: `[${( localizeWithPath(
-        'vs/workbench/contrib/debug/browser/welcomeView',
-        'detectThenRunAndDebug',
-        "Show all automatic debug configurations"
-    ))}](command:${SELECT_AND_START_ID}).`,
-    when: CONTEXT_DEBUGGERS_AVAILABLE,
-    group: ViewContentGroups.Debug,
-    order: 10
-});
-viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
-    content: ( localizeWithPath('vs/workbench/contrib/debug/browser/welcomeView', {
-        key: 'customizeRunAndDebug',
-        comment: [
-            'Please do not translate the word "command", it is part of our internal syntax which must not change',
-            '{Locked="](command:{0})"}'
-        ]
-    }, "To customize Run and Debug [create a launch.json file](command:{0}).", DEBUG_CONFIGURE_COMMAND_ID)),
-    when: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( WorkbenchStateContext.notEqualsTo('empty')))),
-    group: ViewContentGroups.Debug
-});
-viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
-    content: ( localizeWithPath('vs/workbench/contrib/debug/browser/welcomeView', {
-        key: 'customizeRunAndDebugOpenFolder',
-        comment: [
-            'Please do not translate the word "command", it is part of our internal syntax which must not change',
-            'Please do not translate "launch.json", it is the specific configuration file name',
-            '{Locked="](command:{0})"}',
-        ]
-    }, "To customize Run and Debug, [open a folder](command:{0}) and create a launch.json file.", (isMacintosh && !isWeb) ? OpenFileFolderAction.ID : OpenFolderAction.ID)),
-    when: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( WorkbenchStateContext.isEqualTo('empty')))),
-    group: ViewContentGroups.Debug
-});
-viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
-    content: ( localizeWithPath(
-        'vs/workbench/contrib/debug/browser/welcomeView',
-        'allDebuggersDisabled',
-        "All debug extensions are disabled. Enable a debug extension or install a new one from the Marketplace."
-    )),
-    when: ( CONTEXT_DEBUG_EXTENSION_AVAILABLE.toNegated()),
-    group: ViewContentGroups.Debug
-});
-
-export { WelcomeView };