@codingame/monaco-vscode-api 1.78.6-next.0 → 1.78.7

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

@@ -1,954 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
-import { HighlightedLabel } from 'monaco-editor/esm/vs/base/browser/ui/highlightedlabel/highlightedLabel.js';
-import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
-import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { createMatches } from 'monaco-editor/esm/vs/base/common/filters.js';
-import { dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { posix } from 'monaco-editor/esm/vs/base/common/path.js';
-import { commonSuffixLength } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { createAndFillInContextMenuActions, MenuEntryActionViewItem, SubmenuEntryActionViewItem, createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
-import { registerAction2, MenuId, MenuItemAction, SubmenuItemAction, MenuRegistry, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-import { WorkbenchCompressibleAsyncDataTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
-import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { asCssVariable, textLinkForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
-import { ViewAction, ViewPane } from '../../../browser/parts/views/viewPane.js';
-import { IViewDescriptorService } from '../../../common/views.js';
-import { renderViewTree } from './baseDebugView.js';
-import { STOP_ID, DISCONNECT_ID, PAUSE_LABEL, PAUSE_ID, CONTINUE_LABEL, CONTINUE_ID, STEP_OVER_LABEL, STEP_OVER_ID, STEP_INTO_LABEL, STEP_INTO_ID, STEP_OUT_LABEL, STEP_OUT_ID, RESTART_LABEL, RESTART_SESSION_ID, STOP_LABEL, DISCONNECT_LABEL } from './debugCommands.js';
-import { callstackViewSession, debugRestartFrame, debugPause, debugContinue, debugStepOver, debugStepInto, debugStepOut, debugRestart, debugStop, debugDisconnect } from './debugIcons.js';
-import { createDisconnectMenuItemAction } from './debugToolBar.js';
-import { CALLSTACK_VIEW_ID, CONTEXT_DEBUG_STATE, getStateLabel, CONTEXT_CALLSTACK_ITEM_TYPE, CONTEXT_CALLSTACK_SESSION_IS_ATTACH, CONTEXT_CALLSTACK_ITEM_STOPPED, CONTEXT_CALLSTACK_SESSION_HAS_ONE_THREAD, IDebugService, CONTEXT_STACK_FRAME_SUPPORTS_RESTART } from '../common/debug.js';
-import { Thread, StackFrame, ThreadAndSessionIds } from '../common/debugModel.js';
-import { isSessionAttach } from '../common/debugUtils.js';
-const $ = dom.$;
-function assignSessionContext(element, context) {
-    context.sessionId = element.getId();
-    return context;
-}
-function assignThreadContext(element, context) {
-    context.threadId = element.getId();
-    assignSessionContext(element.session, context);
-    return context;
-}
-function assignStackFrameContext(element, context) {
-    context.frameId = element.getId();
-    context.frameName = element.name;
-    context.frameLocation = { range: element.range, source: element.source.raw };
-    assignThreadContext(element.thread, context);
-    return context;
-}
-function getContext(element) {
-    if (element instanceof StackFrame) {
-        return assignStackFrameContext(element, {});
-    }
-    else if (element instanceof Thread) {
-        return assignThreadContext(element, {});
-    }
-    else if (isDebugSession(element)) {
-        return assignSessionContext(element, {});
-    }
-    else {
-        return undefined;
-    }
-}
-function getContextForContributedActions(element) {
-    if (element instanceof StackFrame) {
-        if (element.source.inMemory) {
-            return element.source.raw.path || element.source.reference || element.source.name;
-        }
-        return ( element.source.uri.toString());
-    }
-    if (element instanceof Thread) {
-        return element.threadId;
-    }
-    if (isDebugSession(element)) {
-        return element.getId();
-    }
-    return '';
-}
-function getSpecificSourceName(stackFrame) {
-    let callStack = stackFrame.thread.getStaleCallStack();
-    callStack = callStack.length > 0 ? callStack : stackFrame.thread.getCallStack();
-    const otherSources = ( callStack.map(sf => sf.source)).filter(s => s !== stackFrame.source);
-    let suffixLength = 0;
-    otherSources.forEach(s => {
-        if (s.name === stackFrame.source.name) {
-            suffixLength = Math.max(suffixLength, commonSuffixLength(stackFrame.source.uri.path, s.uri.path));
-        }
-    });
-    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);
-}
-async function expandTo(session, tree) {
-    if (session.parentSession) {
-        await expandTo(session.parentSession, tree);
-    }
-    await tree.expand(session);
-}
-let CallStackView = class CallStackView extends ViewPane {
-    constructor(options, contextMenuService, debugService, keybindingService, instantiationService, viewDescriptorService, configurationService, contextKeyService, openerService, themeService, telemetryService, menuService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
-        this.options = options;
-        this.debugService = debugService;
-        this.menuService = menuService;
-        this.needsRefresh = false;
-        this.ignoreSelectionChangedEvent = false;
-        this.ignoreFocusStackFrameEvent = false;
-        this.autoExpandedSessions = ( new Set());
-        this.selectionNeedsUpdate = false;
-        this.onCallStackChangeScheduler = this._register(( new RunOnceScheduler(async () => {
-            const sessions = this.debugService.getModel().getSessions();
-            if (sessions.length === 0) {
-                this.autoExpandedSessions.clear();
-            }
-            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')) {
-                this.stateMessageLabel.textContent = stoppedDescription(stoppedDetails);
-                this.stateMessageLabel.title = stoppedText(stoppedDetails);
-                this.stateMessageLabel.classList.toggle('exception', stoppedDetails.reason === 'exception');
-                this.stateMessage.hidden = false;
-            }
-            else if (sessions.length === 1 && sessions[0].state === 3 ) {
-                this.stateMessageLabel.textContent = ( localize({ key: 'running', comment: ['indicates state'] }, "Running"));
-                this.stateMessageLabel.title = sessions[0].getLabel();
-                this.stateMessageLabel.classList.remove('exception');
-                this.stateMessage.hidden = false;
-            }
-            else {
-                this.stateMessage.hidden = true;
-            }
-            this.updateActions();
-            this.needsRefresh = false;
-            this.dataSource.deemphasizedStackFramesToShow = [];
-            await this.tree.updateChildren();
-            try {
-                const toExpand = ( new Set());
-                sessions.forEach(s => {
-                    if (s.parentSession && !( this.autoExpandedSessions.has(s.parentSession))) {
-                        toExpand.add(s.parentSession);
-                    }
-                });
-                for (const session of toExpand) {
-                    await expandTo(session, this.tree);
-                    this.autoExpandedSessions.add(session);
-                }
-            }
-            catch (e) {
-            }
-            if (this.selectionNeedsUpdate) {
-                this.selectionNeedsUpdate = false;
-                await this.updateTreeSelection();
-            }
-        }, 50)));
-    }
-    renderHeaderTitle(container) {
-        super.renderHeaderTitle(container, this.options.title);
-        this.stateMessage = dom.append(container, $('span.call-stack-state-message'));
-        this.stateMessage.hidden = true;
-        this.stateMessageLabel = dom.append(this.stateMessage, $('span.label'));
-    }
-    renderBody(container) {
-        super.renderBody(container);
-        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),
-            ( new 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;
-                    }
-                    return ( localize('showMoreStackFrames2', "Show More Stack Frames"));
-                },
-                getCompressedNodeKeyboardNavigationLabel: (e) => {
-                    const firstItem = e[0];
-                    if (isDebugSession(firstItem)) {
-                        return firstItem.getLabel();
-                    }
-                    return '';
-                }
-            },
-            expandOnlyOnTwistieClick: true,
-            overrideStyles: {
-                listBackground: this.getBackgroundColor()
-            }
-        });
-        this.tree.setInput(this.debugService.getModel());
-        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.ignoreFocusStackFrameEvent = false;
-                }
-            };
-            const element = e.element;
-            if (element instanceof StackFrame) {
-                const opts = {
-                    preserveFocus: e.editorOptions.preserveFocus,
-                    sideBySide: e.sideBySide,
-                    pinned: e.editorOptions.pinned
-                };
-                focusStackFrame(element, element.thread, element.thread.session, opts);
-            }
-            if (element instanceof Thread) {
-                focusStackFrame(undefined, element, element.session);
-            }
-            if (isDebugSession(element)) {
-                focusStackFrame(undefined, undefined, element);
-            }
-            if (element instanceof ThreadAndSessionIds) {
-                const session = this.debugService.getModel().getSession(element.sessionId);
-                const thread = session && session.getThread(element.threadId);
-                if (thread) {
-                    const totalFrames = thread.stoppedDetails?.totalFrames;
-                    const remainingFramesCount = typeof totalFrames === 'number' ? (totalFrames - thread.getCallStack().length) : undefined;
-                    await thread.fetchCallStack(remainingFramesCount);
-                    await this.tree.updateChildren();
-                }
-            }
-            if (element instanceof Array) {
-                this.dataSource.deemphasizedStackFramesToShow.push(...element);
-                this.tree.updateChildren();
-            }
-        }));
-        this._register(this.debugService.getModel().onDidChangeCallStack(() => {
-            if (!this.isBodyVisible()) {
-                this.needsRefresh = true;
-                return;
-            }
-            if (!this.onCallStackChangeScheduler.isScheduled()) {
-                this.onCallStackChangeScheduler.schedule();
-            }
-        }));
-        const onFocusChange = Event.any(this.debugService.getViewModel().onDidFocusStackFrame, this.debugService.getViewModel().onDidFocusSession);
-        this._register(onFocusChange(async () => {
-            if (this.ignoreFocusStackFrameEvent) {
-                return;
-            }
-            if (!this.isBodyVisible()) {
-                this.needsRefresh = true;
-                return;
-            }
-            if (this.onCallStackChangeScheduler.isScheduled()) {
-                this.selectionNeedsUpdate = true;
-                return;
-            }
-            await this.updateTreeSelection();
-        }));
-        this._register(this.tree.onContextMenu(e => this.onContextMenu(e)));
-        if (this.debugService.state === 2 ) {
-            this.onCallStackChangeScheduler.schedule(0);
-        }
-        this._register(this.onDidChangeBodyVisibility(visible => {
-            if (visible && this.needsRefresh) {
-                this.onCallStackChangeScheduler.schedule();
-            }
-        }));
-        this._register(this.debugService.onDidNewSession(s => {
-            const sessionListeners = [];
-            sessionListeners.push(s.onDidChangeName(() => {
-                if (this.tree.hasNode(s)) {
-                    this.tree.rerender(s);
-                }
-            }));
-            sessionListeners.push(s.onDidEndAdapter(() => dispose(sessionListeners)));
-            if (s.parentSession) {
-                this.autoExpandedSessions.delete(s.parentSession);
-            }
-        }));
-    }
-    layoutBody(height, width) {
-        super.layoutBody(height, width);
-        this.tree.layout(height, width);
-    }
-    focus() {
-        this.tree.domFocus();
-    }
-    collapseAll() {
-        this.tree.collapseAll();
-    }
-    async updateTreeSelection() {
-        if (!this.tree || !this.tree.getInput()) {
-            return;
-        }
-        const updateSelectionAndReveal = (element) => {
-            this.ignoreSelectionChangedEvent = true;
-            try {
-                this.tree.setSelection([element]);
-                if (this.tree.getRelativeTop(element) === null) {
-                    this.tree.reveal(element, 0.5);
-                }
-                else {
-                    this.tree.reveal(element);
-                }
-            }
-            catch (e) { }
-            finally {
-                this.ignoreSelectionChangedEvent = false;
-            }
-        };
-        const thread = this.debugService.getViewModel().focusedThread;
-        const session = this.debugService.getViewModel().focusedSession;
-        const stackFrame = this.debugService.getViewModel().focusedStackFrame;
-        if (!thread) {
-            if (!session) {
-                this.tree.setSelection([]);
-            }
-            else {
-                updateSelectionAndReveal(session);
-            }
-        }
-        else {
-            try {
-                await expandTo(thread.session, this.tree);
-            }
-            catch (e) { }
-            try {
-                await this.tree.expand(thread);
-            }
-            catch (e) { }
-            const toReveal = stackFrame || session;
-            if (toReveal) {
-                updateSelectionAndReveal(toReveal);
-            }
-        }
-    }
-    onContextMenu(e) {
-        const element = e.element;
-        let overlay = [];
-        if (isDebugSession(element)) {
-            overlay = getSessionContextOverlay(element);
-        }
-        else if (element instanceof Thread) {
-            overlay = getThreadContextOverlay(element);
-        }
-        else if (element instanceof StackFrame) {
-            overlay = getStackFrameContextOverlay(element);
-        }
-        const primary = [];
-        const secondary = [];
-        const result = { primary, secondary };
-        const contextKeyService = this.contextKeyService.createOverlay(overlay);
-        const menu = this.menuService.createMenu(MenuId.DebugCallStackContext, contextKeyService);
-        createAndFillInContextMenuActions(menu, { arg: getContextForContributedActions(element), shouldForwardArgs: true }, result, 'inline');
-        this.contextMenuService.showContextMenu({
-            getAnchor: () => e.anchor,
-            getActions: () => result.secondary,
-            getActionsContext: () => getContext(element)
-        });
-    }
-};
-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, ITelemetryService)),
-    ( __param(11, IMenuService))
-], CallStackView));
-function getSessionContextOverlay(session) {
-    return [
-        [CONTEXT_CALLSTACK_ITEM_TYPE.key, 'session'],
-        [CONTEXT_CALLSTACK_SESSION_IS_ATTACH.key, isSessionAttach(session)],
-        [CONTEXT_CALLSTACK_ITEM_STOPPED.key, session.state === 2 ],
-        [CONTEXT_CALLSTACK_SESSION_HAS_ONE_THREAD.key, session.getAllThreads().length === 1],
-    ];
-}
-let SessionsRenderer = class SessionsRenderer {
-    constructor(instantiationService, contextKeyService, menuService) {
-        this.instantiationService = instantiationService;
-        this.contextKeyService = contextKeyService;
-        this.menuService = menuService;
-    }
-    get templateId() {
-        return SessionsRenderer.ID;
-    }
-    renderTemplate(container) {
-        const session = dom.append(container, $('.session'));
-        dom.append(session, $(ThemeIcon.asCSSSelector(callstackViewSession)));
-        const name = dom.append(session, $('.name'));
-        const stateLabel = dom.append(session, $('span.state.label.monaco-count-badge.long'));
-        const label = ( new HighlightedLabel(name));
-        const templateDisposable = ( new DisposableStore());
-        const stopActionViewItemDisposables = templateDisposable.add(( new DisposableStore()));
-        const actionBar = templateDisposable.add(( new ActionBar(session, {
-            actionViewItemProvider: action => {
-                if ((action.id === STOP_ID || action.id === DISCONNECT_ID) && action instanceof MenuItemAction) {
-                    stopActionViewItemDisposables.clear();
-                    const item = this.instantiationService.invokeFunction(accessor => createDisconnectMenuItemAction(action, stopActionViewItemDisposables, accessor));
-                    if (item) {
-                        return item;
-                    }
-                }
-                if (action instanceof MenuItemAction) {
-                    return this.instantiationService.createInstance(MenuEntryActionViewItem, action, undefined);
-                }
-                else if (action instanceof SubmenuItemAction) {
-                    return this.instantiationService.createInstance(SubmenuEntryActionViewItem, action, undefined);
-                }
-                return undefined;
-            }
-        })));
-        const elementDisposable = templateDisposable.add(( new DisposableStore()));
-        return { session, name, stateLabel, label, actionBar, elementDisposable, templateDisposable };
-    }
-    renderElement(element, _, data) {
-        this.doRenderElement(element.element, createMatches(element.filterData), data);
-    }
-    renderCompressedElements(node, _index, templateData) {
-        const lastElement = node.element.elements[node.element.elements.length - 1];
-        const matches = createMatches(node.filterData);
-        this.doRenderElement(lastElement, matches, templateData);
-    }
-    doRenderElement(session, matches, data) {
-        data.session.title = ( localize({ key: 'session', comment: ['Session is a noun'] }, "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 setupActionBar = () => {
-            data.actionBar.clear();
-            const primary = [];
-            const secondary = [];
-            const result = { primary, secondary };
-            createAndFillInActionBarActions(menu, { arg: getContextForContributedActions(session), shouldForwardArgs: true }, result, '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 = '';
-        if (stoppedDetails) {
-            data.stateLabel.textContent = stoppedDescription(stoppedDetails);
-            data.session.title = `${session.getLabel()}: ${stoppedText(stoppedDetails)}`;
-            data.stateLabel.classList.toggle('exception', stoppedDetails.reason === 'exception');
-        }
-        else if (thread && thread.stoppedDetails) {
-            data.stateLabel.textContent = stoppedDescription(thread.stoppedDetails);
-            data.session.title = `${session.getLabel()}: ${stoppedText(thread.stoppedDetails)}`;
-            data.stateLabel.classList.toggle('exception', thread.stoppedDetails.reason === 'exception');
-        }
-        else {
-            data.stateLabel.textContent = ( localize({ key: 'running', comment: ['indicates state'] }, "Running"));
-            data.stateLabel.classList.remove('exception');
-        }
-    }
-    disposeTemplate(templateData) {
-        templateData.templateDisposable.dispose();
-    }
-    disposeElement(_element, _, templateData) {
-        templateData.elementDisposable.clear();
-    }
-    disposeCompressedElements(node, index, templateData, height) {
-        templateData.elementDisposable.clear();
-    }
-};
-SessionsRenderer.ID = 'session';
-SessionsRenderer = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IContextKeyService)),
-    ( __param(2, IMenuService))
-], SessionsRenderer));
-function getThreadContextOverlay(thread) {
-    return [
-        [CONTEXT_CALLSTACK_ITEM_TYPE.key, 'thread'],
-        [CONTEXT_CALLSTACK_ITEM_STOPPED.key, thread.stopped]
-    ];
-}
-let ThreadsRenderer = class ThreadsRenderer {
-    constructor(contextKeyService, menuService) {
-        this.contextKeyService = contextKeyService;
-        this.menuService = menuService;
-    }
-    get templateId() {
-        return ThreadsRenderer.ID;
-    }
-    renderTemplate(container) {
-        const thread = dom.append(container, $('.thread'));
-        const name = dom.append(thread, $('.name'));
-        const stateLabel = dom.append(thread, $('span.state.label.monaco-count-badge.long'));
-        const label = ( new HighlightedLabel(name));
-        const templateDisposable = ( new DisposableStore());
-        const actionBar = templateDisposable.add(( new ActionBar(thread)));
-        const elementDisposable = templateDisposable.add(( new DisposableStore()));
-        return { thread, name, stateLabel, label, actionBar, elementDisposable, templateDisposable };
-    }
-    renderElement(element, _index, data) {
-        const thread = element.element;
-        data.thread.title = thread.name;
-        data.label.set(thread.name, createMatches(element.filterData));
-        data.stateLabel.textContent = thread.stateLabel;
-        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 setupActionBar = () => {
-            data.actionBar.clear();
-            const primary = [];
-            const secondary = [];
-            const result = { primary, secondary };
-            createAndFillInActionBarActions(menu, { arg: getContextForContributedActions(thread), shouldForwardArgs: true }, result, '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, _height) {
-        throw new Error('Method not implemented.');
-    }
-    disposeElement(_element, _index, templateData) {
-        templateData.elementDisposable.clear();
-    }
-    disposeTemplate(templateData) {
-        templateData.templateDisposable.dispose();
-    }
-};
-ThreadsRenderer.ID = 'thread';
-ThreadsRenderer = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, IMenuService))
-], ThreadsRenderer));
-function getStackFrameContextOverlay(stackFrame) {
-    return [
-        [CONTEXT_CALLSTACK_ITEM_TYPE.key, 'stackFrame'],
-        [CONTEXT_STACK_FRAME_SUPPORTS_RESTART.key, stackFrame.canRestart]
-    ];
-}
-let StackFramesRenderer = class StackFramesRenderer {
-    constructor(labelService, notificationService) {
-        this.labelService = labelService;
-        this.notificationService = notificationService;
-    }
-    get templateId() {
-        return StackFramesRenderer.ID;
-    }
-    renderTemplate(container) {
-        const stackFrame = dom.append(container, $('.stack-frame'));
-        const labelDiv = dom.append(stackFrame, $('span.label.expression'));
-        const file = dom.append(stackFrame, $('.file'));
-        const fileName = dom.append(file, $('span.file-name'));
-        const wrapper = dom.append(file, $('span.line-number-wrapper'));
-        const lineNumber = dom.append(wrapper, $('span.line-number.monaco-count-badge'));
-        const label = ( new HighlightedLabel(labelDiv));
-        const templateDisposable = ( new DisposableStore());
-        const actionBar = templateDisposable.add(( new ActionBar(stackFrame)));
-        return { file, fileName, label, lineNumber, stackFrame, actionBar, templateDisposable };
-    }
-    renderElement(element, index, data) {
-        const stackFrame = element.element;
-        data.stackFrame.classList.toggle('disabled', !stackFrame.source || !stackFrame.source.available || isDeemphasized(stackFrame));
-        data.stackFrame.classList.toggle('label', stackFrame.presentationHint === 'label');
-        data.stackFrame.classList.toggle('subtle', stackFrame.presentationHint === 'subtle');
-        const hasActions = !!stackFrame.thread.session.capabilities.supportsRestartFrame && stackFrame.presentationHint !== 'label' && stackFrame.presentationHint !== 'subtle' && stackFrame.canRestart;
-        data.stackFrame.classList.toggle('has-actions', hasActions);
-        data.file.title = stackFrame.source.inMemory ? stackFrame.source.uri.path : this.labelService.getUriLabel(stackFrame.source.uri);
-        if (stackFrame.source.raw.origin) {
-            data.file.title += `\n${stackFrame.source.raw.origin}`;
-        }
-        data.label.set(stackFrame.name, createMatches(element.filterData), stackFrame.name);
-        data.fileName.textContent = getSpecificSourceName(stackFrame);
-        if (stackFrame.range.startLineNumber !== undefined) {
-            data.lineNumber.textContent = `${stackFrame.range.startLineNumber}`;
-            if (stackFrame.range.startColumn) {
-                data.lineNumber.textContent += `:${stackFrame.range.startColumn}`;
-            }
-            data.lineNumber.classList.remove('unavailable');
-        }
-        else {
-            data.lineNumber.classList.add('unavailable');
-        }
-        data.actionBar.clear();
-        if (hasActions) {
-            const action = ( new Action('debug.callStack.restartFrame', ( localize('restartFrame', "Restart Frame")), ThemeIcon.asClassName(debugRestartFrame), true, async () => {
-                try {
-                    await stackFrame.restart();
-                }
-                catch (e) {
-                    this.notificationService.error(e);
-                }
-            }));
-            data.actionBar.push(action, { icon: true, label: false });
-        }
-    }
-    renderCompressedElements(node, index, templateData, height) {
-        throw new Error('Method not implemented.');
-    }
-    disposeTemplate(templateData) {
-        templateData.actionBar.dispose();
-    }
-};
-StackFramesRenderer.ID = 'stackFrame';
-StackFramesRenderer = ( __decorate([
-    ( __param(0, ILabelService)),
-    ( __param(1, INotificationService))
-], StackFramesRenderer));
-class ErrorsRenderer {
-    get templateId() {
-        return ErrorsRenderer.ID;
-    }
-    renderTemplate(container) {
-        const label = dom.append(container, $('.error'));
-        return { label };
-    }
-    renderElement(element, index, data) {
-        const error = element.element;
-        data.label.textContent = error;
-        data.label.title = error;
-    }
-    renderCompressedElements(node, index, templateData, height) {
-        throw new Error('Method not implemented.');
-    }
-    disposeTemplate(templateData) {
-    }
-}
-ErrorsRenderer.ID = 'error';
-class LoadMoreRenderer {
-    constructor() { }
-    get templateId() {
-        return LoadMoreRenderer.ID;
-    }
-    renderTemplate(container) {
-        const label = dom.append(container, $('.load-all'));
-        label.style.color = asCssVariable(textLinkForeground);
-        return { label };
-    }
-    renderElement(element, index, data) {
-        data.label.textContent = LoadMoreRenderer.LABEL;
-    }
-    renderCompressedElements(node, index, templateData, height) {
-        throw new Error('Method not implemented.');
-    }
-    disposeTemplate(templateData) {
-    }
-}
-LoadMoreRenderer.ID = 'loadMore';
-LoadMoreRenderer.LABEL = ( localize('loadAllStackFrames', "Load More Stack Frames"));
-class ShowMoreRenderer {
-    constructor() { }
-    get templateId() {
-        return ShowMoreRenderer.ID;
-    }
-    renderTemplate(container) {
-        const label = dom.append(container, $('.show-more'));
-        label.style.color = asCssVariable(textLinkForeground);
-        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))) {
-            data.label.textContent = ( localize(
-                'showMoreAndOrigin',
-                "Show {0} More: {1}",
-                stackFrames.length,
-                stackFrames[0].source.origin
-            ));
-        }
-        else {
-            data.label.textContent = ( localize('showMoreStackFrames', "Show {0} More Stack Frames", stackFrames.length));
-        }
-    }
-    renderCompressedElements(node, index, templateData, height) {
-        throw new Error('Method not implemented.');
-    }
-    disposeTemplate(templateData) {
-    }
-}
-ShowMoreRenderer.ID = 'showMore';
-class CallStackDelegate {
-    getHeight(element) {
-        if (element instanceof StackFrame && element.presentationHint === 'label') {
-            return 16;
-        }
-        if (element instanceof ThreadAndSessionIds || element instanceof Array) {
-            return 16;
-        }
-        return 22;
-    }
-    getTemplateId(element) {
-        if (isDebugSession(element)) {
-            return SessionsRenderer.ID;
-        }
-        if (element instanceof Thread) {
-            return ThreadsRenderer.ID;
-        }
-        if (element instanceof StackFrame) {
-            return StackFramesRenderer.ID;
-        }
-        if (typeof element === 'string') {
-            return ErrorsRenderer.ID;
-        }
-        if (element instanceof ThreadAndSessionIds) {
-            return LoadMoreRenderer.ID;
-        }
-        return ShowMoreRenderer.ID;
-    }
-}
-function stoppedText(stoppedDetails) {
-    return stoppedDetails.text ?? stoppedDescription(stoppedDetails);
-}
-function stoppedDescription(stoppedDetails) {
-    return stoppedDetails.description ||
-        (stoppedDetails.reason ? ( localize(
-        { key: 'pausedOn', comment: ['indicates reason for program being paused'] },
-        "Paused on {0}",
-        stoppedDetails.reason
-    )) : ( localize('paused', "Paused")));
-}
-function isDebugModel(obj) {
-    return typeof obj.getSessions === 'function';
-}
-function isDebugSession(obj) {
-    return obj && typeof obj.getAllThreads === 'function';
-}
-function isDeemphasized(frame) {
-    return frame.source.presentationHint === 'deemphasize' || frame.presentationHint === 'deemphasize';
-}
-class CallStackDataSource {
-    constructor(debugService) {
-        this.debugService = debugService;
-        this.deemphasizedStackFramesToShow = [];
-    }
-    hasChildren(element) {
-        if (isDebugSession(element)) {
-            const threads = element.getAllThreads();
-            return (threads.length > 1) || (threads.length === 1 && threads[0].stopped) || !!(this.debugService.getModel().getSessions().find(s => s.parentSession === element));
-        }
-        return isDebugModel(element) || (element instanceof Thread && element.stopped);
-    }
-    async getChildren(element) {
-        if (isDebugModel(element)) {
-            const sessions = element.getSessions();
-            if (sessions.length === 0) {
-                return Promise.resolve([]);
-            }
-            if (sessions.length > 1 || this.debugService.getViewModel().isMultiSessionView()) {
-                return Promise.resolve(sessions.filter(s => !s.parentSession));
-            }
-            const threads = sessions[0].getAllThreads();
-            return threads.length === 1 ? this.getThreadChildren(threads[0]) : Promise.resolve(threads);
-        }
-        else if (isDebugSession(element)) {
-            const childSessions = this.debugService.getModel().getSessions().filter(s => s.parentSession === element);
-            const threads = element.getAllThreads();
-            if (threads.length === 1) {
-                const children = await this.getThreadChildren(threads[0]);
-                return children.concat(childSessions);
-            }
-            return Promise.resolve(threads.concat(childSessions));
-        }
-        else {
-            return this.getThreadChildren(element);
-        }
-    }
-    getThreadChildren(thread) {
-        return this.getThreadCallstack(thread).then(children => {
-            const result = [];
-            children.forEach((child, index) => {
-                if (child instanceof StackFrame && child.source && isDeemphasized(child)) {
-                    if (this.deemphasizedStackFramesToShow.indexOf(child) === -1) {
-                        if (result.length) {
-                            const last = result[result.length - 1];
-                            if (last instanceof Array) {
-                                last.push(child);
-                                return;
-                            }
-                        }
-                        const nextChild = index < children.length - 1 ? children[index + 1] : undefined;
-                        if (nextChild instanceof StackFrame && nextChild.source && isDeemphasized(nextChild)) {
-                            result.push([child]);
-                            return;
-                        }
-                    }
-                }
-                result.push(child);
-            });
-            return result;
-        });
-    }
-    async getThreadCallstack(thread) {
-        let callStack = thread.getCallStack();
-        if (!callStack || !callStack.length) {
-            await thread.fetchCallStack();
-            callStack = thread.getCallStack();
-        }
-        if (callStack.length === 1 && thread.session.capabilities.supportsDelayedStackTraceLoading && thread.stoppedDetails && thread.stoppedDetails.totalFrames && thread.stoppedDetails.totalFrames > 1) {
-            callStack = callStack.concat(thread.getStaleCallStack().slice(1));
-        }
-        if (thread.stoppedDetails && thread.stoppedDetails.framesErrorMessage) {
-            callStack = callStack.concat([thread.stoppedDetails.framesErrorMessage]);
-        }
-        if (!thread.reachedEndOfCallStack && thread.stoppedDetails) {
-            callStack = callStack.concat([( new ThreadAndSessionIds(thread.session.getId(), thread.threadId))]);
-        }
-        return callStack;
-    }
-}
-class CallStackAccessibilityProvider {
-    getWidgetAriaLabel() {
-        return ( localize(
-            { comment: ['Debug is a noun in this context, not a verb.'], key: 'callStackAriaLabel' },
-            "Debug Call Stack"
-        ));
-    }
-    getWidgetRole() {
-        return 'treegrid';
-    }
-    getRole(_element) {
-        return 'row';
-    }
-    getAriaLabel(element) {
-        if (element instanceof Thread) {
-            return ( localize(
-                { key: 'threadAriaLabel', comment: ['Placeholders stand for the thread name and the thread state.For example "Thread 1" and "Stopped'] },
-                "Thread {0} {1}",
-                element.name,
-                element.stateLabel
-            ));
-        }
-        if (element instanceof StackFrame) {
-            return ( localize(
-                'stackFrameAriaLabel',
-                "Stack Frame {0}, line {1}, {2}",
-                element.name,
-                element.range.startLineNumber,
-                getSpecificSourceName(element)
-            ));
-        }
-        if (isDebugSession(element)) {
-            const thread = element.getAllThreads().find(t => t.stopped);
-            const state = thread ? thread.stateLabel : ( localize({ key: 'running', comment: ['indicates state'] }, "Running"));
-            return ( localize(
-                { key: 'sessionLabel', comment: ['Placeholders stand for the session name and the session state. For example "Launch Program" and "Running"'] },
-                "Session {0} {1}",
-                element.getLabel(),
-                state
-            ));
-        }
-        if (typeof element === 'string') {
-            return element;
-        }
-        if (element instanceof Array) {
-            return ( localize('showMoreStackFrames', "Show {0} More Stack Frames", element.length));
-        }
-        return LoadMoreRenderer.LABEL;
-    }
-}
-class CallStackCompressionDelegate {
-    constructor(debugService) {
-        this.debugService = debugService;
-    }
-    isIncompressible(stat) {
-        if (isDebugSession(stat)) {
-            if (stat.compact) {
-                return false;
-            }
-            const sessions = this.debugService.getModel().getSessions();
-            if (( sessions.some(s => s.parentSession === stat && s.compact))) {
-                return false;
-            }
-            return true;
-        }
-        return true;
-    }
-}
-registerAction2(class Collapse extends ViewAction {
-    constructor() {
-        super({
-            id: 'callStack.collapse',
-            viewId: CALLSTACK_VIEW_ID,
-            title: ( localize('collapse', "Collapse All")),
-            f1: false,
-            icon: Codicon.collapseAll,
-            precondition: ( CONTEXT_DEBUG_STATE.isEqualTo(getStateLabel(2 ))),
-            menu: {
-                id: MenuId.ViewTitle,
-                order: 10,
-                group: 'navigation',
-                when: ( ContextKeyExpr.equals('view', CALLSTACK_VIEW_ID))
-            }
-        });
-    }
-    runInView(_accessor, view) {
-        view.collapseAll();
-    }
-});
-function registerCallStackInlineMenuItem(id, title, icon, when, order, precondition) {
-    MenuRegistry.appendMenuItem(MenuId.DebugCallStackContext, {
-        group: 'inline',
-        order,
-        when,
-        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))));
-registerCallStackInlineMenuItem(PAUSE_ID, PAUSE_LABEL, debugPause, ( ContextKeyExpr.and(threadOrSessionWithOneThread, ( CONTEXT_CALLSTACK_ITEM_STOPPED.toNegated()))), 10);
-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);
-export { CallStackView, getContext, getContextForContributedActions, getSpecificSourceName };