@codingame/monaco-vscode-katex-common 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatListWidget.js

@@ -0,0 +1,485 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { createElement, Dimension } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { WorkbenchObjectTree } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { asCssVariable } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import { buttonSecondaryHoverBackground, buttonSecondaryForeground, buttonSecondaryBackground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { katexContainerClassName } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/markdown/common/markedKatexExtension';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatModeKind, ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { isRequestVM, isResponseVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel';
+import { CodeBlockModelCollection } from '../../common/widget/codeBlockModelCollection.js';
+import { ChatAccessibilityProvider } from '../accessibility/chatAccessibilityProvider.js';
+import { IChatAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatListDelegate, ChatListItemRenderer } from './chatListRenderer.js';
+import { ChatEditorOptions } from './chatOptions.js';
+
+let ChatListWidget = class ChatListWidget extends Disposable {
+    get onDidClickRequest() {
+        return this._renderer.onDidClickRequest;
+    }
+    get onDidRerender() {
+        return this._renderer.onDidRerender;
+    }
+    get onDidDispose() {
+        return this._renderer.onDidDispose;
+    }
+    get onDidFocusOutside() {
+        return this._renderer.onDidFocusOutside;
+    }
+    get domNode() {
+        return this._container;
+    }
+    get scrollTop() {
+        return this._tree.scrollTop;
+    }
+    set scrollTop(value) {
+        this._tree.scrollTop = value;
+    }
+    get scrollHeight() {
+        return this._tree.scrollHeight;
+    }
+    get renderHeight() {
+        return this._tree.renderHeight;
+    }
+    get contentHeight() {
+        return this._tree.contentHeight;
+    }
+    get isScrolledToBottom() {
+        return this._tree.scrollTop + this._tree.renderHeight >= this._tree.scrollHeight - 2;
+    }
+    get lastItem() {
+        return this._lastItem;
+    }
+    constructor(
+        container,
+        options,
+        instantiationService,
+        contextKeyService,
+        chatService,
+        contextMenuService,
+        logService,
+        configurationService,
+        chatAccessibilityService
+    ) {
+        super();
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.chatService = chatService;
+        this.contextMenuService = contextMenuService;
+        this.logService = logService;
+        this.configurationService = configurationService;
+        this.chatAccessibilityService = chatAccessibilityService;
+        this._onDidScroll = this._register(( new Emitter()));
+        this.onDidScroll = this._onDidScroll.event;
+        this._onDidChangeContentHeight = this._register(( new Emitter()));
+        this.onDidChangeContentHeight = this._onDidChangeContentHeight.event;
+        this._onDidClickFollowup = this._register(( new Emitter()));
+        this.onDidClickFollowup = this._onDidClickFollowup.event;
+        this._onDidFocus = this._register(( new Emitter()));
+        this.onDidFocus = this._onDidFocus.event;
+        this._onDidChangeItemHeight = this._register(( new Emitter()));
+        this.onDidChangeItemHeight = this._onDidChangeItemHeight.event;
+        this._visible = true;
+        this._mostRecentlyFocusedItemIndex = -1;
+        this._scrollLock = true;
+        this._settingChangeCounter = 0;
+        this._visibleChangeCount = 0;
+        this._bodyDimension = null;
+        this._previousLastItemMinHeight = null;
+        this._viewModel = options.viewModel;
+        this._codeBlockModelCollection = options.codeBlockModelCollection ?? this._register(
+            this.instantiationService.createInstance(CodeBlockModelCollection, "chatListWidget")
+        );
+        this._location = options.location;
+        this._getCurrentLanguageModelId = options.getCurrentLanguageModelId;
+        this._getCurrentModeInfo = options.getCurrentModeInfo;
+        this._lastItemIdContextKey = ChatContextKeys.lastItemId.bindTo(this.contextKeyService);
+        this._container = container;
+        const scopedInstantiationService = this._register(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.contextKeyService]))));
+        this._renderStyle = options.renderStyle;
+        const overflowWidgetsContainer = options.overflowWidgetsDomNode ?? createElement("div");
+        if (!options.overflowWidgetsDomNode) {
+            overflowWidgetsContainer.classList.add("chat-overflow-widget-container", "monaco-editor");
+            this._container.append(overflowWidgetsContainer);
+            this._register(toDisposable(() => overflowWidgetsContainer.remove()));
+        }
+        const editorOptions = options.editorOptions ?? this._register(scopedInstantiationService.createInstance(
+            ChatEditorOptions,
+            options.viewId,
+            "foreground",
+            options.inputEditorBackground ?? "chat.requestEditor.background",
+            options.resultEditorBackground ?? "chat.responseEditor.background"
+        ));
+        const delegate = scopedInstantiationService.createInstance(ChatListDelegate, options.defaultElementHeight ?? 200);
+        const rendererDelegate = {
+            getListLength: () => this._tree.getNode(null).visibleChildrenCount,
+            onDidScroll: this.onDidScroll,
+            container: this._container,
+            currentChatMode: options.currentChatMode ?? (() => ChatModeKind.Ask)
+        };
+        this._renderer = this._register(scopedInstantiationService.createInstance(
+            ChatListItemRenderer,
+            editorOptions,
+            options.rendererOptions ?? {},
+            rendererDelegate,
+            this._codeBlockModelCollection,
+            overflowWidgetsContainer,
+            this._viewModel
+        ));
+        this._register(this._renderer.onDidClickFollowup(item => {
+            this._onDidClickFollowup.fire(item);
+        }));
+        this._register(this._renderer.onDidChangeItemHeight(e => {
+            this._updateElementHeight(e.element, e.height);
+            const secondToLastItem = this._viewModel?.getItems().at(-2);
+            if (e.element.id === secondToLastItem?.id) {
+                this.updateLastItemMinHeight();
+            }
+            this._onDidChangeItemHeight.fire(e);
+        }));
+        this._register(this._renderer.onDidClickRerunWithAgentOrCommandDetection(e => {
+            const request = this.chatService.getSession(e.sessionResource)?.getRequests().find(candidate => candidate.id === e.requestId);
+            if (request) {
+                const sendOptions = {
+                    noCommandDetection: true,
+                    attempt: request.attempt + 1,
+                    location: this._location,
+                    userSelectedModelId: this._getCurrentLanguageModelId?.(),
+                    modeInfo: this._getCurrentModeInfo?.()
+                };
+                this.chatAccessibilityService.acceptRequest(e.sessionResource);
+                this.chatService.resendRequest(request, sendOptions).catch(e => this.logService.error("FAILED to rerun request", e));
+            }
+        }));
+        const styles = options.styles ?? {};
+        this._tree = this._register(scopedInstantiationService.createInstance(
+            WorkbenchObjectTree,
+            "ChatList",
+            this._container,
+            delegate,
+            [this._renderer],
+            {
+                identityProvider: {
+                    getId: e => e.id
+                },
+                horizontalScrolling: false,
+                alwaysConsumeMouseWheel: false,
+                supportDynamicHeights: true,
+                hideTwistiesOfChildlessElements: true,
+                accessibilityProvider: this.instantiationService.createInstance(ChatAccessibilityProvider),
+                keyboardNavigationLabelProvider: {
+                    getKeyboardNavigationLabel: e => isRequestVM(e) ? e.message : isResponseVM(e) ? e.response.value : ""
+                },
+                setRowLineHeight: false,
+                scrollToActiveElement: true,
+                filter: options.filter,
+                overrideStyles: {
+                    listFocusBackground: styles.listBackground,
+                    listInactiveFocusBackground: styles.listBackground,
+                    listActiveSelectionBackground: styles.listBackground,
+                    listFocusAndSelectionBackground: styles.listBackground,
+                    listInactiveSelectionBackground: styles.listBackground,
+                    listHoverBackground: styles.listBackground,
+                    listBackground: styles.listBackground,
+                    listFocusForeground: styles.listForeground,
+                    listHoverForeground: styles.listForeground,
+                    listInactiveFocusForeground: styles.listForeground,
+                    listInactiveSelectionForeground: styles.listForeground,
+                    listActiveSelectionForeground: styles.listForeground,
+                    listFocusAndSelectionForeground: styles.listForeground,
+                    listActiveSelectionIconForeground: undefined,
+                    listInactiveSelectionIconForeground: undefined
+                }
+            }
+        ));
+        this._scrollDownButton = this._register(( new Button(this._container, {
+            buttonBackground: asCssVariable(buttonSecondaryBackground),
+            buttonForeground: asCssVariable(buttonSecondaryForeground),
+            buttonHoverBackground: asCssVariable(buttonSecondaryHoverBackground),
+            buttonSecondaryBackground: undefined,
+            buttonSecondaryForeground: undefined,
+            buttonSecondaryHoverBackground: undefined,
+            buttonSeparator: undefined,
+            supportIcons: true
+        })));
+        this._scrollDownButton.element.classList.add("chat-scroll-down");
+        this._scrollDownButton.label = `$(${Codicon.chevronDown.id})`;
+        this._scrollDownButton.element.style.display = "none";
+        this._register(this._scrollDownButton.onDidClick(() => {
+            this.setScrollLock(true);
+            this.scrollToEnd();
+        }));
+        this._register(this._tree.onDidChangeContentHeight(() => {
+            this._onDidChangeContentHeight.fire();
+        }));
+        this._register(this._tree.onDidFocus(() => {
+            this._onDidFocus.fire();
+        }));
+        this._register(this._tree.onDidChangeFocus(() => {
+            const focused = this.getFocus();
+            if (focused && focused.length > 0) {
+                const focusedItem = focused[0];
+                const items = this.getItems();
+                const idx = items.findIndex(i => i === focusedItem);
+                if (idx !== -1) {
+                    this._mostRecentlyFocusedItemIndex = idx;
+                }
+            }
+        }));
+        this._register(this._tree.onDidScroll(e => {
+            this._onDidScroll.fire(e);
+            this.updateScrollDownButtonVisibility();
+        }));
+        this._register(this._tree.onContextMenu(e => {
+            this.handleContextMenu(e);
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ChatConfiguration.EditRequests) || e.affectsConfiguration(ChatConfiguration.CheckpointsEnabled)) {
+                this._settingChangeCounter++;
+                this.refresh();
+            }
+        }));
+    }
+    updateScrollDownButtonVisibility() {
+        const show = !this.isScrolledToBottom && !this._scrollLock;
+        this._scrollDownButton.element.style.display = show ? "" : "none";
+    }
+    handleContextMenu(e) {
+        e.browserEvent.preventDefault();
+        e.browserEvent.stopPropagation();
+        const selected = e.element;
+        const target = e.browserEvent.target;
+        const isKatexElement = target.closest(`.${katexContainerClassName}`) !== null;
+        const scopedContextKeyService = this.contextKeyService.createOverlay([[
+            ChatContextKeys.responseIsFiltered.key,
+            isResponseVM(selected) && !!selected.errorDetails?.responseIsFiltered
+        ], [ChatContextKeys.isKatexMathElement.key, isKatexElement]]);
+        this.contextMenuService.showContextMenu({
+            menuId: MenuId.ChatContext,
+            menuActionOptions: {
+                shouldForwardArgs: true
+            },
+            contextKeyService: scopedContextKeyService,
+            getAnchor: () => e.anchor,
+            getActionsContext: () => selected
+        });
+    }
+    setViewModel(viewModel) {
+        this._viewModel = viewModel;
+        this._renderer.updateViewModel(viewModel);
+    }
+    refresh() {
+        if (!this._viewModel) {
+            this._tree.setChildren(null, []);
+            this._lastItem = undefined;
+            this._lastItemIdContextKey.set([]);
+            return;
+        }
+        const items = this._viewModel.getItems();
+        this._lastItem = items.at(-1);
+        this._lastItemIdContextKey.set(this._lastItem ? [this._lastItem.id] : []);
+        const treeItems = ( items.map(item => ({
+            element: item,
+            collapsed: false,
+            collapsible: false
+        })));
+        const editing = this._viewModel.editing;
+        const checkpoint = this._viewModel.model?.checkpoint;
+        this._withPersistedAutoScroll(() => {
+            this._tree.setChildren(null, treeItems, {
+                diffIdentityProvider: {
+                    getId: element => {
+                        return (
+                            element.dataId +
+                            `${isResponseVM(element) && element.renderData ? `_${this._visibleChangeCount}` : ""}` + (isResponseVM(element) ? `_${element.contentReferences.length}` : "") +
+                            `_${element.shouldBeRemovedOnSend ? `${element.shouldBeRemovedOnSend.afterUndoStop || "1"}` : "0"}` +
+                            `_${editing ? "1" : "0"}` +
+                            `_${checkpoint ? "1" : "0"}` +
+                            `_setting${this._settingChangeCounter}` + (isRequestVM(element) && element.contentReferences ? `_${element.contentReferences?.length}` : "")
+                        );
+                    }
+                }
+            });
+        });
+    }
+    setScrollLock(value) {
+        this._scrollLock = value;
+        this.updateScrollDownButtonVisibility();
+    }
+    get scrollLock() {
+        return this._scrollLock;
+    }
+    setVisibleChangeCount(value) {
+        this._visibleChangeCount = value;
+    }
+    scrollToCurrentItem(currentElement) {
+        if (!this._viewModel?.editing || !currentElement) {
+            return;
+        }
+        if (!this._tree.hasElement(currentElement)) {
+            return;
+        }
+        const relativeTop = this._tree.getRelativeTop(currentElement);
+        if (relativeTop === null || relativeTop < 0 || relativeTop > 1) {
+            this._tree.reveal(currentElement, 0);
+        }
+    }
+    rerender() {
+        this._tree.rerender();
+    }
+    getItems() {
+        const items = [];
+        const root = this._tree.getNode(null);
+        for (const child of root.children) {
+            if (child.element) {
+                items.push(child.element);
+            }
+        }
+        return items;
+    }
+    delegateScrollFromMouseWheelEvent(event) {
+        this._tree.delegateScrollFromMouseWheelEvent(event);
+    }
+    hasElement(element) {
+        return this._tree.hasElement(element);
+    }
+    _updateElementHeight(element, height) {
+        if (this._tree.hasElement(element) && this._visible) {
+            this._withPersistedAutoScroll(() => {
+                this._tree.updateElementHeight(element, height);
+            });
+        }
+    }
+    reveal(element, relativeTop) {
+        this._tree.reveal(element, relativeTop);
+    }
+    getFocus() {
+        return this._tree.getFocus().filter(e => e !== null);
+    }
+    setFocus(elements) {
+        this._tree.setFocus(elements);
+    }
+    focusItem(item) {
+        if (!this.hasElement(item)) {
+            return;
+        }
+        this._tree.setFocus([item]);
+        this._tree.domFocus();
+    }
+    focusLastItem(useMostRecentlyFocusedIndex) {
+        const items = this.getItems();
+        if (items.length === 0) {
+            return -1;
+        }
+        let focusIndex;
+        if (useMostRecentlyFocusedIndex && this._mostRecentlyFocusedItemIndex >= 0 && this._mostRecentlyFocusedItemIndex < items.length) {
+            focusIndex = this._mostRecentlyFocusedItemIndex;
+        } else {
+            focusIndex = items.length - 1;
+        }
+        this._tree.setFocus([items[focusIndex]]);
+        this._tree.domFocus();
+        return focusIndex;
+    }
+    scrollToEnd() {
+        if (this._lastItem) {
+            const offset = Math.max(this._lastItem.currentRenderedHeight ?? 0, 1e6);
+            if (this._tree.hasElement(this._lastItem)) {
+                this._tree.reveal(this._lastItem, offset);
+            }
+        }
+    }
+    _withPersistedAutoScroll(fn) {
+        const wasScrolledToBottom = this.isScrolledToBottom;
+        fn();
+        if (wasScrolledToBottom) {
+            this.scrollToEnd();
+        }
+    }
+    focus() {
+        this._tree.domFocus();
+    }
+    isDOMFocused() {
+        return this._tree.isDOMFocused();
+    }
+    getCodeBlockInfosForResponse(response) {
+        return this._renderer.getCodeBlockInfosForResponse(response);
+    }
+    getCodeBlockInfoForEditor(uri) {
+        return this._renderer.getCodeBlockInfoForEditor(uri);
+    }
+    getFileTreeInfosForResponse(response) {
+        return this._renderer.getFileTreeInfosForResponse(response);
+    }
+    getLastFocusedFileTreeForResponse(response) {
+        return this._renderer.getLastFocusedFileTreeForResponse(response);
+    }
+    editorsInUse() {
+        return this._renderer.editorsInUse();
+    }
+    getTemplateDataForRequestId(requestId) {
+        if (!requestId) {
+            return undefined;
+        }
+        return this._renderer.getTemplateDataForRequestId(requestId);
+    }
+    updateRendererOptions(options) {
+        this._renderer.updateOptions(options);
+    }
+    setVisible(visible) {
+        this._visible = visible;
+        this._renderer.setVisible(visible);
+    }
+    layout(height, width) {
+        this._bodyDimension = new Dimension(width ?? this._container.clientWidth, height);
+        this.updateLastItemMinHeight();
+        this._tree.layout(height, width);
+        this._renderer.layout(width ?? this._container.clientWidth);
+    }
+    updateLastItemMinHeight() {
+        if (!this._bodyDimension) {
+            return;
+        }
+        const contentHeight = this._bodyDimension.height;
+        if (this._renderStyle === "compact" || this._renderStyle === "minimal") {
+            this._container.style.removeProperty("--chat-current-response-min-height");
+        } else {
+            const secondToLastItem = this._viewModel?.getItems().at(-2);
+            const secondToLastItemHeight = Math.min(secondToLastItem?.currentRenderedHeight ?? 150, 150);
+            const lastItemMinHeight = Math.max(contentHeight - (secondToLastItemHeight + 10), 0);
+            this._container.style.setProperty("--chat-current-response-min-height", lastItemMinHeight + "px");
+            if (lastItemMinHeight !== this._previousLastItemMinHeight) {
+                this._previousLastItemMinHeight = lastItemMinHeight;
+                const lastItem = this._viewModel?.getItems().at(-1);
+                if (lastItem && this._visible && this._tree.hasElement(lastItem)) {
+                    this._updateElementHeight(lastItem, undefined);
+                }
+            }
+        }
+    }
+};
+ChatListWidget = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IContextKeyService)), ( __param(4, IChatService)), ( __param(5, IContextMenuService)), ( __param(6, ILogService)), ( __param(7, IConfigurationService)), ( __param(8, IChatAccessibilityService))], ChatListWidget));
+
+export { ChatListWidget };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatOptions.js

@@ -8,24 +8,38 @@ import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/w
 
 var ChatEditorOptions_1;
 let ChatEditorOptions = class ChatEditorOptions extends Disposable {
-    static { ChatEditorOptions_1 = this; }
-    static { this.lineHeightEm = 1.4; }
+    static {
+        ChatEditorOptions_1 = this;
+    }
+    static {
+        this.lineHeightEm = 1.4;
+    }
     get configuration() {
         return this._config;
     }
-    static { this.relevantSettingIds = [
-        'chat.editor.lineHeight',
-        'chat.editor.fontSize',
-        'chat.editor.fontFamily',
-        'chat.editor.fontWeight',
-        'chat.editor.wordWrap',
-        'editor.cursorBlinking',
-        'editor.fontLigatures',
-        'editor.accessibilitySupport',
-        'editor.bracketPairColorization.enabled',
-        'editor.bracketPairColorization.independentColorPoolPerBracketType',
-    ]; }
-    constructor(viewId, foreground, inputEditorBackgroundColor, resultEditorBackgroundColor, configurationService, themeService, viewDescriptorService) {
+    static {
+        this.relevantSettingIds = [
+            "chat.editor.lineHeight",
+            "chat.editor.fontSize",
+            "chat.editor.fontFamily",
+            "chat.editor.fontWeight",
+            "chat.editor.wordWrap",
+            "editor.cursorBlinking",
+            "editor.fontLigatures",
+            "editor.accessibilitySupport",
+            "editor.bracketPairColorization.enabled",
+            "editor.bracketPairColorization.independentColorPoolPerBracketType"
+        ];
+    }
+    constructor(
+        viewId,
+        foreground,
+        inputEditorBackgroundColor,
+        resultEditorBackgroundColor,
+        configurationService,
+        themeService,
+        viewDescriptorService
+    ) {
         super();
         this.foreground = foreground;
         this.inputEditorBackgroundColor = inputEditorBackgroundColor;
@@ -49,36 +63,32 @@ let ChatEditorOptions = class ChatEditorOptions extends Disposable {
         this.update();
     }
     update() {
-        const editorConfig = this.configurationService.getValue('editor');
-        const chatEditorConfig = this.configurationService.getValue('chat')?.editor;
-        const accessibilitySupport = this.configurationService.getValue('editor.accessibilitySupport');
+        const editorConfig = this.configurationService.getValue("editor");
+        const chatEditorConfig = this.configurationService.getValue("chat")?.editor;
+        const accessibilitySupport = this.configurationService.getValue("editor.accessibilitySupport");
         this._config = {
             foreground: this.themeService.getColorTheme().getColor(this.foreground),
             inputEditor: {
                 backgroundColor: this.themeService.getColorTheme().getColor(this.inputEditorBackgroundColor),
-                accessibilitySupport,
+                accessibilitySupport
             },
             resultEditor: {
                 backgroundColor: this.themeService.getColorTheme().getColor(this.resultEditorBackgroundColor),
                 fontSize: chatEditorConfig.fontSize,
-                fontFamily: chatEditorConfig.fontFamily === 'default' ? editorConfig.fontFamily : chatEditorConfig.fontFamily,
+                fontFamily: chatEditorConfig.fontFamily === "default" ? editorConfig.fontFamily : chatEditorConfig.fontFamily,
                 fontWeight: chatEditorConfig.fontWeight,
                 lineHeight: chatEditorConfig.lineHeight ? chatEditorConfig.lineHeight : ChatEditorOptions_1.lineHeightEm * chatEditorConfig.fontSize,
                 bracketPairColorization: {
-                    enabled: this.configurationService.getValue('editor.bracketPairColorization.enabled'),
-                    independentColorPoolPerBracketType: this.configurationService.getValue('editor.bracketPairColorization.independentColorPoolPerBracketType'),
+                    enabled: this.configurationService.getValue("editor.bracketPairColorization.enabled"),
+                    independentColorPoolPerBracketType: this.configurationService.getValue("editor.bracketPairColorization.independentColorPoolPerBracketType")
                 },
                 wordWrap: chatEditorConfig.wordWrap,
-                fontLigatures: editorConfig.fontLigatures,
+                fontLigatures: editorConfig.fontLigatures
             }
         };
         this._onDidChange.fire();
     }
 };
-ChatEditorOptions = ChatEditorOptions_1 = ( __decorate([
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IThemeService)),
-    ( __param(6, IViewDescriptorService))
-], ChatEditorOptions));
+ChatEditorOptions = ChatEditorOptions_1 = ( __decorate([( __param(4, IConfigurationService)), ( __param(5, IThemeService)), ( __param(6, IViewDescriptorService))], ChatEditorOptions));
 
 export { ChatEditorOptions };