@theia/core 1.67.0-next.3 → 1.67.0-next.59

package/package.json

@@ -1,30 +1,31 @@
 {
   "name": "@theia/core",
-  "version": "1.67.0-next.3+7946ca874",
+  "version": "1.67.0-next.59+3f14297ea",
   "description": "Theia is a cloud & desktop IDE framework implemented in TypeScript.",
   "main": "lib/common/index.js",
   "typings": "lib/common/index.d.ts",
   "dependencies": {
     "@babel/runtime": "^7.10.0",
-    "@lumino/algorithm": "^2.0.2",
-    "@lumino/commands": "^2.3.1",
-    "@lumino/coreutils": "^2.2.0",
-    "@lumino/domutils": "^2.0.2",
-    "@lumino/dragdrop": "^2.1.5",
-    "@lumino/messaging": "^2.0.2",
-    "@lumino/properties": "^2.0.2",
-    "@lumino/signaling": "^2.1.3",
-    "@lumino/virtualdom": "^2.0.2",
-    "@lumino/widgets": "2.5.0",
+    "@lumino/algorithm": "^2.0.4",
+    "@lumino/commands": "^2.3.3",
+    "@lumino/coreutils": "^2.2.2",
+    "@lumino/domutils": "^2.0.4",
+    "@lumino/dragdrop": "^2.1.7",
+    "@lumino/messaging": "^2.0.4",
+    "@lumino/properties": "^2.0.4",
+    "@lumino/signaling": "^2.1.5",
+    "@lumino/virtualdom": "^2.0.4",
+    "@lumino/widgets": "2.7.2",
     "@parcel/watcher": "^2.5.0",
-    "@theia/application-package": "1.67.0-next.3+7946ca874",
-    "@theia/request": "1.67.0-next.3+7946ca874",
+    "@theia/application-package": "1.67.0-next.59+3f14297ea",
+    "@theia/request": "1.67.0-next.59+3f14297ea",
     "@types/body-parser": "^1.16.4",
     "@types/express": "^4.17.21",
     "@types/fs-extra": "^4.0.2",
     "@types/lodash.debounce": "4.0.3",
     "@types/lodash.throttle": "^4.1.3",
-    "@types/markdown-it": "^12.2.3",
+    "@types/markdown-it": "^14.1.0",
+    "@types/markdown-it-emoji": "^3.0.1",
     "@types/react": "^18.0.15",
     "@types/react-dom": "^18.0.6",
     "@types/route-parser": "^0.1.1",
@@ -53,7 +54,9 @@
     "keytar": "7.9.0",
     "lodash.debounce": "^4.0.8",
     "lodash.throttle": "^4.1.1",
-    "markdown-it": "^12.3.2",
+    "markdown-it": "^14.1.0",
+    "markdown-it-anchor": "^9.2.0",
+    "markdown-it-emoji": "^3.0.0",
     "msgpackr": "^1.10.2",
     "p-debounce": "^2.1.0",
     "perfect-scrollbar": "1.5.5",
@@ -122,6 +125,8 @@
         "lodash.debounce as debounce",
         "lodash.throttle as throttle",
         "markdown-it as markdownit",
+        "markdown-it-anchor as markdownitanchor",
+        "markdown-it-emoji as markdownitemoji",
         "react as React",
         "ws as WebSocket",
         "yargs"
@@ -216,5 +221,5 @@
   "nyc": {
     "extends": "../../configs/nyc.json"
   },
-  "gitHead": "7946ca874b04e6249d883e9a586f193194df1365"
+  "gitHead": "3f14297ea2edcdb1fffd74afee0613e70b43e125"
 }

package/shared/markdown-it-anchor/index.d.ts

@@ -0,0 +1,2 @@
+import markdownitanchor = require('markdown-it-anchor');
+export = markdownitanchor;

package/shared/markdown-it-anchor/index.js

@@ -0,0 +1 @@
+module.exports = require('markdown-it-anchor');

package/shared/markdown-it-emoji/index.d.ts

@@ -0,0 +1,2 @@
+import markdownitemoji = require('markdown-it-emoji');
+export = markdownitemoji;

package/shared/markdown-it-emoji/index.js

@@ -0,0 +1 @@
+module.exports = require('markdown-it-emoji');

package/src/browser/authentication-service.ts

@@ -43,6 +43,7 @@ export interface AuthenticationProviderSessionOptions {
 export interface AuthenticationSession {
     id: string;
     accessToken: string;
+    idToken?: string;
     account: AuthenticationSessionAccountInformation;
     scopes: ReadonlyArray<string>;
 }

package/src/browser/badges/badge-service.ts

@@ -0,0 +1,44 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable } from 'inversify';
+import { Emitter, Event } from '../../common';
+import { Widget } from '../widgets';
+
+export interface Badge {
+    value: number;
+    tooltip: string;
+}
+
+@injectable()
+export class BadgeService {
+    protected readonly badges = new WeakMap<Widget, Badge>();
+    protected readonly onDidChangeBadgesEmitter = new Emitter<Widget>();
+    get onDidChangeBadges(): Event<Widget> { return this.onDidChangeBadgesEmitter.event; }
+
+    getBadge(widget: Widget): Badge | undefined {
+        return this.badges.get(widget);
+    }
+
+    showBadge(widget: Widget, badge?: Badge): void {
+        if (badge) {
+            this.badges.set(widget, badge);
+            this.onDidChangeBadgesEmitter.fire(widget);
+        } else if (this.badges.delete(widget)) {
+            this.onDidChangeBadgesEmitter.fire(widget);
+        }
+    }
+}

package/src/browser/badges/index.ts

@@ -0,0 +1,18 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+export * from './badge-service';
+export * from './tabbar-badge-decorator';

package/src/browser/badges/tabbar-badge-decorator.ts

@@ -0,0 +1,63 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable, interfaces } from 'inversify';
+import { ViewContainer } from '../view-container';
+import { WidgetDecoration } from '../widget-decoration';
+import { Title, Widget } from '../widgets';
+import { TabBarDecorator } from '../shell/tab-bar-decorator';
+import { Disposable, Event } from '../../common';
+import { Badge, BadgeService } from './badge-service';
+
+@injectable()
+export class TabBarBadgeDecorator implements TabBarDecorator {
+    readonly id = 'theia-plugin-view-container-badge-decorator';
+
+    @inject(BadgeService)
+    protected readonly badgeService: BadgeService;
+
+    onDidChangeDecorations(...[cb, thisArg, disposable]: Parameters<Event<void>>): Disposable { return this.badgeService.onDidChangeBadges(() => cb(), thisArg, disposable); }
+
+    decorate({ owner }: Title<Widget>): WidgetDecoration.Data[] {
+        let total = 0;
+        const result: WidgetDecoration.Data[] = [];
+        const aggregate = (badge?: Badge) => {
+            if (badge?.value) {
+                total += badge.value;
+            }
+            if (badge?.tooltip) {
+                result.push({ tooltip: badge.tooltip });
+            }
+        };
+        if (owner instanceof ViewContainer) {
+            for (const { wrapped } of owner.getParts()) {
+                aggregate(this.badgeService.getBadge(wrapped));
+            }
+        } else {
+            aggregate(this.badgeService.getBadge(owner));
+        }
+        if (total !== 0) {
+            result.push({ badge: total });
+        }
+        return result;
+    }
+}
+
+export function bindBadgeDecoration(bind: interfaces.Bind): void {
+    bind(BadgeService).toSelf().inSingletonScope();
+    bind(TabBarBadgeDecorator).toSelf().inSingletonScope();
+    bind(TabBarDecorator).toService(TabBarBadgeDecorator);
+}

package/src/browser/context-key-service.ts

@@ -89,7 +89,9 @@ export interface ContextKeyService extends ContextMatcher {
     setContext(key: string, value: unknown): void;
 }
 
-export type ScopedValueStore = Omit<ContextKeyService, 'onDidChange' | 'match' | 'parseKeys' | 'with' | 'createOverlay'> & Disposable;
+export type ScopedValueStore = Omit<ContextKeyService, 'onDidChange' | 'match' | 'parseKeys' | 'with' | 'createOverlay'> & Disposable & {
+    onDidChangeContext: Event<ContextKeyChangeEvent>;
+};
 
 @injectable()
 export class ContextKeyServiceDummyImpl implements ContextKeyService {
@@ -99,6 +101,8 @@ export class ContextKeyServiceDummyImpl implements ContextKeyService {
         this.onDidChangeEmitter.fire(event);
     }
 
+    onDidChangeContext: Event<ContextKeyChangeEvent> = this.onDidChangeEmitter.event;
+
     createKey<T extends ContextKeyValue>(key: string, defaultValue: T | undefined): ContextKey<T> {
         return ContextKey.None;
     }

package/src/browser/dialogs.ts

@@ -248,8 +248,9 @@ export abstract class AbstractDialog<T> extends BaseWidget {
      * Please note that this may also include other popups such as the suggestion overlay, the notification center or quick picks.
      * @returns a disposable that will restore the previous tabbing behavior
      */
-    protected preventTabbingOutsideDialog(elements = Array.from(this.node.ownerDocument.body.children)): Disposable {
-        const nonInertElements = elements.filter(child => child !== this.node && !(child.hasAttribute('inert')));
+    protected preventTabbingOutsideDialog(elements = Array.from(this.node.ownerDocument.body.children)): Disposable { //
+        const inertBlacklist = ['select-component-container']; // IDs of elements that should remain interactive
+        const nonInertElements = elements.filter(child => child !== this.node && !(child.hasAttribute('inert')) && !inertBlacklist.includes(child.id));
         nonInertElements.forEach(child => child.setAttribute('inert', ''));
         return Disposable.create(() => nonInertElements.forEach(child => child.removeAttribute('inert')));
     }

package/src/browser/frontend-application-module.ts

@@ -143,6 +143,7 @@ import { DomInputUndoRedoHandler, UndoRedoHandler, UndoRedoHandlerService } from
 import { WidgetStatusBarContribution, WidgetStatusBarService } from './widget-status-bar-service';
 import { SymbolIconColorContribution } from './symbol-icon-color-contribution';
 import { CorePreferences, bindCorePreferences } from '../common/core-preferences';
+import { bindBadgeDecoration } from './badges';
 
 export { bindResourceProvider, bindMessageService, bindPreferenceService };
 
@@ -481,4 +482,5 @@ export const frontendApplicationModule = new ContainerModule((bind, _unbind, _is
     bind(WidgetStatusBarService).toSelf().inSingletonScope();
     bind(FrontendApplicationContribution).toService(WidgetStatusBarService);
     bindContributionProvider(bind, WidgetStatusBarContribution);
+    bindBadgeDecoration(bind);
 });

package/src/browser/index.ts

@@ -50,3 +50,6 @@ export * from './hover-service';
 export * from './saveable-service';
 export * from './undo-redo-handler';
 export * from './widget-status-bar-service';
+export * from './badges';
+export * from './markdown-rendering/markdown-renderer';
+export * from './markdown-rendering/markdown';

package/src/browser/markdown-rendering/markdown-renderer.ts

@@ -17,6 +17,7 @@
 import * as DOMPurify from 'dompurify';
 import { injectable, inject, postConstruct } from 'inversify';
 import * as markdownit from 'markdown-it';
+import * as markdownitemoji from 'markdown-it-emoji';
 import { MarkdownString } from '../../common/markdown-rendering/markdown-string';
 import { Disposable, DisposableGroup } from '../../common';
 import { LabelParser } from '../label-parser';
@@ -65,7 +66,7 @@ export interface MarkdownRendererFactory {
 @injectable()
 export class MarkdownRendererImpl implements MarkdownRenderer {
     @inject(LabelParser) protected readonly labelParser: LabelParser;
-    protected readonly markdownIt = markdownit();
+    protected readonly markdownIt = markdownit().use(markdownitemoji.full);
     protected resetRenderer: Disposable | undefined;
 
     @postConstruct()

package/src/browser/markdown-rendering/markdown.spec.tsx

@@ -0,0 +1,371 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import * as assert from 'assert';
+import * as React from 'react';
+import { createRoot, Root } from 'react-dom/client';
+import { enableJSDOM } from '../test/jsdom';
+import { Markdown, LocalizedMarkdown } from './markdown';
+import { MarkdownRenderer } from './markdown-renderer';
+import { MarkdownString, MarkdownStringImpl } from '../../common/markdown-rendering/markdown-string';
+
+let disableJSDOM: () => void;
+
+describe('Markdown', () => {
+    let mockRenderer: MarkdownRenderer & { lastRenderedMarkdown?: MarkdownString };
+    let container: HTMLElement;
+    let root: Root;
+
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    beforeEach(() => {
+        container = document.createElement('div');
+        document.body.appendChild(container);
+        root = createRoot(container);
+
+        mockRenderer = {
+            lastRenderedMarkdown: undefined,
+            render: (markdown: MarkdownString | undefined) => {
+                // Store the markdown for verification
+                if (typeof markdown === 'object' && 'value' in markdown) {
+                    mockRenderer.lastRenderedMarkdown = markdown;
+                }
+                const div = document.createElement('div');
+                if (markdown) {
+                    const p = document.createElement('p');
+                    const value = typeof markdown === 'object' && 'value' in markdown
+                        ? markdown.value
+                        : String(markdown);
+                    p.textContent = value;
+                    div.appendChild(p);
+                }
+                return {
+                    element: div,
+                    dispose: () => { }
+                };
+            }
+        };
+    });
+
+    afterEach(() => {
+        root.unmount();
+        document.body.removeChild(container);
+    });
+
+    it('should render markdown content', done => {
+        root.render(
+            <Markdown
+                markdown="**Hello World**"
+                markdownRenderer={mockRenderer}
+                className="test-class"
+            />
+        );
+
+        setTimeout(() => {
+            const div = container.querySelector('.test-class');
+            assert.ok(div, 'Container should exist');
+            assert.ok(div?.textContent?.includes('Hello World'), 'Should contain markdown text');
+            done();
+        }, 50);
+    });
+
+    it('should render empty div when markdown is undefined', done => {
+        root.render(
+            <Markdown
+                markdown={undefined}
+                markdownRenderer={mockRenderer}
+                className="test-class"
+            />
+        );
+
+        setTimeout(() => {
+            const div = container.querySelector('.test-class');
+            assert.ok(div, 'Container should exist');
+            assert.strictEqual(div?.childNodes.length, 0, 'Should have no children');
+            done();
+        }, 50);
+    });
+
+    it('should render empty div when markdown is empty string', done => {
+        root.render(
+            <Markdown
+                markdown=""
+                markdownRenderer={mockRenderer}
+                className="test-class"
+            />
+        );
+
+        setTimeout(() => {
+            const div = container.querySelector('.test-class');
+            assert.ok(div, 'Container should exist');
+            assert.strictEqual(div?.childNodes.length, 0, 'Should have no children');
+            done();
+        }, 50);
+    });
+
+    it('should render empty div when markdown is whitespace only', done => {
+        root.render(
+            <Markdown
+                markdown="   "
+                markdownRenderer={mockRenderer}
+                className="test-class"
+            />
+        );
+
+        setTimeout(() => {
+            const div = container.querySelector('.test-class');
+            assert.ok(div, 'Container should exist');
+            assert.strictEqual(div?.childNodes.length, 0, 'Should have no children');
+            done();
+        }, 50);
+    });
+
+    it('should accept MarkdownString object', done => {
+        const markdownString = new MarkdownStringImpl('**Bold Text**');
+        root.render(
+            <Markdown
+                markdown={markdownString}
+                markdownRenderer={mockRenderer}
+                className="test-class"
+            />
+        );
+
+        setTimeout(() => {
+            const div = container.querySelector('.test-class');
+            assert.ok(div, 'Container should exist');
+            assert.ok(div?.textContent?.includes('Bold Text'), 'Should contain markdown text');
+            done();
+        }, 50);
+    });
+
+    it('should call onRender callback when content is rendered', done => {
+        let renderCallbackCalled = false;
+        let receivedElement: HTMLElement | undefined;
+
+        root.render(
+            <Markdown
+                markdown="Test content"
+                markdownRenderer={mockRenderer}
+                className="test-class"
+                onRender={element => {
+                    renderCallbackCalled = true;
+                    receivedElement = element;
+                }}
+            />
+        );
+
+        setTimeout(() => {
+            assert.ok(renderCallbackCalled, 'onRender should be called');
+            assert.ok(receivedElement, 'Should receive element');
+            done();
+        }, 50);
+    });
+
+    it('should call onRender callback with undefined when content is empty', done => {
+        let renderCallbackCalled = false;
+        let receivedElement: HTMLElement | undefined = document.createElement('div'); // Initialize to non-undefined
+
+        root.render(
+            <Markdown
+                markdown={undefined}
+                markdownRenderer={mockRenderer}
+                className="test-class"
+                onRender={element => {
+                    renderCallbackCalled = true;
+                    receivedElement = element;
+                }}
+            />
+        );
+
+        setTimeout(() => {
+            assert.ok(renderCallbackCalled, 'onRender should be called even for empty content');
+            assert.strictEqual(receivedElement, undefined, 'Should receive undefined for empty content');
+            done();
+        }, 100);
+    });
+
+    it('should apply className to container', done => {
+        root.render(
+            <Markdown
+                markdown="Test"
+                markdownRenderer={mockRenderer}
+                className="custom-class"
+            />
+        );
+
+        setTimeout(() => {
+            const div = container.querySelector('.custom-class');
+            assert.ok(div, 'Container with custom class should exist');
+            done();
+        }, 50);
+    });
+});
+
+describe('LocalizedMarkdown', () => {
+    let mockRenderer: MarkdownRenderer & { lastRenderedMarkdown?: MarkdownString };
+    let container: HTMLElement;
+    let root: Root;
+
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    beforeEach(() => {
+        container = document.createElement('div');
+        document.body.appendChild(container);
+        root = createRoot(container);
+
+        mockRenderer = {
+            lastRenderedMarkdown: undefined,
+            render: (markdown: MarkdownString | undefined) => {
+                // Store the markdown for verification
+                if (typeof markdown === 'object' && 'value' in markdown) {
+                    mockRenderer.lastRenderedMarkdown = markdown;
+                }
+                const div = document.createElement('div');
+                if (markdown) {
+                    const p = document.createElement('p');
+                    const value = typeof markdown === 'object' && 'value' in markdown
+                        ? markdown.value
+                        : String(markdown);
+                    p.textContent = value;
+                    div.appendChild(p);
+                }
+                return {
+                    element: div,
+                    dispose: () => { }
+                };
+            }
+        };
+    });
+
+    afterEach(() => {
+        root.unmount();
+        document.body.removeChild(container);
+    });
+
+    it('should render localized markdown content', done => {
+        root.render(
+            <LocalizedMarkdown
+                localizationKey="test/basic"
+                defaultMarkdown="Welcome to **Theia**!"
+                markdownRenderer={mockRenderer}
+                className="test-class"
+            />
+        );
+
+        setTimeout(() => {
+            const div = container.querySelector('.test-class');
+            assert.ok(div, 'Container should exist');
+            // The content should be localized (though in tests it will be the default)
+            assert.ok(div?.textContent?.includes('Theia'), 'Should contain localized text');
+            done();
+        }, 50);
+    });
+
+    it('should render localized markdown with parameters', done => {
+        root.render(
+            <LocalizedMarkdown
+                localizationKey="test/greeting"
+                defaultMarkdown="Hello **{0}**! You have {1} messages."
+                args={['Alice', 5]}
+                markdownRenderer={mockRenderer}
+                className="test-class"
+            />
+        );
+
+        setTimeout(() => {
+            const div = container.querySelector('.test-class');
+            assert.ok(div, 'Container should exist');
+            assert.ok(div?.textContent?.includes('Alice'), 'Should contain first parameter');
+            assert.ok(div?.textContent?.includes('5'), 'Should contain second parameter');
+            done();
+        }, 50);
+    });
+
+    it('should render empty div when default markdown is empty', done => {
+        root.render(
+            <LocalizedMarkdown
+                localizationKey="test/empty"
+                defaultMarkdown=""
+                markdownRenderer={mockRenderer}
+                className="test-class"
+            />
+        );
+
+        setTimeout(() => {
+            const div = container.querySelector('.test-class');
+            assert.ok(div, 'Container should exist');
+            assert.strictEqual(div?.childNodes.length, 0, 'Should have no children');
+            done();
+        }, 50);
+    });
+
+    it('should update when localization key changes', done => {
+        const { rerender } = { rerender: (element: React.ReactElement) => root.render(element) };
+
+        root.render(
+            <LocalizedMarkdown
+                localizationKey="test/first"
+                defaultMarkdown="First content"
+                markdownRenderer={mockRenderer}
+                className="test-class"
+            />
+        );
+
+        setTimeout(() => {
+            const div = container.querySelector('.test-class');
+            assert.ok(div?.textContent?.includes('First'), 'Should contain first content');
+
+            rerender(
+                <LocalizedMarkdown
+                    localizationKey="test/second"
+                    defaultMarkdown="Second content"
+                    markdownRenderer={mockRenderer}
+                    className="test-class"
+                />
+            );
+
+            setTimeout(() => {
+                const updatedDiv = container.querySelector('.test-class');
+                assert.ok(updatedDiv?.textContent?.includes('Second'), 'Should contain second content');
+                done();
+            }, 50);
+        }, 50);
+    });
+
+    it('should pass markdown options correctly', done => {
+        root.render(
+            <LocalizedMarkdown
+                localizationKey="test/html"
+                defaultMarkdown="Content with <span>HTML</span>"
+                markdownRenderer={mockRenderer}
+                className="test-class"
+                markdownOptions={{ supportHtml: true, supportThemeIcons: true, isTrusted: true }}
+            />
+        );
+
+        setTimeout(() => {
+            const div = container.querySelector('.test-class');
+            assert.ok(div, 'Container should exist');
+            assert.ok(mockRenderer.lastRenderedMarkdown, 'Should have rendered markdown');
+            assert.strictEqual(mockRenderer.lastRenderedMarkdown?.supportHtml, true, 'Should pass supportHtml option');
+            assert.strictEqual(mockRenderer.lastRenderedMarkdown?.supportThemeIcons, true, 'Should pass supportThemeIcons option');
+            assert.strictEqual(mockRenderer.lastRenderedMarkdown?.isTrusted, true, 'Should pass isTrusted option');
+            done();
+        }, 50);
+    });
+});