@codingame/monaco-vscode-debug-service-override 1.83.16 → 1.85.0-next.0

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

@@ -1,14 +1,14 @@
 import { getDomNodePagePosition } from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
 import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
-import { EditorAction2, EditorAction, registerEditorAction } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { EditorAction, registerEditorAction } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
 import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
 import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
 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, registerAction2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { Action2, MenuId, registerAction2 } 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';
@@ -201,8 +201,8 @@ class EditBreakpointAction extends EditorAction {
         editor.getContribution(BREAKPOINT_EDITOR_CONTRIBUTION_ID)?.showBreakpointWidget(closestBreakpoint.lineNumber, closestBreakpoint.column);
     }
 }
-class OpenDisassemblyViewAction extends EditorAction2 {
-    static { this.ID = 'editor.debug.action.openDisassemblyView'; }
+class OpenDisassemblyViewAction extends Action2 {
+    static { this.ID = 'debug.action.openDisassemblyView'; }
     constructor() {
         super({
             id: OpenDisassemblyViewAction.ID,
@@ -240,11 +240,9 @@ class OpenDisassemblyViewAction extends EditorAction2 {
             ]
         });
     }
-    runEditorCommand(accessor, editor, ...args) {
-        if (editor.hasModel()) {
-            const editorService = accessor.get(IEditorService);
-            editorService.openEditor(DisassemblyViewInput.instance, { pinned: true, revealIfOpened: true });
-        }
+    run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        editorService.openEditor(DisassemblyViewInput.instance, { pinned: true, revealIfOpened: true });
     }
 }
 class ToggleDisassemblyViewSourceCodeAction extends Action2 {
@@ -279,7 +277,7 @@ class ToggleDisassemblyViewSourceCodeAction extends Action2 {
 }
 class RunToCursorAction extends EditorAction {
     static { this.ID = 'editor.debug.action.runToCursor'; }
-    static { this.LABEL = ( nls.localizeWithPath(
+    static { this.LABEL = ( nls.localize2WithPath(
         'vs/workbench/contrib/debug/browser/debugEditorActions',
         'runToCursor',
         "Run to Cursor"
@@ -287,7 +285,7 @@ class RunToCursorAction extends EditorAction {
     constructor() {
         super({
             id: RunToCursorAction.ID,
-            label: RunToCursorAction.LABEL,
+            label: RunToCursorAction.LABEL.value,
             alias: 'Debug: Run to Cursor',
             precondition: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( PanelFocusContext.toNegated()), ( ContextKeyExpr.or(EditorContextKeys.editorTextFocus, CONTEXT_DISASSEMBLY_VIEW_FOCUS)))),
             contextMenuOpts: {
@@ -316,7 +314,7 @@ class RunToCursorAction extends EditorAction {
 }
 class SelectionToReplAction extends EditorAction {
     static { this.ID = 'editor.debug.action.selectionToRepl'; }
-    static { this.LABEL = ( nls.localizeWithPath(
+    static { this.LABEL = ( nls.localize2WithPath(
         'vs/workbench/contrib/debug/browser/debugEditorActions',
         'evaluateInDebugConsole',
         "Evaluate in Debug Console"
@@ -324,7 +322,7 @@ class SelectionToReplAction extends EditorAction {
     constructor() {
         super({
             id: SelectionToReplAction.ID,
-            label: SelectionToReplAction.LABEL,
+            label: SelectionToReplAction.LABEL.value,
             alias: 'Debug: Evaluate in Console',
             precondition: ( ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, EditorContextKeys.editorTextFocus)),
             contextMenuOpts: {
@@ -355,7 +353,7 @@ class SelectionToReplAction extends EditorAction {
 }
 class SelectionToWatchExpressionsAction extends EditorAction {
     static { this.ID = 'editor.debug.action.selectionToWatch'; }
-    static { this.LABEL = ( nls.localizeWithPath(
+    static { this.LABEL = ( nls.localize2WithPath(
         'vs/workbench/contrib/debug/browser/debugEditorActions',
         'addToWatch',
         "Add to Watch"
@@ -363,7 +361,7 @@ class SelectionToWatchExpressionsAction extends EditorAction {
     constructor() {
         super({
             id: SelectionToWatchExpressionsAction.ID,
-            label: SelectionToWatchExpressionsAction.LABEL,
+            label: SelectionToWatchExpressionsAction.LABEL.value,
             alias: 'Debug: Add to Watch',
             precondition: ( ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, EditorContextKeys.editorTextFocus)),
             contextMenuOpts: {

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

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { addDisposableListener } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { addDisposableListener, isKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { DomEmitter } from 'monaco-editor/esm/vs/base/browser/event.js';
 import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
 import { flatten, distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
@@ -153,10 +153,11 @@ function getWordToLineNumbersMap(model) {
         return result;
     }
     for (let lineNumber = 1, len = model.getLineCount(); lineNumber <= len; ++lineNumber) {
-        const lineContent = model.getLineContent(lineNumber);
-        if (lineContent.length > MAX_TOKENIZATION_LINE_LEN) {
+        const lineLength = model.getLineLength(lineNumber);
+        if (lineLength > MAX_TOKENIZATION_LINE_LEN) {
             continue;
         }
+        const lineContent = model.getLineContent(lineNumber);
         model.tokenization.forceTokenization(lineNumber);
         const lineTokens = model.tokenization.getLineTokens(lineNumber);
         for (let tokenIndex = 0, tokenCount = lineTokens.getCount(); tokenIndex < tokenCount; tokenIndex++) {
@@ -260,10 +261,11 @@ let DebugEditorContribution = class DebugEditorContribution {
     }
     applyHoverConfiguration(model, stackFrame) {
         if (stackFrame && this.uriIdentityService.extUri.isEqual(model.uri, stackFrame.source.uri)) {
+            const ownerDocument = this.editor.getContainerDomNode().ownerDocument;
             if (this.altListener) {
                 this.altListener.dispose();
             }
-            this.altListener = addDisposableListener(document, 'keydown', keydownEvent => {
+            this.altListener = addDisposableListener(ownerDocument, 'keydown', keydownEvent => {
                 const standardKeyboardEvent = ( new StandardKeyboardEvent(keydownEvent));
                 if (standardKeyboardEvent.keyCode === 6 ) {
                     this.altPressed = true;
@@ -273,10 +275,10 @@ let DebugEditorContribution = class DebugEditorContribution {
                     if (debugHoverWasVisible && this.hoverPosition) {
                         this.showEditorHover(this.hoverPosition, false);
                     }
-                    const onKeyUp = ( new DomEmitter(document, 'keyup'));
+                    const onKeyUp = ( new DomEmitter(ownerDocument, 'keyup'));
                     const listener = Event.any(this.hostService.onDidChangeFocus, onKeyUp.event)(keyupEvent => {
                         let standardKeyboardEvent = undefined;
-                        if (keyupEvent instanceof KeyboardEvent) {
+                        if (isKeyboardEvent(keyupEvent)) {
                             standardKeyboardEvent = ( new StandardKeyboardEvent(keyupEvent));
                         }
                         if (!standardKeyboardEvent || standardKeyboardEvent.keyCode === 6 ) {

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

@@ -253,7 +253,7 @@ let DebugHoverWidget = class DebugHoverWidget {
         if (!this._isVisible) {
             return;
         }
-        if (dom.isAncestor(document.activeElement, this.domNode)) {
+        if (dom.isAncestorOfActiveElement(this.domNode)) {
             this.editor.focus();
         }
         this._isVisible = false;

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

@@ -929,6 +929,11 @@ let DebugService = class DebugService {
         await this.sendDataBreakpoints();
         this.debugStorage.storeBreakpoints(this.model);
     }
+    async updateDataBreakpoint(id, update) {
+        this.model.updateDataBreakpoint(id, update);
+        this.debugStorage.storeBreakpoints(this.model);
+        await this.sendDataBreakpoints();
+    }
     async removeDataBreakpoints(id) {
         this.model.removeDataBreakpoints(id);
         this.debugStorage.storeBreakpoints(this.model);

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

@@ -6,7 +6,7 @@ import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancel
 import { canceled } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { normalizeDriveLetter } from 'monaco-editor/esm/vs/base/common/labels.js';
-import { DisposableStore, MutableDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { DisposableStore, MutableDisposable, dispose, Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { mixin } from 'monaco-editor/esm/vs/base/common/objects.js';
 import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
 import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
@@ -31,6 +31,8 @@ import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/service
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite';
+import { getActiveWindow } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { mainWindow } from 'monaco-editor/esm/vs/base/browser/window.js';
 
 let DebugSession = class DebugSession {
     constructor(id, _configuration, root, model, options, debugService, telemetryService, hostService, configurationService, paneCompositeService, workspaceContextService, productService, notificationService, lifecycleService, uriIdentityService, instantiationService, customEndpointTelemetryService, workbenchEnvironmentService, logService) {
@@ -795,7 +797,13 @@ let DebugSession = class DebugSession {
             return;
         }
         this.rawListeners.add(this.raw.onDidInitialize(async () => {
-            aria.status(( localizeWithPath(
+            aria.status(this.configuration.noDebug
+                ? ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugSession',
+                'debuggingStartedNoDebug',
+                "Started running without debugging."
+            ))
+                : ( localizeWithPath(
                 'vs/workbench/contrib/debug/browser/debugSession',
                 'debuggingStarted',
                 "Debugging started."
@@ -820,20 +828,20 @@ let DebugSession = class DebugSession {
                 await this.fetchThreads();
             }
         }));
-        const statusQueue = ( new Queue());
+        const statusQueue = this.rawListeners.add(( new ThreadStatusScheduler()));
         this.rawListeners.add(this.raw.onDidStop(async (event) => {
-            statusQueue.queue(async () => {
-                this.passFocusScheduler.cancel();
-                this.stoppedDetails.push(event.body);
-                await this.fetchThreads(event.body);
+            this.passFocusScheduler.cancel();
+            this.stoppedDetails.push(event.body);
+            statusQueue.run(this.fetchThreads(event.body).then(() => event.body.threadId === undefined ? this.threadIds : [event.body.threadId]), async (threadId, token) => {
+                const hasLotsOfThreads = event.body.threadId === undefined && this.threadIds.length > 10;
                 const focusedThread = this.debugService.getViewModel().focusedThread;
                 const focusedThreadDoesNotExist = focusedThread !== undefined && focusedThread.session === this && !( this.threads.has(focusedThread.threadId));
                 if (focusedThreadDoesNotExist) {
                     this.debugService.focusStackFrame(undefined, undefined);
                 }
-                const thread = typeof event.body.threadId === 'number' ? this.getThread(event.body.threadId) : undefined;
+                const thread = typeof threadId === 'number' ? this.getThread(threadId) : undefined;
                 if (thread) {
-                    const promises = this.model.refreshTopOfCallstack(thread);
+                    const promises = this.model.refreshTopOfCallstack(thread,  !hasLotsOfThreads);
                     const focus = async () => {
                         if (focusedThreadDoesNotExist || (!event.body.preserveFocusHint && thread.getCallStack().length)) {
                             const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
@@ -841,19 +849,28 @@ let DebugSession = class DebugSession {
                                 const preserveFocus = !this.configurationService.getValue('debug').focusEditorOnBreak;
                                 await this.debugService.focusStackFrame(undefined, thread, undefined, { preserveFocus });
                             }
-                            if (thread.stoppedDetails) {
+                            if (thread.stoppedDetails && !token.isCancellationRequested) {
                                 if (thread.stoppedDetails.reason === 'breakpoint' && this.configurationService.getValue('debug').openDebug === 'openOnDebugBreak' && !this.suppressDebugView) {
                                     await this.paneCompositeService.openPaneComposite(VIEWLET_ID, 0 );
                                 }
                                 if (this.configurationService.getValue('debug').focusWindowOnBreak && !this.workbenchEnvironmentService.extensionTestsLocationURI) {
-                                    await this.hostService.focus({ force: true  });
+                                    const activeWindow = getActiveWindow();
+                                    if (!activeWindow.document.hasFocus()) {
+                                        await this.hostService.focus(mainWindow, { force: true  });
+                                    }
                                 }
                             }
                         }
                     };
                     await promises.topCallStack;
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
                     focus();
                     await promises.wholeCallStack;
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
                     const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
                     if (!focusedStackFrame || !focusedStackFrame.source || focusedStackFrame.source.presentationHint === 'deemphasize' || focusedStackFrame.presentationHint === 'deemphasize') {
                         focus();
@@ -863,28 +880,27 @@ let DebugSession = class DebugSession {
             });
         }));
         this.rawListeners.add(this.raw.onDidThread(event => {
-            statusQueue.queue(async () => {
-                if (event.body.reason === 'started') {
-                    if (!this.fetchThreadsScheduler) {
-                        this.fetchThreadsScheduler = ( new RunOnceScheduler(() => {
-                            this.fetchThreads();
-                        }, 100));
-                        this.rawListeners.add(this.fetchThreadsScheduler);
-                    }
-                    if (!this.fetchThreadsScheduler.isScheduled()) {
-                        this.fetchThreadsScheduler.schedule();
-                    }
+            statusQueue.cancel([event.body.threadId]);
+            if (event.body.reason === 'started') {
+                if (!this.fetchThreadsScheduler) {
+                    this.fetchThreadsScheduler = ( new RunOnceScheduler(() => {
+                        this.fetchThreads();
+                    }, 100));
+                    this.rawListeners.add(this.fetchThreadsScheduler);
                 }
-                else if (event.body.reason === 'exited') {
-                    this.model.clearThreads(this.getId(), true, event.body.threadId);
-                    const viewModel = this.debugService.getViewModel();
-                    const focusedThread = viewModel.focusedThread;
-                    this.passFocusScheduler.cancel();
-                    if (focusedThread && event.body.threadId === focusedThread.threadId) {
-                        this.debugService.focusStackFrame(undefined, undefined, viewModel.focusedSession, { explicit: false });
-                    }
+                if (!this.fetchThreadsScheduler.isScheduled()) {
+                    this.fetchThreadsScheduler.schedule();
                 }
-            });
+            }
+            else if (event.body.reason === 'exited') {
+                this.model.clearThreads(this.getId(), true, event.body.threadId);
+                const viewModel = this.debugService.getViewModel();
+                const focusedThread = viewModel.focusedThread;
+                this.passFocusScheduler.cancel();
+                if (focusedThread && event.body.threadId === focusedThread.threadId) {
+                    this.debugService.focusStackFrame(undefined, undefined, viewModel.focusedSession, { explicit: false });
+                }
+            }
         }));
         this.rawListeners.add(this.raw.onDidTerminateDebugee(async (event) => {
             aria.status(( localizeWithPath(
@@ -900,23 +916,23 @@ let DebugSession = class DebugSession {
             }
         }));
         this.rawListeners.add(this.raw.onDidContinued(event => {
-            statusQueue.queue(async () => {
-                const threadId = event.body.allThreadsContinued !== false ? undefined : event.body.threadId;
-                if (typeof threadId === 'number') {
-                    this.stoppedDetails = this.stoppedDetails.filter(sd => sd.threadId !== threadId);
-                    const tokens = this.cancellationMap.get(threadId);
-                    this.cancellationMap.delete(threadId);
-                    tokens?.forEach(t => t.dispose(true));
-                }
-                else {
-                    this.stoppedDetails = [];
-                    this.cancelAllRequests();
-                }
-                this.lastContinuedThreadId = threadId;
-                this.passFocusScheduler.schedule();
-                this.model.clearThreads(this.getId(), false, threadId);
-                this._onDidChangeState.fire();
-            });
+            const allThreads = event.body.allThreadsContinued !== false;
+            statusQueue.cancel(allThreads ? undefined : [event.body.threadId]);
+            const threadId = allThreads ? undefined : event.body.threadId;
+            if (typeof threadId === 'number') {
+                this.stoppedDetails = this.stoppedDetails.filter(sd => sd.threadId !== threadId);
+                const tokens = this.cancellationMap.get(threadId);
+                this.cancellationMap.delete(threadId);
+                tokens?.forEach(t => t.dispose(true));
+            }
+            else {
+                this.stoppedDetails = [];
+                this.cancelAllRequests();
+            }
+            this.lastContinuedThreadId = threadId;
+            this.passFocusScheduler.schedule();
+            this.model.clearThreads(this.getId(), false, threadId);
+            this._onDidChangeState.fire();
         }));
         const outputQueue = ( new Queue());
         this.rawListeners.add(this.raw.onDidOutput(async (event) => {
@@ -1163,5 +1179,61 @@ DebugSession = ( __decorate([
     ( __param(17, IWorkbenchEnvironmentService)),
     ( __param(18, ILogService))
 ], DebugSession));
+class ThreadStatusScheduler extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.pendingCancellations = [];
+        this.threadOps = this._register(( new DisposableMap()));
+    }
+    async run(threadIdsP, operation) {
+        const cancelledWhileLookingUpThreads = ( new Set());
+        this.pendingCancellations.push(cancelledWhileLookingUpThreads);
+        const threadIds = await threadIdsP;
+        for (let i = 0; i < this.pendingCancellations.length; i++) {
+            const s = this.pendingCancellations[i];
+            if (s === cancelledWhileLookingUpThreads) {
+                this.pendingCancellations.splice(i, 1);
+                break;
+            }
+            else {
+                for (const threadId of threadIds) {
+                    s.add(threadId);
+                }
+            }
+        }
+        if (( cancelledWhileLookingUpThreads.has(undefined))) {
+            return;
+        }
+        await Promise.all(( threadIds.map(threadId => {
+            if (( cancelledWhileLookingUpThreads.has(threadId))) {
+                return;
+            }
+            this.threadOps.get(threadId)?.cancel();
+            const cts = ( new CancellationTokenSource());
+            this.threadOps.set(threadId, cts);
+            return operation(threadId, cts.token);
+        })));
+    }
+    cancel(threadIds) {
+        if (!threadIds) {
+            for (const [_, op] of this.threadOps) {
+                op.cancel();
+            }
+            this.threadOps.clearAndDisposeAll();
+            for (const s of this.pendingCancellations) {
+                s.add(undefined);
+            }
+        }
+        else {
+            for (const threadId of threadIds) {
+                this.threadOps.get(threadId)?.cancel();
+                this.threadOps.deleteAndDispose(threadId);
+                for (const s of this.pendingCancellations) {
+                    s.add(threadId);
+                }
+            }
+        }
+    }
+}
 
-export { DebugSession };
+export { DebugSession, ThreadStatusScheduler };

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

@@ -2,7 +2,7 @@ import { __decorate, __param } from '../../../../../../../external/tslib/tslib.e
 import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
-import { ITitleService } from 'vscode/vscode/vs/workbench/services/title/common/titleService';
+import { ITitleService } from 'vscode/vscode/vs/workbench/services/title/browser/titleService';
 
 let DebugTitleContribution = class DebugTitleContribution {
     constructor(debugService, hostService, titleService) {

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

@@ -27,9 +27,10 @@ import { FocusSessionActionViewItem } from './debugActionViewItems.js';
 import { debugToolBarBackground, debugToolBarBorder } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugColors';
 import { CONTINUE_LABEL, CONTINUE_ID, PAUSE_LABEL, PAUSE_ID, DISCONNECT_ID, DISCONNECT_LABEL, STOP_LABEL, STOP_ID, STEP_OVER_LABEL, STEP_OVER_ID, STEP_INTO_LABEL, STEP_INTO_ID, STEP_OUT_LABEL, STEP_OUT_ID, STEP_BACK_ID, REVERSE_CONTINUE_ID, FOCUS_SESSION_LABEL, FOCUS_SESSION_ID, DISCONNECT_AND_SUSPEND_ID, DISCONNECT_AND_SUSPEND_LABEL, RESTART_LABEL, RESTART_SESSION_ID } from './debugCommands.js';
 import { debugContinue, debugPause, debugDisconnect, debugStop, debugStepOver, debugStepInto, debugStepOut, debugStepBack, debugReverseContinue, debugGripper, debugRestart } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugIcons';
-import { VIEWLET_ID, CONTEXT_DEBUG_STATE, CONTEXT_IN_DEBUG_MODE, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_MULTI_SESSION_DEBUG, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { VIEWLET_ID, CONTEXT_DEBUG_STATE, CONTEXT_IN_DEBUG_MODE, CONTEXT_FOCUSED_SESSION_IS_NO_DEBUG, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_MULTI_SESSION_DEBUG, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { mainWindow } from 'monaco-editor/esm/vs/base/browser/window.js';
 
 const DEBUG_TOOLBAR_POSITION_KEY = 'debug.actionswidgetposition';
 const DEBUG_TOOLBAR_Y_KEY = 'debug.actionswidgety';
@@ -48,7 +49,7 @@ let DebugToolBar = class DebugToolBar extends Themable {
         this.isBuilt = false;
         this.stopActionViewItemDisposables = this._register(( new DisposableStore()));
         this.$el = dom.$('div.debug-toolbar');
-        this.$el.style.top = `${layoutService.offset.top}px`;
+        this.$el.style.top = `${layoutService.mainContainerOffset.top}px`;
         this.dragArea = dom.append(this.$el, dom.$('div.drag-area' + ThemeIcon.asCSSSelector(debugGripper)));
         const actionBarContainer = dom.append(this.$el, dom.$('div.action-bar-container'));
         this.debugToolBarMenu = menuService.createMenu(MenuId.DebugToolBar, contextKeyService);
@@ -98,6 +99,10 @@ let DebugToolBar = class DebugToolBar extends Themable {
             if (e.affectsConfiguration('debug.toolBarLocation')) {
                 this.updateScheduler.schedule();
             }
+            if (e.affectsConfiguration("workbench.editor.showTabs" ) || e.affectsConfiguration("window.commandCenter" )) {
+                this._yRange = undefined;
+                this.setYCoordinate();
+            }
         }));
         this._register(this.debugToolBarMenu.onDidChange(() => this.updateScheduler.schedule()));
         this._register(this.actionBar.actionRunner.onDidRun((e) => {
@@ -106,23 +111,23 @@ let DebugToolBar = class DebugToolBar extends Themable {
             }
             this.telemetryService.publicLog2('workbenchActionExecuted', { id: e.action.id, from: 'debugActionsWidget' });
         }));
-        this._register(dom.addDisposableListener(window, dom.EventType.RESIZE, () => this.setCoordinates()));
+        this._register(dom.addDisposableListener(mainWindow, dom.EventType.RESIZE, () => this.setCoordinates()));
         this._register(dom.addDisposableGenericMouseUpListener(this.dragArea, (event) => {
-            const mouseClickEvent = ( new StandardMouseEvent(event));
+            const mouseClickEvent = ( new StandardMouseEvent(dom.getWindow(this.dragArea), event));
             if (mouseClickEvent.detail === 2) {
                 const widgetWidth = this.$el.clientWidth;
-                this.setCoordinates(0.5 * window.innerWidth - 0.5 * widgetWidth, 0);
+                this.setCoordinates(0.5 * mainWindow.innerWidth - 0.5 * widgetWidth, 0);
                 this.storePosition();
             }
         }));
         this._register(dom.addDisposableGenericMouseDownListener(this.dragArea, (event) => {
             this.dragArea.classList.add('dragged');
-            const mouseMoveListener = dom.addDisposableGenericMouseMoveListener(window, (e) => {
-                const mouseMoveEvent = ( new StandardMouseEvent(e));
+            const mouseMoveListener = dom.addDisposableGenericMouseMoveListener(mainWindow, (e) => {
+                const mouseMoveEvent = ( new StandardMouseEvent(mainWindow, e));
                 mouseMoveEvent.preventDefault();
-                this.setCoordinates(mouseMoveEvent.posx - 14, mouseMoveEvent.posy - (this.layoutService.offset.top));
+                this.setCoordinates(mouseMoveEvent.posx - 14, mouseMoveEvent.posy - 14);
             });
-            const mouseUpListener = dom.addDisposableGenericMouseUpListener(window, (e) => {
+            const mouseUpListener = dom.addDisposableGenericMouseUpListener(mainWindow, (e) => {
                 this.storePosition();
                 this.dragArea.classList.remove('dragged');
                 mouseMoveListener.dispose();
@@ -135,9 +140,15 @@ let DebugToolBar = class DebugToolBar extends Themable {
     storePosition() {
         const left = dom.getComputedStyle(this.$el).left;
         if (left) {
-            const position = parseFloat(left) / window.innerWidth;
+            const position = parseFloat(left) / mainWindow.innerWidth;
             this.storageService.store(DEBUG_TOOLBAR_POSITION_KEY, position, 0 , 1 );
         }
+        if (this.yCoordinate) {
+            this.storageService.store(DEBUG_TOOLBAR_Y_KEY, this.yCoordinate, 0 , 1 );
+        }
+        else {
+            this.storageService.remove(DEBUG_TOOLBAR_Y_KEY, 0 );
+        }
     }
     updateStyles() {
         super.updateStyles();
@@ -156,11 +167,6 @@ let DebugToolBar = class DebugToolBar extends Themable {
             }
         }
     }
-    setYCoordinate(y = this.yCoordinate) {
-        const titlebarOffset = this.layoutService.offset.top;
-        this.$el.style.top = `${titlebarOffset + y}px`;
-        this.yCoordinate = y;
-    }
     setCoordinates(x, y) {
         if (!this.isVisible) {
             return;
@@ -168,19 +174,40 @@ let DebugToolBar = class DebugToolBar extends Themable {
         const widgetWidth = this.$el.clientWidth;
         if (x === undefined) {
             const positionPercentage = this.storageService.get(DEBUG_TOOLBAR_POSITION_KEY, 0 );
-            x = positionPercentage !== undefined ? parseFloat(positionPercentage) * window.innerWidth : (0.5 * window.innerWidth - 0.5 * widgetWidth);
+            x = positionPercentage !== undefined ? parseFloat(positionPercentage) * mainWindow.innerWidth : (0.5 * mainWindow.innerWidth - 0.5 * widgetWidth);
         }
-        x = Math.max(0, Math.min(x, window.innerWidth - widgetWidth));
+        x = Math.max(0, Math.min(x, mainWindow.innerWidth - widgetWidth));
         this.$el.style.left = `${x}px`;
         if (y === undefined) {
             y = this.storageService.getNumber(DEBUG_TOOLBAR_Y_KEY, 0 , 0);
         }
-        const titleAreaHeight = 35;
-        if ((y < titleAreaHeight / 2) || (y > titleAreaHeight + titleAreaHeight / 2)) {
-            const moveToTop = y < titleAreaHeight;
-            this.setYCoordinate(moveToTop ? 0 : titleAreaHeight);
-            this.storageService.store(DEBUG_TOOLBAR_Y_KEY, moveToTop ? 0 : 2 * titleAreaHeight, 0 , 1 );
+        this.setYCoordinate(y);
+    }
+    setYCoordinate(y = this.yCoordinate) {
+        const [yMin, yMax] = this.yRange;
+        y = Math.max(yMin, Math.min(y, yMax));
+        this.$el.style.top = `${y}px`;
+        this.yCoordinate = y;
+    }
+    get yRange() {
+        if (!this._yRange) {
+            const isTitleBarVisible = this.layoutService.isVisible("workbench.parts.titlebar" , mainWindow);
+            const yMin = isTitleBarVisible ? 0 : this.layoutService.mainContainerOffset.top;
+            let yMax = 0;
+            if (isTitleBarVisible) {
+                if (this.configurationService.getValue("window.commandCenter" ) === true) {
+                    yMax += 35;
+                }
+                else {
+                    yMax += 28;
+                }
+            }
+            if (this.configurationService.getValue("workbench.editor.showTabs" ) !== "none" ) {
+                yMax += 35;
+            }
+            this._yRange = [yMin, yMax];
         }
+        return this._yRange;
     }
     show() {
         if (this.isVisible) {
@@ -189,7 +216,7 @@ let DebugToolBar = class DebugToolBar extends Themable {
         }
         if (!this.isBuilt) {
             this.isBuilt = true;
-            this.layoutService.container.appendChild(this.$el);
+            this.layoutService.mainContainer.appendChild(this.$el);
         }
         this.isVisible = true;
         dom.show(this.$el);
@@ -282,7 +309,7 @@ MenuRegistry.appendMenuItem(MenuId.CommandCenterCenter, {
     when: ( ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, CONTEXT_TOOLBAR_COMMAND_CENTER))
 });
 registerDebugToolBarItem(CONTINUE_ID, CONTINUE_LABEL, 10, debugContinue, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
-registerDebugToolBarItem(PAUSE_ID, PAUSE_LABEL, 10, debugPause, ( CONTEXT_DEBUG_STATE.notEqualsTo('stopped')), ( CONTEXT_DEBUG_STATE.isEqualTo('running')));
+registerDebugToolBarItem(PAUSE_ID, PAUSE_LABEL, 10, debugPause, ( CONTEXT_DEBUG_STATE.notEqualsTo('stopped')), ( ContextKeyExpr.and(( CONTEXT_DEBUG_STATE.isEqualTo('running')), ( CONTEXT_FOCUSED_SESSION_IS_NO_DEBUG.toNegated()))));
 registerDebugToolBarItem(STOP_ID, STOP_LABEL, 70, debugStop, ( CONTEXT_FOCUSED_SESSION_IS_ATTACH.toNegated()), undefined, { id: DISCONNECT_ID, title: DISCONNECT_LABEL, icon: debugDisconnect, precondition: ( ContextKeyExpr.and(( CONTEXT_FOCUSED_SESSION_IS_ATTACH.toNegated()), CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED)), });
 registerDebugToolBarItem(DISCONNECT_ID, DISCONNECT_LABEL, 70, debugDisconnect, CONTEXT_FOCUSED_SESSION_IS_ATTACH, undefined, { id: STOP_ID, title: STOP_LABEL, icon: debugStop, precondition: ( ContextKeyExpr.and(CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED)), });
 registerDebugToolBarItem(STEP_OVER_ID, STEP_OVER_LABEL, 20, debugStepOver, undefined, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));