@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/customEditor/browser/customEditorInput.js

@@ -0,0 +1,290 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { basename } from 'monaco-editor/esm/vs/base/common/path.js';
+import { dirname, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IFileDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { IUndoRedoService } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
+import { ICustomEditorService } from '../common/customEditor.js';
+import { IWebviewService } from '../../webview/browser/webview.js';
+import { LazilyResolvedWebviewEditorInput, IWebviewWorkbenchService } from '../../webviewPanel/browser/webviewWorkbenchService.js';
+import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.js';
+import { IUntitledTextEditorService } from '../../../services/untitled/common/untitledTextEditorService.js';
+let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEditorInput {
+    static create(instantiationService, resource, viewType, group, options) {
+        return instantiationService.invokeFunction(accessor => {
+            const untitledString = accessor.get(IUntitledTextEditorService).getValue(resource);
+            const untitledDocumentData = untitledString ? VSBuffer.fromString(untitledString) : undefined;
+            const webview = accessor.get(IWebviewService).createWebviewOverlay({
+                providedViewType: viewType,
+                title: undefined,
+                options: { customClasses: options?.customClasses },
+                contentOptions: {},
+                extension: undefined,
+            });
+            const input = instantiationService.createInstance(CustomEditorInput, { resource, viewType }, webview, { untitledDocumentData: untitledDocumentData, oldResource: options?.oldResource });
+            if (typeof group !== 'undefined') {
+                input.updateGroup(group);
+            }
+            return input;
+        });
+    }
+    get resource() { return this._editorResource; }
+    constructor(init, webview, options, webviewWorkbenchService, instantiationService, labelService, customEditorService, fileDialogService, undoRedoService, fileService, filesConfigurationService) {
+        super({ providedId: init.viewType, viewType: init.viewType, name: '' }, webview, webviewWorkbenchService);
+        this.instantiationService = instantiationService;
+        this.labelService = labelService;
+        this.customEditorService = customEditorService;
+        this.fileDialogService = fileDialogService;
+        this.undoRedoService = undoRedoService;
+        this.fileService = fileService;
+        this.filesConfigurationService = filesConfigurationService;
+        this._shortDescription = undefined;
+        this._mediumDescription = undefined;
+        this._longDescription = undefined;
+        this._shortTitle = undefined;
+        this._mediumTitle = undefined;
+        this._longTitle = undefined;
+        this._editorResource = init.resource;
+        this.oldResource = options.oldResource;
+        this._defaultDirtyState = options.startsDirty;
+        this._backupId = options.backupId;
+        this._untitledDocumentData = options.untitledDocumentData;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.labelService.onDidChangeFormatters(e => this.onLabelEvent(e.scheme)));
+        this._register(this.fileService.onDidChangeFileSystemProviderRegistrations(e => this.onLabelEvent(e.scheme)));
+        this._register(this.fileService.onDidChangeFileSystemProviderCapabilities(e => this.onLabelEvent(e.scheme)));
+    }
+    onLabelEvent(scheme) {
+        if (scheme === this.resource.scheme) {
+            this.updateLabel();
+        }
+    }
+    updateLabel() {
+        this._shortDescription = undefined;
+        this._mediumDescription = undefined;
+        this._longDescription = undefined;
+        this._shortTitle = undefined;
+        this._mediumTitle = undefined;
+        this._longTitle = undefined;
+        this._onDidChangeLabel.fire();
+    }
+    get typeId() {
+        return CustomEditorInput.typeId;
+    }
+    get editorId() {
+        return this.viewType;
+    }
+    get capabilities() {
+        let capabilities = 0 ;
+        capabilities |= 128 ;
+        if (!this.customEditorService.getCustomEditorCapabilities(this.viewType)?.supportsMultipleEditorsPerDocument) {
+            capabilities |= 8 ;
+        }
+        if (this._modelRef) {
+            if (this._modelRef.object.isReadonly()) {
+                capabilities |= 2 ;
+            }
+        }
+        else {
+            if (this.filesConfigurationService.isReadonly(this.resource)) {
+                capabilities |= 2 ;
+            }
+        }
+        if (this.resource.scheme === Schemas.untitled) {
+            capabilities |= 4 ;
+        }
+        return capabilities;
+    }
+    getName() {
+        return basename(this.labelService.getUriLabel(this.resource));
+    }
+    getDescription(verbosity = 1 ) {
+        switch (verbosity) {
+            case 0 :
+                return this.shortDescription;
+            case 2 :
+                return this.longDescription;
+            case 1 :
+            default:
+                return this.mediumDescription;
+        }
+    }
+    get shortDescription() {
+        if (typeof this._shortDescription !== 'string') {
+            this._shortDescription = this.labelService.getUriBasenameLabel(dirname(this.resource));
+        }
+        return this._shortDescription;
+    }
+    get mediumDescription() {
+        if (typeof this._mediumDescription !== 'string') {
+            this._mediumDescription = this.labelService.getUriLabel(dirname(this.resource), { relative: true });
+        }
+        return this._mediumDescription;
+    }
+    get longDescription() {
+        if (typeof this._longDescription !== 'string') {
+            this._longDescription = this.labelService.getUriLabel(dirname(this.resource));
+        }
+        return this._longDescription;
+    }
+    get shortTitle() {
+        if (typeof this._shortTitle !== 'string') {
+            this._shortTitle = this.getName();
+        }
+        return this._shortTitle;
+    }
+    get mediumTitle() {
+        if (typeof this._mediumTitle !== 'string') {
+            this._mediumTitle = this.labelService.getUriLabel(this.resource, { relative: true });
+        }
+        return this._mediumTitle;
+    }
+    get longTitle() {
+        if (typeof this._longTitle !== 'string') {
+            this._longTitle = this.labelService.getUriLabel(this.resource);
+        }
+        return this._longTitle;
+    }
+    getTitle(verbosity) {
+        switch (verbosity) {
+            case 0 :
+                return this.shortTitle;
+            case 2 :
+                return this.longTitle;
+            default:
+            case 1 :
+                return this.mediumTitle;
+        }
+    }
+    matches(other) {
+        if (super.matches(other)) {
+            return true;
+        }
+        return this === other || (other instanceof CustomEditorInput
+            && this.viewType === other.viewType
+            && isEqual(this.resource, other.resource));
+    }
+    copy() {
+        return CustomEditorInput.create(this.instantiationService, this.resource, this.viewType, this.group, this.webview.options);
+    }
+    isDirty() {
+        if (!this._modelRef) {
+            return !!this._defaultDirtyState;
+        }
+        return this._modelRef.object.isDirty();
+    }
+    async save(groupId, options) {
+        if (!this._modelRef) {
+            return undefined;
+        }
+        const target = await this._modelRef.object.saveCustomEditor(options);
+        if (!target) {
+            return undefined;
+        }
+        if (!isEqual(target, this.resource)) {
+            return { resource: target };
+        }
+        return this;
+    }
+    async saveAs(groupId, options) {
+        if (!this._modelRef) {
+            return undefined;
+        }
+        const dialogPath = this._editorResource;
+        const target = await this.fileDialogService.pickFileToSave(dialogPath, options?.availableFileSystems);
+        if (!target) {
+            return undefined;
+        }
+        if (!(await this._modelRef.object.saveCustomEditorAs(this._editorResource, target, options))) {
+            return undefined;
+        }
+        return (await this.rename(groupId, target))?.editor;
+    }
+    async revert(group, options) {
+        if (this._modelRef) {
+            return this._modelRef.object.revert(options);
+        }
+        this._defaultDirtyState = false;
+        this._onDidChangeDirty.fire();
+    }
+    async resolve() {
+        await super.resolve();
+        if (this.isDisposed()) {
+            return null;
+        }
+        if (!this._modelRef) {
+            const oldCapabilities = this.capabilities;
+            this._modelRef = this._register(assertIsDefined(await this.customEditorService.models.tryRetain(this.resource, this.viewType)));
+            this._register(this._modelRef.object.onDidChangeDirty(() => this._onDidChangeDirty.fire()));
+            this._register(this._modelRef.object.onDidChangeReadonly(() => this._onDidChangeCapabilities.fire()));
+            if (this._untitledDocumentData) {
+                this._defaultDirtyState = true;
+            }
+            if (this.isDirty()) {
+                this._onDidChangeDirty.fire();
+            }
+            if (this.capabilities !== oldCapabilities) {
+                this._onDidChangeCapabilities.fire();
+            }
+        }
+        return null;
+    }
+    async rename(group, newResource) {
+        return { editor: { resource: newResource } };
+    }
+    undo() {
+        assertIsDefined(this._modelRef);
+        return this.undoRedoService.undo(this.resource);
+    }
+    redo() {
+        assertIsDefined(this._modelRef);
+        return this.undoRedoService.redo(this.resource);
+    }
+    onMove(handler) {
+        this._moveHandler = handler;
+    }
+    transfer(other) {
+        if (!super.transfer(other)) {
+            return;
+        }
+        other._moveHandler = this._moveHandler;
+        this._moveHandler = undefined;
+        return other;
+    }
+    get backupId() {
+        if (this._modelRef) {
+            return this._modelRef.object.backupId;
+        }
+        return this._backupId;
+    }
+    get untitledDocumentData() {
+        return this._untitledDocumentData;
+    }
+    toUntyped() {
+        return {
+            resource: this.resource,
+            options: {
+                override: this.viewType
+            }
+        };
+    }
+};
+CustomEditorInput.typeId = 'workbench.editors.webviewEditor';
+CustomEditorInput = ( __decorate([
+    ( __param(3, IWebviewWorkbenchService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, ILabelService)),
+    ( __param(6, ICustomEditorService)),
+    ( __param(7, IFileDialogService)),
+    ( __param(8, IUndoRedoService)),
+    ( __param(9, IFileService)),
+    ( __param(10, IFilesConfigurationService))
+], CustomEditorInput));
+export { CustomEditorInput };

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

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const ICustomEditorService = ( createDecorator('customEditorService'));
+export { ICustomEditorService };

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

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import "../../../../../../assets/breakpointWidget.css";
+import './media/breakpointWidget.css.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { SelectBox } from 'monaco-editor/esm/vs/base/browser/ui/selectBox/selectBox.js';
 import * as lifecycle from 'monaco-editor/esm/vs/base/common/lifecycle.js';

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

@@ -12,7 +12,7 @@ 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";
+import './media/callStackEditorContribution.css.js';
 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.'

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

@@ -1,6 +1,6 @@
 import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
-import "../../../../../../assets/debug.contribution.css";
-import "../../../../../../assets/debugHover.css";
+import './media/debug.contribution.css.js';
+import './media/debugHover.css.js';
 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';
@@ -9,15 +9,17 @@ import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.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 { EditorPaneDescriptor } from '../../../browser/editor.js';
 import { ViewPaneContainer } from '../../../browser/parts/views/viewPaneContainer.js';
 import { Extensions } from '../../../common/contributions.js';
+import { EditorExtensions } from '../../../common/editor.js';
 import { Extensions as Extensions$2 } from '../../../common/views.js';
 import { BreakpointEditorContribution } from './breakpointEditorContribution.js';
 import { BreakpointsView } from './breakpointsView.js';
 import { CallStackEditorContribution } from './callStackEditorContribution.js';
 import { CallStackView } from './callStackView.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_COMMAND_CATEGORY, TERMINATE_THREAD_ID, STEP_OVER_LABEL, STEP_OVER_ID, STEP_INTO_LABEL, STEP_INTO_ID, STEP_INTO_TARGET_LABEL, STEP_INTO_TARGET_ID, STEP_OUT_LABEL, STEP_OUT_ID, PAUSE_LABEL, PAUSE_ID, STOP_LABEL, STOP_ID, CONTINUE_LABEL, CONTINUE_ID, FOCUS_REPL_ID, JUMP_TO_CURSOR_ID, TOGGLE_INLINE_BREAKPOINT_ID, SELECT_AND_START_LABEL, NEXT_DEBUG_CONSOLE_LABEL, NEXT_DEBUG_CONSOLE_ID, PREV_DEBUG_CONSOLE_LABEL, PREV_DEBUG_CONSOLE_ID, OPEN_LOADED_SCRIPTS_LABEL, SHOW_LOADED_SCRIPTS_ID, SELECT_DEBUG_CONSOLE_LABEL, SELECT_DEBUG_SESSION_LABEL, SELECT_DEBUG_SESSION_ID, CALLSTACK_TOP_LABEL, CALLSTACK_TOP_ID, CALLSTACK_BOTTOM_LABEL, CALLSTACK_BOTTOM_ID, CALLSTACK_UP_LABEL, CALLSTACK_UP_ID, CALLSTACK_DOWN_LABEL, CALLSTACK_DOWN_ID, RESTART_LABEL, RESTART_SESSION_ID, DISCONNECT_LABEL, DISCONNECT_ID, DISCONNECT_AND_SUSPEND_LABEL, DISCONNECT_AND_SUSPEND_ID, RESTART_FRAME_ID, COPY_STACK_TRACE_ID, EDIT_EXPRESSION_COMMAND_ID, SET_EXPRESSION_COMMAND_ID, REMOVE_EXPRESSION_COMMAND_ID } from './debugCommands.js';
+import { DEBUG_QUICK_ACCESS_PREFIX, SELECT_AND_START_ID, DEBUG_CONSOLE_QUICK_ACCESS_PREFIX, SELECT_DEBUG_CONSOLE_ID, TOGGLE_INLINE_BREAKPOINT_ID, DEBUG_COMMAND_CATEGORY, TERMINATE_THREAD_ID, STEP_OVER_LABEL, STEP_OVER_ID, STEP_INTO_LABEL, STEP_INTO_ID, STEP_INTO_TARGET_LABEL, STEP_INTO_TARGET_ID, STEP_OUT_LABEL, STEP_OUT_ID, PAUSE_LABEL, PAUSE_ID, STOP_LABEL, STOP_ID, CONTINUE_LABEL, CONTINUE_ID, FOCUS_REPL_ID, JUMP_TO_CURSOR_ID, SELECT_AND_START_LABEL, NEXT_DEBUG_CONSOLE_LABEL, NEXT_DEBUG_CONSOLE_ID, PREV_DEBUG_CONSOLE_LABEL, PREV_DEBUG_CONSOLE_ID, OPEN_LOADED_SCRIPTS_LABEL, SHOW_LOADED_SCRIPTS_ID, SELECT_DEBUG_CONSOLE_LABEL, SELECT_DEBUG_SESSION_LABEL, SELECT_DEBUG_SESSION_ID, CALLSTACK_TOP_LABEL, CALLSTACK_TOP_ID, CALLSTACK_BOTTOM_LABEL, CALLSTACK_BOTTOM_ID, CALLSTACK_UP_LABEL, CALLSTACK_UP_ID, CALLSTACK_DOWN_LABEL, CALLSTACK_DOWN_ID, RESTART_LABEL, RESTART_SESSION_ID, DISCONNECT_LABEL, DISCONNECT_ID, DISCONNECT_AND_SUSPEND_LABEL, DISCONNECT_AND_SUSPEND_ID, RESTART_FRAME_ID, COPY_STACK_TRACE_ID, EDIT_EXPRESSION_COMMAND_ID, SET_EXPRESSION_COMMAND_ID, REMOVE_EXPRESSION_COMMAND_ID } from './debugCommands.js';
 import { DebugConsoleQuickAccess } from './debugConsoleQuickAccess.js';
 import { RunToCursorAction, SelectionToReplAction, SelectionToWatchExpressionsAction } from './debugEditorActions.js';
 import { DebugEditorContribution } from './debugEditorContribution.js';
@@ -25,12 +27,14 @@ import { debugRun, debugConsoleViewIcon, runViewIcon, variablesViewIcon, watchVi
 import { StartDebugQuickAccessProvider } from './debugQuickAccess.js';
 import { DebugToolBar } from './debugToolBar.js';
 import { DebugViewPaneContainer } from './debugViewlet.js';
+import { DisassemblyView } from './disassemblyView.js';
 import { LoadedScriptsView } from './loadedScriptsView.js';
 import { Repl } from './repl.js';
 import { VariablesView, VIEW_MEMORY_ID, SET_VARIABLE_ID, COPY_VALUE_ID, COPY_EVALUATE_PATH_ID, ADD_TO_WATCH_ID, BREAK_WHEN_VALUE_IS_READ_ID, BREAK_WHEN_VALUE_CHANGES_ID, BREAK_WHEN_VALUE_IS_ACCESSED_ID } from './variablesView.js';
 import { WatchExpressionsView, ADD_WATCH_LABEL, ADD_WATCH_ID, REMOVE_WATCH_EXPRESSIONS_LABEL, REMOVE_WATCH_EXPRESSIONS_COMMAND_ID } from './watchExpressionsView.js';
-import { BREAKPOINT_EDITOR_CONTRIBUTION_ID, EDITOR_CONTRIBUTION_ID, DEBUG_PANEL_ID, REPL_VIEW_ID, CONTEXT_DEBUGGERS_AVAILABLE, VIEWLET_ID, VARIABLES_VIEW_ID, CONTEXT_DEBUG_UX, WATCH_VIEW_ID, CALLSTACK_VIEW_ID, BREAKPOINTS_VIEW_ID, CONTEXT_BREAKPOINTS_EXIST, CONTEXT_HAS_DEBUGGED, LOADED_SCRIPTS_VIEW_ID, CONTEXT_LOADED_SCRIPTS_SUPPORTED, INTERNAL_CONSOLE_OPTIONS_SCHEMA, CONTEXT_IN_DEBUG_MODE, CONTEXT_DEBUG_STATE, CONTEXT_STEP_INTO_TARGETS_SUPPORTED, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, CONTEXT_JUMP_TO_CURSOR_SUPPORTED, getStateLabel, CONTEXT_CALLSTACK_ITEM_TYPE, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, CONTEXT_STACK_FRAME_SUPPORTS_RESTART, CONTEXT_RESTART_FRAME_SUPPORTED, CONTEXT_CAN_VIEW_MEMORY, CONTEXT_VARIABLE_IS_READONLY, CONTEXT_SET_VARIABLE_SUPPORTED, CONTEXT_VARIABLE_EVALUATE_NAME_PRESENT, CONTEXT_SET_EXPRESSION_SUPPORTED, CONTEXT_BREAK_WHEN_VALUE_IS_READ_SUPPORTED, CONTEXT_BREAK_WHEN_VALUE_CHANGES_SUPPORTED, CONTEXT_BREAK_WHEN_VALUE_IS_ACCESSED_SUPPORTED, CONTEXT_WATCH_ITEM_TYPE } from '../common/debug.js';
+import { BREAKPOINT_EDITOR_CONTRIBUTION_ID, EDITOR_CONTRIBUTION_ID, CONTEXT_DEBUGGERS_AVAILABLE, DEBUG_PANEL_ID, REPL_VIEW_ID, VIEWLET_ID, VARIABLES_VIEW_ID, CONTEXT_DEBUG_UX, WATCH_VIEW_ID, CALLSTACK_VIEW_ID, BREAKPOINTS_VIEW_ID, CONTEXT_BREAKPOINTS_EXIST, CONTEXT_HAS_DEBUGGED, LOADED_SCRIPTS_VIEW_ID, CONTEXT_LOADED_SCRIPTS_SUPPORTED, DISASSEMBLY_VIEW_ID, INTERNAL_CONSOLE_OPTIONS_SCHEMA, CONTEXT_IN_DEBUG_MODE, CONTEXT_DEBUG_STATE, CONTEXT_STEP_INTO_TARGETS_SUPPORTED, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, CONTEXT_JUMP_TO_CURSOR_SUPPORTED, getStateLabel, CONTEXT_CALLSTACK_ITEM_TYPE, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, CONTEXT_STACK_FRAME_SUPPORTS_RESTART, CONTEXT_RESTART_FRAME_SUPPORTED, CONTEXT_CAN_VIEW_MEMORY, CONTEXT_VARIABLE_IS_READONLY, CONTEXT_SET_VARIABLE_SUPPORTED, CONTEXT_VARIABLE_EVALUATE_NAME_PRESENT, CONTEXT_SET_EXPRESSION_SUPPORTED, CONTEXT_BREAK_WHEN_VALUE_IS_READ_SUPPORTED, CONTEXT_BREAK_WHEN_VALUE_CHANGES_SUPPORTED, CONTEXT_BREAK_WHEN_VALUE_IS_ACCESSED_SUPPORTED, CONTEXT_WATCH_ITEM_TYPE } from '../common/debug.js';
 import { DebugContentProvider } from '../common/debugContentProvider.js';
+import { DisassemblyViewInput } from '../common/disassemblyViewInput.js';
 import { launchSchemaId } from '../../../services/configuration/common/configuration.js';
 const debugCategory = ( nls.localize('debugCategory', "Debug"));
 registerColors();
@@ -135,6 +139,27 @@ registerDebugViewMenuItem(MenuId.DebugWatchContext, VIEW_MEMORY_ID, ( nls.locali
 registerDebugViewMenuItem(MenuId.DebugWatchContext, REMOVE_EXPRESSION_COMMAND_ID, ( nls.localize('removeWatchExpression', "Remove Expression")), 20, ( CONTEXT_WATCH_ITEM_TYPE.isEqualTo('expression')), undefined, 'inline', watchExpressionRemove);
 registerDebugViewMenuItem(MenuId.DebugWatchContext, REMOVE_WATCH_EXPRESSIONS_COMMAND_ID, REMOVE_WATCH_EXPRESSIONS_LABEL, 20, undefined, undefined, 'z_commands');
 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.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
+});
 const VIEW_CONTAINER = ( Registry.as(Extensions$2.ViewContainersRegistry)).registerViewContainer({
     id: DEBUG_PANEL_ID,
     title: ( nls.localize(
@@ -191,6 +216,7 @@ viewsRegistry.registerViews([{ id: WATCH_VIEW_ID, name: ( nls.localize('watch',
 viewsRegistry.registerViews([{ id: CALLSTACK_VIEW_ID, name: ( nls.localize('callStack', "Call Stack")), containerIcon: callStackViewIcon, ctorDescriptor: ( new SyncDescriptor(CallStackView)), order: 30, weight: 30, canToggleVisibility: true, canMoveView: true, focusCommand: { id: 'workbench.debug.action.focusCallStackView' }, when: ( CONTEXT_DEBUG_UX.isEqualTo('default')) }], viewContainer);
 viewsRegistry.registerViews([{ id: BREAKPOINTS_VIEW_ID, name: ( nls.localize('breakpoints', "Breakpoints")), containerIcon: breakpointsViewIcon, ctorDescriptor: ( new SyncDescriptor(BreakpointsView)), order: 40, weight: 20, canToggleVisibility: true, canMoveView: true, focusCommand: { id: 'workbench.debug.action.focusBreakpointsView' }, when: ( ContextKeyExpr.or(CONTEXT_BREAKPOINTS_EXIST, ( CONTEXT_DEBUG_UX.isEqualTo('default')), CONTEXT_HAS_DEBUGGED)) }], viewContainer);
 viewsRegistry.registerViews([{ id: LOADED_SCRIPTS_VIEW_ID, name: ( nls.localize('loadedScripts', "Loaded Scripts")), containerIcon: loadedScriptsViewIcon, ctorDescriptor: ( new SyncDescriptor(LoadedScriptsView)), order: 35, weight: 5, canToggleVisibility: true, canMoveView: true, collapsed: true, when: ( ContextKeyExpr.and(CONTEXT_LOADED_SCRIPTS_SUPPORTED, ( CONTEXT_DEBUG_UX.isEqualTo('default')))) }], viewContainer);
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(DisassemblyView, DISASSEMBLY_VIEW_ID, ( nls.localize('disassembly', "Disassembly"))), [( new SyncDescriptor(DisassemblyViewInput))]);
 const configurationRegistry = ( Registry.as(Extensions$3.Configuration));
 configurationRegistry.registerConfiguration({
     id: 'debug',

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

@@ -59,6 +59,7 @@ let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseAction
         const keybindingLabel = keybinding ? ` (${keybinding})` : '';
         this.start.title = this.action.label + keybindingLabel;
         this.start.setAttribute('role', 'button');
+        this.start.ariaLabel = this.start.title;
         this.toDispose.push(dom.addDisposableListener(this.start, dom.EventType.CLICK, () => {
             this.start.blur();
             if (this.debugService.state !== 1 ) {

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

@@ -2,7 +2,7 @@ import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { List } from 'monaco-editor/esm/vs/base/browser/ui/list/listWidget.js';
 import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
 import { IListService } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
-import { IDebugService, CONTEXT_DISASSEMBLY_VIEW_FOCUS, CONTEXT_JUMP_TO_CURSOR_SUPPORTED, CONTEXT_IN_DEBUG_REPL, CONTEXT_IN_DEBUG_MODE, CONTEXT_DEBUG_STATE, CONTEXT_STEP_INTO_TARGETS_SUPPORTED, CONTEXT_FOCUSED_SESSION_IS_ATTACH, REPL_VIEW_ID, CONTEXT_BREAKPOINTS_FOCUSED, CONTEXT_WATCH_EXPRESSIONS_FOCUSED, CONTEXT_VARIABLES_FOCUSED, CONTEXT_EXPRESSION_SELECTED, CONTEXT_BREAKPOINT_INPUT_FOCUSED } from '../common/debug.js';
+import { IDebugService, CONTEXT_DISASSEMBLY_VIEW_FOCUS, CONTEXT_JUMP_TO_CURSOR_SUPPORTED, CONTEXT_IN_DEBUG_REPL, CONTEXT_IN_DEBUG_MODE, CONTEXT_DEBUG_STATE, CONTEXT_STEP_INTO_TARGETS_SUPPORTED, CONTEXT_FOCUSED_SESSION_IS_ATTACH, REPL_VIEW_ID, CONTEXT_BREAKPOINTS_FOCUSED, CONTEXT_WATCH_EXPRESSIONS_FOCUSED, CONTEXT_VARIABLES_FOCUSED, CONTEXT_EXPRESSION_SELECTED, CONTEXT_BREAKPOINT_INPUT_FOCUSED, CONTEXT_DEBUGGERS_AVAILABLE, VIEWLET_ID } from '../common/debug.js';
 import { Expression, Variable, Breakpoint, FunctionBreakpoint, DataBreakpoint } from '../common/debugModel.js';
 import { isCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
 import { MenuRegistry, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
@@ -20,6 +20,7 @@ import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configurati
 import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
 import { IViewsService } from '../../../common/views.js';
 import { isWeb, isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
 import { showLoadedScriptMenu } from '../common/loadedScriptsPicker.js';
 import { showDebugSessionMenu } from './debugSessionPicker.js';
 const ADD_CONFIGURATION_ID = 'debug.addConfiguration';
@@ -406,7 +407,8 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
 KeybindingsRegistry.registerCommandAndKeybindingRule({
     id: STEP_OVER_ID,
     weight: 200 ,
-    primary: isWeb ? ((512  | 68) ) : 68 ,
+    primary: 68 ,
+    secondary: isWeb ? [((512  | 68) )] : undefined,
     when: ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')),
     handler: async (accessor, _, context) => {
         const contextKeyService = accessor.get(IContextKeyService);
@@ -822,4 +824,15 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
         return undefined;
     }
 });
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'debug.openView',
+    weight: 200 ,
+    when: ( CONTEXT_DEBUGGERS_AVAILABLE.toNegated()),
+    primary: 63 ,
+    secondary: [2048  | 63 ],
+    handler: async (accessor) => {
+        const paneCompositeService = accessor.get(IPaneCompositePartService);
+        await paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , true);
+    }
+});
 export { ADD_CONFIGURATION_ID, CALLSTACK_BOTTOM_ID, CALLSTACK_BOTTOM_LABEL, CALLSTACK_DOWN_ID, CALLSTACK_DOWN_LABEL, CALLSTACK_TOP_ID, CALLSTACK_TOP_LABEL, CALLSTACK_UP_ID, CALLSTACK_UP_LABEL, CONTINUE_ID, CONTINUE_LABEL, COPY_STACK_TRACE_ID, DEBUG_COMMAND_CATEGORY, DEBUG_CONFIGURE_COMMAND_ID, DEBUG_CONFIGURE_LABEL, DEBUG_CONSOLE_QUICK_ACCESS_PREFIX, DEBUG_QUICK_ACCESS_PREFIX, DEBUG_START_COMMAND_ID, DISCONNECT_AND_SUSPEND_ID, DISCONNECT_AND_SUSPEND_LABEL, DISCONNECT_ID, DISCONNECT_LABEL, EDIT_EXPRESSION_COMMAND_ID, FOCUS_REPL_ID, FOCUS_SESSION_ID, FOCUS_SESSION_LABEL, JUMP_TO_CURSOR_ID, NEXT_DEBUG_CONSOLE_ID, NEXT_DEBUG_CONSOLE_LABEL, OPEN_LOADED_SCRIPTS_LABEL, PAUSE_ID, PAUSE_LABEL, PREV_DEBUG_CONSOLE_ID, PREV_DEBUG_CONSOLE_LABEL, REMOVE_EXPRESSION_COMMAND_ID, RESTART_FRAME_ID, RESTART_LABEL, RESTART_SESSION_ID, REVERSE_CONTINUE_ID, SELECT_AND_START_ID, SELECT_AND_START_LABEL, SELECT_DEBUG_CONSOLE_ID, SELECT_DEBUG_CONSOLE_LABEL, SELECT_DEBUG_SESSION_ID, SELECT_DEBUG_SESSION_LABEL, SET_EXPRESSION_COMMAND_ID, SHOW_LOADED_SCRIPTS_ID, STEP_BACK_ID, STEP_INTO_ID, STEP_INTO_LABEL, STEP_INTO_TARGET_ID, STEP_INTO_TARGET_LABEL, STEP_OUT_ID, STEP_OUT_LABEL, STEP_OVER_ID, STEP_OVER_LABEL, STOP_ID, STOP_LABEL, TERMINATE_THREAD_ID, TOGGLE_INLINE_BREAKPOINT_ID };

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

@@ -3,7 +3,7 @@ import { flatten, distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { sequence } from 'monaco-editor/esm/vs/base/common/async.js';
 import { CancellationTokenSource, CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import * as Json from 'monaco-editor/esm/vs/base/common/json.js';
+import * as json from 'monaco-editor/esm/vs/base/common/json.js';
 import { dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
 import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
@@ -163,22 +163,6 @@ let ConfigurationManager = class ConfigurationManager {
                 type,
                 pick: async () => {
                     await this.adapterManager.activateDebuggers(onDebugDynamicConfigurationsName, type);
-                    const disposables = ( new DisposableStore());
-                    const input = disposables.add(this.quickInputService.createQuickPick());
-                    input.busy = true;
-                    input.placeholder = ( nls.localize('selectConfiguration', "Select Launch Configuration"));
-                    input.show();
-                    const chosenPromise = ( new Promise(resolve => {
-                        disposables.add(input.onDidAccept(() => resolve(input.activeItems[0])));
-                        disposables.add(input.onDidTriggerItemButton(async (context) => {
-                            resolve(undefined);
-                            const { launch, config } = context.item;
-                            await launch.openConfigFile({ preserveFocus: false, type: config.type, suppressInitialConfigs: true });
-                            await launch.writeConfiguration(config);
-                            await this.selectConfiguration(launch, config.name);
-                            this.removeRecentDynamicConfigurations(config.name, config.type);
-                        }));
-                    }));
                     const token = ( new CancellationTokenSource());
                     const picks = [];
                     const provider = this.configProviders.find(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Dynamic && p.provideDebugConfigurations);
@@ -196,10 +180,26 @@ let ConfigurationManager = class ConfigurationManager {
                             })))));
                         }
                     });
+                    const disposables = ( new DisposableStore());
+                    const input = disposables.add(this.quickInputService.createQuickPick());
+                    input.busy = true;
+                    input.placeholder = ( nls.localize('selectConfiguration', "Select Launch Configuration"));
+                    const chosenPromise = ( new Promise(resolve => {
+                        disposables.add(input.onDidAccept(() => resolve(input.activeItems[0])));
+                        disposables.add(input.onDidTriggerItemButton(async (context) => {
+                            resolve(undefined);
+                            const { launch, config } = context.item;
+                            await launch.openConfigFile({ preserveFocus: false, type: config.type, suppressInitialConfigs: true });
+                            await launch.writeConfiguration(config);
+                            await this.selectConfiguration(launch, config.name);
+                            this.removeRecentDynamicConfigurations(config.name, config.type);
+                        }));
+                    }));
                     const nestedPicks = await Promise.all(picks);
                     const items = flatten(nestedPicks);
                     input.items = items;
                     input.busy = false;
+                    input.show();
                     const chosen = await chosenPromise;
                     disposables.dispose();
                     if (!chosen) {
@@ -225,7 +225,7 @@ let ConfigurationManager = class ConfigurationManager {
     }
     removeRecentDynamicConfigurations(name, type) {
         const remaining = this.getRecentDynamicConfigurations().filter(c => c.name !== name || c.type !== type);
-        this.storageService.store(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, JSON.stringify(remaining), 1 , 0 );
+        this.storageService.store(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, JSON.stringify(remaining), 1 , 1 );
         if (this.selectedConfiguration.name === name && this.selectedType === type && this.selectedDynamic) {
             this.selectConfiguration(undefined, undefined);
         }
@@ -349,7 +349,7 @@ let ConfigurationManager = class ConfigurationManager {
             if (name && dynamicConfig.type) {
                 recentDynamicProviders.unshift({ name, type: dynamicConfig.type });
                 recentDynamicProviders = distinct(recentDynamicProviders, t => `${t.name} : ${t.type}`);
-                this.storageService.store(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, JSON.stringify(recentDynamicProviders), 1 , 0 );
+                this.storageService.store(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, JSON.stringify(recentDynamicProviders), 1 , 1 );
             }
         }
         else if (!this.selectedName || names.indexOf(this.selectedName) === -1) {
@@ -562,7 +562,7 @@ let WorkspaceLaunch = class WorkspaceLaunch extends AbstractLaunch {
         if (!launchExistInFile) {
             const content = await this.getInitialConfigurationContent(undefined, type, useInitialConfigs, token);
             if (content) {
-                await this.configurationService.updateValue('launch', Json.parse(content), 5 );
+                await this.configurationService.updateValue('launch', json.parse(content), 5 );
             }
             else {
                 return { editor: null, created: false };

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

@@ -7,7 +7,7 @@ import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorCont
 import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
 import { MessageController } from 'monaco-editor/esm/vs/editor/contrib/message/browser/messageController.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { MenuId, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { registerAction2, MenuId, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
@@ -233,7 +233,7 @@ class RunToCursorAction extends EditorAction {
             id: RunToCursorAction.ID,
             label: RunToCursorAction.LABEL,
             alias: 'Debug: Run to Cursor',
-            precondition: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( PanelFocusContext.toNegated()), EditorContextKeys.editorTextFocus)),
+            precondition: ( ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, ( PanelFocusContext.toNegated()), ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')), EditorContextKeys.editorTextFocus)),
             contextMenuOpts: {
                 group: 'debug',
                 order: 2
@@ -300,7 +300,7 @@ class SelectionToWatchExpressionsAction extends EditorAction {
             id: SelectionToWatchExpressionsAction.ID,
             label: SelectionToWatchExpressionsAction.LABEL,
             alias: 'Debug: Add to Watch',
-            precondition: ( ContextKeyExpr.and(EditorContextKeys.editorTextFocus)),
+            precondition: ( ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, EditorContextKeys.editorTextFocus)),
             contextMenuOpts: {
                 group: 'debug',
                 order: 1
@@ -507,6 +507,8 @@ class CloseExceptionWidgetAction extends EditorAction {
         contribution?.closeExceptionWidget();
     }
 }
+registerAction2(OpenDisassemblyViewAction);
+registerAction2(ToggleDisassemblyViewSourceCodeAction);
 registerEditorAction(ToggleBreakpointAction);
 registerEditorAction(ConditionalBreakpointAction);
 registerEditorAction(LogPointAction);

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

@@ -306,12 +306,15 @@ let DebugEditorContribution = class DebugEditorContribution {
     async showHover(position, focus) {
         const sf = this.debugService.getViewModel().focusedStackFrame;
         const model = this.editor.getModel();
-        if (sf && model && this.uriIdentityService.extUri.isEqual(sf.source.uri, model.uri) && !this.altPressed) {
+        if (sf && model && this.uriIdentityService.extUri.isEqual(sf.source.uri, model.uri)) {
             const result = await this.hoverWidget.showAt(position, focus);
             if (result === 1 ) {
                 this.showEditorHover(position, focus);
             }
         }
+        else {
+            this.showEditorHover(position, focus);
+        }
     }
     showEditorHover(position, focus) {
         const hoverController = this.editor.getContribution(ModesHoverController.ID);
@@ -334,7 +337,7 @@ let DebugEditorContribution = class DebugEditorContribution {
     get showHoverScheduler() {
         const hoverOption = this.editor.getOption(58 );
         const scheduler = ( new RunOnceScheduler(() => {
-            if (this.hoverPosition) {
+            if (this.hoverPosition && !this.altPressed) {
                 this.showHover(this.hoverPosition, false);
             }
         }, hoverOption.delay * 2));