@codingame/monaco-vscode-debug-service-override 25.1.2 → 26.0.0

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

@@ -69,20 +69,20 @@ function getStackFrameContext(element) {
         ...getThreadContext(element.thread),
         frameId: element.getId(),
         frameName: element.name,
-        frameLocation: { range: element.range, source: element.source.raw }
+        frameLocation: {
+            range: element.range,
+            source: element.source.raw
+        }
     };
 }
 function getContext(element) {
     if (element instanceof StackFrame) {
         return getStackFrameContext(element);
-    }
-    else if (element instanceof Thread) {
+    } else if (element instanceof Thread) {
         return getThreadContext(element);
-    }
-    else if (isDebugSession(element)) {
+    } else if (isDebugSession(element)) {
         return getSessionContext(element);
-    }
-    else {
+    } else {
         return undefined;
     }
 }
@@ -99,7 +99,7 @@ function getContextForContributedActions(element) {
     if (isDebugSession(element)) {
         return element.getId();
     }
-    return '';
+    return "";
 }
 function getSpecificSourceName(stackFrame) {
     let callStack = stackFrame.thread.getStaleCallStack();
@@ -114,8 +114,11 @@ function getSpecificSourceName(stackFrame) {
     if (suffixLength === 0) {
         return stackFrame.source.name;
     }
-    const from = Math.max(0, stackFrame.source.uri.path.lastIndexOf(posix.sep, stackFrame.source.uri.path.length - suffixLength - 1));
-    return (from > 0 ? '...' : '') + stackFrame.source.uri.path.substring(from);
+    const from = Math.max(
+        0,
+        stackFrame.source.uri.path.lastIndexOf(posix.sep, stackFrame.source.uri.path.length - suffixLength - 1)
+    );
+    return (from > 0 ? "..." : "") + stackFrame.source.uri.path.substring(from);
 }
 async function expandTo(session, tree) {
     if (session.parentSession) {
@@ -124,8 +127,32 @@ async function expandTo(session, tree) {
     await tree.expand(session);
 }
 let CallStackView = class CallStackView extends ViewPane {
-    constructor(options, contextMenuService, debugService, keybindingService, instantiationService, viewDescriptorService, configurationService, contextKeyService, openerService, themeService, hoverService, menuService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, hoverService);
+    constructor(
+        options,
+        contextMenuService,
+        debugService,
+        keybindingService,
+        instantiationService,
+        viewDescriptorService,
+        configurationService,
+        contextKeyService,
+        openerService,
+        themeService,
+        hoverService,
+        menuService
+    ) {
+        super(
+            options,
+            keybindingService,
+            contextMenuService,
+            configurationService,
+            contextKeyService,
+            viewDescriptorService,
+            instantiationService,
+            openerService,
+            themeService,
+            hoverService
+        );
         this.options = options;
         this.debugService = debugService;
         this.menuService = menuService;
@@ -141,19 +168,17 @@ let CallStackView = class CallStackView extends ViewPane {
             }
             const thread = sessions.length === 1 && sessions[0].getAllThreads().length === 1 ? sessions[0].getAllThreads()[0] : undefined;
             const stoppedDetails = sessions.length === 1 ? sessions[0].getStoppedDetails() : undefined;
-            if (stoppedDetails && (thread || typeof stoppedDetails.threadId !== 'number')) {
+            if (stoppedDetails && (thread || typeof stoppedDetails.threadId !== "number")) {
                 this.stateMessageLabel.textContent = stoppedDescription(stoppedDetails);
                 this.stateMessageLabelHover.update(stoppedText(stoppedDetails));
-                this.stateMessageLabel.classList.toggle('exception', stoppedDetails.reason === 'exception');
+                this.stateMessageLabel.classList.toggle("exception", stoppedDetails.reason === "exception");
                 this.stateMessage.hidden = false;
-            }
-            else if (sessions.length === 1 && sessions[0].state === State.Running) {
-                this.stateMessageLabel.textContent = ( localize(6569, "Running"));
+            } else if (sessions.length === 1 && sessions[0].state === State.Running) {
+                this.stateMessageLabel.textContent = ( localize(6879, "Running"));
                 this.stateMessageLabelHover.update(sessions[0].getLabel());
-                this.stateMessageLabel.classList.remove('exception');
+                this.stateMessageLabel.classList.remove("exception");
                 this.stateMessage.hidden = false;
-            }
-            else {
+            } else {
                 this.stateMessage.hidden = true;
             }
             this.updateActions();
@@ -170,9 +195,7 @@ let CallStackView = class CallStackView extends ViewPane {
                     await expandTo(session, this.tree);
                     this.autoExpandedSessions.add(session);
                 }
-            }
-            catch (e) {
-            }
+            } catch (e) {}
             if (this.selectionNeedsUpdate) {
                 this.selectionNeedsUpdate = false;
                 await this.updateTreeSelection();
@@ -181,79 +204,94 @@ let CallStackView = class CallStackView extends ViewPane {
     }
     renderHeaderTitle(container) {
         super.renderHeaderTitle(container, this.options.title);
-        this.stateMessage = append(container, $('span.call-stack-state-message'));
+        this.stateMessage = append(container, $("span.call-stack-state-message"));
         this.stateMessage.hidden = true;
-        this.stateMessageLabel = append(this.stateMessage, $('span.label'));
-        this.stateMessageLabelHover = this._register(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), this.stateMessage, ''));
+        this.stateMessageLabel = append(this.stateMessage, $("span.label"));
+        this.stateMessageLabelHover = this._register(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), this.stateMessage, "")
+        );
     }
     renderBody(container) {
         super.renderBody(container);
-        this.element.classList.add('debug-pane');
-        container.classList.add('debug-call-stack');
+        this.element.classList.add("debug-pane");
+        container.classList.add("debug-call-stack");
         const treeContainer = renderViewTree(container);
         this.dataSource = ( new CallStackDataSource(this.debugService));
-        this.tree = this.instantiationService.createInstance((WorkbenchCompressibleAsyncDataTree), 'CallStackView', treeContainer, ( new CallStackDelegate()), ( new CallStackCompressionDelegate(this.debugService)), [
-            this.instantiationService.createInstance(SessionsRenderer),
-            this.instantiationService.createInstance(ThreadsRenderer),
-            this.instantiationService.createInstance(StackFramesRenderer),
-            this.instantiationService.createInstance(ErrorsRenderer),
-            ( new LoadMoreRenderer()),
-            ( new ShowMoreRenderer())
-        ], this.dataSource, {
-            accessibilityProvider: ( new CallStackAccessibilityProvider()),
-            compressionEnabled: true,
-            autoExpandSingleChildren: true,
-            identityProvider: {
-                getId: (element) => {
-                    if (typeof element === 'string') {
-                        return element;
-                    }
-                    if (element instanceof Array) {
-                        return `showMore ${element[0].getId()}`;
-                    }
-                    return element.getId();
-                }
-            },
-            keyboardNavigationLabelProvider: {
-                getKeyboardNavigationLabel: (e) => {
-                    if (isDebugSession(e)) {
-                        return e.getLabel();
-                    }
-                    if (e instanceof Thread) {
-                        return `${e.name} ${e.stateLabel}`;
-                    }
-                    if (e instanceof StackFrame || typeof e === 'string') {
-                        return e;
-                    }
-                    if (e instanceof ThreadAndSessionIds) {
-                        return LoadMoreRenderer.LABEL;
+        this.tree = this.instantiationService.createInstance(
+            WorkbenchCompressibleAsyncDataTree,
+            "CallStackView",
+            treeContainer,
+            ( new CallStackDelegate()),
+            ( new CallStackCompressionDelegate(this.debugService)),
+            [
+                this.instantiationService.createInstance(SessionsRenderer),
+                this.instantiationService.createInstance(ThreadsRenderer),
+                this.instantiationService.createInstance(StackFramesRenderer),
+                this.instantiationService.createInstance(ErrorsRenderer),
+                ( new LoadMoreRenderer()),
+                ( new ShowMoreRenderer())
+            ],
+            this.dataSource,
+            {
+                accessibilityProvider: ( new CallStackAccessibilityProvider()),
+                compressionEnabled: true,
+                autoExpandSingleChildren: true,
+                identityProvider: {
+                    getId: element => {
+                        if (typeof element === "string") {
+                            return element;
+                        }
+                        if (element instanceof Array) {
+                            return `showMore ${element[0].getId()}`;
+                        }
+                        return element.getId();
                     }
-                    return localize(6570, "Show More Stack Frames");
                 },
-                getCompressedNodeKeyboardNavigationLabel: (e) => {
-                    const firstItem = e[0];
-                    if (isDebugSession(firstItem)) {
-                        return firstItem.getLabel();
+                keyboardNavigationLabelProvider: {
+                    getKeyboardNavigationLabel: e => {
+                        if (isDebugSession(e)) {
+                            return e.getLabel();
+                        }
+                        if (e instanceof Thread) {
+                            return `${e.name} ${e.stateLabel}`;
+                        }
+                        if (e instanceof StackFrame || typeof e === "string") {
+                            return e;
+                        }
+                        if (e instanceof ThreadAndSessionIds) {
+                            return LoadMoreRenderer.LABEL;
+                        }
+                        return localize(6880, "Show More Stack Frames");
+                    },
+                    getCompressedNodeKeyboardNavigationLabel: e => {
+                        const firstItem = e[0];
+                        if (isDebugSession(firstItem)) {
+                            return firstItem.getLabel();
+                        }
+                        return "";
                     }
-                    return '';
-                }
-            },
-            expandOnlyOnTwistieClick: true,
-            overrideStyles: this.getLocationBasedColors().listOverrideStyles
-        });
+                },
+                expandOnlyOnTwistieClick: true,
+                overrideStyles: this.getLocationBasedColors().listOverrideStyles
+            }
+        );
         CONTEXT_CALLSTACK_FOCUSED.bindTo(this.tree.contextKeyService);
         this.tree.setInput(this.debugService.getModel());
         this._register(this.tree);
-        this._register(this.tree.onDidOpen(async (e) => {
+        this._register(this.tree.onDidOpen(async e => {
             if (this.ignoreSelectionChangedEvent) {
                 return;
             }
             const focusStackFrame = (stackFrame, thread, session, options = {}) => {
                 this.ignoreFocusStackFrameEvent = true;
                 try {
-                    this.debugService.focusStackFrame(stackFrame, thread, session, { ...options, ...{ explicit: true } });
-                }
-                finally {
+                    this.debugService.focusStackFrame(stackFrame, thread, session, {
+                        ...options,
+                        ...{
+                            explicit: true
+                        }
+                    });
+                } finally {
                     this.ignoreFocusStackFrameEvent = false;
                 }
             };
@@ -277,7 +315,7 @@ let CallStackView = class CallStackView extends ViewPane {
                 const thread = session && session.getThread(element.threadId);
                 if (thread) {
                     const totalFrames = thread.stoppedDetails?.totalFrames;
-                    const remainingFramesCount = typeof totalFrames === 'number' ? (totalFrames - thread.getCallStack().length) : undefined;
+                    const remainingFramesCount = typeof totalFrames === "number" ? (totalFrames - thread.getCallStack().length) : undefined;
                     await thread.fetchCallStack(remainingFramesCount);
                     await this.tree.updateChildren();
                 }
@@ -296,7 +334,10 @@ let CallStackView = class CallStackView extends ViewPane {
                 this.onCallStackChangeScheduler.schedule();
             }
         }));
-        const onFocusChange = Event.any(this.debugService.getViewModel().onDidFocusStackFrame, this.debugService.getViewModel().onDidFocusSession);
+        const onFocusChange = Event.any(
+            this.debugService.getViewModel().onDidFocusStackFrame,
+            this.debugService.getViewModel().onDidFocusSession
+        );
         this._register(onFocusChange(async () => {
             if (this.ignoreFocusStackFrameEvent) {
                 return;
@@ -349,19 +390,16 @@ let CallStackView = class CallStackView extends ViewPane {
         if (!this.tree || !this.tree.getInput()) {
             return;
         }
-        const updateSelectionAndReveal = (element) => {
+        const updateSelectionAndReveal = element => {
             this.ignoreSelectionChangedEvent = true;
             try {
                 this.tree.setSelection([element]);
                 if (this.tree.getRelativeTop(element) === null) {
                     this.tree.reveal(element, 0.5);
-                }
-                else {
+                } else {
                     this.tree.reveal(element);
                 }
-            }
-            catch (e) { }
-            finally {
+            } catch (e) {} finally {
                 this.ignoreSelectionChangedEvent = false;
             }
         };
@@ -371,20 +409,16 @@ let CallStackView = class CallStackView extends ViewPane {
         if (!thread) {
             if (!session) {
                 this.tree.setSelection([]);
-            }
-            else {
+            } else {
                 updateSelectionAndReveal(session);
             }
-        }
-        else {
+        } else {
             try {
                 await expandTo(thread.session, this.tree);
-            }
-            catch (e) { }
+            } catch (e) {}
             try {
                 await this.tree.expand(thread);
-            }
-            catch (e) { }
+            } catch (e) {}
             const toReveal = stackFrame || session;
             if (toReveal) {
                 updateSelectionAndReveal(toReveal);
@@ -396,16 +430,17 @@ let CallStackView = class CallStackView extends ViewPane {
         let overlay = [];
         if (isDebugSession(element)) {
             overlay = getSessionContextOverlay(element);
-        }
-        else if (element instanceof Thread) {
+        } else if (element instanceof Thread) {
             overlay = getThreadContextOverlay(element);
-        }
-        else if (element instanceof StackFrame) {
+        } else if (element instanceof StackFrame) {
             overlay = getStackFrameContextOverlay(element);
         }
         const contextKeyService = this.contextKeyService.createOverlay(overlay);
-        const menu = this.menuService.getMenuActions(MenuId.DebugCallStackContext, contextKeyService, { arg: getContextForContributedActions(element), shouldForwardArgs: true });
-        const result = getContextMenuActions(menu, 'inline');
+        const menu = this.menuService.getMenuActions(MenuId.DebugCallStackContext, contextKeyService, {
+            arg: getContextForContributedActions(element),
+            shouldForwardArgs: true
+        });
+        const result = getContextMenuActions(menu, "inline");
         this.contextMenuService.showContextMenu({
             getAnchor: () => e.anchor,
             getActions: () => result.secondary,
@@ -413,30 +448,25 @@ let CallStackView = class CallStackView extends ViewPane {
         });
     }
 };
-CallStackView = ( __decorate([
-    ( __param(1, IContextMenuService)),
-    ( __param(2, IDebugService)),
-    ( __param(3, IKeybindingService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IViewDescriptorService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, IContextKeyService)),
-    ( __param(8, IOpenerService)),
-    ( __param(9, IThemeService)),
-    ( __param(10, IHoverService)),
-    ( __param(11, IMenuService))
-], CallStackView));
+CallStackView = ( __decorate([( __param(1, IContextMenuService)), ( __param(2, IDebugService)), ( __param(3, IKeybindingService)), ( __param(4, IInstantiationService)), ( __param(5, IViewDescriptorService)), ( __param(6, IConfigurationService)), ( __param(7, IContextKeyService)), ( __param(8, IOpenerService)), ( __param(9, IThemeService)), ( __param(10, IHoverService)), ( __param(11, IMenuService))], CallStackView));
 function getSessionContextOverlay(session) {
     return [
-        [CONTEXT_CALLSTACK_ITEM_TYPE.key, 'session'],
+        [CONTEXT_CALLSTACK_ITEM_TYPE.key, "session"],
         [CONTEXT_CALLSTACK_SESSION_IS_ATTACH.key, isSessionAttach(session)],
         [CONTEXT_CALLSTACK_ITEM_STOPPED.key, session.state === State.Stopped],
-        [CONTEXT_CALLSTACK_SESSION_HAS_ONE_THREAD.key, session.getAllThreads().length === 1],
+        [
+            CONTEXT_CALLSTACK_SESSION_HAS_ONE_THREAD.key,
+            session.getAllThreads().length === 1
+        ]
     ];
 }
 let SessionsRenderer = class SessionsRenderer {
-    static { SessionsRenderer_1 = this; }
-    static { this.ID = 'session'; }
+    static {
+        SessionsRenderer_1 = this;
+    }
+    static {
+        this.ID = "session";
+    }
     constructor(instantiationService, contextKeyService, hoverService, menuService) {
         this.instantiationService = instantiationService;
         this.contextKeyService = contextKeyService;
@@ -447,10 +477,10 @@ let SessionsRenderer = class SessionsRenderer {
         return SessionsRenderer_1.ID;
     }
     renderTemplate(container) {
-        const session = append(container, $('.session'));
+        const session = append(container, $(".session"));
         append(session, $(ThemeIcon.asCSSSelector(callstackViewSession)));
-        const name = append(session, $('.name'));
-        const stateLabel = append(session, $('span.state.label.monaco-count-badge.long'));
+        const name = append(session, $(".name"));
+        const stateLabel = append(session, $("span.state.label.monaco-count-badge.long"));
         const templateDisposable = ( new DisposableStore());
         const label = templateDisposable.add(( new HighlightedLabel(name)));
         const stopActionViewItemDisposables = templateDisposable.add(( new DisposableStore()));
@@ -458,22 +488,38 @@ let SessionsRenderer = class SessionsRenderer {
             actionViewItemProvider: (action, options) => {
                 if ((action.id === STOP_ID || action.id === DISCONNECT_ID) && action instanceof MenuItemAction) {
                     stopActionViewItemDisposables.clear();
-                    const item = this.instantiationService.invokeFunction(accessor => createDisconnectMenuItemAction(action, stopActionViewItemDisposables, accessor, { ...options, menuAsChild: false }));
+                    const item = this.instantiationService.invokeFunction(
+                        accessor => createDisconnectMenuItemAction(action, stopActionViewItemDisposables, accessor, {
+                            ...options,
+                            menuAsChild: false
+                        })
+                    );
                     if (item) {
                         return item;
                     }
                 }
                 if (action instanceof MenuItemAction) {
-                    return this.instantiationService.createInstance(MenuEntryActionViewItem, action, { hoverDelegate: options.hoverDelegate });
-                }
-                else if (action instanceof SubmenuItemAction) {
-                    return this.instantiationService.createInstance(SubmenuEntryActionViewItem, action, { hoverDelegate: options.hoverDelegate });
+                    return this.instantiationService.createInstance(MenuEntryActionViewItem, action, {
+                        hoverDelegate: options.hoverDelegate
+                    });
+                } else if (action instanceof SubmenuItemAction) {
+                    return this.instantiationService.createInstance(SubmenuEntryActionViewItem, action, {
+                        hoverDelegate: options.hoverDelegate
+                    });
                 }
                 return undefined;
             }
         })));
         const elementDisposable = templateDisposable.add(( new DisposableStore()));
-        return { session, name, stateLabel, label, actionBar, elementDisposable, templateDisposable };
+        return {
+            session,
+            name,
+            stateLabel,
+            label,
+            actionBar,
+            elementDisposable,
+            templateDisposable
+        };
     }
     renderElement(element, _, data) {
         this.doRenderElement(element.element, createMatches(element.filterData), data);
@@ -484,34 +530,44 @@ let SessionsRenderer = class SessionsRenderer {
         this.doRenderElement(lastElement, matches, templateData);
     }
     doRenderElement(session, matches, data) {
-        const sessionHover = data.elementDisposable.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.session, ( localize(6571, "Session"))));
+        const sessionHover = data.elementDisposable.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), data.session, ( localize(6881, "Session")))
+        );
         data.label.set(session.getLabel(), matches);
         const stoppedDetails = session.getStoppedDetails();
         const thread = session.getAllThreads().find(t => t.stopped);
         const contextKeyService = this.contextKeyService.createOverlay(getSessionContextOverlay(session));
-        const menu = data.elementDisposable.add(this.menuService.createMenu(MenuId.DebugCallStackContext, contextKeyService));
+        const menu = data.elementDisposable.add(
+            this.menuService.createMenu(MenuId.DebugCallStackContext, contextKeyService)
+        );
         const setupActionBar = () => {
             data.actionBar.clear();
-            const { primary } = getActionBarActions(menu.getActions({ arg: getContextForContributedActions(session), shouldForwardArgs: true }), 'inline');
-            data.actionBar.push(primary, { icon: true, label: false });
+            const {
+                primary
+            } = getActionBarActions(menu.getActions({
+                arg: getContextForContributedActions(session),
+                shouldForwardArgs: true
+            }), "inline");
+            data.actionBar.push(primary, {
+                icon: true,
+                label: false
+            });
             data.actionBar.context = getContext(session);
         };
         data.elementDisposable.add(menu.onDidChange(() => setupActionBar()));
         setupActionBar();
-        data.stateLabel.style.display = '';
+        data.stateLabel.style.display = "";
         if (stoppedDetails) {
             data.stateLabel.textContent = stoppedDescription(stoppedDetails);
             sessionHover.update(`${session.getLabel()}: ${stoppedText(stoppedDetails)}`);
-            data.stateLabel.classList.toggle('exception', stoppedDetails.reason === 'exception');
-        }
-        else if (thread && thread.stoppedDetails) {
+            data.stateLabel.classList.toggle("exception", stoppedDetails.reason === "exception");
+        } else if (thread && thread.stoppedDetails) {
             data.stateLabel.textContent = stoppedDescription(thread.stoppedDetails);
             sessionHover.update(`${session.getLabel()}: ${stoppedText(thread.stoppedDetails)}`);
-            data.stateLabel.classList.toggle('exception', thread.stoppedDetails.reason === 'exception');
-        }
-        else {
-            data.stateLabel.textContent = ( localize(6569, "Running"));
-            data.stateLabel.classList.remove('exception');
+            data.stateLabel.classList.toggle("exception", thread.stoppedDetails.reason === "exception");
+        } else {
+            data.stateLabel.textContent = ( localize(6879, "Running"));
+            data.stateLabel.classList.remove("exception");
         }
     }
     disposeTemplate(templateData) {
@@ -524,21 +580,20 @@ let SessionsRenderer = class SessionsRenderer {
         templateData.elementDisposable.clear();
     }
 };
-SessionsRenderer = SessionsRenderer_1 = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IContextKeyService)),
-    ( __param(2, IHoverService)),
-    ( __param(3, IMenuService))
-], SessionsRenderer));
+SessionsRenderer = SessionsRenderer_1 = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IContextKeyService)), ( __param(2, IHoverService)), ( __param(3, IMenuService))], SessionsRenderer));
 function getThreadContextOverlay(thread) {
     return [
-        [CONTEXT_CALLSTACK_ITEM_TYPE.key, 'thread'],
+        [CONTEXT_CALLSTACK_ITEM_TYPE.key, "thread"],
         [CONTEXT_CALLSTACK_ITEM_STOPPED.key, thread.stopped]
     ];
 }
 let ThreadsRenderer = class ThreadsRenderer {
-    static { ThreadsRenderer_1 = this; }
-    static { this.ID = 'thread'; }
+    static {
+        ThreadsRenderer_1 = this;
+    }
+    static {
+        this.ID = "thread";
+    }
     constructor(contextKeyService, hoverService, menuService) {
         this.contextKeyService = contextKeyService;
         this.hoverService = hoverService;
@@ -548,34 +603,54 @@ let ThreadsRenderer = class ThreadsRenderer {
         return ThreadsRenderer_1.ID;
     }
     renderTemplate(container) {
-        const thread = append(container, $('.thread'));
-        const name = append(thread, $('.name'));
-        const stateLabel = append(thread, $('span.state.label.monaco-count-badge.long'));
+        const thread = append(container, $(".thread"));
+        const name = append(thread, $(".name"));
+        const stateLabel = append(thread, $("span.state.label.monaco-count-badge.long"));
         const templateDisposable = ( new DisposableStore());
         const label = templateDisposable.add(( new HighlightedLabel(name)));
         const actionBar = templateDisposable.add(( new ActionBar(thread)));
         const elementDisposable = templateDisposable.add(( new DisposableStore()));
-        return { thread, name, stateLabel, label, actionBar, elementDisposable, templateDisposable };
+        return {
+            thread,
+            name,
+            stateLabel,
+            label,
+            actionBar,
+            elementDisposable,
+            templateDisposable
+        };
     }
     renderElement(element, _index, data) {
         const thread = element.element;
-        data.elementDisposable.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.thread, thread.name));
+        data.elementDisposable.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), data.thread, thread.name)
+        );
         data.label.set(thread.name, createMatches(element.filterData));
         data.stateLabel.textContent = thread.stateLabel;
-        data.stateLabel.classList.toggle('exception', thread.stoppedDetails?.reason === 'exception');
+        data.stateLabel.classList.toggle("exception", thread.stoppedDetails?.reason === "exception");
         const contextKeyService = this.contextKeyService.createOverlay(getThreadContextOverlay(thread));
-        const menu = data.elementDisposable.add(this.menuService.createMenu(MenuId.DebugCallStackContext, contextKeyService));
+        const menu = data.elementDisposable.add(
+            this.menuService.createMenu(MenuId.DebugCallStackContext, contextKeyService)
+        );
         const setupActionBar = () => {
             data.actionBar.clear();
-            const { primary } = getActionBarActions(menu.getActions({ arg: getContextForContributedActions(thread), shouldForwardArgs: true }), 'inline');
-            data.actionBar.push(primary, { icon: true, label: false });
+            const {
+                primary
+            } = getActionBarActions(menu.getActions({
+                arg: getContextForContributedActions(thread),
+                shouldForwardArgs: true
+            }), "inline");
+            data.actionBar.push(primary, {
+                icon: true,
+                label: false
+            });
             data.actionBar.context = getContext(thread);
         };
         data.elementDisposable.add(menu.onDidChange(() => setupActionBar()));
         setupActionBar();
     }
     renderCompressedElements(_node, _index, _templateData) {
-        throw ( new Error('Method not implemented.'));
+        throw ( new Error("Method not implemented."));
     }
     disposeElement(_element, _index, templateData) {
         templateData.elementDisposable.clear();
@@ -584,20 +659,20 @@ let ThreadsRenderer = class ThreadsRenderer {
         templateData.templateDisposable.dispose();
     }
 };
-ThreadsRenderer = ThreadsRenderer_1 = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, IHoverService)),
-    ( __param(2, IMenuService))
-], ThreadsRenderer));
+ThreadsRenderer = ThreadsRenderer_1 = ( __decorate([( __param(0, IContextKeyService)), ( __param(1, IHoverService)), ( __param(2, IMenuService))], ThreadsRenderer));
 function getStackFrameContextOverlay(stackFrame) {
     return [
-        [CONTEXT_CALLSTACK_ITEM_TYPE.key, 'stackFrame'],
+        [CONTEXT_CALLSTACK_ITEM_TYPE.key, "stackFrame"],
         [CONTEXT_STACK_FRAME_SUPPORTS_RESTART.key, stackFrame.canRestart]
     ];
 }
 let StackFramesRenderer = class StackFramesRenderer {
-    static { StackFramesRenderer_1 = this; }
-    static { this.ID = 'stackFrame'; }
+    static {
+        StackFramesRenderer_1 = this;
+    }
+    static {
+        this.ID = "stackFrame";
+    }
     constructor(hoverService, labelService, notificationService) {
         this.hoverService = hoverService;
         this.labelService = labelService;
@@ -607,30 +682,44 @@ let StackFramesRenderer = class StackFramesRenderer {
         return StackFramesRenderer_1.ID;
     }
     renderTemplate(container) {
-        const stackFrame = append(container, $('.stack-frame'));
-        const labelDiv = append(stackFrame, $('span.label.expression'));
-        const file = append(stackFrame, $('.file'));
-        const fileName = append(file, $('span.file-name'));
-        const wrapper = append(file, $('span.line-number-wrapper'));
-        const lineNumber = append(wrapper, $('span.line-number.monaco-count-badge'));
+        const stackFrame = append(container, $(".stack-frame"));
+        const labelDiv = append(stackFrame, $("span.label.expression"));
+        const file = append(stackFrame, $(".file"));
+        const fileName = append(file, $("span.file-name"));
+        const wrapper = append(file, $("span.line-number-wrapper"));
+        const lineNumber = append(wrapper, $("span.line-number.monaco-count-badge"));
         const templateDisposable = ( new DisposableStore());
         const elementDisposables = ( new DisposableStore());
         templateDisposable.add(elementDisposables);
         const label = templateDisposable.add(( new HighlightedLabel(labelDiv)));
         const actionBar = templateDisposable.add(( new ActionBar(stackFrame)));
-        return { file, fileName, label, lineNumber, stackFrame, actionBar, templateDisposable, elementDisposables };
+        return {
+            file,
+            fileName,
+            label,
+            lineNumber,
+            stackFrame,
+            actionBar,
+            templateDisposable,
+            elementDisposables
+        };
     }
     renderElement(element, index, data) {
         const stackFrame = element.element;
-        data.stackFrame.classList.toggle('disabled', !stackFrame.source || !stackFrame.source.available || isFrameDeemphasized(stackFrame));
-        data.stackFrame.classList.toggle('label', stackFrame.presentationHint === 'label');
-        const hasActions = !!stackFrame.thread.session.capabilities.supportsRestartFrame && stackFrame.presentationHint !== 'label' && stackFrame.presentationHint !== 'subtle' && stackFrame.canRestart;
-        data.stackFrame.classList.toggle('has-actions', hasActions);
+        data.stackFrame.classList.toggle(
+            "disabled",
+            !stackFrame.source || !stackFrame.source.available || isFrameDeemphasized(stackFrame)
+        );
+        data.stackFrame.classList.toggle("label", stackFrame.presentationHint === "label");
+        const hasActions = !!stackFrame.thread.session.capabilities.supportsRestartFrame && stackFrame.presentationHint !== "label" && stackFrame.presentationHint !== "subtle" && stackFrame.canRestart;
+        data.stackFrame.classList.toggle("has-actions", hasActions);
         let title = stackFrame.source.inMemory ? stackFrame.source.uri.path : this.labelService.getUriLabel(stackFrame.source.uri);
         if (stackFrame.source.raw.origin) {
             title += `\n${stackFrame.source.raw.origin}`;
         }
-        data.elementDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.file, title));
+        data.elementDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), data.file, title)
+        );
         data.label.set(stackFrame.name, createMatches(element.filterData), stackFrame.name);
         data.fileName.textContent = getSpecificSourceName(stackFrame);
         if (stackFrame.range.startLineNumber !== undefined) {
@@ -638,26 +727,27 @@ let StackFramesRenderer = class StackFramesRenderer {
             if (stackFrame.range.startColumn) {
                 data.lineNumber.textContent += `:${stackFrame.range.startColumn}`;
             }
-            data.lineNumber.classList.remove('unavailable');
-        }
-        else {
-            data.lineNumber.classList.add('unavailable');
+            data.lineNumber.classList.remove("unavailable");
+        } else {
+            data.lineNumber.classList.add("unavailable");
         }
         data.actionBar.clear();
         if (hasActions) {
-            const action = data.elementDisposables.add(( new Action('debug.callStack.restartFrame', ( localize(6572, "Restart Frame")), ThemeIcon.asClassName(debugRestartFrame), true, async () => {
+            const action = data.elementDisposables.add(( new Action("debug.callStack.restartFrame", ( localize(6882, "Restart Frame")), ThemeIcon.asClassName(debugRestartFrame), true, async () => {
                 try {
                     await stackFrame.restart();
-                }
-                catch (e) {
+                } catch (e) {
                     this.notificationService.error(e);
                 }
             })));
-            data.actionBar.push(action, { icon: true, label: false });
+            data.actionBar.push(action, {
+                icon: true,
+                label: false
+            });
         }
     }
     renderCompressedElements(node, index, templateData) {
-        throw ( new Error('Method not implemented.'));
+        throw ( new Error("Method not implemented."));
     }
     disposeElement(element, index, templateData) {
         templateData.elementDisposables.clear();
@@ -666,14 +756,14 @@ let StackFramesRenderer = class StackFramesRenderer {
         templateData.templateDisposable.dispose();
     }
 };
-StackFramesRenderer = StackFramesRenderer_1 = ( __decorate([
-    ( __param(0, IHoverService)),
-    ( __param(1, ILabelService)),
-    ( __param(2, INotificationService))
-], StackFramesRenderer));
+StackFramesRenderer = StackFramesRenderer_1 = ( __decorate([( __param(0, IHoverService)), ( __param(1, ILabelService)), ( __param(2, INotificationService))], StackFramesRenderer));
 let ErrorsRenderer = class ErrorsRenderer {
-    static { ErrorsRenderer_1 = this; }
-    static { this.ID = 'error'; }
+    static {
+        ErrorsRenderer_1 = this;
+    }
+    static {
+        this.ID = "error";
+    }
     get templateId() {
         return ErrorsRenderer_1.ID;
     }
@@ -681,78 +771,89 @@ let ErrorsRenderer = class ErrorsRenderer {
         this.hoverService = hoverService;
     }
     renderTemplate(container) {
-        const label = append(container, $('.error'));
-        return { label, templateDisposable: ( new DisposableStore()) };
+        const label = append(container, $(".error"));
+        return {
+            label,
+            templateDisposable: ( new DisposableStore())
+        };
     }
     renderElement(element, index, data) {
         const error = element.element;
         data.label.textContent = error;
-        data.templateDisposable.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.label, error));
+        data.templateDisposable.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), data.label, error)
+        );
     }
     renderCompressedElements(node, index, templateData) {
-        throw ( new Error('Method not implemented.'));
-    }
-    disposeTemplate(templateData) {
+        throw ( new Error("Method not implemented."));
     }
+    disposeTemplate(templateData) {}
 };
-ErrorsRenderer = ErrorsRenderer_1 = ( __decorate([
-    ( __param(0, IHoverService))
-], ErrorsRenderer));
+ErrorsRenderer = ErrorsRenderer_1 = ( __decorate([( __param(0, IHoverService))], ErrorsRenderer));
 class LoadMoreRenderer {
-    static { this.ID = 'loadMore'; }
-    static { this.LABEL = ( localize(6573, "Load More Stack Frames")); }
-    constructor() { }
+    static {
+        this.ID = "loadMore";
+    }
+    static {
+        this.LABEL = ( localize(6883, "Load More Stack Frames"));
+    }
+    constructor() {}
     get templateId() {
         return LoadMoreRenderer.ID;
     }
     renderTemplate(container) {
-        const label = append(container, $('.load-all'));
+        const label = append(container, $(".load-all"));
         label.style.color = asCssVariable(textLinkForeground);
-        return { label };
+        return {
+            label
+        };
     }
     renderElement(element, index, data) {
         data.label.textContent = LoadMoreRenderer.LABEL;
     }
     renderCompressedElements(node, index, templateData) {
-        throw ( new Error('Method not implemented.'));
-    }
-    disposeTemplate(templateData) {
+        throw ( new Error("Method not implemented."));
     }
+    disposeTemplate(templateData) {}
 }
 class ShowMoreRenderer {
-    static { this.ID = 'showMore'; }
-    constructor() { }
+    static {
+        this.ID = "showMore";
+    }
+    constructor() {}
     get templateId() {
         return ShowMoreRenderer.ID;
     }
     renderTemplate(container) {
-        const label = append(container, $('.show-more'));
+        const label = append(container, $(".show-more"));
         label.style.color = asCssVariable(textLinkForeground);
-        return { label };
+        return {
+            label
+        };
     }
     renderElement(element, index, data) {
         const stackFrames = element.element;
-        if (stackFrames.every(sf => !!(sf.source && sf.source.origin && sf.source.origin === stackFrames[0].source.origin))) {
+        if (stackFrames.every(
+            sf => !!(sf.source && sf.source.origin && sf.source.origin === stackFrames[0].source.origin)
+        )) {
             data.label.textContent = ( localize(
-                6574,
+                6884,
                 "Show {0} More: {1}",
                 stackFrames.length,
                 stackFrames[0].source.origin
             ));
-        }
-        else {
-            data.label.textContent = ( localize(6575, "Show {0} More Stack Frames", stackFrames.length));
+        } else {
+            data.label.textContent = ( localize(6885, "Show {0} More Stack Frames", stackFrames.length));
         }
     }
     renderCompressedElements(node, index, templateData) {
-        throw ( new Error('Method not implemented.'));
-    }
-    disposeTemplate(templateData) {
+        throw ( new Error("Method not implemented."));
     }
+    disposeTemplate(templateData) {}
 }
 class CallStackDelegate {
     getHeight(element) {
-        if (element instanceof StackFrame && element.presentationHint === 'label') {
+        if (element instanceof StackFrame && element.presentationHint === "label") {
             return 16;
         }
         if (element instanceof ThreadAndSessionIds || element instanceof Array) {
@@ -770,7 +871,7 @@ class CallStackDelegate {
         if (element instanceof StackFrame) {
             return StackFramesRenderer.ID;
         }
-        if (typeof element === 'string') {
+        if (typeof element === "string") {
             return ErrorsRenderer.ID;
         }
         if (element instanceof ThreadAndSessionIds) {
@@ -783,14 +884,13 @@ function stoppedText(stoppedDetails) {
     return stoppedDetails.text ?? stoppedDescription(stoppedDetails);
 }
 function stoppedDescription(stoppedDetails) {
-    return stoppedDetails.description ||
-        (stoppedDetails.reason ? ( localize(6576, "Paused on {0}", stoppedDetails.reason)) : ( localize(6577, "Paused")));
+    return stoppedDetails.description || (stoppedDetails.reason ? ( localize(6886, "Paused on {0}", stoppedDetails.reason)) : ( localize(6887, "Paused")));
 }
 function isDebugModel(obj) {
-    return !!obj && typeof obj.getSessions === 'function';
+    return !!obj && typeof obj.getSessions === "function";
 }
 function isDebugSession(obj) {
-    return !!obj && typeof obj.getAllThreads === 'function';
+    return !!obj && typeof obj.getAllThreads === "function";
 }
 class CallStackDataSource {
     constructor(debugService) {
@@ -815,8 +915,7 @@ class CallStackDataSource {
             }
             const threads = sessions[0].getAllThreads();
             return threads.length === 1 ? this.getThreadChildren(threads[0]) : Promise.resolve(threads);
-        }
-        else if (isDebugSession(element)) {
+        } else if (isDebugSession(element)) {
             const childSessions = this.debugService.getModel().getSessions().filter(s => s.parentSession === element);
             const threads = element.getAllThreads();
             if (threads.length === 1) {
@@ -824,8 +923,7 @@ class CallStackDataSource {
                 return children.concat(childSessions);
             }
             return Promise.resolve(threads.concat(childSessions));
-        }
-        else {
+        } else {
             return this.getThreadChildren(element);
         }
     }
@@ -874,21 +972,21 @@ class CallStackDataSource {
 }
 class CallStackAccessibilityProvider {
     getWidgetAriaLabel() {
-        return localize(6578, "Debug Call Stack");
+        return localize(6888, "Debug Call Stack");
     }
     getWidgetRole() {
-        return 'treegrid';
+        return "treegrid";
     }
     getRole(_element) {
-        return 'row';
+        return "row";
     }
     getAriaLabel(element) {
         if (element instanceof Thread) {
-            return localize(6579, "Thread {0} {1}", element.name, element.stateLabel);
+            return localize(6889, "Thread {0} {1}", element.name, element.stateLabel);
         }
         if (element instanceof StackFrame) {
             return localize(
-                6580,
+                6890,
                 "Stack Frame {0}, line {1}, {2}",
                 element.name,
                 element.range.startLineNumber,
@@ -897,14 +995,14 @@ class CallStackAccessibilityProvider {
         }
         if (isDebugSession(element)) {
             const thread = element.getAllThreads().find(t => t.stopped);
-            const state = thread ? thread.stateLabel : ( localize(6569, "Running"));
-            return localize(6581, "Session {0} {1}", element.getLabel(), state);
+            const state = thread ? thread.stateLabel : ( localize(6879, "Running"));
+            return localize(6891, "Session {0} {1}", element.getLabel(), state);
         }
-        if (typeof element === 'string') {
+        if (typeof element === "string") {
             return element;
         }
         if (element instanceof Array) {
-            return localize(6575, "Show {0} More Stack Frames", element.length);
+            return localize(6885, "Show {0} More Stack Frames", element.length);
         }
         return LoadMoreRenderer.LABEL;
     }
@@ -930,17 +1028,17 @@ class CallStackCompressionDelegate {
 registerAction2(class Collapse extends ViewAction {
     constructor() {
         super({
-            id: 'callStack.collapse',
+            id: "callStack.collapse",
             viewId: CALLSTACK_VIEW_ID,
-            title: ( localize(6582, "Collapse All")),
+            title: ( localize(6892, "Collapse All")),
             f1: false,
             icon: Codicon.collapseAll,
             precondition: ( CONTEXT_DEBUG_STATE.isEqualTo(getStateLabel(State.Stopped))),
             menu: {
                 id: MenuId.ViewTitle,
                 order: 10,
-                group: 'navigation',
-                when: ( ContextKeyExpr.equals('view', CALLSTACK_VIEW_ID))
+                group: "navigation",
+                when: ( ContextKeyExpr.equals("view", CALLSTACK_VIEW_ID))
             }
         });
     }
@@ -950,20 +1048,46 @@ registerAction2(class Collapse extends ViewAction {
 });
 function registerCallStackInlineMenuItem(id, title, icon, when, order, precondition) {
     MenuRegistry.appendMenuItem(MenuId.DebugCallStackContext, {
-        group: 'inline',
+        group: "inline",
         order,
         when,
-        command: { id, title, icon, precondition }
+        command: {
+            id,
+            title,
+            icon,
+            precondition
+        }
     });
 }
-const threadOrSessionWithOneThread = ( ContextKeyExpr.or(( CONTEXT_CALLSTACK_ITEM_TYPE.isEqualTo('thread')), ( ContextKeyExpr.and(( CONTEXT_CALLSTACK_ITEM_TYPE.isEqualTo('session')), CONTEXT_CALLSTACK_SESSION_HAS_ONE_THREAD))));
+const threadOrSessionWithOneThread = ( ContextKeyExpr.or(( CONTEXT_CALLSTACK_ITEM_TYPE.isEqualTo("thread")), ( ContextKeyExpr.and(( CONTEXT_CALLSTACK_ITEM_TYPE.isEqualTo("session")), CONTEXT_CALLSTACK_SESSION_HAS_ONE_THREAD))));
 registerCallStackInlineMenuItem(PAUSE_ID, PAUSE_LABEL, debugPause, ( ContextKeyExpr.and(threadOrSessionWithOneThread, ( CONTEXT_CALLSTACK_ITEM_STOPPED.toNegated()))), 10, ( CONTEXT_FOCUSED_SESSION_IS_NO_DEBUG.toNegated()));
 registerCallStackInlineMenuItem(CONTINUE_ID, CONTINUE_LABEL, debugContinue, ( ContextKeyExpr.and(threadOrSessionWithOneThread, CONTEXT_CALLSTACK_ITEM_STOPPED)), 10);
-registerCallStackInlineMenuItem(STEP_OVER_ID, STEP_OVER_LABEL, debugStepOver, threadOrSessionWithOneThread, 20, CONTEXT_CALLSTACK_ITEM_STOPPED);
-registerCallStackInlineMenuItem(STEP_INTO_ID, STEP_INTO_LABEL, debugStepInto, threadOrSessionWithOneThread, 30, CONTEXT_CALLSTACK_ITEM_STOPPED);
-registerCallStackInlineMenuItem(STEP_OUT_ID, STEP_OUT_LABEL, debugStepOut, threadOrSessionWithOneThread, 40, CONTEXT_CALLSTACK_ITEM_STOPPED);
-registerCallStackInlineMenuItem(RESTART_SESSION_ID, RESTART_LABEL, debugRestart, ( CONTEXT_CALLSTACK_ITEM_TYPE.isEqualTo('session')), 50);
-registerCallStackInlineMenuItem(STOP_ID, STOP_LABEL, debugStop, ( ContextKeyExpr.and(( CONTEXT_CALLSTACK_SESSION_IS_ATTACH.toNegated()), ( CONTEXT_CALLSTACK_ITEM_TYPE.isEqualTo('session')))), 60);
-registerCallStackInlineMenuItem(DISCONNECT_ID, DISCONNECT_LABEL, debugDisconnect, ( ContextKeyExpr.and(CONTEXT_CALLSTACK_SESSION_IS_ATTACH, ( CONTEXT_CALLSTACK_ITEM_TYPE.isEqualTo('session')))), 60);
+registerCallStackInlineMenuItem(
+    STEP_OVER_ID,
+    STEP_OVER_LABEL,
+    debugStepOver,
+    threadOrSessionWithOneThread,
+    20,
+    CONTEXT_CALLSTACK_ITEM_STOPPED
+);
+registerCallStackInlineMenuItem(
+    STEP_INTO_ID,
+    STEP_INTO_LABEL,
+    debugStepInto,
+    threadOrSessionWithOneThread,
+    30,
+    CONTEXT_CALLSTACK_ITEM_STOPPED
+);
+registerCallStackInlineMenuItem(
+    STEP_OUT_ID,
+    STEP_OUT_LABEL,
+    debugStepOut,
+    threadOrSessionWithOneThread,
+    40,
+    CONTEXT_CALLSTACK_ITEM_STOPPED
+);
+registerCallStackInlineMenuItem(RESTART_SESSION_ID, RESTART_LABEL, debugRestart, ( CONTEXT_CALLSTACK_ITEM_TYPE.isEqualTo("session")), 50);
+registerCallStackInlineMenuItem(STOP_ID, STOP_LABEL, debugStop, ( ContextKeyExpr.and(( CONTEXT_CALLSTACK_SESSION_IS_ATTACH.toNegated()), ( CONTEXT_CALLSTACK_ITEM_TYPE.isEqualTo("session")))), 60);
+registerCallStackInlineMenuItem(DISCONNECT_ID, DISCONNECT_LABEL, debugDisconnect, ( ContextKeyExpr.and(CONTEXT_CALLSTACK_SESSION_IS_ATTACH, ( CONTEXT_CALLSTACK_ITEM_TYPE.isEqualTo("session")))), 60);
 
 export { CallStackView, getContext, getContextForContributedActions, getSpecificSourceName };