@codingame/monaco-vscode-api 1.83.8 → 1.83.10-next.0

package/vscode/src/vs/workbench/contrib/comments/browser/commentThreadHeader.js

@@ -1,107 +0,0 @@
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
-import { Action, ActionRunner } from 'monaco-editor/esm/vs/base/common/actions.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { createActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
-import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
-import { StandardMouseEvent } from 'monaco-editor/esm/vs/base/browser/mouseEvent.js';
-const collapseIcon = registerIcon('review-comment-collapse', Codicon.chevronUp, ( nls.localizeWithPath(
-    'vs/workbench/contrib/comments/browser/commentThreadHeader',
-    'collapseIcon',
-    'Icon to collapse a review comment.'
-)));
-const COLLAPSE_ACTION_CLASS = 'expand-review-action ' + ThemeIcon.asClassName(collapseIcon);
-class CommentThreadHeader extends Disposable {
-    constructor(container, _delegate, _commentMenus, _commentThread, _contextKeyService, instantiationService, _contextMenuService) {
-        super();
-        this._delegate = _delegate;
-        this._commentMenus = _commentMenus;
-        this._commentThread = _commentThread;
-        this._contextKeyService = _contextKeyService;
-        this.instantiationService = instantiationService;
-        this._contextMenuService = _contextMenuService;
-        this._headElement = dom.$('.head');
-        container.appendChild(this._headElement);
-        this._fillHead();
-    }
-    _fillHead() {
-        const titleElement = dom.append(this._headElement, dom.$('.review-title'));
-        this._headingLabel = dom.append(titleElement, dom.$('span.filename'));
-        this.createThreadLabel();
-        const actionsContainer = dom.append(this._headElement, dom.$('.review-actions'));
-        this._actionbarWidget = ( new ActionBar(actionsContainer, {
-            actionViewItemProvider: createActionViewItem.bind(undefined, this.instantiationService)
-        }));
-        this._register(this._actionbarWidget);
-        this._collapseAction = ( new Action('review.expand', ( nls.localizeWithPath(
-            'vs/workbench/contrib/comments/browser/commentThreadHeader',
-            'label.collapse',
-            "Collapse"
-        )), COLLAPSE_ACTION_CLASS, true, () => this._delegate.collapse()));
-        const menu = this._commentMenus.getCommentThreadTitleActions(this._contextKeyService);
-        this.setActionBarActions(menu);
-        this._register(menu);
-        this._register(menu.onDidChange(e => {
-            this.setActionBarActions(menu);
-        }));
-        this._register(dom.addDisposableListener(this._headElement, dom.EventType.CONTEXT_MENU, e => {
-            return this.onContextMenu(e);
-        }));
-        this._actionbarWidget.context = this._commentThread;
-    }
-    setActionBarActions(menu) {
-        const groups = menu.getActions({ shouldForwardArgs: true }).reduce((r, [, actions]) => [...r, ...actions], []);
-        this._actionbarWidget.clear();
-        this._actionbarWidget.push([...groups, this._collapseAction], { label: false, icon: true });
-    }
-    updateCommentThread(commentThread) {
-        this._commentThread = commentThread;
-        this._actionbarWidget.context = this._commentThread;
-        this.createThreadLabel();
-    }
-    createThreadLabel() {
-        let label;
-        label = this._commentThread.label;
-        if (label === undefined) {
-            if (!(this._commentThread.comments && this._commentThread.comments.length)) {
-                label = ( nls.localizeWithPath(
-                    'vs/workbench/contrib/comments/browser/commentThreadHeader',
-                    'startThread',
-                    "Start discussion"
-                ));
-            }
-        }
-        if (label) {
-            this._headingLabel.textContent = strings.escape(label);
-            this._headingLabel.setAttribute('aria-label', label);
-        }
-    }
-    updateHeight(headHeight) {
-        this._headElement.style.height = `${headHeight}px`;
-        this._headElement.style.lineHeight = this._headElement.style.height;
-    }
-    onContextMenu(e) {
-        const actions = ( this._commentMenus.getCommentThreadTitleContextActions(this._contextKeyService).getActions({ shouldForwardArgs: true }).map((value) => value[1])).flat();
-        if (!actions.length) {
-            return;
-        }
-        const event = ( new StandardMouseEvent(e));
-        this._contextMenuService.showContextMenu({
-            getAnchor: () => event,
-            getActions: () => actions,
-            actionRunner: ( new ActionRunner()),
-            getActionsContext: () => {
-                return {
-                    commentControlHandle: this._commentThread.controllerHandle,
-                    commentThreadHandle: this._commentThread.commentThreadHandle,
-                    $mid: 7
-                };
-            },
-        });
-    }
-}
-export { CommentThreadHeader };

package/vscode/src/vs/workbench/contrib/comments/browser/commentThreadRangeDecorator.js

@@ -1,107 +0,0 @@
-import { Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { CommentThreadCollapsibleState } from 'monaco-editor/esm/vs/editor/common/languages.js';
-import { ModelDecorationOptions } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
-class CommentThreadRangeDecoration {
-    get id() {
-        return this._decorationId;
-    }
-    set id(id) {
-        this._decorationId = id;
-    }
-    constructor(range, options) {
-        this.range = range;
-        this.options = options;
-    }
-}
-class CommentThreadRangeDecorator extends Disposable {
-    static { this.description = 'comment-thread-range-decorator'; }
-    constructor(commentService) {
-        super();
-        this.decorationIds = [];
-        this.activeDecorationIds = [];
-        this.threadCollapseStateListeners = [];
-        const decorationOptions = {
-            description: CommentThreadRangeDecorator.description,
-            isWholeLine: false,
-            zIndex: 20,
-            className: 'comment-thread-range',
-            shouldFillLineOnLineBreak: true
-        };
-        this.decorationOptions = ModelDecorationOptions.createDynamic(decorationOptions);
-        const activeDecorationOptions = {
-            description: CommentThreadRangeDecorator.description,
-            isWholeLine: false,
-            zIndex: 20,
-            className: 'comment-thread-range-current',
-            shouldFillLineOnLineBreak: true
-        };
-        this.activeDecorationOptions = ModelDecorationOptions.createDynamic(activeDecorationOptions);
-        this._register(commentService.onDidChangeCurrentCommentThread(thread => {
-            this.updateCurrent(thread);
-        }));
-        this._register(commentService.onDidUpdateCommentThreads(() => {
-            this.updateCurrent(undefined);
-        }));
-    }
-    updateCurrent(thread) {
-        if (!this.editor || (thread?.resource && (thread.resource?.toString() !== this.editor.getModel()?.uri.toString()))) {
-            return;
-        }
-        this.currentThreadCollapseStateListener?.dispose();
-        const newDecoration = [];
-        if (thread) {
-            const range = thread.range;
-            if (range && !((range.startLineNumber === range.endLineNumber) && (range.startColumn === range.endColumn))) {
-                if (thread.collapsibleState === CommentThreadCollapsibleState.Expanded) {
-                    this.currentThreadCollapseStateListener = thread.onDidChangeCollapsibleState(state => {
-                        if (state === CommentThreadCollapsibleState.Collapsed) {
-                            this.updateCurrent(undefined);
-                        }
-                    });
-                    newDecoration.push(( new CommentThreadRangeDecoration(range, this.activeDecorationOptions)));
-                }
-            }
-        }
-        this.editor.changeDecorations((changeAccessor) => {
-            this.activeDecorationIds = changeAccessor.deltaDecorations(this.activeDecorationIds, newDecoration);
-            newDecoration.forEach((decoration, index) => decoration.id = this.decorationIds[index]);
-        });
-    }
-    update(editor, commentInfos) {
-        const model = editor?.getModel();
-        if (!editor || !model) {
-            return;
-        }
-        dispose(this.threadCollapseStateListeners);
-        this.editor = editor;
-        const commentThreadRangeDecorations = [];
-        for (const info of commentInfos) {
-            info.threads.forEach(thread => {
-                if (thread.isDisposed) {
-                    return;
-                }
-                const range = thread.range;
-                if (!range || (range.startLineNumber === range.endLineNumber) && (range.startColumn === range.endColumn)) {
-                    return;
-                }
-                this.threadCollapseStateListeners.push(thread.onDidChangeCollapsibleState(() => {
-                    this.update(editor, commentInfos);
-                }));
-                if (thread.collapsibleState === CommentThreadCollapsibleState.Collapsed) {
-                    return;
-                }
-                commentThreadRangeDecorations.push(( new CommentThreadRangeDecoration(range, this.decorationOptions)));
-            });
-        }
-        editor.changeDecorations((changeAccessor) => {
-            this.decorationIds = changeAccessor.deltaDecorations(this.decorationIds, commentThreadRangeDecorations);
-            commentThreadRangeDecorations.forEach((decoration, index) => decoration.id = this.decorationIds[index]);
-        });
-    }
-    dispose() {
-        dispose(this.threadCollapseStateListeners);
-        this.currentThreadCollapseStateListener?.dispose();
-        super.dispose();
-    }
-}
-export { CommentThreadRangeDecorator };

package/vscode/src/vs/workbench/contrib/comments/browser/commentThreadWidget.js

@@ -1,329 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import './media/review.css.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import * as languages from 'monaco-editor/esm/vs/editor/common/languages.js';
-import { CommentReply } from './commentReply.js';
-import { ICommentService } from './commentService.js';
-import { CommentThreadBody } from './commentThreadBody.js';
-import { CommentThreadHeader } from './commentThreadHeader.js';
-import { CommentThreadAdditionalActions } from './commentThreadAdditionalActions.js';
-import { CommentContextKeys } from '../common/commentContextKeys.js';
-import { textLinkForeground, textLinkActiveForeground, focusBorder, textBlockQuoteBackground, textBlockQuoteBorder, contrastBorder, inputValidationErrorBorder, inputValidationErrorBackground, inputValidationErrorForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
-import { PANEL_BORDER } from '../../../common/theme.js';
-import { commentThreadStateColorVar, commentThreadStateBackgroundColorVar } from './commentColors.js';
-import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
-import { registerNavigableContainer } from '../../../browser/actions/widgetNavigationCommands.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { COMMENTS_SECTION } from '../common/commentsConfiguration.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-let CommentThreadWidget = class CommentThreadWidget extends Disposable {
-    get commentThread() {
-        return this._commentThread;
-    }
-    constructor(container, _parentEditor, _owner, _parentResourceUri, _contextKeyService, _scopedInstantiationService, _commentThread, _pendingComment, _pendingEdits, _markdownOptions, _commentOptions, _containerDelegate, commentService, contextMenuService, configurationService, _keybindingService) {
-        super();
-        this.container = container;
-        this._parentEditor = _parentEditor;
-        this._owner = _owner;
-        this._parentResourceUri = _parentResourceUri;
-        this._contextKeyService = _contextKeyService;
-        this._scopedInstantiationService = _scopedInstantiationService;
-        this._commentThread = _commentThread;
-        this._pendingComment = _pendingComment;
-        this._pendingEdits = _pendingEdits;
-        this._markdownOptions = _markdownOptions;
-        this._commentOptions = _commentOptions;
-        this._containerDelegate = _containerDelegate;
-        this.commentService = commentService;
-        this.configurationService = configurationService;
-        this._keybindingService = _keybindingService;
-        this._commentThreadDisposables = [];
-        this._onDidResize = ( new Emitter());
-        this.onDidResize = this._onDidResize.event;
-        this._threadIsEmpty = CommentContextKeys.commentThreadIsEmpty.bindTo(this._contextKeyService);
-        this._threadIsEmpty.set(!_commentThread.comments || !_commentThread.comments.length);
-        this._focusedContextKey = CommentContextKeys.commentFocused.bindTo(this._contextKeyService);
-        this._commentMenus = this.commentService.getCommentMenus(this._owner);
-        this._header = ( new CommentThreadHeader(container, {
-            collapse: this.collapse.bind(this)
-        }, this._commentMenus, this._commentThread, this._contextKeyService, this._scopedInstantiationService, contextMenuService));
-        this._header.updateCommentThread(this._commentThread);
-        const bodyElement = dom.$('.body');
-        container.appendChild(bodyElement);
-        const tracker = this._register(dom.trackFocus(bodyElement));
-        this._register(registerNavigableContainer({
-            focusNotifiers: [tracker],
-            focusNextWidget: () => {
-                if (!this._commentReply?.isCommentEditorFocused()) {
-                    this._commentReply?.expandReplyAreaAndFocusCommentEditor();
-                }
-            },
-            focusPreviousWidget: () => {
-                if (this._commentReply?.isCommentEditorFocused() && this._commentThread.comments?.length) {
-                    this._body.focus();
-                }
-            }
-        }));
-        this._register(tracker.onDidFocus(() => this._focusedContextKey.set(true)));
-        this._register(tracker.onDidBlur(() => this._focusedContextKey.reset()));
-        this._register(this.configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration("accessibility.verbosity.comments" )) {
-                this._setAriaLabel();
-            }
-        }));
-        this._body = this._scopedInstantiationService.createInstance(CommentThreadBody, this._parentEditor, this._owner, this._parentResourceUri, bodyElement, this._markdownOptions, this._commentThread, this._pendingEdits, this._scopedInstantiationService, this);
-        this._register(this._body);
-        this._setAriaLabel();
-        this._styleElement = dom.createStyleSheet(this.container);
-        this._commentThreadContextValue = CommentContextKeys.commentThreadContext.bindTo(this._contextKeyService);
-        this._commentThreadContextValue.set(_commentThread.contextValue);
-        const commentControllerKey = CommentContextKeys.commentControllerContext.bindTo(this._contextKeyService);
-        const controller = this.commentService.getCommentController(this._owner);
-        if (controller?.contextValue) {
-            commentControllerKey.set(controller.contextValue);
-        }
-        this.currentThreadListeners();
-    }
-    _setAriaLabel() {
-        let ariaLabel = ( localizeWithPath(
-            'vs/workbench/contrib/comments/browser/commentThreadWidget',
-            'commentLabel',
-            "Comment"
-        ));
-        let keybinding;
-        const verbose = this.configurationService.getValue("accessibility.verbosity.comments" );
-        if (verbose) {
-            keybinding = this._keybindingService.lookupKeybinding("editor.action.accessibilityHelp" , this._contextKeyService)?.getLabel() ?? undefined;
-        }
-        if (keybinding) {
-            ariaLabel = ( localizeWithPath(
-                'vs/workbench/contrib/comments/browser/commentThreadWidget',
-                'commentLabelWithKeybinding',
-                "{0}, use ({1}) for accessibility help",
-                ariaLabel,
-                keybinding
-            ));
-        }
-        else {
-            ariaLabel = ( localizeWithPath(
-                'vs/workbench/contrib/comments/browser/commentThreadWidget',
-                'commentLabelWithKeybindingNoKeybinding',
-                "{0}, run the command Open Accessibility Help which is currently not triggerable via keybinding.",
-                ariaLabel
-            ));
-        }
-        this._body.container.ariaLabel = ariaLabel;
-    }
-    updateCurrentThread(hasMouse, hasFocus) {
-        if (hasMouse || hasFocus) {
-            this.commentService.setCurrentCommentThread(this.commentThread);
-        }
-        else {
-            this.commentService.setCurrentCommentThread(undefined);
-        }
-    }
-    currentThreadListeners() {
-        let hasMouse = false;
-        let hasFocus = false;
-        this._register(dom.addDisposableListener(this.container, dom.EventType.MOUSE_ENTER, (e) => {
-            if (e.toElement === this.container) {
-                hasMouse = true;
-                this.updateCurrentThread(hasMouse, hasFocus);
-            }
-        }, true));
-        this._register(dom.addDisposableListener(this.container, dom.EventType.MOUSE_LEAVE, (e) => {
-            if (e.fromElement === this.container) {
-                hasMouse = false;
-                this.updateCurrentThread(hasMouse, hasFocus);
-            }
-        }, true));
-        this._register(dom.addDisposableListener(this.container, dom.EventType.FOCUS_IN, () => {
-            hasFocus = true;
-            this.updateCurrentThread(hasMouse, hasFocus);
-        }, true));
-        this._register(dom.addDisposableListener(this.container, dom.EventType.FOCUS_OUT, () => {
-            hasFocus = false;
-            this.updateCurrentThread(hasMouse, hasFocus);
-        }, true));
-    }
-    updateCommentThread(commentThread) {
-        const shouldCollapse = (this._commentThread.collapsibleState === languages.CommentThreadCollapsibleState.Expanded) && (this._commentThreadState === languages.CommentThreadState.Unresolved)
-            && (commentThread.state === languages.CommentThreadState.Resolved);
-        this._commentThreadState = commentThread.state;
-        this._commentThread = commentThread;
-        dispose(this._commentThreadDisposables);
-        this._commentThreadDisposables = [];
-        this._bindCommentThreadListeners();
-        this._body.updateCommentThread(commentThread);
-        this._threadIsEmpty.set(!this._body.length);
-        this._header.updateCommentThread(commentThread);
-        this._commentReply?.updateCommentThread(commentThread);
-        if (this._commentThread.contextValue) {
-            this._commentThreadContextValue.set(this._commentThread.contextValue);
-        }
-        else {
-            this._commentThreadContextValue.reset();
-        }
-        if (shouldCollapse && this.configurationService.getValue(COMMENTS_SECTION).collapseOnResolve) {
-            this.collapse();
-        }
-    }
-    display(lineHeight) {
-        const headHeight = Math.max(23, Math.ceil(lineHeight * 1.2));
-        this._header.updateHeight(headHeight);
-        this._body.display();
-        if (this._commentThread.canReply) {
-            this._createCommentForm();
-        }
-        this._createAdditionalActions();
-        this._register(this._body.onDidResize(dimension => {
-            this._refresh(dimension);
-        }));
-        if (this._commentThread.canReply && this._commentReply) {
-            this._commentReply.focusIfNeeded();
-        }
-        this._bindCommentThreadListeners();
-    }
-    _refresh(dimension) {
-        this._body.layout();
-        this._onDidResize.fire(dimension);
-    }
-    dispose() {
-        super.dispose();
-        this.updateCurrentThread(false, false);
-    }
-    _bindCommentThreadListeners() {
-        this._commentThreadDisposables.push(this._commentThread.onDidChangeCanReply(() => {
-            if (this._commentReply) {
-                this._commentReply.updateCanReply();
-            }
-            else {
-                if (this._commentThread.canReply) {
-                    this._createCommentForm();
-                }
-            }
-        }));
-        this._commentThreadDisposables.push(this._commentThread.onDidChangeComments(async (_) => {
-            await this.updateCommentThread(this._commentThread);
-        }));
-        this._commentThreadDisposables.push(this._commentThread.onDidChangeLabel(_ => {
-            this._header.createThreadLabel();
-        }));
-    }
-    _createCommentForm() {
-        this._commentReply = this._scopedInstantiationService.createInstance(CommentReply, this._owner, this._body.container, this._parentEditor, this._commentThread, this._scopedInstantiationService, this._contextKeyService, this._commentMenus, this._commentOptions, this._pendingComment, this, this._containerDelegate.actionRunner);
-        this._register(this._commentReply);
-    }
-    _createAdditionalActions() {
-        this._additionalActions = this._scopedInstantiationService.createInstance(CommentThreadAdditionalActions, this._body.container, this._commentThread, this._contextKeyService, this._commentMenus, this._containerDelegate.actionRunner);
-        this._register(this._additionalActions);
-    }
-    getCommentCoords(commentUniqueId) {
-        return this._body.getCommentCoords(commentUniqueId);
-    }
-    getPendingEdits() {
-        return this._body.getPendingEdits();
-    }
-    getPendingComment() {
-        if (this._commentReply) {
-            return this._commentReply.getPendingComment();
-        }
-        return undefined;
-    }
-    getDimensions() {
-        return this._body.getDimensions();
-    }
-    layout(widthInPixel) {
-        this._body.layout();
-        if (widthInPixel !== undefined) {
-            this._commentReply?.layout(widthInPixel);
-        }
-    }
-    focusCommentEditor() {
-        this._commentReply?.focusCommentEditor();
-    }
-    focus() {
-        this._body.focus();
-    }
-    async submitComment() {
-        const activeComment = this._body.activeComment;
-        if (activeComment) {
-            return activeComment.submitComment();
-        }
-        else if ((this._commentReply?.getPendingComment()?.length ?? 0) > 0) {
-            return this._commentReply?.submitComment();
-        }
-    }
-    collapse() {
-        this._containerDelegate.collapse();
-    }
-    applyTheme(theme, fontInfo) {
-        const content = [];
-        content.push(`.monaco-editor .review-widget > .body { border-top: 1px solid var(${commentThreadStateColorVar}) }`);
-        content.push(`.monaco-editor .review-widget > .head { background-color: var(${commentThreadStateBackgroundColorVar}) }`);
-        const linkColor = theme.getColor(textLinkForeground);
-        if (linkColor) {
-            content.push(`.review-widget .body .comment-body a { color: ${linkColor} }`);
-        }
-        const linkActiveColor = theme.getColor(textLinkActiveForeground);
-        if (linkActiveColor) {
-            content.push(`.review-widget .body .comment-body a:hover, a:active { color: ${linkActiveColor} }`);
-        }
-        const focusColor = theme.getColor(focusBorder);
-        if (focusColor) {
-            content.push(`.review-widget .body .comment-body a:focus { outline: 1px solid ${focusColor}; }`);
-            content.push(`.review-widget .body .monaco-editor.focused { outline: 1px solid ${focusColor}; }`);
-        }
-        const blockQuoteBackground = theme.getColor(textBlockQuoteBackground);
-        if (blockQuoteBackground) {
-            content.push(`.review-widget .body .review-comment blockquote { background: ${blockQuoteBackground}; }`);
-        }
-        const blockQuoteBOrder = theme.getColor(textBlockQuoteBorder);
-        if (blockQuoteBOrder) {
-            content.push(`.review-widget .body .review-comment blockquote { border-color: ${blockQuoteBOrder}; }`);
-        }
-        const border = theme.getColor(PANEL_BORDER);
-        if (border) {
-            content.push(`.review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item a.action-label { border-color: ${border}; }`);
-        }
-        const hcBorder = theme.getColor(contrastBorder);
-        if (hcBorder) {
-            content.push(`.review-widget .body .comment-form .review-thread-reply-button { outline-color: ${hcBorder}; }`);
-            content.push(`.review-widget .body .monaco-editor { outline: 1px solid ${hcBorder}; }`);
-        }
-        const errorBorder = theme.getColor(inputValidationErrorBorder);
-        if (errorBorder) {
-            content.push(`.review-widget .validation-error { border: 1px solid ${errorBorder}; }`);
-        }
-        const errorBackground = theme.getColor(inputValidationErrorBackground);
-        if (errorBackground) {
-            content.push(`.review-widget .validation-error { background: ${errorBackground}; }`);
-        }
-        const errorForeground = theme.getColor(inputValidationErrorForeground);
-        if (errorForeground) {
-            content.push(`.review-widget .body .comment-form .validation-error { color: ${errorForeground}; }`);
-        }
-        const fontFamilyVar = '--comment-thread-editor-font-family';
-        const fontSizeVar = '--comment-thread-editor-font-size';
-        const fontWeightVar = '--comment-thread-editor-font-weight';
-        this.container?.style.setProperty(fontFamilyVar, fontInfo.fontFamily);
-        this.container?.style.setProperty(fontSizeVar, `${fontInfo.fontSize}px`);
-        this.container?.style.setProperty(fontWeightVar, fontInfo.fontWeight);
-        content.push(`.review-widget .body code {
-			font-family: var(${fontFamilyVar});
-			font-weight: var(${fontWeightVar});
-		}`);
-        this._styleElement.textContent = content.join('\n');
-        this._commentReply?.setCommentEditorDecorations();
-    }
-};
-CommentThreadWidget = ( __decorate([
-    ( __param(12, ICommentService)),
-    ( __param(13, IContextMenuService)),
-    ( __param(14, IConfigurationService)),
-    ( __param(15, IKeybindingService))
-], CommentThreadWidget));
-export { CommentThreadWidget };