@codingame/monaco-vscode-testing-service-override 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/contrib/testing/browser/testingOutputPeek.js

@@ -1,2091 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { append, $, reset, Dimension, scheduleAtNextAnimationFrame, getWindow } from 'vscode/vscode/vs/base/browser/dom';
-import { renderStringAsPlaintext } from 'vscode/vscode/vs/base/browser/markdownRenderer';
-import { ActionBar } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionbar';
-import { alert } from 'vscode/vscode/vs/base/browser/ui/aria/aria';
-import { renderLabelWithIcons } from 'vscode/vscode/vs/base/browser/ui/iconLabel/iconLabels';
-import { DomScrollableElement } from 'vscode/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
-import { SplitView, Sizing } from 'vscode/vscode/vs/base/browser/ui/splitview/splitview';
-import { Separator, Action } from 'vscode/vscode/vs/base/common/actions';
-import { Limiter, Delayer, RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
-import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
-import { Color } from 'vscode/vscode/vs/base/common/color';
-import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
-import { stripIcons } from 'vscode/vscode/vs/base/common/iconLabels';
-import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
-import { Lazy } from 'vscode/vscode/vs/base/common/lazy';
-import { DisposableStore, Disposable, MutableDisposable, toDisposable, combinedDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { count } from 'vscode/vscode/vs/base/common/strings';
-import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
-import { isDefined } from 'vscode/vscode/vs/base/common/types';
-import './testingOutputPeek.css.js';
-import { isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
-import { EditorAction2 } from 'vscode/vscode/vs/editor/browser/editorExtensions';
-import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
-import { CodeEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/codeEditorWidget';
-import { DiffEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/diffEditor/diffEditorWidget';
-import { EmbeddedCodeEditorWidget, EmbeddedDiffEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/embeddedCodeEditorWidget';
-import { Range } from 'vscode/vscode/vs/editor/common/core/range';
-import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
-import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
-import { MarkdownRenderer } from 'vscode/vscode/vs/editor/browser/widget/markdownRenderer/browser/markdownRenderer';
-import { PeekViewWidget, peekViewTitleForeground, peekViewTitleInfoForeground, IPeekViewService, peekViewResultsBackground } from 'vscode/vscode/vs/editor/contrib/peekView/browser/peekView';
-import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
-import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
-import { FloatingClickMenu } from 'vscode/vscode/vs/platform/actions/browser/floatingMenu';
-import { MenuEntryActionViewItem, createAndFillInActionBarActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
-import { MenuItemAction, Action2, MenuId, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/common/serviceCollection';
-import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
-import { WorkbenchCompressibleObjectTree } from 'vscode/vscode/vs/platform/list/browser/listService';
-import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
-import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
-import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { TerminalCapabilityStore } from 'vscode/vscode/vs/platform/terminal/common/capabilities/terminalCapabilityStore';
-import { formatMessageForTerminal } from 'vscode/vscode/vs/platform/terminal/common/terminalStrings';
-import { editorBackground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
-import { widgetClose } from 'vscode/vscode/vs/platform/theme/common/iconRegistry';
-import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-import { ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
-import { EditorModel } from 'vscode/vscode/vs/workbench/common/editor/editorModel';
-import { PANEL_BACKGROUND, SIDE_BAR_BACKGROUND } from 'vscode/vscode/vs/workbench/common/theme';
-import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
-import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
-import { DetachedProcessInfo } from 'vscode/vscode/vs/workbench/contrib/terminal/browser/detachedTerminal';
-import { ITerminalService } from 'vscode/vscode/vs/workbench/contrib/terminal/browser/terminal';
-import { getXtermScaledDimensions } from 'vscode/vscode/vs/workbench/contrib/terminal/browser/xterm/xtermTerminal';
-import { TERMINAL_BACKGROUND_COLOR } from 'vscode/vscode/vs/workbench/contrib/terminal/common/terminalColorRegistry';
-import { getTestItemContextOverlay } from './explorerProjections/testItemContextOverlay.js';
-import { testingStatesToIcons, testingRunIcon, testingDebugIcon, testingCoverageReport } from './icons.js';
-import { testingPeekBorder, testingMessagePeekBorder, testingPeekHeaderBackground, testingPeekMessageHeaderBackground } from './theme.js';
-import { getTestingConfiguration } from '../common/configuration.js';
-import { MutableObservableValue, staticObservableValue } from 'vscode/vscode/vs/workbench/contrib/testing/common/observableValue';
-import { StoredValue } from 'vscode/vscode/vs/workbench/contrib/testing/common/storedValue';
-import { ITestCoverageService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testCoverageService';
-import { ITestExplorerFilterState } from 'vscode/vscode/vs/workbench/contrib/testing/common/testExplorerFilterState';
-import { ITestProfileService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testProfileService';
-import { resultItemParents, LiveTestResult, maxCountPriority } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResult';
-import { ITestResultService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResultService';
-import { ITestService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testService';
-import { ITestMessage, getMarkId } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
-import { TestingContextKeys } from 'vscode/vscode/vs/workbench/contrib/testing/common/testingContextKeys';
-import { ITestingPeekOpener } from 'vscode/vscode/vs/workbench/contrib/testing/common/testingPeekOpener';
-import { isFailedState, cmpPriority } from 'vscode/vscode/vs/workbench/contrib/testing/common/testingStates';
-import { parseTestUri, buildTestUri } from '../common/testingUri.js';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { autorun } from 'vscode/vscode/vs/base/common/observableInternal/autorun';
-
-var TestingOutputPeekController_1, TestResultsViewContent_1, TestResultsPeek_1, TestRunElementRenderer_1;
-class MessageSubject {
-    get isDiffable() {
-        return this.message.type === 0  && isDiffable(this.message);
-    }
-    get contextValue() {
-        return this.message.type === 0  ? this.message.contextValue : undefined;
-    }
-    get context() {
-        return {
-            $mid: 18 ,
-            extId: this.test.extId,
-            message: ITestMessage.serialize(this.message),
-        };
-    }
-    constructor(result, test, taskIndex, messageIndex) {
-        this.result = result;
-        this.taskIndex = taskIndex;
-        this.messageIndex = messageIndex;
-        this.test = test.item;
-        const messages = test.tasks[taskIndex].messages;
-        this.messageIndex = messageIndex;
-        const parts = { messageIndex, resultId: result.id, taskIndex, testExtId: test.item.extId };
-        this.expectedUri = buildTestUri({ ...parts, type: 4  });
-        this.actualUri = buildTestUri({ ...parts, type: 3  });
-        this.messageUri = buildTestUri({ ...parts, type: 2  });
-        const message = this.message = messages[this.messageIndex];
-        this.revealLocation = message.location ?? (test.item.uri && test.item.range ? { uri: test.item.uri, range: Range.lift(test.item.range) } : undefined);
-    }
-}
-class TaskSubject {
-    constructor(result, taskIndex) {
-        this.result = result;
-        this.taskIndex = taskIndex;
-        this.outputUri = buildTestUri({ resultId: result.id, taskIndex, type: 0  });
-    }
-}
-class TestOutputSubject {
-    constructor(result, taskIndex, test) {
-        this.result = result;
-        this.taskIndex = taskIndex;
-        this.test = test;
-        this.outputUri = buildTestUri({ resultId: this.result.id, taskIndex: this.taskIndex, testExtId: this.test.item.extId, type: 1  });
-        this.task = result.tasks[this.taskIndex];
-    }
-}
-const equalsSubject = (a, b) => ((a instanceof MessageSubject && b instanceof MessageSubject && a.message === b.message) ||
-    (a instanceof TaskSubject && b instanceof TaskSubject && a.result === b.result && a.taskIndex === b.taskIndex) ||
-    (a instanceof TestOutputSubject && b instanceof TestOutputSubject && a.test === b.test && a.taskIndex === b.taskIndex));
-function* allMessages(results) {
-    for (const result of results) {
-        for (const test of result.tests) {
-            for (let taskIndex = 0; taskIndex < test.tasks.length; taskIndex++) {
-                for (let messageIndex = 0; messageIndex < test.tasks[taskIndex].messages.length; messageIndex++) {
-                    yield { result, test, taskIndex, messageIndex };
-                }
-            }
-        }
-    }
-}
-let TestingPeekOpener = class TestingPeekOpener extends Disposable {
-    constructor(configuration, editorService, codeEditorService, testResults, testService, storageService, viewsService, commandService, notificationService) {
-        super();
-        this.configuration = configuration;
-        this.editorService = editorService;
-        this.codeEditorService = codeEditorService;
-        this.testResults = testResults;
-        this.testService = testService;
-        this.storageService = storageService;
-        this.viewsService = viewsService;
-        this.commandService = commandService;
-        this.notificationService = notificationService;
-        this.historyVisible = MutableObservableValue.stored(this._register(( new StoredValue({
-            key: 'testHistoryVisibleInPeek',
-            scope: 0 ,
-            target: 0 ,
-        }, this.storageService))), false);
-        this._register(testResults.onTestChanged(this.openPeekOnFailure, this));
-    }
-    async open() {
-        let uri;
-        const active = this.editorService.activeTextEditorControl;
-        if (isCodeEditor(active) && active.getModel()?.uri) {
-            const modelUri = active.getModel()?.uri;
-            if (modelUri) {
-                uri = await this.getFileCandidateMessage(modelUri, active.getPosition());
-            }
-        }
-        if (!uri) {
-            uri = this.lastUri;
-        }
-        if (!uri) {
-            uri = this.getAnyCandidateMessage();
-        }
-        if (!uri) {
-            return false;
-        }
-        return this.showPeekFromUri(uri);
-    }
-    tryPeekFirstError(result, test, options) {
-        const candidate = this.getFailedCandidateMessage(test);
-        if (!candidate) {
-            return false;
-        }
-        this.showPeekFromUri({
-            type: 2 ,
-            documentUri: candidate.location.uri,
-            taskIndex: candidate.taskId,
-            messageIndex: candidate.index,
-            resultId: result.id,
-            testExtId: test.item.extId,
-        }, undefined, { selection: candidate.location.range, selectionRevealType: 3 , ...options });
-        return true;
-    }
-    peekUri(uri, options = {}) {
-        const parsed = parseTestUri(uri);
-        const result = parsed && this.testResults.getResult(parsed.resultId);
-        if (!parsed || !result || !('testExtId' in parsed)) {
-            return false;
-        }
-        if (!('messageIndex' in parsed)) {
-            return false;
-        }
-        const message = result.getStateById(parsed.testExtId)?.tasks[parsed.taskIndex].messages[parsed.messageIndex];
-        if (!message?.location) {
-            return false;
-        }
-        this.showPeekFromUri({
-            type: 2 ,
-            documentUri: message.location.uri,
-            taskIndex: parsed.taskIndex,
-            messageIndex: parsed.messageIndex,
-            resultId: result.id,
-            testExtId: parsed.testExtId,
-        }, options.inEditor, { selection: message.location.range, ...options.options });
-        return true;
-    }
-    closeAllPeeks() {
-        for (const editor of this.codeEditorService.listCodeEditors()) {
-            TestingOutputPeekController.get(editor)?.removePeek();
-        }
-    }
-    openCurrentInEditor() {
-        const current = this.getActiveControl();
-        if (!current) {
-            return;
-        }
-        const options = { pinned: false, revealIfOpened: true };
-        if (current instanceof TaskSubject || current instanceof TestOutputSubject) {
-            this.editorService.openEditor({ resource: current.outputUri, options });
-            return;
-        }
-        if (current instanceof TestOutputSubject) {
-            this.editorService.openEditor({ resource: current.outputUri, options });
-            return;
-        }
-        const message = current.message;
-        if (current.isDiffable) {
-            this.editorService.openEditor({
-                original: { resource: current.expectedUri },
-                modified: { resource: current.actualUri },
-                options,
-            });
-        }
-        else if (typeof message.message === 'string') {
-            this.editorService.openEditor({ resource: current.messageUri, options });
-        }
-        else {
-            this.commandService.executeCommand('markdown.showPreview', current.messageUri).catch(err => {
-                this.notificationService.error(( localizeWithPath(
-                    'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                    'testing.markdownPeekError',
-                    'Could not open markdown preview: {0}.\n\nPlease make sure the markdown extension is enabled.',
-                    err.message
-                )));
-            });
-        }
-    }
-    getActiveControl() {
-        const editor = getPeekedEditorFromFocus(this.codeEditorService);
-        const controller = editor && TestingOutputPeekController.get(editor);
-        return controller?.subject ?? this.viewsService.getActiveViewWithId("workbench.panel.testResults.view" )?.subject;
-    }
-    async showPeekFromUri(uri, editor, options) {
-        if (isCodeEditor(editor)) {
-            this.lastUri = uri;
-            TestingOutputPeekController.get(editor)?.show(buildTestUri(this.lastUri));
-            return true;
-        }
-        const pane = await this.editorService.openEditor({
-            resource: uri.documentUri,
-            options: { revealIfOpened: true, ...options }
-        });
-        const control = pane?.getControl();
-        if (!isCodeEditor(control)) {
-            return false;
-        }
-        this.lastUri = uri;
-        TestingOutputPeekController.get(control)?.show(buildTestUri(this.lastUri));
-        return true;
-    }
-    openPeekOnFailure(evt) {
-        if (evt.reason !== 1 ) {
-            return;
-        }
-        const candidate = this.getFailedCandidateMessage(evt.item);
-        if (!candidate) {
-            return;
-        }
-        if (evt.result.request.continuous && !getTestingConfiguration(this.configuration, "testing.automaticallyOpenPeekViewDuringAutoRun" )) {
-            return;
-        }
-        const editors = this.codeEditorService.listCodeEditors();
-        const cfg = getTestingConfiguration(this.configuration, "testing.automaticallyOpenPeekView" );
-        switch (cfg) {
-            case "failureInVisibleDocument" : {
-                const editorUris = ( new Set(( editors.map(e => e.getModel()?.uri.toString()))));
-                if (!( Iterable.some(resultItemParents(evt.result, evt.item), i => i.item.uri && ( editorUris.has(( i.item.uri.toString())))))) {
-                    return;
-                }
-                break;
-            }
-            case "failureAnywhere" :
-                break;
-            default:
-                return;
-        }
-        const controllers = ( editors.map(TestingOutputPeekController.get));
-        if (( controllers.some(c => c?.subject))) {
-            return;
-        }
-        this.tryPeekFirstError(evt.result, evt.item);
-    }
-    async getFileCandidateMessage(uri, position) {
-        let best;
-        let bestDistance = Infinity;
-        const demandedUriStr = ( uri.toString());
-        for (const test of this.testService.collection.all) {
-            const result = this.testResults.getStateById(test.item.extId);
-            if (!result) {
-                continue;
-            }
-            mapFindTestMessage(result[1], (_task, message, messageIndex, taskIndex) => {
-                if (message.type !== 0  || !message.location || ( message.location.uri.toString()) !== demandedUriStr) {
-                    return;
-                }
-                const distance = position ? Math.abs(position.lineNumber - message.location.range.startLineNumber) : 0;
-                if (!best || distance <= bestDistance) {
-                    bestDistance = distance;
-                    best = {
-                        type: 2 ,
-                        testExtId: result[1].item.extId,
-                        resultId: result[0].id,
-                        taskIndex,
-                        messageIndex,
-                        documentUri: uri,
-                    };
-                }
-            });
-        }
-        return best;
-    }
-    getAnyCandidateMessage() {
-        const seen = ( new Set());
-        for (const result of this.testResults.results) {
-            for (const test of result.tests) {
-                if (( seen.has(test.item.extId))) {
-                    continue;
-                }
-                seen.add(test.item.extId);
-                const found = mapFindTestMessage(test, (task, message, messageIndex, taskIndex) => (message.location && {
-                    type: 2 ,
-                    testExtId: test.item.extId,
-                    resultId: result.id,
-                    taskIndex,
-                    messageIndex,
-                    documentUri: message.location.uri,
-                }));
-                if (found) {
-                    return found;
-                }
-            }
-        }
-        return undefined;
-    }
-    getFailedCandidateMessage(test) {
-        const fallbackLocation = test.item.uri && test.item.range
-            ? { uri: test.item.uri, range: test.item.range }
-            : undefined;
-        let best;
-        mapFindTestMessage(test, (task, message, messageIndex, taskId) => {
-            const location = message.location || fallbackLocation;
-            if (!isFailedState(task.state) || !location) {
-                return;
-            }
-            if (best && message.type !== 0 ) {
-                return;
-            }
-            best = { taskId, index: messageIndex, message, location };
-        });
-        return best;
-    }
-};
-TestingPeekOpener = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IEditorService)),
-    ( __param(2, ICodeEditorService)),
-    ( __param(3, ITestResultService)),
-    ( __param(4, ITestService)),
-    ( __param(5, IStorageService)),
-    ( __param(6, IViewsService)),
-    ( __param(7, ICommandService)),
-    ( __param(8, INotificationService))
-], TestingPeekOpener));
-const mapFindTestMessage = (test, fn) => {
-    for (let taskIndex = 0; taskIndex < test.tasks.length; taskIndex++) {
-        const task = test.tasks[taskIndex];
-        for (let messageIndex = 0; messageIndex < task.messages.length; messageIndex++) {
-            const r = fn(task, task.messages[messageIndex], messageIndex, taskIndex);
-            if (r !== undefined) {
-                return r;
-            }
-        }
-    }
-    return undefined;
-};
-let TestingOutputPeekController = TestingOutputPeekController_1 = class TestingOutputPeekController extends Disposable {
-    static get(editor) {
-        return editor.getContribution("editor.contrib.testingOutputPeek" );
-    }
-    get subject() {
-        return this.peek.value?.current;
-    }
-    constructor(editor, codeEditorService, instantiationService, testResults, contextKeyService) {
-        super();
-        this.editor = editor;
-        this.codeEditorService = codeEditorService;
-        this.instantiationService = instantiationService;
-        this.testResults = testResults;
-        this.peek = this._register(( new MutableDisposable()));
-        this.visible = TestingContextKeys.isPeekVisible.bindTo(contextKeyService);
-        this._register(editor.onDidChangeModel(() => this.peek.clear()));
-        this._register(testResults.onResultsChanged(this.closePeekOnCertainResultEvents, this));
-        this._register(testResults.onTestChanged(this.closePeekOnTestChange, this));
-    }
-    toggle(uri) {
-        if (this.currentPeekUri?.toString() === ( uri.toString())) {
-            this.peek.clear();
-        }
-        else {
-            this.show(uri);
-        }
-    }
-    async show(uri) {
-        const subject = this.retrieveTest(uri);
-        if (!subject) {
-            return;
-        }
-        if (!this.peek.value) {
-            this.peek.value = this.instantiationService.createInstance(TestResultsPeek, this.editor);
-            this.peek.value.onDidClose(() => {
-                this.visible.set(false);
-                this.currentPeekUri = undefined;
-                this.peek.value = undefined;
-            });
-            this.visible.set(true);
-            this.peek.value.create();
-        }
-        if (subject instanceof MessageSubject) {
-            alert(renderStringAsPlaintext(subject.message.message));
-        }
-        this.peek.value.setModel(subject);
-        this.currentPeekUri = uri;
-    }
-    async openAndShow(uri) {
-        const subject = this.retrieveTest(uri);
-        if (!subject) {
-            return;
-        }
-        if (!subject.revealLocation || ( subject.revealLocation.uri.toString()) === this.editor.getModel()?.uri.toString()) {
-            return this.show(uri);
-        }
-        const otherEditor = await this.codeEditorService.openCodeEditor({
-            resource: subject.revealLocation.uri,
-            options: { pinned: false, revealIfOpened: true }
-        }, this.editor);
-        if (otherEditor) {
-            TestingOutputPeekController_1.get(otherEditor)?.removePeek();
-            return TestingOutputPeekController_1.get(otherEditor)?.show(uri);
-        }
-    }
-    removePeek() {
-        this.peek.clear();
-    }
-    next() {
-        const subject = this.peek.value?.current;
-        if (!subject) {
-            return;
-        }
-        let found = false;
-        for (const { messageIndex, taskIndex, result, test } of allMessages(this.testResults.results)) {
-            if (subject instanceof TaskSubject && result.id === subject.result.id) {
-                found = true;
-            }
-            if (found) {
-                this.openAndShow(buildTestUri({
-                    type: 2 ,
-                    messageIndex,
-                    taskIndex,
-                    resultId: result.id,
-                    testExtId: test.item.extId
-                }));
-                return;
-            }
-            if (subject instanceof TestOutputSubject && subject.test.item.extId === test.item.extId && subject.taskIndex === taskIndex && subject.result.id === result.id) {
-                found = true;
-            }
-            if (subject instanceof MessageSubject && subject.test.extId === test.item.extId && subject.messageIndex === messageIndex && subject.taskIndex === taskIndex && subject.result.id === result.id) {
-                found = true;
-            }
-        }
-    }
-    previous() {
-        const subject = this.peek.value?.current;
-        if (!subject) {
-            return;
-        }
-        let previous;
-        for (const m of allMessages(this.testResults.results)) {
-            if (subject instanceof TaskSubject) {
-                if (m.result.id === subject.result.id) {
-                    break;
-                }
-                continue;
-            }
-            if (subject instanceof TestOutputSubject) {
-                if (m.test.item.extId === subject.test.item.extId && m.result.id === subject.result.id && m.taskIndex === subject.taskIndex) {
-                    break;
-                }
-                continue;
-            }
-            if (subject.test.extId === m.test.item.extId && subject.messageIndex === m.messageIndex && subject.taskIndex === m.taskIndex && subject.result.id === m.result.id) {
-                break;
-            }
-            previous = m;
-        }
-        if (previous) {
-            this.openAndShow(buildTestUri({
-                type: 2 ,
-                messageIndex: previous.messageIndex,
-                taskIndex: previous.taskIndex,
-                resultId: previous.result.id,
-                testExtId: previous.test.item.extId
-            }));
-        }
-    }
-    removeIfPeekingForTest(testId) {
-        const c = this.peek.value?.current;
-        if (c && c instanceof MessageSubject && c.test.extId === testId) {
-            this.peek.clear();
-        }
-    }
-    closePeekOnTestChange(evt) {
-        if (evt.reason !== 1  || evt.previousState === evt.item.ownComputedState) {
-            return;
-        }
-        this.removeIfPeekingForTest(evt.item.item.extId);
-    }
-    closePeekOnCertainResultEvents(evt) {
-        if ('started' in evt) {
-            this.peek.clear();
-        }
-        if ('removed' in evt && this.testResults.results.length === 0) {
-            this.peek.clear();
-        }
-    }
-    retrieveTest(uri) {
-        const parts = parseTestUri(uri);
-        if (!parts) {
-            return undefined;
-        }
-        const result = this.testResults.results.find(r => r.id === parts.resultId);
-        if (!result) {
-            return;
-        }
-        if (parts.type === 0 ) {
-            return ( new TaskSubject(result, parts.taskIndex));
-        }
-        if (parts.type === 1 ) {
-            const test = result.getStateById(parts.testExtId);
-            if (!test) {
-                return;
-            }
-            return ( new TestOutputSubject(result, parts.taskIndex, test));
-        }
-        const { testExtId, taskIndex, messageIndex } = parts;
-        const test = result?.getStateById(testExtId);
-        if (!test || !test.tasks[parts.taskIndex]) {
-            return;
-        }
-        return ( new MessageSubject(result, test, taskIndex, messageIndex));
-    }
-};
-TestingOutputPeekController = TestingOutputPeekController_1 = ( __decorate([
-    ( __param(1, ICodeEditorService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, ITestResultService)),
-    ( __param(4, IContextKeyService))
-], TestingOutputPeekController));
-let TestResultsViewContent = class TestResultsViewContent extends Disposable {
-    static { TestResultsViewContent_1 = this; }
-    constructor(editor, options, instantiationService, modelService, contextKeyService) {
-        super();
-        this.editor = editor;
-        this.options = options;
-        this.instantiationService = instantiationService;
-        this.modelService = modelService;
-        this.contextKeyService = contextKeyService;
-        this.didReveal = this._register(( new Emitter()));
-        this.currentSubjectStore = this._register(( new DisposableStore()));
-        this.contentProvidersUpdateLimiter = this._register(( new Limiter(1)));
-    }
-    fillBody(containerElement) {
-        const initialSpitWidth = TestResultsViewContent_1.lastSplitWidth;
-        this.splitView = ( new SplitView(containerElement, { orientation: 1  }));
-        const { historyVisible, showRevealLocationOnMessages } = this.options;
-        const isInPeekView = this.editor !== undefined;
-        const messageContainer = this.messageContainer = append(containerElement, $('.test-output-peek-message-container'));
-        this.contentProviders = [
-            this._register(this.instantiationService.createInstance(DiffContentProvider, this.editor, messageContainer)),
-            this._register(this.instantiationService.createInstance(MarkdownTestMessagePeek, messageContainer)),
-            this._register(this.instantiationService.createInstance(TerminalMessagePeek, messageContainer, isInPeekView)),
-            this._register(this.instantiationService.createInstance(PlainTextMessagePeek, this.editor, messageContainer)),
-        ];
-        this.messageContextKeyService = this._register(this.contextKeyService.createScoped(this.messageContainer));
-        this.contextKeyTestMessage = TestingContextKeys.testMessageContext.bindTo(this.messageContextKeyService);
-        this.contextKeyResultOutdated = TestingContextKeys.testResultOutdated.bindTo(this.messageContextKeyService);
-        const treeContainer = append(containerElement, $('.test-output-peek-tree'));
-        const tree = this._register(this.instantiationService.createInstance(OutputPeekTree, treeContainer, this.didReveal.event, { showRevealLocationOnMessages, locationForProgress: this.options.locationForProgress }));
-        this.onDidRequestReveal = tree.onDidRequestReview;
-        this.splitView.addView({
-            onDidChange: Event.None,
-            element: messageContainer,
-            minimumSize: 200,
-            maximumSize: Number.MAX_VALUE,
-            layout: width => {
-                TestResultsViewContent_1.lastSplitWidth = width;
-                if (this.dimension) {
-                    for (const provider of this.contentProviders) {
-                        provider.layout({ height: this.dimension.height, width });
-                    }
-                }
-            },
-        }, Sizing.Distribute);
-        this.splitView.addView({
-            onDidChange: Event.None,
-            element: treeContainer,
-            minimumSize: 100,
-            maximumSize: Number.MAX_VALUE,
-            layout: width => {
-                if (this.dimension) {
-                    tree.layout(this.dimension.height, width);
-                }
-            },
-        }, Sizing.Distribute);
-        const historyViewIndex = 1;
-        this.splitView.setViewVisible(historyViewIndex, historyVisible.value);
-        this._register(historyVisible.onDidChange(visible => {
-            this.splitView.setViewVisible(historyViewIndex, visible);
-        }));
-        if (initialSpitWidth) {
-            queueMicrotask(() => this.splitView.resizeView(0, initialSpitWidth));
-        }
-    }
-    reveal(opts) {
-        this.didReveal.fire(opts);
-        if (this.current && equalsSubject(this.current, opts.subject)) {
-            return Promise.resolve();
-        }
-        this.current = opts.subject;
-        return this.contentProvidersUpdateLimiter.queue(async () => {
-            await Promise.all(( this.contentProviders.map(p => p.update(opts.subject))));
-            this.currentSubjectStore.clear();
-            this.populateFloatingClick(opts.subject);
-        });
-    }
-    populateFloatingClick(subject) {
-        if (!(subject instanceof MessageSubject)) {
-            return;
-        }
-        this.currentSubjectStore.add(toDisposable(() => {
-            this.contextKeyResultOutdated.reset();
-            this.contextKeyTestMessage.reset();
-        }));
-        this.contextKeyTestMessage.set(subject.contextValue || '');
-        if (subject.result instanceof LiveTestResult) {
-            this.contextKeyResultOutdated.set(subject.result.getStateById(subject.test.extId)?.retired ?? false);
-            this.currentSubjectStore.add(subject.result.onChange(ev => {
-                if (ev.item.item.extId === subject.test.extId) {
-                    this.contextKeyResultOutdated.set(ev.item.retired ?? false);
-                }
-            }));
-        }
-        else {
-            this.contextKeyResultOutdated.set(true);
-        }
-        this.currentSubjectStore.add(this.instantiationService
-            .createChild(( new ServiceCollection([IContextKeyService, this.messageContextKeyService])))
-            .createInstance(FloatingClickMenu, {
-            container: this.messageContainer,
-            menuId: MenuId.TestMessageContent,
-            getActionArg: () => subject.context,
-        }));
-    }
-    onLayoutBody(height, width) {
-        this.dimension = new Dimension(width, height);
-        this.splitView.layout(width);
-    }
-    onWidth(width) {
-        this.splitView.layout(width);
-    }
-};
-TestResultsViewContent = TestResultsViewContent_1 = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, ITextModelService)),
-    ( __param(4, IContextKeyService))
-], TestResultsViewContent));
-let TestResultsPeek = class TestResultsPeek extends PeekViewWidget {
-    static { TestResultsPeek_1 = this; }
-    constructor(editor, themeService, peekViewService, testingPeek, contextKeyService, menuService, instantiationService, modelService) {
-        super(editor, { showFrame: true, frameWidth: 1, showArrow: true, isResizeable: true, isAccessible: true, className: 'test-output-peek' }, instantiationService);
-        this.themeService = themeService;
-        this.testingPeek = testingPeek;
-        this.contextKeyService = contextKeyService;
-        this.menuService = menuService;
-        this.modelService = modelService;
-        this.visibilityChange = this._disposables.add(( new Emitter()));
-        this._disposables.add(themeService.onDidColorThemeChange(this.applyTheme, this));
-        this._disposables.add(this.onDidClose(() => this.visibilityChange.fire(false)));
-        peekViewService.addExclusiveWidget(editor, this);
-    }
-    applyTheme() {
-        const theme = this.themeService.getColorTheme();
-        const isError = this.current instanceof MessageSubject && this.current.message.type === 0 ;
-        const borderColor = (isError ? theme.getColor(testingPeekBorder) : theme.getColor(testingMessagePeekBorder)) || Color.transparent;
-        const headerBg = (isError ? theme.getColor(testingPeekHeaderBackground) : theme.getColor(testingPeekMessageHeaderBackground)) || Color.transparent;
-        const editorBg = theme.getColor(editorBackground);
-        this.style({
-            arrowColor: borderColor,
-            frameColor: borderColor,
-            headerBackgroundColor: editorBg && headerBg ? headerBg.makeOpaque(editorBg) : headerBg,
-            primaryHeadingColor: theme.getColor(peekViewTitleForeground),
-            secondaryHeadingColor: theme.getColor(peekViewTitleInfoForeground)
-        });
-    }
-    _fillContainer(container) {
-        if (!this.scopedContextKeyService) {
-            this.scopedContextKeyService = this._disposables.add(this.contextKeyService.createScoped(container));
-            TestingContextKeys.isInPeek.bindTo(this.scopedContextKeyService).set(true);
-            const instaService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService])));
-            this.content = this._disposables.add(instaService.createInstance(TestResultsViewContent, this.editor, { historyVisible: this.testingPeek.historyVisible, showRevealLocationOnMessages: false, locationForProgress: "workbench.panel.testResults.view"  }));
-        }
-        super._fillContainer(container);
-    }
-    _fillHead(container) {
-        super._fillHead(container);
-        const actions = [];
-        const menu = this.menuService.createMenu(MenuId.TestPeekTitle, this.contextKeyService);
-        createAndFillInActionBarActions(menu, undefined, actions);
-        this._actionbarWidget.push(actions, { label: false, icon: true, index: 0 });
-        menu.dispose();
-    }
-    _fillBody(containerElement) {
-        this.content.fillBody(containerElement);
-        this.content.onDidRequestReveal(sub => {
-            TestingOutputPeekController.get(this.editor)?.show(sub instanceof MessageSubject
-                ? sub.messageUri
-                : sub.outputUri);
-        });
-    }
-    setModel(subject) {
-        if (subject instanceof TaskSubject || subject instanceof TestOutputSubject) {
-            this.current = subject;
-            return this.showInPlace(subject);
-        }
-        const message = subject.message;
-        const previous = this.current;
-        if (!subject.revealLocation && !previous) {
-            return Promise.resolve();
-        }
-        this.current = subject;
-        if (!subject.revealLocation) {
-            return this.showInPlace(subject);
-        }
-        this.show(subject.revealLocation.range, TestResultsPeek_1.lastHeightInLines || hintMessagePeekHeight(message));
-        const startPosition = subject.revealLocation.range.getStartPosition();
-        this.editor.revealRangeNearTopIfOutsideViewport(Range.fromPositions(startPosition), 0 );
-        return this.showInPlace(subject);
-    }
-    async showInPlace(subject) {
-        if (subject instanceof MessageSubject) {
-            const message = subject.message;
-            this.setTitle(firstLine(renderStringAsPlaintext(message.message)), stripIcons(subject.test.label));
-        }
-        else {
-            this.setTitle(( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                'testOutputTitle',
-                'Test Output'
-            )));
-        }
-        this.applyTheme();
-        await this.content.reveal({ subject: subject, preserveFocus: false });
-    }
-    _relayout(newHeightInLines) {
-        super._relayout(newHeightInLines);
-        TestResultsPeek_1.lastHeightInLines = newHeightInLines;
-    }
-    _doLayoutBody(height, width) {
-        super._doLayoutBody(height, width);
-        this.content.onLayoutBody(height, width);
-    }
-    _onWidth(width) {
-        super._onWidth(width);
-        if (this.dimension) {
-            this.dimension = new Dimension(width, this.dimension.height);
-        }
-        this.content.onWidth(width);
-    }
-};
-TestResultsPeek = TestResultsPeek_1 = ( __decorate([
-    ( __param(1, IThemeService)),
-    ( __param(2, IPeekViewService)),
-    ( __param(3, ITestingPeekOpener)),
-    ( __param(4, IContextKeyService)),
-    ( __param(5, IMenuService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, ITextModelService))
-], TestResultsPeek));
-let TestResultsView = class TestResultsView extends ViewPane {
-    constructor(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, resultService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
-        this.resultService = resultService;
-        this.content = ( new Lazy(
-            () => this._register(this.instantiationService.createInstance(TestResultsViewContent, undefined, {
-                historyVisible: staticObservableValue(true),
-                showRevealLocationOnMessages: true,
-                locationForProgress: "workbench.view.testing" ,
-            }))
-        ));
-    }
-    get subject() {
-        return this.content.rawValue?.current;
-    }
-    showLatestRun(preserveFocus = false) {
-        const result = this.resultService.results.find(r => r.tasks.length);
-        if (!result) {
-            return;
-        }
-        this.content.rawValue?.reveal({ preserveFocus, subject: ( new TaskSubject(result, 0)) });
-    }
-    renderBody(container) {
-        super.renderBody(container);
-        if (this.isBodyVisible()) {
-            this.renderContent(container);
-        }
-        else {
-            this._register(Event.once(Event.filter(this.onDidChangeBodyVisibility, Boolean))(() => this.renderContent(container)));
-        }
-    }
-    layoutBody(height, width) {
-        super.layoutBody(height, width);
-        this.content.rawValue?.onLayoutBody(height, width);
-    }
-    renderContent(container) {
-        const content = this.content.value;
-        content.fillBody(container);
-        content.onDidRequestReveal(subject => content.reveal({ preserveFocus: true, subject }));
-        const [lastResult] = this.resultService.results;
-        if (lastResult && lastResult.tasks.length) {
-            content.reveal({ preserveFocus: true, subject: ( new TaskSubject(lastResult, 0)) });
-        }
-    }
-};
-TestResultsView = ( __decorate([
-    ( __param(1, IKeybindingService)),
-    ( __param(2, IContextMenuService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IContextKeyService)),
-    ( __param(5, IViewDescriptorService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, IOpenerService)),
-    ( __param(8, IThemeService)),
-    ( __param(9, ITelemetryService)),
-    ( __param(10, ITestResultService))
-], TestResultsView));
-const commonEditorOptions = {
-    scrollBeyondLastLine: false,
-    links: true,
-    lineNumbers: 'off',
-    scrollbar: {
-        verticalScrollbarSize: 14,
-        horizontal: 'auto',
-        useShadows: true,
-        verticalHasArrows: false,
-        horizontalHasArrows: false,
-        alwaysConsumeMouseWheel: false
-    },
-    fixedOverflowWidgets: true,
-    readOnly: true,
-    minimap: {
-        enabled: false
-    },
-    wordWrap: 'on',
-};
-const diffEditorOptions = {
-    ...commonEditorOptions,
-    enableSplitViewResizing: true,
-    isInEmbeddedEditor: true,
-    renderOverviewRuler: false,
-    ignoreTrimWhitespace: false,
-    renderSideBySide: true,
-    useInlineViewWhenSpaceIsLimited: false,
-    originalAriaLabel: ( localizeWithPath(
-        'vs/workbench/contrib/testing/browser/testingOutputPeek',
-        'testingOutputExpected',
-        'Expected result'
-    )),
-    modifiedAriaLabel: ( localizeWithPath(
-        'vs/workbench/contrib/testing/browser/testingOutputPeek',
-        'testingOutputActual',
-        'Actual result'
-    )),
-    diffAlgorithm: 'advanced',
-};
-const isDiffable = (message) => message.type === 0  && message.actual !== undefined && message.expected !== undefined;
-let DiffContentProvider = class DiffContentProvider extends Disposable {
-    constructor(editor, container, instantiationService, modelService) {
-        super();
-        this.editor = editor;
-        this.container = container;
-        this.instantiationService = instantiationService;
-        this.modelService = modelService;
-        this.widget = this._register(( new MutableDisposable()));
-        this.model = this._register(( new MutableDisposable()));
-    }
-    async update(subject) {
-        if (!(subject instanceof MessageSubject)) {
-            return this.clear();
-        }
-        const message = subject.message;
-        if (!isDiffable(message)) {
-            return this.clear();
-        }
-        const [original, modified] = await Promise.all([
-            this.modelService.createModelReference(subject.expectedUri),
-            this.modelService.createModelReference(subject.actualUri),
-        ]);
-        const model = this.model.value = ( new SimpleDiffEditorModel(original, modified));
-        if (!this.widget.value) {
-            this.widget.value = this.editor ? this.instantiationService.createInstance(EmbeddedDiffEditorWidget, this.container, diffEditorOptions, {}, this.editor) : this.instantiationService.createInstance(DiffEditorWidget, this.container, diffEditorOptions, {});
-            if (this.dimension) {
-                this.widget.value.layout(this.dimension);
-            }
-        }
-        this.widget.value.setModel(model);
-        this.widget.value.updateOptions(this.getOptions(isMultiline(message.expected) || isMultiline(message.actual)));
-    }
-    clear() {
-        this.model.clear();
-        this.widget.clear();
-    }
-    layout(dimensions) {
-        this.dimension = dimensions;
-        this.widget.value?.layout(dimensions);
-    }
-    getOptions(isMultiline) {
-        return isMultiline
-            ? { ...diffEditorOptions, lineNumbers: 'on' }
-            : { ...diffEditorOptions, lineNumbers: 'off' };
-    }
-};
-DiffContentProvider = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, ITextModelService))
-], DiffContentProvider));
-class ScrollableMarkdownMessage extends Disposable {
-    constructor(container, markdown, message) {
-        super();
-        const rendered = this._register(markdown.render(message, {}));
-        rendered.element.style.height = '100%';
-        rendered.element.style.userSelect = 'text';
-        container.appendChild(rendered.element);
-        this.element = rendered.element;
-        this.scrollable = this._register(( new DomScrollableElement(rendered.element, {
-            className: 'preview-text',
-        })));
-        container.appendChild(this.scrollable.getDomNode());
-        this._register(toDisposable(() => {
-            container.removeChild(this.scrollable.getDomNode());
-        }));
-        this.scrollable.scanDomNode();
-    }
-    layout(height, width) {
-        this.scrollable.setScrollDimensions({
-            width: width - 32,
-            height: height - 16,
-            scrollWidth: this.element.scrollWidth,
-            scrollHeight: this.element.scrollHeight
-        });
-    }
-}
-let MarkdownTestMessagePeek = class MarkdownTestMessagePeek extends Disposable {
-    constructor(container, instantiationService) {
-        super();
-        this.container = container;
-        this.instantiationService = instantiationService;
-        this.markdown = ( new Lazy(
-            () => this._register(this.instantiationService.createInstance(MarkdownRenderer, {}))
-        ));
-        this.textPreview = this._register(( new MutableDisposable()));
-    }
-    update(subject) {
-        if (!(subject instanceof MessageSubject)) {
-            return this.textPreview.clear();
-        }
-        const message = subject.message;
-        if (isDiffable(message) || typeof message.message === 'string') {
-            return this.textPreview.clear();
-        }
-        this.textPreview.value = ( new ScrollableMarkdownMessage(this.container, this.markdown.value, message.message));
-    }
-    layout(dimension) {
-        this.textPreview.value?.layout(dimension.height, dimension.width);
-    }
-};
-MarkdownTestMessagePeek = ( __decorate([
-    ( __param(1, IInstantiationService))
-], MarkdownTestMessagePeek));
-let PlainTextMessagePeek = class PlainTextMessagePeek extends Disposable {
-    constructor(editor, container, instantiationService, modelService) {
-        super();
-        this.editor = editor;
-        this.container = container;
-        this.instantiationService = instantiationService;
-        this.modelService = modelService;
-        this.widget = this._register(( new MutableDisposable()));
-        this.model = this._register(( new MutableDisposable()));
-    }
-    async update(subject) {
-        if (!(subject instanceof MessageSubject)) {
-            return this.clear();
-        }
-        const message = subject.message;
-        if (isDiffable(message) || message.type === 1  || typeof message.message !== 'string') {
-            return this.clear();
-        }
-        const modelRef = this.model.value = await this.modelService.createModelReference(subject.messageUri);
-        if (!this.widget.value) {
-            this.widget.value = this.editor ? this.instantiationService.createInstance(EmbeddedCodeEditorWidget, this.container, commonEditorOptions, {}, this.editor) : this.instantiationService.createInstance(CodeEditorWidget, this.container, commonEditorOptions, { isSimpleWidget: true });
-            if (this.dimension) {
-                this.widget.value.layout(this.dimension);
-            }
-        }
-        this.widget.value.setModel(modelRef.object.textEditorModel);
-        this.widget.value.updateOptions(commonEditorOptions);
-    }
-    clear() {
-        this.model.clear();
-        this.widget.clear();
-    }
-    layout(dimensions) {
-        this.dimension = dimensions;
-        this.widget.value?.layout(dimensions);
-    }
-};
-PlainTextMessagePeek = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, ITextModelService))
-], PlainTextMessagePeek));
-let TerminalMessagePeek = class TerminalMessagePeek extends Disposable {
-    constructor(container, isInPeekView, terminalService, viewDescriptorService, workspaceContext) {
-        super();
-        this.container = container;
-        this.isInPeekView = isInPeekView;
-        this.terminalService = terminalService;
-        this.viewDescriptorService = viewDescriptorService;
-        this.workspaceContext = workspaceContext;
-        this.terminalCwd = this._register(( new MutableObservableValue('')));
-        this.xtermLayoutDelayer = this._register(( new Delayer(50)));
-        this.terminal = this._register(( new MutableDisposable()));
-        this.outputDataListener = this._register(( new MutableDisposable()));
-    }
-    async makeTerminal() {
-        const prev = this.terminal.value;
-        if (prev) {
-            prev.xterm.clearBuffer();
-            prev.xterm.clearSearchDecorations();
-            prev.xterm.write(`\x1b[2J\x1b[0;0H`);
-            return prev;
-        }
-        const capabilities = ( new TerminalCapabilityStore());
-        const cwd = this.terminalCwd;
-        capabilities.add(0 , {
-            type: 0 ,
-            get cwds() { return [cwd.value]; },
-            onDidChangeCwd: cwd.onDidChange,
-            getCwd: () => cwd.value,
-            updateCwd: () => { },
-        });
-        return this.terminal.value = await this.terminalService.createDetachedTerminal({
-            rows: 10,
-            cols: 80,
-            readonly: true,
-            capabilities,
-            processInfo: ( new DetachedProcessInfo({ initialCwd: cwd.value })),
-            colorProvider: {
-                getBackgroundColor: theme => {
-                    const terminalBackground = theme.getColor(TERMINAL_BACKGROUND_COLOR);
-                    if (terminalBackground) {
-                        return terminalBackground;
-                    }
-                    if (this.isInPeekView) {
-                        return theme.getColor(peekViewResultsBackground);
-                    }
-                    const location = this.viewDescriptorService.getViewLocationById("workbench.panel.testResults.view" );
-                    return location === 1
-                        ? theme.getColor(PANEL_BACKGROUND)
-                        : theme.getColor(SIDE_BAR_BACKGROUND);
-                },
-            }
-        });
-    }
-    async update(subject) {
-        this.outputDataListener.clear();
-        if (subject instanceof TaskSubject) {
-            await this.updateForTaskSubject(subject);
-        }
-        else if (subject instanceof TestOutputSubject || ((subject instanceof MessageSubject && subject.message.type === 1) )) {
-            await this.updateForTestSubject(subject);
-        }
-        else {
-            this.clear();
-        }
-    }
-    async updateForTestSubject(subject) {
-        const that = this;
-        const testItem = subject instanceof TestOutputSubject ? subject.test.item : subject.test;
-        const terminal = await this.updateGenerically({
-            subject,
-            noOutputMessage: ( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                'caseNoOutput',
-                'The test case did not report any output.'
-            )),
-            getTarget: result => result?.tasks[subject.taskIndex].output,
-            *doInitialWrite(output, results) {
-                that.updateCwd(testItem.uri);
-                const state = subject instanceof TestOutputSubject ? subject.test : results.getStateById(testItem.extId);
-                if (!state) {
-                    return;
-                }
-                for (const message of state.tasks[subject.taskIndex].messages) {
-                    if (message.type === 1 ) {
-                        yield* output.getRangeIter(message.offset, message.length);
-                    }
-                }
-            },
-            doListenForMoreData: (output, result, write) => result.onChange(e => {
-                if (e.reason === 2  && e.item.item.extId === testItem.extId && e.message.type === 1 ) {
-                    for (const chunk of output.getRangeIter(e.message.offset, e.message.length)) {
-                        write(chunk.buffer);
-                    }
-                }
-            }),
-        });
-        if (subject instanceof MessageSubject && subject.message.type === 1  && subject.message.marker !== undefined) {
-            terminal?.xterm.selectMarkedRange(getMarkId(subject.message.marker, true), getMarkId(subject.message.marker, false),  true);
-        }
-    }
-    updateForTaskSubject(subject) {
-        return this.updateGenerically({
-            subject,
-            noOutputMessage: ( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                'runNoOutput',
-                'The test run did not record any output.'
-            )),
-            getTarget: result => result?.tasks[subject.taskIndex],
-            doInitialWrite: (task, result) => {
-                this.updateCwd(Iterable.find(result.tests, t => !!t.item.uri)?.item.uri);
-                return task.output.buffers;
-            },
-            doListenForMoreData: (task, _result, write) => task.output.onDidWriteData(e => write(e.buffer)),
-        });
-    }
-    async updateGenerically(opts) {
-        const result = opts.subject.result;
-        const target = opts.getTarget(result);
-        if (!target) {
-            return this.clear();
-        }
-        const terminal = await this.makeTerminal();
-        let didWriteData = false;
-        const pendingWrites = ( new MutableObservableValue(0));
-        if (result instanceof LiveTestResult) {
-            for (const chunk of opts.doInitialWrite(target, result)) {
-                didWriteData ||= chunk.byteLength > 0;
-                pendingWrites.value++;
-                terminal.xterm.write(chunk.buffer, () => pendingWrites.value--);
-            }
-        }
-        else {
-            didWriteData = true;
-            this.writeNotice(terminal, ( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                'runNoOutputForPast',
-                'Test output is only available for new test runs.'
-            )));
-        }
-        this.attachTerminalToDom(terminal);
-        this.outputDataListener.clear();
-        if (result instanceof LiveTestResult && !result.completedAt) {
-            const l1 = result.onComplete(() => {
-                if (!didWriteData) {
-                    this.writeNotice(terminal, opts.noOutputMessage);
-                }
-            });
-            const l2 = opts.doListenForMoreData(target, result, data => {
-                terminal.xterm.write(data);
-                didWriteData ||= data.byteLength > 0;
-            });
-            this.outputDataListener.value = combinedDisposable(l1, l2);
-        }
-        if (!this.outputDataListener.value && !didWriteData) {
-            this.writeNotice(terminal, opts.noOutputMessage);
-        }
-        if (pendingWrites.value > 0) {
-            await ( new Promise(resolve => {
-                const l = pendingWrites.onDidChange(() => {
-                    if (pendingWrites.value === 0) {
-                        l.dispose();
-                        resolve();
-                    }
-                });
-            }));
-        }
-        return terminal;
-    }
-    updateCwd(testUri) {
-        const wf = (testUri && this.workspaceContext.getWorkspaceFolder(testUri))
-            || this.workspaceContext.getWorkspace().folders[0];
-        if (wf) {
-            this.terminalCwd.value = wf.uri.fsPath;
-        }
-    }
-    writeNotice(terminal, str) {
-        terminal.xterm.write(formatMessageForTerminal(str));
-    }
-    attachTerminalToDom(terminal) {
-        terminal.xterm.write('\x1b[?25l');
-        scheduleAtNextAnimationFrame(getWindow(this.container), () => this.layoutTerminal(terminal));
-        terminal.attachToElement(this.container, { enableGpu: false });
-    }
-    clear() {
-        this.outputDataListener.clear();
-        this.xtermLayoutDelayer.cancel();
-        this.terminal.clear();
-    }
-    layout(dimensions) {
-        this.dimensions = dimensions;
-        if (this.terminal.value) {
-            this.layoutTerminal(this.terminal.value, dimensions.width, dimensions.height);
-        }
-    }
-    layoutTerminal({ xterm }, width = this.dimensions?.width ?? this.container.clientWidth, height = this.dimensions?.height ?? this.container.clientHeight) {
-        width -= 10 + 20;
-        this.xtermLayoutDelayer.trigger(() => {
-            const scaled = getXtermScaledDimensions(getWindow(this.container), xterm.getFont(), width, height);
-            if (scaled) {
-                xterm.resize(scaled.cols, scaled.rows);
-            }
-        });
-    }
-};
-TerminalMessagePeek = ( __decorate([
-    ( __param(2, ITerminalService)),
-    ( __param(3, IViewDescriptorService)),
-    ( __param(4, IWorkspaceContextService))
-], TerminalMessagePeek));
-const hintMessagePeekHeight = (msg) => {
-    const msgHeight = isDiffable(msg)
-        ? Math.max(hintPeekStrHeight(msg.actual), hintPeekStrHeight(msg.expected))
-        : hintPeekStrHeight(typeof msg.message === 'string' ? msg.message : msg.message.value);
-    return msgHeight + 8;
-};
-const firstLine = (str) => {
-    const index = str.indexOf('\n');
-    return index === -1 ? str : str.slice(0, index);
-};
-const isMultiline = (str) => !!str && str.includes('\n');
-const hintPeekStrHeight = (str) => Math.min(count(str, '\n'), 24);
-class SimpleDiffEditorModel extends EditorModel {
-    constructor(_original, _modified) {
-        super();
-        this._original = _original;
-        this._modified = _modified;
-        this.original = this._original.object.textEditorModel;
-        this.modified = this._modified.object.textEditorModel;
-    }
-    dispose() {
-        super.dispose();
-        this._original.dispose();
-        this._modified.dispose();
-    }
-}
-function getOuterEditorFromDiffEditor(codeEditorService) {
-    const diffEditors = codeEditorService.listDiffEditors();
-    for (const diffEditor of diffEditors) {
-        if (diffEditor.hasTextFocus() && diffEditor instanceof EmbeddedDiffEditorWidget) {
-            return diffEditor.getParentEditor();
-        }
-    }
-    return null;
-}
-class CloseTestPeek extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'editor.closeTestPeek',
-            title: ( localizeWithPath('vs/workbench/contrib/testing/browser/testingOutputPeek', 'close', 'Close')),
-            icon: Codicon.close,
-            precondition: ( ContextKeyExpr.or(TestingContextKeys.isInPeek, TestingContextKeys.isPeekVisible)),
-            keybinding: {
-                weight: 100  - 101,
-                primary: 9 ,
-                when: ContextKeyExpr.not('config.editor.stablePeek')
-            }
-        });
-    }
-    runEditorCommand(accessor, editor) {
-        const parent = getPeekedEditorFromFocus(accessor.get(ICodeEditorService));
-        TestingOutputPeekController.get(parent ?? editor)?.removePeek();
-    }
-}
-class TestResultElement {
-    get icon() {
-        return testingStatesToIcons.get(this.value.completedAt === undefined
-            ? 2
-            : maxCountPriority(this.value.counts));
-    }
-    constructor(value) {
-        this.value = value;
-        this.changeEmitter = ( new Emitter());
-        this.onDidChange = this.changeEmitter.event;
-        this.type = 'result';
-        this.context = this.value.id;
-        this.id = this.value.id;
-        this.label = this.value.name;
-    }
-}
-const openCoverageLabel = ( localizeWithPath(
-    'vs/workbench/contrib/testing/browser/testingOutputPeek',
-    'openTestCoverage',
-    'View Test Coverage'
-));
-const closeCoverageLabel = ( localizeWithPath(
-    'vs/workbench/contrib/testing/browser/testingOutputPeek',
-    'closeTestCoverage',
-    'Close Test Coverage'
-));
-class CoverageElement {
-    get label() {
-        return this.isOpen ? closeCoverageLabel : openCoverageLabel;
-    }
-    get icon() {
-        return this.isOpen ? widgetClose : testingCoverageReport;
-    }
-    get isOpen() {
-        return this.coverageService.selected.get()?.fromTaskId === this.task.id;
-    }
-    constructor(results, task, coverageService) {
-        this.results = results;
-        this.task = task;
-        this.coverageService = coverageService;
-        this.type = 'coverage';
-        this.id = `coverage-${this.results.id}/${this.task.id}`;
-        this.onDidChange = Event.fromObservableLight(coverageService.selected);
-    }
-}
-class TestCaseElement {
-    get onDidChange() {
-        if (!(this.results instanceof LiveTestResult)) {
-            return Event.None;
-        }
-        return Event.filter(this.results.onChange, e => e.item.item.extId === this.test.item.extId);
-    }
-    get state() {
-        return this.test.tasks[this.taskIndex].state;
-    }
-    get label() {
-        return this.test.item.label;
-    }
-    get labelWithIcons() {
-        return renderLabelWithIcons(this.label);
-    }
-    get icon() {
-        return testingStatesToIcons.get(this.state);
-    }
-    get outputSubject() {
-        return ( new TestOutputSubject(this.results, this.taskIndex, this.test));
-    }
-    constructor(results, test, taskIndex) {
-        this.results = results;
-        this.test = test;
-        this.taskIndex = taskIndex;
-        this.type = 'test';
-        this.context = this.test.item.extId;
-        this.id = `${this.results.id}/${this.test.item.extId}`;
-    }
-}
-class TaskElement {
-    get icon() {
-        return this.results.tasks[this.index].running ? testingStatesToIcons.get(2 ) : undefined;
-    }
-    constructor(results, task, index) {
-        this.results = results;
-        this.task = task;
-        this.index = index;
-        this.changeEmitter = ( new Emitter());
-        this.onDidChange = this.changeEmitter.event;
-        this.type = 'task';
-        this.itemsCache = ( new CreationCache());
-        this.id = `${results.id}/${index}`;
-        this.task = results.tasks[index];
-        this.context = String(index);
-        this.label = this.task.name ?? ( localizeWithPath(
-            'vs/workbench/contrib/testing/browser/testingOutputPeek',
-            'testUnnamedTask',
-            'Unnamed Task'
-        ));
-    }
-}
-class TestMessageElement {
-    get onDidChange() {
-        if (!(this.result instanceof LiveTestResult)) {
-            return Event.None;
-        }
-        return Event.filter(this.result.onChange, e => e.item.item.extId === this.test.item.extId);
-    }
-    get context() {
-        return {
-            $mid: 18 ,
-            extId: this.test.item.extId,
-            message: ITestMessage.serialize(this.message),
-        };
-    }
-    constructor(result, test, taskIndex, messageIndex) {
-        this.result = result;
-        this.test = test;
-        this.taskIndex = taskIndex;
-        this.messageIndex = messageIndex;
-        this.type = 'message';
-        const m = this.message = test.tasks[taskIndex].messages[messageIndex];
-        this.location = m.location;
-        this.contextValue = m.type === 0  ? m.contextValue : undefined;
-        this.uri = buildTestUri({
-            type: 2 ,
-            messageIndex,
-            resultId: result.id,
-            taskIndex,
-            testExtId: test.item.extId
-        });
-        this.id = ( this.uri.toString());
-        const asPlaintext = renderStringAsPlaintext(m.message);
-        const lines = count(asPlaintext.trimEnd(), '\n');
-        this.label = firstLine(asPlaintext);
-        if (lines > 0) {
-            this.description = lines > 1
-                ? ( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                'messageMoreLinesN',
-                '+ {0} more lines',
-                lines
-            ))
-                : ( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                'messageMoreLines1',
-                '+ 1 more line'
-            ));
-        }
-    }
-}
-let OutputPeekTree = class OutputPeekTree extends Disposable {
-    constructor(container, onDidReveal, options, contextMenuService, results, instantiationService, explorerFilter, coverageService, progressService) {
-        super();
-        this.contextMenuService = contextMenuService;
-        this.disposed = false;
-        this.requestReveal = this._register(( new Emitter()));
-        this.onDidRequestReview = this.requestReveal.event;
-        this.treeActions = instantiationService.createInstance(TreeActionsProvider, options.showRevealLocationOnMessages, this.requestReveal);
-        const diffIdentityProvider = {
-            getId(e) {
-                return e.id;
-            }
-        };
-        this.tree = this._register(instantiationService.createInstance(WorkbenchCompressibleObjectTree, 'Test Output Peek', container, {
-            getHeight: () => 22,
-            getTemplateId: () => TestRunElementRenderer.ID,
-        }, [instantiationService.createInstance(TestRunElementRenderer, this.treeActions)], {
-            compressionEnabled: true,
-            hideTwistiesOfChildlessElements: true,
-            identityProvider: diffIdentityProvider,
-            sorter: {
-                compare(a, b) {
-                    if (a instanceof TestCaseElement && b instanceof TestCaseElement) {
-                        return cmpPriority(a.state, b.state);
-                    }
-                    return 0;
-                },
-            },
-            accessibilityProvider: {
-                getAriaLabel(element) {
-                    return element.ariaLabel || element.label;
-                },
-                getWidgetAriaLabel() {
-                    return ( localizeWithPath(
-                        'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                        'testingPeekLabel',
-                        'Test Result Messages'
-                    ));
-                }
-            }
-        }));
-        const cc = ( new CreationCache());
-        const getTaskChildren = (taskElem) => {
-            const { results, index, itemsCache, task } = taskElem;
-            const tests = Iterable.filter(results.tests, test => test.tasks[index].state >= 2  || test.tasks[index].messages.length > 0);
-            let result = ( Iterable.map(tests, test => ({
-                element: itemsCache.getOrCreate(test, () => ( new TestCaseElement(results, test, index))),
-                incompressible: true,
-                children: getTestChildren(results, test, index),
-            })));
-            if (task.coverage.get()) {
-                result = Iterable.concat(Iterable.single({
-                    element: ( new CoverageElement(results, task, coverageService)),
-                }), result);
-            }
-            return result;
-        };
-        const getTestChildren = (result, test, taskIndex) => {
-            return ( test.tasks[taskIndex].messages
-                .map((m, messageIndex) => m.type === 0
-                ? { element: cc.getOrCreate(m, () => ( new TestMessageElement(result, test, taskIndex, messageIndex))), incompressible: false }
-                : undefined))
-                .filter(isDefined);
-        };
-        const getResultChildren = (result) => {
-            return ( result.tasks.map((task, taskIndex) => {
-                const taskElem = cc.getOrCreate(task, () => ( new TaskElement(result, task, taskIndex)));
-                return ({
-                    element: taskElem,
-                    incompressible: false,
-                    children: getTaskChildren(taskElem),
-                });
-            }));
-        };
-        const getRootChildren = () => ( results.results.map(result => {
-            const element = cc.getOrCreate(result, () => ( new TestResultElement(result)));
-            return {
-                element,
-                incompressible: true,
-                collapsed: this.tree.hasElement(element) ? this.tree.isCollapsed(element) : true,
-                children: getResultChildren(result)
-            };
-        }));
-        const taskChildrenToUpdate = ( new Set());
-        const taskChildrenUpdate = this._register(( new RunOnceScheduler(() => {
-            for (const taskNode of taskChildrenToUpdate) {
-                if (this.tree.hasElement(taskNode)) {
-                    this.tree.setChildren(taskNode, getTaskChildren(taskNode), { diffIdentityProvider });
-                }
-            }
-            taskChildrenToUpdate.clear();
-        }, 300)));
-        const queueTaskChildrenUpdate = (taskNode) => {
-            taskChildrenToUpdate.add(taskNode);
-            if (!taskChildrenUpdate.isScheduled()) {
-                taskChildrenUpdate.schedule();
-            }
-        };
-        const attachToResults = (result) => {
-            const resultNode = cc.get(result);
-            const disposable = ( new DisposableStore());
-            disposable.add(result.onNewTask(i => {
-                if (result.tasks.length === 1) {
-                    this.requestReveal.fire(( new TaskSubject(result, 0)));
-                }
-                if (this.tree.hasElement(resultNode)) {
-                    this.tree.setChildren(resultNode, getResultChildren(result), { diffIdentityProvider });
-                }
-                const task = result.tasks[i];
-                disposable.add(autorun(reader => {
-                    task.coverage.read(reader);
-                    queueTaskChildrenUpdate(cc.get(task));
-                }));
-            }));
-            disposable.add(result.onEndTask(index => {
-                cc.get(result.tasks[index])?.changeEmitter.fire();
-            }));
-            disposable.add(result.onChange(e => {
-                for (const [index, task] of result.tasks.entries()) {
-                    const taskNode = cc.get(task);
-                    if (!this.tree.hasElement(taskNode)) {
-                        continue;
-                    }
-                    const itemNode = taskNode.itemsCache.get(e.item);
-                    if (itemNode && this.tree.hasElement(itemNode)) {
-                        if (e.reason === 2  && e.message.type === 0 ) {
-                            this.tree.setChildren(itemNode, getTestChildren(result, e.item, index), { diffIdentityProvider });
-                        }
-                        return;
-                    }
-                    queueTaskChildrenUpdate(taskNode);
-                }
-            }));
-            disposable.add(result.onComplete(() => {
-                resultNode.changeEmitter.fire();
-                disposable.dispose();
-            }));
-            return resultNode;
-        };
-        this._register(results.onResultsChanged(e => {
-            if (this.disposed) {
-                return;
-            }
-            if ('completed' in e) {
-                cc.get(e.completed)?.changeEmitter.fire();
-                return;
-            }
-            this.tree.setChildren(null, getRootChildren(), { diffIdentityProvider });
-            if ('started' in e) {
-                for (const child of this.tree.getNode(null).children) {
-                    this.tree.collapse(child.element, false);
-                }
-                this.tree.expand(attachToResults(e.started), true);
-            }
-        }));
-        const revealItem = (element, preserveFocus) => {
-            this.tree.setFocus([element]);
-            this.tree.setSelection([element]);
-            if (!preserveFocus) {
-                this.tree.domFocus();
-            }
-        };
-        this._register(onDidReveal(async ({ subject, preserveFocus = false }) => {
-            if (subject instanceof TaskSubject) {
-                const resultItem = this.tree.getNode(null).children.find(c => {
-                    if (c.element instanceof TaskElement) {
-                        return c.element.results.id === subject.result.id && c.element.index === subject.taskIndex;
-                    }
-                    if (c.element instanceof TestResultElement) {
-                        return c.element.id === subject.result.id;
-                    }
-                    return false;
-                });
-                if (resultItem) {
-                    revealItem(resultItem.element, preserveFocus);
-                }
-                return;
-            }
-            const revealElement = subject instanceof TestOutputSubject
-                ? cc.get(subject.task)?.itemsCache.get(subject.test)
-                : cc.get(subject.message);
-            if (!revealElement || !this.tree.hasElement(revealElement)) {
-                return;
-            }
-            const parents = [];
-            for (let parent = this.tree.getParentElement(revealElement); parent; parent = this.tree.getParentElement(parent)) {
-                parents.unshift(parent);
-            }
-            for (const parent of parents) {
-                this.tree.expand(parent);
-            }
-            if (this.tree.getRelativeTop(revealElement) === null) {
-                this.tree.reveal(revealElement, 0.5);
-            }
-            revealItem(revealElement, preserveFocus);
-        }));
-        this._register(this.tree.onDidOpen(async (e) => {
-            if (e.element instanceof TestMessageElement) {
-                this.requestReveal.fire(( new MessageSubject(
-                    e.element.result,
-                    e.element.test,
-                    e.element.taskIndex,
-                    e.element.messageIndex
-                )));
-            }
-            else if (e.element instanceof TestCaseElement) {
-                const t = e.element;
-                const message = mapFindTestMessage(e.element.test, (_t, _m, mesasgeIndex, taskIndex) => ( new MessageSubject(t.results, t.test, taskIndex, mesasgeIndex)));
-                this.requestReveal.fire(message || ( new TestOutputSubject(t.results, 0, t.test)));
-            }
-            else if (e.element instanceof CoverageElement) {
-                const task = e.element.task;
-                if (e.element.isOpen) {
-                    return coverageService.closeCoverage();
-                }
-                progressService.withProgress({ location: options.locationForProgress }, () => coverageService.openCoverage(task, true));
-            }
-        }));
-        this._register(this.tree.onDidChangeSelection(evt => {
-            for (const element of evt.elements) {
-                if (element && 'test' in element) {
-                    explorerFilter.reveal.value = element.test.item.extId;
-                    break;
-                }
-            }
-        }));
-        this._register(this.tree.onContextMenu(e => this.onContextMenu(e)));
-        this.tree.setChildren(null, getRootChildren());
-        for (const result of results.results) {
-            if (!result.completedAt && result instanceof LiveTestResult) {
-                attachToResults(result);
-            }
-        }
-    }
-    layout(height, width) {
-        this.tree.layout(height, width);
-    }
-    onContextMenu(evt) {
-        if (!evt.element) {
-            return;
-        }
-        const actions = this.treeActions.provideActionBar(evt.element);
-        this.contextMenuService.showContextMenu({
-            getAnchor: () => evt.anchor,
-            getActions: () => actions.secondary.length
-                ? [...actions.primary, ( new Separator()), ...actions.secondary]
-                : actions.primary,
-            getActionsContext: () => evt.element?.context
-        });
-    }
-    dispose() {
-        super.dispose();
-        this.disposed = true;
-    }
-};
-OutputPeekTree = ( __decorate([
-    ( __param(3, IContextMenuService)),
-    ( __param(4, ITestResultService)),
-    ( __param(5, IInstantiationService)),
-    ( __param(6, ITestExplorerFilterState)),
-    ( __param(7, ITestCoverageService)),
-    ( __param(8, IProgressService))
-], OutputPeekTree));
-let TestRunElementRenderer = class TestRunElementRenderer {
-    static { TestRunElementRenderer_1 = this; }
-    static { this.ID = 'testRunElementRenderer'; }
-    constructor(treeActions, instantiationService) {
-        this.treeActions = treeActions;
-        this.instantiationService = instantiationService;
-        this.templateId = TestRunElementRenderer_1.ID;
-    }
-    renderCompressedElements(node, _index, templateData) {
-        const chain = node.element.elements;
-        const lastElement = chain[chain.length - 1];
-        if ((lastElement instanceof TaskElement || lastElement instanceof TestMessageElement) && chain.length >= 2) {
-            this.doRender(chain[chain.length - 2], templateData, lastElement);
-        }
-        else {
-            this.doRender(lastElement, templateData);
-        }
-    }
-    renderTemplate(container) {
-        const templateDisposable = ( new DisposableStore());
-        const wrapper = append(container, $('.test-peek-item'));
-        const icon = append(wrapper, $('.state'));
-        const label = append(wrapper, $('.name'));
-        const actionBar = ( new ActionBar(wrapper, {
-            actionViewItemProvider: action => action instanceof MenuItemAction
-                ? this.instantiationService.createInstance(MenuEntryActionViewItem, action, undefined)
-                : undefined
-        }));
-        const elementDisposable = ( new DisposableStore());
-        templateDisposable.add(elementDisposable);
-        templateDisposable.add(actionBar);
-        return {
-            icon,
-            label,
-            actionBar,
-            elementDisposable,
-            templateDisposable,
-        };
-    }
-    renderElement(element, _index, templateData) {
-        this.doRender(element.element, templateData);
-    }
-    disposeTemplate(templateData) {
-        templateData.templateDisposable.dispose();
-    }
-    doRender(element, templateData, subjectElement) {
-        templateData.elementDisposable.clear();
-        templateData.elementDisposable.add(element.onDidChange(() => this.doRender(element, templateData, subjectElement)));
-        this.doRenderInner(element, templateData, subjectElement);
-    }
-    doRenderInner(element, templateData, subjectElement) {
-        let { label, labelWithIcons, description } = element;
-        if (subjectElement instanceof TestMessageElement) {
-            description = subjectElement.label;
-        }
-        const descriptionElement = description ? $('span.test-label-description', {}, description) : '';
-        if (labelWithIcons) {
-            reset(templateData.label, ...labelWithIcons, descriptionElement);
-        }
-        else {
-            reset(templateData.label, label, descriptionElement);
-        }
-        const icon = element.icon;
-        templateData.icon.className = `computed-state ${icon ? ThemeIcon.asClassName(icon) : ''}`;
-        const actions = this.treeActions.provideActionBar(element);
-        templateData.actionBar.clear();
-        templateData.actionBar.context = element.context;
-        templateData.actionBar.push(actions.primary, { icon: true, label: false });
-    }
-};
-TestRunElementRenderer = TestRunElementRenderer_1 = ( __decorate([
-    ( __param(1, IInstantiationService))
-], TestRunElementRenderer));
-let TreeActionsProvider = class TreeActionsProvider {
-    constructor(showRevealLocationOnMessages, requestReveal, contextKeyService, menuService, commandService, testProfileService, editorService) {
-        this.showRevealLocationOnMessages = showRevealLocationOnMessages;
-        this.requestReveal = requestReveal;
-        this.contextKeyService = contextKeyService;
-        this.menuService = menuService;
-        this.commandService = commandService;
-        this.testProfileService = testProfileService;
-        this.editorService = editorService;
-    }
-    provideActionBar(element) {
-        const test = element instanceof TestCaseElement ? element.test : undefined;
-        const capabilities = test ? this.testProfileService.capabilitiesForTest(test) : 0;
-        const contextKeys = [
-            ['peek', "editor.contrib.testingOutputPeek" ],
-            [TestingContextKeys.peekItemType.key, element.type],
-        ];
-        let id = MenuId.TestPeekElement;
-        const primary = [];
-        const secondary = [];
-        if (element instanceof TaskElement) {
-            primary.push(( new Action('testing.outputPeek.showResultOutput', ( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                'testing.showResultOutput',
-                "Show Result Output"
-            )), ThemeIcon.asClassName(Codicon.terminal), undefined, () => this.requestReveal.fire(( new TaskSubject(element.results, element.index))))));
-        }
-        if (element instanceof TestResultElement) {
-            if (element.value.tasks.length === 1) {
-                primary.push(( new Action('testing.outputPeek.showResultOutput', ( localizeWithPath(
-                    'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                    'testing.showResultOutput',
-                    "Show Result Output"
-                )), ThemeIcon.asClassName(Codicon.terminal), undefined, () => this.requestReveal.fire(( new TaskSubject(element.value, 0))))));
-            }
-            primary.push(( new Action('testing.outputPeek.reRunLastRun', ( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                'testing.reRunLastRun',
-                "Rerun Test Run"
-            )), ThemeIcon.asClassName(testingRunIcon), undefined, () => this.commandService.executeCommand('testing.reRunLastRun', element.value.id))));
-            if (capabilities & 4 ) {
-                primary.push(( new Action('testing.outputPeek.debugLastRun', ( localizeWithPath(
-                    'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                    'testing.debugLastRun',
-                    "Debug Test Run"
-                )), ThemeIcon.asClassName(testingDebugIcon), undefined, () => this.commandService.executeCommand('testing.debugLastRun', element.value.id))));
-            }
-        }
-        if (element instanceof TestCaseElement || element instanceof TestMessageElement) {
-            contextKeys.push([TestingContextKeys.testResultOutdated.key, element.test.retired], ...getTestItemContextOverlay(element.test, capabilities));
-        }
-        if (element instanceof TestCaseElement) {
-            const extId = element.test.item.extId;
-            if (( element.test.tasks[element.taskIndex].messages.some(m => m.type === 1 ))) {
-                primary.push(( new Action('testing.outputPeek.showResultOutput', ( localizeWithPath(
-                    'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                    'testing.showResultOutput',
-                    "Show Result Output"
-                )), ThemeIcon.asClassName(Codicon.terminal), undefined, () => this.requestReveal.fire(element.outputSubject))));
-            }
-            secondary.push(( new Action('testing.outputPeek.revealInExplorer', ( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                'testing.revealInExplorer',
-                "Reveal in Test Explorer"
-            )), ThemeIcon.asClassName(Codicon.listTree), undefined, () => this.commandService.executeCommand('_revealTestInExplorer', extId))));
-            if (capabilities & 2 ) {
-                primary.push(( new Action('testing.outputPeek.runTest', ( localizeWithPath(
-                    'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                    'run test',
-                    'Run Test'
-                )), ThemeIcon.asClassName(testingRunIcon), undefined, () => this.commandService.executeCommand('vscode.runTestsById', 2 , extId))));
-            }
-            if (capabilities & 4 ) {
-                primary.push(( new Action('testing.outputPeek.debugTest', ( localizeWithPath(
-                    'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                    'debug test',
-                    'Debug Test'
-                )), ThemeIcon.asClassName(testingDebugIcon), undefined, () => this.commandService.executeCommand('vscode.runTestsById', 4 , extId))));
-            }
-            primary.push(( new Action('testing.outputPeek.goToFile', ( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                'testing.goToFile',
-                "Go to Source"
-            )), ThemeIcon.asClassName(Codicon.goToFile), undefined, () => this.commandService.executeCommand('vscode.revealTest', extId))));
-        }
-        if (element instanceof TestMessageElement) {
-            id = MenuId.TestMessageContext;
-            contextKeys.push([TestingContextKeys.testMessageContext.key, element.contextValue]);
-            if (this.showRevealLocationOnMessages && element.location) {
-                primary.push(( new Action('testing.outputPeek.goToError', ( localizeWithPath(
-                    'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                    'testing.goToError',
-                    "Go to Source"
-                )), ThemeIcon.asClassName(Codicon.goToFile), undefined, () => this.editorService.openEditor({
-                    resource: element.location.uri,
-                    options: {
-                        selection: element.location.range,
-                        preserveFocus: true,
-                    }
-                }))));
-            }
-        }
-        const contextOverlay = this.contextKeyService.createOverlay(contextKeys);
-        const result = { primary, secondary };
-        const menu = this.menuService.createMenu(id, contextOverlay);
-        try {
-            createAndFillInActionBarActions(menu, { arg: element.context }, result, 'inline');
-            return result;
-        }
-        finally {
-            menu.dispose();
-        }
-    }
-};
-TreeActionsProvider = ( __decorate([
-    ( __param(2, IContextKeyService)),
-    ( __param(3, IMenuService)),
-    ( __param(4, ICommandService)),
-    ( __param(5, ITestProfileService)),
-    ( __param(6, IEditorService))
-], TreeActionsProvider));
-const navWhen = ( ContextKeyExpr.and(EditorContextKeys.focus, TestingContextKeys.isPeekVisible));
-const getPeekedEditorFromFocus = (codeEditorService) => {
-    const editor = codeEditorService.getFocusedCodeEditor() || codeEditorService.getActiveCodeEditor();
-    return editor && getPeekedEditor(codeEditorService, editor);
-};
-const getPeekedEditor = (codeEditorService, editor) => {
-    if (TestingOutputPeekController.get(editor)?.subject) {
-        return editor;
-    }
-    if (editor instanceof EmbeddedCodeEditorWidget) {
-        return editor.getParentEditor();
-    }
-    const outer = getOuterEditorFromDiffEditor(codeEditorService);
-    if (outer) {
-        return outer;
-    }
-    return editor;
-};
-class GoToNextMessageAction extends Action2 {
-    static { this.ID = 'testing.goToNextMessage'; }
-    constructor() {
-        super({
-            id: GoToNextMessageAction.ID,
-            f1: true,
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                'testing.goToNextMessage',
-                'Go to Next Test Failure'
-            )),
-            icon: Codicon.arrowDown,
-            category: Categories.Test,
-            keybinding: {
-                primary: 512  | 66 ,
-                weight: 100  + 1,
-                when: navWhen,
-            },
-            menu: [{
-                    id: MenuId.TestPeekTitle,
-                    group: 'navigation',
-                    order: 2,
-                }, {
-                    id: MenuId.CommandPalette,
-                    when: navWhen
-                }],
-        });
-    }
-    run(accessor) {
-        const editor = getPeekedEditorFromFocus(accessor.get(ICodeEditorService));
-        if (editor) {
-            TestingOutputPeekController.get(editor)?.next();
-        }
-    }
-}
-class GoToPreviousMessageAction extends Action2 {
-    static { this.ID = 'testing.goToPreviousMessage'; }
-    constructor() {
-        super({
-            id: GoToPreviousMessageAction.ID,
-            f1: true,
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                'testing.goToPreviousMessage',
-                'Go to Previous Test Failure'
-            )),
-            icon: Codicon.arrowUp,
-            category: Categories.Test,
-            keybinding: {
-                primary: 1024  | 512  | 66 ,
-                weight: 100  + 1,
-                when: navWhen
-            },
-            menu: [{
-                    id: MenuId.TestPeekTitle,
-                    group: 'navigation',
-                    order: 1,
-                }, {
-                    id: MenuId.CommandPalette,
-                    when: navWhen
-                }],
-        });
-    }
-    run(accessor) {
-        const editor = getPeekedEditorFromFocus(accessor.get(ICodeEditorService));
-        if (editor) {
-            TestingOutputPeekController.get(editor)?.previous();
-        }
-    }
-}
-class OpenMessageInEditorAction extends Action2 {
-    static { this.ID = 'testing.openMessageInEditor'; }
-    constructor() {
-        super({
-            id: OpenMessageInEditorAction.ID,
-            f1: false,
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                'testing.openMessageInEditor',
-                'Open in Editor'
-            )),
-            icon: Codicon.goToFile,
-            category: Categories.Test,
-            menu: [{ id: MenuId.TestPeekTitle }],
-        });
-    }
-    run(accessor) {
-        accessor.get(ITestingPeekOpener).openCurrentInEditor();
-    }
-}
-class ToggleTestingPeekHistory extends Action2 {
-    static { this.ID = 'testing.toggleTestingPeekHistory'; }
-    constructor() {
-        super({
-            id: ToggleTestingPeekHistory.ID,
-            f1: true,
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                'testing.toggleTestingPeekHistory',
-                'Toggle Test History in Peek'
-            )),
-            icon: Codicon.history,
-            category: Categories.Test,
-            menu: [{
-                    id: MenuId.TestPeekTitle,
-                    group: 'navigation',
-                    order: 3,
-                }],
-            keybinding: {
-                weight: 200 ,
-                primary: 512  | 38 ,
-                when: ( TestingContextKeys.isPeekVisible.isEqualTo(true)),
-            },
-        });
-    }
-    run(accessor) {
-        const opener = accessor.get(ITestingPeekOpener);
-        opener.historyVisible.value = !opener.historyVisible.value;
-    }
-}
-class CreationCache {
-    constructor() {
-        this.v = ( new WeakMap());
-    }
-    get(key) {
-        return this.v.get(key);
-    }
-    getOrCreate(ref, factory) {
-        const existing = this.v.get(ref);
-        if (existing) {
-            return existing;
-        }
-        const fresh = factory();
-        this.v.set(ref, fresh);
-        return fresh;
-    }
-}
-
-export { CloseTestPeek, GoToNextMessageAction, GoToPreviousMessageAction, OpenMessageInEditorAction, TestResultsView, TestingOutputPeekController, TestingPeekOpener, ToggleTestingPeekHistory };