@codingame/monaco-vscode-api 1.78.4 → 1.78.5

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

@@ -0,0 +1,172 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { OverviewRulerLane } from 'monaco-editor/esm/vs/editor/common/model.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { registerColor } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { themeColorFromId } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { debugStackframe, debugStackframeFocused } from './debugIcons.js';
+import { IDebugService } from '../common/debug.js';
+import "../../../../../../assets/callStackEditorContribution.css";
+const topStackFrameColor = registerColor('editor.stackFrameHighlightBackground', { dark: '#ffff0033', light: '#ffff6673', hcDark: '#ffff0033', hcLight: '#ffff6673' }, ( localize(
+    'topStackFrameLineHighlight',
+    'Background color for the highlight of line at the top stack frame position.'
+)));
+const focusedStackFrameColor = registerColor('editor.focusedStackFrameHighlightBackground', { dark: '#7abd7a4d', light: '#cee7ce73', hcDark: '#7abd7a4d', hcLight: '#cee7ce73' }, ( localize(
+    'focusedStackFrameLineHighlight',
+    'Background color for the highlight of line at focused stack frame position.'
+)));
+const stickiness = 1 ;
+const TOP_STACK_FRAME_MARGIN = {
+    description: 'top-stack-frame-margin',
+    glyphMarginClassName: ThemeIcon.asClassName(debugStackframe),
+    stickiness,
+    overviewRuler: {
+        position: OverviewRulerLane.Full,
+        color: themeColorFromId(topStackFrameColor)
+    }
+};
+const FOCUSED_STACK_FRAME_MARGIN = {
+    description: 'focused-stack-frame-margin',
+    glyphMarginClassName: ThemeIcon.asClassName(debugStackframeFocused),
+    stickiness,
+    overviewRuler: {
+        position: OverviewRulerLane.Full,
+        color: themeColorFromId(focusedStackFrameColor)
+    }
+};
+const TOP_STACK_FRAME_DECORATION = {
+    description: 'top-stack-frame-decoration',
+    isWholeLine: true,
+    className: 'debug-top-stack-frame-line',
+    stickiness
+};
+const FOCUSED_STACK_FRAME_DECORATION = {
+    description: 'focused-stack-frame-decoration',
+    isWholeLine: true,
+    className: 'debug-focused-stack-frame-line',
+    stickiness
+};
+function createDecorationsForStackFrame(stackFrame, isFocusedSession, noCharactersBefore) {
+    const result = [];
+    const columnUntilEOLRange = ( new Range(
+        stackFrame.range.startLineNumber,
+        stackFrame.range.startColumn,
+        stackFrame.range.startLineNumber,
+        1073741824
+    ));
+    const range = ( new Range(
+        stackFrame.range.startLineNumber,
+        stackFrame.range.startColumn,
+        stackFrame.range.startLineNumber,
+        stackFrame.range.startColumn + 1
+    ));
+    const topStackFrame = stackFrame.thread.getTopStackFrame();
+    if (stackFrame.getId() === topStackFrame?.getId()) {
+        if (isFocusedSession) {
+            result.push({
+                options: TOP_STACK_FRAME_MARGIN,
+                range
+            });
+        }
+        result.push({
+            options: TOP_STACK_FRAME_DECORATION,
+            range: columnUntilEOLRange
+        });
+        if (stackFrame.range.startColumn > 1) {
+            result.push({
+                options: {
+                    description: 'top-stack-frame-inline-decoration',
+                    before: {
+                        content: '\uEB8B',
+                        inlineClassName: noCharactersBefore ? 'debug-top-stack-frame-column start-of-line' : 'debug-top-stack-frame-column',
+                        inlineClassNameAffectsLetterSpacing: true
+                    },
+                },
+                range: columnUntilEOLRange
+            });
+        }
+    }
+    else {
+        if (isFocusedSession) {
+            result.push({
+                options: FOCUSED_STACK_FRAME_MARGIN,
+                range
+            });
+        }
+        result.push({
+            options: FOCUSED_STACK_FRAME_DECORATION,
+            range: columnUntilEOLRange
+        });
+    }
+    return result;
+}
+let CallStackEditorContribution = class CallStackEditorContribution extends Disposable {
+    constructor(editor, debugService, uriIdentityService, logService) {
+        super();
+        this.editor = editor;
+        this.debugService = debugService;
+        this.uriIdentityService = uriIdentityService;
+        this.logService = logService;
+        this.decorations = this.editor.createDecorationsCollection();
+        const setDecorations = () => this.decorations.set(this.createCallStackDecorations());
+        this._register(Event.any(this.debugService.getViewModel().onDidFocusStackFrame, this.debugService.getModel().onDidChangeCallStack)(() => {
+            setDecorations();
+        }));
+        this._register(this.editor.onDidChangeModel(e => {
+            if (e.newModelUrl) {
+                setDecorations();
+            }
+        }));
+        setDecorations();
+    }
+    createCallStackDecorations() {
+        const editor = this.editor;
+        if (!editor.hasModel()) {
+            return [];
+        }
+        const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
+        const decorations = [];
+        this.debugService.getModel().getSessions().forEach(s => {
+            const isSessionFocused = s === focusedStackFrame?.thread.session;
+            s.getAllThreads().forEach(t => {
+                if (t.stopped) {
+                    const callStack = t.getCallStack();
+                    const stackFrames = [];
+                    if (callStack.length > 0) {
+                        if (focusedStackFrame && !focusedStackFrame.equals(callStack[0])) {
+                            stackFrames.push(focusedStackFrame);
+                        }
+                        stackFrames.push(callStack[0]);
+                    }
+                    stackFrames.forEach(candidateStackFrame => {
+                        if (candidateStackFrame && this.uriIdentityService.extUri.isEqual(candidateStackFrame.source.uri, editor.getModel()?.uri)) {
+                            if (candidateStackFrame.range.startLineNumber > editor.getModel()?.getLineCount() || candidateStackFrame.range.startLineNumber < 1) {
+                                this.logService.warn(`CallStackEditorContribution: invalid stack frame line number: ${candidateStackFrame.range.startLineNumber}`);
+                                return;
+                            }
+                            const noCharactersBefore = editor.getModel().getLineFirstNonWhitespaceColumn(candidateStackFrame.range.startLineNumber) >= candidateStackFrame.range.startColumn;
+                            decorations.push(...createDecorationsForStackFrame(candidateStackFrame, isSessionFocused, noCharactersBefore));
+                        }
+                    });
+                }
+            });
+        });
+        return distinct(decorations, d => `${d.options.className} ${d.options.glyphMarginClassName} ${d.range.startLineNumber} ${d.range.startColumn}`);
+    }
+    dispose() {
+        super.dispose();
+        this.decorations.clear();
+    }
+};
+CallStackEditorContribution = ( __decorate([
+    ( __param(1, IDebugService)),
+    ( __param(2, IUriIdentityService)),
+    ( __param(3, ILogService))
+], CallStackEditorContribution));
+export { CallStackEditorContribution, createDecorationsForStackFrame, focusedStackFrameColor, topStackFrameColor };

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

@@ -0,0 +1,451 @@
+import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import "../../../../../../assets/debug.contribution.css";
+import "../../../../../../assets/debugHover.css";
+import { registerEditorContribution } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { MenuRegistry, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { Extensions as Extensions$2 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from '../../../common/contributions.js';
+import { BreakpointEditorContribution } from './breakpointEditorContribution.js';
+import { CallStackEditorContribution } from './callStackEditorContribution.js';
+import { registerColors } from './debugColors.js';
+import { DEBUG_QUICK_ACCESS_PREFIX, SELECT_AND_START_ID, DEBUG_CONSOLE_QUICK_ACCESS_PREFIX, SELECT_DEBUG_CONSOLE_ID, DEBUG_START_COMMAND_ID, DEBUG_RUN_COMMAND_ID, STOP_ID, RESTART_SESSION_ID, ADD_CONFIGURATION_ID, STEP_OVER_ID, STEP_INTO_ID, STEP_OUT_ID, CONTINUE_ID, TOGGLE_INLINE_BREAKPOINT_ID } from './debugCommands.js';
+import { DebugConsoleQuickAccess } from './debugConsoleQuickAccess.js';
+import { DebugEditorContribution } from './debugEditorContribution.js';
+import { debugRun } from './debugIcons.js';
+import { StartDebugQuickAccessProvider } from './debugQuickAccess.js';
+import { DebugToolBar } from './debugToolBar.js';
+import { BREAKPOINT_EDITOR_CONTRIBUTION_ID, EDITOR_CONTRIBUTION_ID, CONTEXT_DEBUGGERS_AVAILABLE, CONTEXT_IN_DEBUG_MODE, CONTEXT_DEBUG_STATE, INTERNAL_CONSOLE_OPTIONS_SCHEMA } from '../common/debug.js';
+import { DebugContentProvider } from '../common/debugContentProvider.js';
+import { launchSchemaId } from '../../../services/configuration/common/configuration.js';
+registerColors();
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(DebugToolBar, 3 );
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(DebugContentProvider, 4 );
+( Registry.as(Extensions$1.Quickaccess)).registerQuickAccessProvider({
+    ctor: StartDebugQuickAccessProvider,
+    prefix: DEBUG_QUICK_ACCESS_PREFIX,
+    contextKey: 'inLaunchConfigurationsPicker',
+    placeholder: ( nls.localize('startDebugPlaceholder', "Type the name of a launch configuration to run.")),
+    helpEntries: [{ description: ( nls.localize('startDebuggingHelp', "Start Debugging")), commandId: SELECT_AND_START_ID }]
+});
+( Registry.as(Extensions$1.Quickaccess)).registerQuickAccessProvider({
+    ctor: DebugConsoleQuickAccess,
+    prefix: DEBUG_CONSOLE_QUICK_ACCESS_PREFIX,
+    contextKey: 'inDebugConsolePicker',
+    placeholder: ( nls.localize('tasksQuickAccessPlaceholder', "Type the name of a debug console to open.")),
+    helpEntries: [{ description: ( nls.localize('tasksQuickAccessHelp', "Show All Debug Consoles")), commandId: SELECT_DEBUG_CONSOLE_ID }]
+});
+registerEditorContribution('editor.contrib.callStack', CallStackEditorContribution, 1 );
+registerEditorContribution(BREAKPOINT_EDITOR_CONTRIBUTION_ID, BreakpointEditorContribution, 1 );
+registerEditorContribution(EDITOR_CONTRIBUTION_ID, DebugEditorContribution, 2 );
+MenuRegistry.appendMenuItem(MenuId.EditorTitle, { submenu: MenuId.EditorTitleRun, rememberDefaultAction: true, title: { value: ( nls.localize('run', "Run or Debug...")), original: 'Run or Debug...', }, icon: debugRun, group: 'navigation', order: -1 });
+MenuRegistry.appendMenuItem(MenuId.MenubarMainMenu, {
+    submenu: MenuId.MenubarDebugMenu,
+    title: {
+        value: 'Run',
+        original: 'Run',
+        mnemonicTitle: ( nls.localize({ key: 'mRun', comment: ['&& denotes a mnemonic'] }, "&&Run"))
+    },
+    order: 6
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarDebugMenu, {
+    group: '1_debug',
+    command: {
+        id: DEBUG_START_COMMAND_ID,
+        title: ( nls.localize(
+            { key: 'miStartDebugging', comment: ['&& denotes a mnemonic'] },
+            "&&Start Debugging"
+        ))
+    },
+    order: 1,
+    when: CONTEXT_DEBUGGERS_AVAILABLE
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarDebugMenu, {
+    group: '1_debug',
+    command: {
+        id: DEBUG_RUN_COMMAND_ID,
+        title: ( nls.localize(
+            { key: 'miRun', comment: ['&& denotes a mnemonic'] },
+            "Run &&Without Debugging"
+        ))
+    },
+    order: 2,
+    when: CONTEXT_DEBUGGERS_AVAILABLE
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarDebugMenu, {
+    group: '1_debug',
+    command: {
+        id: STOP_ID,
+        title: ( nls.localize(
+            { key: 'miStopDebugging', comment: ['&& denotes a mnemonic'] },
+            "&&Stop Debugging"
+        )),
+        precondition: CONTEXT_IN_DEBUG_MODE
+    },
+    order: 3,
+    when: CONTEXT_DEBUGGERS_AVAILABLE
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarDebugMenu, {
+    group: '1_debug',
+    command: {
+        id: RESTART_SESSION_ID,
+        title: ( nls.localize(
+            { key: 'miRestart Debugging', comment: ['&& denotes a mnemonic'] },
+            "&&Restart Debugging"
+        )),
+        precondition: CONTEXT_IN_DEBUG_MODE
+    },
+    order: 4,
+    when: CONTEXT_DEBUGGERS_AVAILABLE
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarDebugMenu, {
+    group: '2_configuration',
+    command: {
+        id: ADD_CONFIGURATION_ID,
+        title: ( nls.localize(
+            { key: 'miAddConfiguration', comment: ['&& denotes a mnemonic'] },
+            "A&&dd Configuration..."
+        ))
+    },
+    order: 2,
+    when: CONTEXT_DEBUGGERS_AVAILABLE
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarDebugMenu, {
+    group: '3_step',
+    command: {
+        id: STEP_OVER_ID,
+        title: ( nls.localize({ key: 'miStepOver', comment: ['&& denotes a mnemonic'] }, "Step &&Over")),
+        precondition: ( CONTEXT_DEBUG_STATE.isEqualTo('stopped'))
+    },
+    order: 1,
+    when: CONTEXT_DEBUGGERS_AVAILABLE
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarDebugMenu, {
+    group: '3_step',
+    command: {
+        id: STEP_INTO_ID,
+        title: ( nls.localize({ key: 'miStepInto', comment: ['&& denotes a mnemonic'] }, "Step &&Into")),
+        precondition: ( CONTEXT_DEBUG_STATE.isEqualTo('stopped'))
+    },
+    order: 2,
+    when: CONTEXT_DEBUGGERS_AVAILABLE
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarDebugMenu, {
+    group: '3_step',
+    command: {
+        id: STEP_OUT_ID,
+        title: ( nls.localize({ key: 'miStepOut', comment: ['&& denotes a mnemonic'] }, "Step O&&ut")),
+        precondition: ( CONTEXT_DEBUG_STATE.isEqualTo('stopped'))
+    },
+    order: 3,
+    when: CONTEXT_DEBUGGERS_AVAILABLE
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarDebugMenu, {
+    group: '3_step',
+    command: {
+        id: CONTINUE_ID,
+        title: ( nls.localize({ key: 'miContinue', comment: ['&& denotes a mnemonic'] }, "&&Continue")),
+        precondition: ( CONTEXT_DEBUG_STATE.isEqualTo('stopped'))
+    },
+    order: 4,
+    when: CONTEXT_DEBUGGERS_AVAILABLE
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarNewBreakpointMenu, {
+    group: '1_breakpoints',
+    command: {
+        id: TOGGLE_INLINE_BREAKPOINT_ID,
+        title: ( nls.localize(
+            { key: 'miInlineBreakpoint', comment: ['&& denotes a mnemonic'] },
+            "Inline Breakp&&oint"
+        ))
+    },
+    order: 2,
+    when: CONTEXT_DEBUGGERS_AVAILABLE
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarDebugMenu, {
+    group: '4_new_breakpoint',
+    title: ( nls.localize(
+        { key: 'miNewBreakpoint', comment: ['&& denotes a mnemonic'] },
+        "&&New Breakpoint"
+    )),
+    submenu: MenuId.MenubarNewBreakpointMenu,
+    order: 2,
+    when: CONTEXT_DEBUGGERS_AVAILABLE
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarDebugMenu, {
+    group: 'z_install',
+    command: {
+        id: 'debug.installAdditionalDebuggers',
+        title: ( nls.localize(
+            { key: 'miInstallAdditionalDebuggers', comment: ['&& denotes a mnemonic'] },
+            "&&Install Additional Debuggers..."
+        ))
+    },
+    order: 1
+});
+const configurationRegistry = ( Registry.as(Extensions$2.Configuration));
+configurationRegistry.registerConfiguration({
+    id: 'debug',
+    order: 20,
+    title: ( nls.localize('debugConfigurationTitle', "Debug")),
+    type: 'object',
+    properties: {
+        'debug.allowBreakpointsEverywhere': {
+            type: 'boolean',
+            description: ( nls.localize(
+                { comment: ['This is the description for a setting'], key: 'allowBreakpointsEverywhere' },
+                "Allow setting breakpoints in any file."
+            )),
+            default: false
+        },
+        'debug.openExplorerOnEnd': {
+            type: 'boolean',
+            description: ( nls.localize(
+                { comment: ['This is the description for a setting'], key: 'openExplorerOnEnd' },
+                "Automatically open the explorer view at the end of a debug session."
+            )),
+            default: false
+        },
+        'debug.inlineValues': {
+            type: 'string',
+            'enum': ['on', 'off', 'auto'],
+            description: ( nls.localize(
+                { comment: ['This is the description for a setting'], key: 'inlineValues' },
+                "Show variable values inline in editor while debugging."
+            )),
+            'enumDescriptions': [
+                ( nls.localize(
+                    'inlineValues.on',
+                    "Always show variable values inline in editor while debugging."
+                )),
+                ( nls.localize(
+                    'inlineValues.off',
+                    "Never show variable values inline in editor while debugging."
+                )),
+                ( nls.localize(
+                    'inlineValues.focusNoScroll',
+                    "Show variable values inline in editor while debugging when the language supports inline value locations."
+                )),
+            ],
+            default: 'auto'
+        },
+        'debug.toolBarLocation': {
+            enum: ['floating', 'docked', 'hidden'],
+            markdownDescription: ( nls.localize(
+                { comment: ['This is the description for a setting'], key: 'toolBarLocation' },
+                "Controls the location of the debug toolbar. Either `floating` in all views, `docked` in the debug view, or `hidden`."
+            )),
+            default: 'floating'
+        },
+        'debug.showInStatusBar': {
+            enum: ['never', 'always', 'onFirstSessionStart'],
+            enumDescriptions: [( nls.localize('never', "Never show debug in Status bar")), ( nls.localize('always', "Always show debug in Status bar")), ( nls.localize(
+                'onFirstSessionStart',
+                "Show debug in Status bar only after debug was started for the first time"
+            ))],
+            description: ( nls.localize(
+                { comment: ['This is the description for a setting'], key: 'showInStatusBar' },
+                "Controls when the debug Status bar should be visible."
+            )),
+            default: 'onFirstSessionStart'
+        },
+        'debug.internalConsoleOptions': INTERNAL_CONSOLE_OPTIONS_SCHEMA,
+        'debug.console.closeOnEnd': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'debug.console.closeOnEnd',
+                "Controls if the Debug Console should be automatically closed when the debug session ends."
+            )),
+            default: false
+        },
+        'debug.terminal.clearBeforeReusing': {
+            type: 'boolean',
+            description: ( nls.localize(
+                { comment: ['This is the description for a setting'], key: 'debug.terminal.clearBeforeReusing' },
+                "Before starting a new debug session in an integrated or external terminal, clear the terminal."
+            )),
+            default: false
+        },
+        'debug.openDebug': {
+            enum: ['neverOpen', 'openOnSessionStart', 'openOnFirstSessionStart', 'openOnDebugBreak'],
+            default: 'openOnDebugBreak',
+            description: ( nls.localize('openDebug', "Controls when the debug view should open."))
+        },
+        'debug.showSubSessionsInToolBar': {
+            type: 'boolean',
+            description: ( nls.localize(
+                { comment: ['This is the description for a setting'], key: 'showSubSessionsInToolBar' },
+                "Controls whether the debug sub-sessions are shown in the debug tool bar. When this setting is false the stop command on a sub-session will also stop the parent session."
+            )),
+            default: false
+        },
+        'debug.console.fontSize': {
+            type: 'number',
+            description: ( nls.localize(
+                'debug.console.fontSize',
+                "Controls the font size in pixels in the Debug Console."
+            )),
+            default: isMacintosh ? 12 : 14,
+        },
+        'debug.console.fontFamily': {
+            type: 'string',
+            description: ( nls.localize(
+                'debug.console.fontFamily',
+                "Controls the font family in the Debug Console."
+            )),
+            default: 'default'
+        },
+        'debug.console.lineHeight': {
+            type: 'number',
+            description: ( nls.localize(
+                'debug.console.lineHeight',
+                "Controls the line height in pixels in the Debug Console. Use 0 to compute the line height from the font size."
+            )),
+            default: 0
+        },
+        'debug.console.wordWrap': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'debug.console.wordWrap',
+                "Controls if the lines should wrap in the Debug Console."
+            )),
+            default: true
+        },
+        'debug.console.historySuggestions': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'debug.console.historySuggestions',
+                "Controls if the Debug Console should suggest previously typed input."
+            )),
+            default: true
+        },
+        'debug.console.collapseIdenticalLines': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'debug.console.collapseIdenticalLines',
+                "Controls if the Debug Console should collapse identical lines and show a number of occurrences with a badge."
+            )),
+            default: true
+        },
+        'debug.console.acceptSuggestionOnEnter': {
+            enum: ['off', 'on'],
+            description: ( nls.localize(
+                'debug.console.acceptSuggestionOnEnter',
+                "Controls whether suggestions should be accepted on Enter in the Debug Console. Enter is also used to evaluate whatever is typed in the Debug Console."
+            )),
+            default: 'off'
+        },
+        'launch': {
+            type: 'object',
+            description: ( nls.localize(
+                { comment: ['This is the description for a setting'], key: 'launch' },
+                "Global debug launch configuration. Should be used as an alternative to 'launch.json' that is shared across workspaces."
+            )),
+            default: { configurations: [], compounds: [] },
+            $ref: launchSchemaId
+        },
+        'debug.focusWindowOnBreak': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'debug.focusWindowOnBreak',
+                "Controls whether the workbench window should be focused when the debugger breaks."
+            )),
+            default: true
+        },
+        'debug.focusEditorOnBreak': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'debug.focusEditorOnBreak',
+                "Controls whether the editor should be focused when the debugger breaks."
+            )),
+            default: true
+        },
+        'debug.onTaskErrors': {
+            enum: ['debugAnyway', 'showErrors', 'prompt', 'abort'],
+            enumDescriptions: [( nls.localize('debugAnyway', "Ignore task errors and start debugging.")), ( nls.localize('showErrors', "Show the Problems view and do not start debugging.")), ( nls.localize('prompt', "Prompt user.")), ( nls.localize('cancel', "Cancel debugging."))],
+            description: ( nls.localize(
+                'debug.onTaskErrors',
+                "Controls what to do when errors are encountered after running a preLaunchTask."
+            )),
+            default: 'prompt'
+        },
+        'debug.showBreakpointsInOverviewRuler': {
+            type: 'boolean',
+            description: ( nls.localize(
+                { comment: ['This is the description for a setting'], key: 'showBreakpointsInOverviewRuler' },
+                "Controls whether breakpoints should be shown in the overview ruler."
+            )),
+            default: false
+        },
+        'debug.showInlineBreakpointCandidates': {
+            type: 'boolean',
+            description: ( nls.localize(
+                { comment: ['This is the description for a setting'], key: 'showInlineBreakpointCandidates' },
+                "Controls whether inline breakpoints candidate decorations should be shown in the editor while debugging."
+            )),
+            default: true
+        },
+        'debug.saveBeforeStart': {
+            description: ( nls.localize(
+                'debug.saveBeforeStart',
+                "Controls what editors to save before starting a debug session."
+            )),
+            enum: ['allEditorsInActiveGroup', 'nonUntitledEditorsInActiveGroup', 'none'],
+            enumDescriptions: [
+                ( nls.localize(
+                    'debug.saveBeforeStart.allEditorsInActiveGroup',
+                    "Save all editors in the active group before starting a debug session."
+                )),
+                ( nls.localize(
+                    'debug.saveBeforeStart.nonUntitledEditorsInActiveGroup',
+                    "Save all editors in the active group except untitled ones before starting a debug session."
+                )),
+                ( nls.localize(
+                    'debug.saveBeforeStart.none',
+                    "Don't save any editors before starting a debug session."
+                )),
+            ],
+            default: 'allEditorsInActiveGroup',
+            scope: 5
+        },
+        'debug.confirmOnExit': {
+            description: ( nls.localize(
+                'debug.confirmOnExit',
+                "Controls whether to confirm when the window closes if there are active debug sessions."
+            )),
+            type: 'string',
+            enum: ['never', 'always'],
+            enumDescriptions: [
+                ( nls.localize('debug.confirmOnExit.never', "Never confirm.")),
+                ( nls.localize(
+                    'debug.confirmOnExit.always',
+                    "Always confirm if there are debug sessions."
+                )),
+            ],
+            default: 'never'
+        },
+        'debug.disassemblyView.showSourceCode': {
+            type: 'boolean',
+            default: true,
+            description: ( nls.localize(
+                'debug.disassemblyView.showSourceCode',
+                "Show Source Code in Disassembly View."
+            ))
+        },
+        'debug.autoExpandLazyVariables': {
+            type: 'boolean',
+            default: false,
+            description: ( nls.localize(
+                'debug.autoExpandLazyVariables',
+                "Automatically show values for variables that are lazily resolved by the debugger, such as getters."
+            ))
+        },
+        'debug.enableStatusBarColor': {
+            type: 'boolean',
+            description: ( nls.localize('debug.enableStatusBarColor', "Color status bar when debugger is active")),
+            default: true
+        }
+    }
+});