@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.1

package/dist/vscode/vs/workbench/contrib/interactiveSession/browser/interactiveSessionListRenderer.js

@@ -1,622 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { renderIcon } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabels.js';
-import { IntervalTimer } from 'monaco-editor/esm/vs/base/common/async.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
-import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
-import { FileAccess } from 'monaco-editor/esm/vs/base/common/network.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
-import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
-import { EditorExtensionsRegistry } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
-import { CodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/codeEditorWidget.js';
-import { EDITOR_FONT_DEFAULTS } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
-import { BracketMatchingController } from 'monaco-editor/esm/vs/editor/contrib/bracketMatching/browser/bracketMatching.js';
-import { ContextMenuController } from 'monaco-editor/esm/vs/editor/contrib/contextmenu/browser/contextmenu.js';
-import { MarkdownRenderer } from 'monaco-editor/esm/vs/editor/contrib/markdownRenderer/browser/markdownRenderer.js';
-import { ViewportSemanticTokensContribution } from 'monaco-editor/esm/vs/editor/contrib/semanticTokens/browser/viewportSemanticTokens.js';
-import { SmartSelectController } from 'monaco-editor/esm/vs/editor/contrib/smartSelect/browser/smartSelect.js';
-import { WordHighlighterContribution } from 'monaco-editor/esm/vs/editor/contrib/wordHighlighter/browser/wordHighlighter.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { MenuEntryActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
-import { MenuWorkbenchToolBar } from 'monaco-editor/esm/vs/platform/actions/browser/toolbar.js';
-import { MenuId, MenuItemAction } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { defaultButtonStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
-import { MenuPreventer } from '../../codeEditor/browser/menuPreventer.js';
-import { SelectionClipboardContributionID } from '../../codeEditor/browser/selectionClipboard.js';
-import { getSimpleEditorOptions } from '../../codeEditor/browser/simpleEditorOptions.js';
-import { InteractiveSessionFollowups } from './interactiveSessionFollowups.js';
-import { CONTEXT_RESPONSE_HAS_PROVIDER_ID, CONTEXT_RESPONSE_VOTE } from '../common/interactiveSessionContextKeys.js';
-import { InteractiveSessionVoteDirection, IInteractiveSessionService } from '../common/interactiveSessionService.js';
-import { isResponseVM, isRequestVM, isWelcomeVM } from '../common/interactiveSessionViewModel.js';
-import { getNWords } from '../common/interactiveSessionWordCounter.js';
-const $ = dom.$;
-let InteractiveListItemRenderer = class InteractiveListItemRenderer extends Disposable {
-    constructor(editorOptions, delegate, instantiationService, configService, logService, commandService, contextKeyService, interactiveSessionService) {
-        super();
-        this.editorOptions = editorOptions;
-        this.delegate = delegate;
-        this.instantiationService = instantiationService;
-        this.configService = configService;
-        this.logService = logService;
-        this.commandService = commandService;
-        this.contextKeyService = contextKeyService;
-        this.interactiveSessionService = interactiveSessionService;
-        this._onDidClickFollowup = this._register(( new Emitter()));
-        this.onDidClickFollowup = this._onDidClickFollowup.event;
-        this._onDidChangeItemHeight = this._register(( new Emitter()));
-        this.onDidChangeItemHeight = this._onDidChangeItemHeight.event;
-        this._currentLayoutWidth = 0;
-        this._isVisible = true;
-        this.renderer = this.instantiationService.createInstance(MarkdownRenderer, {});
-        this._editorPool = this._register(this.instantiationService.createInstance(EditorPool, this.editorOptions));
-    }
-    get templateId() {
-        return InteractiveListItemRenderer.ID;
-    }
-    traceLayout(method, message) {
-        {
-            this.logService.trace(`InteractiveListItemRenderer#${method}: ${message}`);
-        }
-    }
-    progressiveRenderEnabled() {
-        return !this.configService.getValue('interactive.experimental.disableProgressiveRendering');
-    }
-    getProgressiveRenderRate(element) {
-        const configuredRate = this.configService.getValue('interactive.experimental.progressiveRenderingRate');
-        if (typeof configuredRate === 'number') {
-            return configuredRate;
-        }
-        if (element.isComplete) {
-            return 60;
-        }
-        if (element.contentUpdateTimings && element.contentUpdateTimings.impliedWordLoadRate) {
-            const rateBoost = 1.5;
-            return element.contentUpdateTimings.impliedWordLoadRate * rateBoost;
-        }
-        return 8;
-    }
-    setVisible(visible) {
-        this._isVisible = visible;
-    }
-    layout(width) {
-        this._currentLayoutWidth = width - 40;
-        this._editorPool.inUse.forEach(editor => {
-            editor.layout(this._currentLayoutWidth);
-        });
-    }
-    renderTemplate(container) {
-        const templateDisposables = ( new DisposableStore());
-        const rowContainer = dom.append(container, $('.interactive-item-container'));
-        const header = dom.append(rowContainer, $('.header'));
-        const user = dom.append(header, $('.user'));
-        const avatar = dom.append(user, $('.avatar'));
-        const username = dom.append(user, $('h3.username'));
-        const value = dom.append(rowContainer, $('.value'));
-        const elementDisposables = ( new DisposableStore());
-        const contextKeyService = templateDisposables.add(this.contextKeyService.createScoped(rowContainer));
-        const scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyService])));
-        const titleToolbar = templateDisposables.add(scopedInstantiationService.createInstance(MenuWorkbenchToolBar, header, MenuId.InteractiveSessionTitle, {
-            menuOptions: {
-                shouldForwardArgs: true
-            },
-            actionViewItemProvider: (action, options) => {
-                if (action instanceof MenuItemAction) {
-                    return scopedInstantiationService.createInstance(InteractiveSessionVoteButton, action, options);
-                }
-                return undefined;
-            }
-        }));
-        const template = { avatar, username, value, rowContainer, elementDisposables, titleToolbar, templateDisposables, contextKeyService };
-        return template;
-    }
-    renderElement(node, index, templateData) {
-        const { element } = node;
-        const kind = isRequestVM(element) ? 'request' :
-            isResponseVM(element) ? 'response' :
-                'welcome';
-        this.traceLayout('renderElement', `${kind}, index=${index}`);
-        CONTEXT_RESPONSE_HAS_PROVIDER_ID.bindTo(templateData.contextKeyService).set(isResponseVM(element) && !!element.providerResponseId);
-        if (isResponseVM(element)) {
-            CONTEXT_RESPONSE_VOTE.bindTo(templateData.contextKeyService).set(element.vote === InteractiveSessionVoteDirection.Up ? 'up' : element.vote === InteractiveSessionVoteDirection.Down ? 'down' : '');
-        }
-        else {
-            CONTEXT_RESPONSE_VOTE.bindTo(templateData.contextKeyService).set('');
-        }
-        templateData.titleToolbar.context = element;
-        templateData.rowContainer.classList.toggle('interactive-request', isRequestVM(element));
-        templateData.rowContainer.classList.toggle('interactive-response', isResponseVM(element));
-        templateData.rowContainer.classList.toggle('interactive-welcome', isWelcomeVM(element));
-        templateData.rowContainer.classList.toggle('filtered-response', !!(isResponseVM(element) && element.errorDetails?.responseIsFiltered));
-        templateData.username.textContent = element.username;
-        if (element.avatarIconUri) {
-            const avatarIcon = dom.$('img.icon');
-            avatarIcon.src = ( FileAccess.uriToBrowserUri(element.avatarIconUri).toString(true));
-            templateData.avatar.replaceChildren(avatarIcon);
-        }
-        else {
-            const defaultIcon = isRequestVM(element) ? Codicon.account : Codicon.hubot;
-            const avatarIcon = dom.$(ThemeIcon.asCSSSelector(defaultIcon));
-            templateData.avatar.replaceChildren(avatarIcon);
-        }
-        if (isResponseVM(element) && index === this.delegate.getListLength() - 1 && !element.isPlaceholder && (!element.isComplete || element.renderData) && this.progressiveRenderEnabled()) {
-            this.traceLayout('renderElement', `start progressive render ${kind}, index=${index}`);
-            const progressiveRenderingDisposables = templateData.elementDisposables.add(( new DisposableStore()));
-            const timer = templateData.elementDisposables.add(( new IntervalTimer()));
-            const runProgressiveRender = (initial) => {
-                try {
-                    if (this.doNextProgressiveRender(element, index, templateData, !!initial, progressiveRenderingDisposables)) {
-                        timer.cancel();
-                    }
-                }
-                catch (err) {
-                    timer.cancel();
-                    throw err;
-                }
-            };
-            timer.cancelAndSet(runProgressiveRender, 50);
-            runProgressiveRender(true);
-        }
-        else if (isResponseVM(element)) {
-            this.basicRenderElement(element.response.value, element, index, templateData);
-        }
-        else if (isRequestVM(element)) {
-            this.basicRenderElement(element.messageText, element, index, templateData);
-        }
-        else {
-            this.renderWelcomeMessage(element, templateData);
-        }
-    }
-    basicRenderElement(markdownValue, element, index, templateData) {
-        const fillInIncompleteTokens = isResponseVM(element) && (!element.isComplete || element.isCanceled || element.errorDetails?.responseIsFiltered || element.errorDetails?.responseIsIncomplete);
-        const result = this.renderMarkdown(( new MarkdownString(markdownValue)), element, templateData.elementDisposables, templateData, fillInIncompleteTokens);
-        dom.clearNode(templateData.value);
-        templateData.value.appendChild(result.element);
-        templateData.elementDisposables.add(result);
-        if (isResponseVM(element) && element.errorDetails?.message) {
-            const icon = element.errorDetails.responseIsFiltered ? Codicon.info : Codicon.error;
-            const errorDetails = dom.append(templateData.value, $('.interactive-response-error-details', undefined, renderIcon(icon)));
-            errorDetails.appendChild($('span', undefined, element.errorDetails.message));
-        }
-        if (isResponseVM(element) && element.commandFollowups?.length) {
-            const followupsContainer = dom.append(templateData.value, $('.interactive-response-followups'));
-            templateData.elementDisposables.add(( new InteractiveSessionFollowups(
-                followupsContainer,
-                element.commandFollowups,
-                defaultButtonStyles,
-                followup => {
-                    this.interactiveSessionService.notifyUserAction({
-                        providerId: element.providerId,
-                        action: {
-                            kind: 'command',
-                            command: followup
-                        }
-                    });
-                    return this.commandService.executeCommand(followup.commandId, ...(followup.args ?? []));
-                }
-            )));
-        }
-    }
-    renderWelcomeMessage(element, templateData) {
-        dom.clearNode(templateData.value);
-        const slashCommands = this.delegate.getSlashCommands();
-        for (const item of element.content) {
-            if (Array.isArray(item)) {
-                templateData.elementDisposables.add(( new InteractiveSessionFollowups(
-                    templateData.value,
-                    item,
-                    undefined,
-                    followup => this._onDidClickFollowup.fire(followup)
-                )));
-            }
-            else {
-                const result = this.renderMarkdown(item, element, templateData.elementDisposables, templateData);
-                for (const codeElement of result.element.querySelectorAll('code')) {
-                    if (codeElement.textContent && slashCommands.find(command => codeElement.textContent === `/${command.command}`)) {
-                        codeElement.classList.add('interactive-slash-command');
-                    }
-                }
-                templateData.value.appendChild(result.element);
-                templateData.elementDisposables.add(result);
-            }
-        }
-    }
-    doNextProgressiveRender(element, index, templateData, isInRenderElement, disposables) {
-        if (!this._isVisible) {
-            return true;
-        }
-        disposables.clear();
-        let isFullyRendered = false;
-        if (element.isCanceled) {
-            this.traceLayout('runProgressiveRender', `canceled, index=${index}`);
-            element.renderData = undefined;
-            this.basicRenderElement(element.response.value, element, index, templateData);
-            isFullyRendered = true;
-        }
-        else {
-            const renderValue = this.getWordsForProgressiveRender(element);
-            isFullyRendered = !!element.renderData?.isFullyRendered;
-            if (isFullyRendered) {
-                this.traceLayout('runProgressiveRender', `end progressive render, index=${index}`);
-                if (element.isComplete) {
-                    this.traceLayout('runProgressiveRender', `and disposing renderData, response is complete, index=${index}`);
-                    element.renderData = undefined;
-                }
-                else {
-                    this.traceLayout('runProgressiveRender', `Rendered all available words, but model is not complete.`);
-                }
-                disposables.clear();
-                this.basicRenderElement(element.response.value, element, index, templateData);
-            }
-            else if (renderValue) {
-                element.renderData = {
-                    renderedWordCount: renderValue.actualWordCount,
-                    lastRenderTime: Date.now(),
-                    isFullyRendered: renderValue.isFullString
-                };
-                const plusCursor = renderValue.value.match(/```\s*$/) ?
-                    renderValue.value :
-                    renderValue.value + ` ${InteractiveListItemRenderer.cursorCharacter}`;
-                const result = this.renderMarkdown(( new MarkdownString(plusCursor)), element, disposables, templateData, true);
-                dom.clearNode(templateData.value);
-                templateData.value.appendChild(result.element);
-                disposables.add(result);
-            }
-            else {
-                return false;
-            }
-        }
-        const height = templateData.rowContainer.offsetHeight;
-        element.currentRenderedHeight = height;
-        if (!isInRenderElement) {
-            this._onDidChangeItemHeight.fire({ element, height: templateData.rowContainer.offsetHeight });
-        }
-        return !!isFullyRendered;
-    }
-    renderMarkdown(markdown, element, disposables, templateData, fillInIncompleteTokens = false) {
-        const disposablesList = [];
-        let codeBlockIndex = 0;
-        const slashCommands = this.delegate.getSlashCommands();
-        const usedSlashCommand = slashCommands.find(s => markdown.value.startsWith(`/${s.command} `));
-        const toRender = usedSlashCommand ? markdown.value.slice(usedSlashCommand.command.length + 2) : markdown.value;
-        markdown = ( new MarkdownString(toRender));
-        const result = this.renderer.render(markdown, {
-            fillInIncompleteTokens,
-            codeBlockRendererSync: (languageId, text) => {
-                const ref = this.renderCodeBlock({ languageId, text, codeBlockIndex: codeBlockIndex++, element, parentContextKeyService: templateData.contextKeyService }, disposables);
-                disposables.add(ref.object.onDidChangeContentHeight(() => {
-                    ref.object.layout(this._currentLayoutWidth);
-                    this._onDidChangeItemHeight.fire({ element, height: templateData.rowContainer.offsetHeight });
-                }));
-                disposablesList.push(ref);
-                return ref.object.element;
-            }
-        });
-        if (usedSlashCommand) {
-            const slashCommandElement = $('span.interactive-slash-command', { title: usedSlashCommand.detail }, `/${usedSlashCommand.command} `);
-            if (result.element.firstChild?.nodeName.toLowerCase() === 'p') {
-                result.element.firstChild.insertBefore(slashCommandElement, result.element.firstChild.firstChild);
-            }
-            else {
-                result.element.insertBefore($('p', undefined, slashCommandElement), result.element.firstChild);
-            }
-        }
-        disposablesList.reverse().forEach(d => disposables.add(d));
-        return result;
-    }
-    renderCodeBlock(data, disposables) {
-        const ref = this._editorPool.get();
-        const editorInfo = ref.object;
-        editorInfo.render(data, this._currentLayoutWidth);
-        return ref;
-    }
-    getWordsForProgressiveRender(element) {
-        const renderData = element.renderData ?? { renderedWordCount: 0, lastRenderTime: 0 };
-        const rate = this.getProgressiveRenderRate(element);
-        const numWordsToRender = renderData.lastRenderTime === 0 ?
-            1 :
-            renderData.renderedWordCount +
-                Math.floor((Date.now() - renderData.lastRenderTime) / 1000 * rate);
-        if (numWordsToRender === renderData.renderedWordCount) {
-            return undefined;
-        }
-        return getNWords(element.response.value, numWordsToRender);
-    }
-    disposeElement(node, index, templateData) {
-        templateData.elementDisposables.clear();
-    }
-    disposeTemplate(templateData) {
-        templateData.templateDisposables.dispose();
-    }
-};
-InteractiveListItemRenderer.cursorCharacter = '\u258c';
-InteractiveListItemRenderer.ID = 'item';
-InteractiveListItemRenderer = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, ILogService)),
-    ( __param(5, ICommandService)),
-    ( __param(6, IContextKeyService)),
-    ( __param(7, IInteractiveSessionService))
-], InteractiveListItemRenderer));
-let InteractiveSessionListDelegate = class InteractiveSessionListDelegate {
-    constructor(logService) {
-        this.logService = logService;
-    }
-    _traceLayout(method, message) {
-        {
-            this.logService.trace(`InteractiveSessionListDelegate#${method}: ${message}`);
-        }
-    }
-    getHeight(element) {
-        const kind = isRequestVM(element) ? 'request' : 'response';
-        const height = ('currentRenderedHeight' in element ? element.currentRenderedHeight : undefined) ?? 200;
-        this._traceLayout('getHeight', `${kind}, height=${height}`);
-        return height;
-    }
-    getTemplateId(element) {
-        return InteractiveListItemRenderer.ID;
-    }
-    hasDynamicHeight(element) {
-        return true;
-    }
-};
-InteractiveSessionListDelegate = ( __decorate([
-    ( __param(0, ILogService))
-], InteractiveSessionListDelegate));
-class InteractiveSessionAccessibilityProvider {
-    getWidgetRole() {
-        return 'list';
-    }
-    getRole(element) {
-        return 'listitem';
-    }
-    getWidgetAriaLabel() {
-        return ( localize('interactiveSession', "Interactive Session"));
-    }
-    getAriaLabel(element) {
-        if (isRequestVM(element)) {
-            return element.messageText;
-        }
-        if (isResponseVM(element)) {
-            return element.response.value;
-        }
-        if (isWelcomeVM(element)) {
-            return ( element.content.map(c => 'value' in c ? c.value : ( c.map(followup => followup.message)).join('\n'))).join('\n');
-        }
-        return '';
-    }
-}
-const codeBlockInfosByModelUri = ( new ResourceMap());
-const defaultCodeblockPadding = 10;
-let CodeBlockPart = class CodeBlockPart extends Disposable {
-    constructor(options, instantiationService, contextKeyService, languageService, modelService) {
-        super();
-        this.options = options;
-        this.languageService = languageService;
-        this.modelService = modelService;
-        this._onDidChangeContentHeight = this._register(( new Emitter()));
-        this.onDidChangeContentHeight = this._onDidChangeContentHeight.event;
-        this.currentScrollWidth = 0;
-        this.element = $('.interactive-result-editor-wrapper');
-        this.contextKeyService = this._register(contextKeyService.createScoped(this.element));
-        const scopedInstantiationService = instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.contextKeyService])));
-        this.toolbar = this._register(scopedInstantiationService.createInstance(MenuWorkbenchToolBar, this.element, MenuId.InteractiveSessionCodeBlock, {
-            menuOptions: {
-                shouldForwardArgs: true
-            }
-        }));
-        const editorElement = dom.append(this.element, $('.interactive-result-editor'));
-        this.editor = this._register(scopedInstantiationService.createInstance(CodeEditorWidget, editorElement, {
-            ...getSimpleEditorOptions(),
-            readOnly: true,
-            lineNumbers: 'off',
-            selectOnLineNumbers: true,
-            scrollBeyondLastLine: false,
-            lineDecorationsWidth: 8,
-            dragAndDrop: false,
-            padding: { top: defaultCodeblockPadding, bottom: defaultCodeblockPadding },
-            mouseWheelZoom: false,
-            scrollbar: {
-                alwaysConsumeMouseWheel: false
-            },
-            ...this.getEditorOptionsFromConfig()
-        }, {
-            isSimpleWidget: true,
-            contributions: EditorExtensionsRegistry.getSomeEditorContributions([
-                MenuPreventer.ID,
-                SelectionClipboardContributionID,
-                ContextMenuController.ID,
-                WordHighlighterContribution.ID,
-                ViewportSemanticTokensContribution.ID,
-                BracketMatchingController.ID,
-                SmartSelectController.ID,
-            ])
-        }));
-        this._register(this.options.onDidChange(() => {
-            this.editor.updateOptions(this.getEditorOptionsFromConfig());
-        }));
-        this._register(this.editor.onDidScrollChange(e => {
-            this.currentScrollWidth = e.scrollWidth;
-        }));
-        this._register(this.editor.onDidContentSizeChange(e => {
-            if (e.contentHeightChanged) {
-                this._onDidChangeContentHeight.fire(e.contentHeight);
-            }
-        }));
-        this._register(this.editor.onDidBlurEditorWidget(() => {
-            WordHighlighterContribution.get(this.editor)?.stopHighlighting();
-        }));
-        this._register(this.editor.onDidFocusEditorWidget(() => {
-            WordHighlighterContribution.get(this.editor)?.restoreViewState(true);
-        }));
-        const vscodeLanguageId = this.languageService.getLanguageIdByLanguageName('javascript');
-        this.textModel = this._register(this.modelService.createModel('', this.languageService.createById(vscodeLanguageId), undefined));
-        this.editor.setModel(this.textModel);
-    }
-    updatePaddingForLayout() {
-        const horizontalScrollbarVisible = this.currentScrollWidth > this.editor.getLayoutInfo().contentWidth;
-        const scrollbarHeight = this.editor.getLayoutInfo().horizontalScrollbarHeight;
-        const bottomPadding = horizontalScrollbarVisible ?
-            Math.max(defaultCodeblockPadding - scrollbarHeight, 2) :
-            defaultCodeblockPadding;
-        this.editor.updateOptions({ padding: { top: defaultCodeblockPadding, bottom: bottomPadding } });
-    }
-    getEditorOptionsFromConfig() {
-        return {
-            wordWrap: this.options.configuration.resultEditor.wordWrap,
-            fontLigatures: this.options.configuration.resultEditor.fontLigatures,
-            bracketPairColorization: this.options.configuration.resultEditor.bracketPairColorization,
-            fontFamily: this.options.configuration.resultEditor.fontFamily === 'default' ?
-                EDITOR_FONT_DEFAULTS.fontFamily :
-                this.options.configuration.resultEditor.fontFamily,
-            fontSize: this.options.configuration.resultEditor.fontSize,
-            fontWeight: this.options.configuration.resultEditor.fontWeight,
-            lineHeight: this.options.configuration.resultEditor.lineHeight,
-        };
-    }
-    layout(width) {
-        const realContentHeight = this.editor.getContentHeight();
-        const editorBorder = 2;
-        this.editor.layout({ width: width - editorBorder, height: realContentHeight });
-        this.updatePaddingForLayout();
-    }
-    render(data, width) {
-        this.contextKeyService.updateParent(data.parentContextKeyService);
-        if (this.options.configuration.resultEditor.wordWrap === 'on') {
-            this.layout(width);
-        }
-        const text = this.fixCodeText(data.text, data.languageId);
-        this.setText(text);
-        const vscodeLanguageId = withNullAsUndefined(this.languageService.getLanguageIdByLanguageName(data.languageId));
-        this.setLanguage(vscodeLanguageId);
-        this.layout(width);
-        if (isResponseVM(data.element) && data.element.providerResponseId) {
-            codeBlockInfosByModelUri.set(this.textModel.uri, {
-                providerId: data.element.providerId,
-                responseId: data.element.providerResponseId,
-                codeBlockIndex: data.codeBlockIndex
-            });
-        }
-        else {
-            codeBlockInfosByModelUri.delete(this.textModel.uri);
-        }
-        this.toolbar.context = {
-            code: data.text,
-            codeBlockIndex: data.codeBlockIndex,
-            element: data.element,
-            languageId: vscodeLanguageId
-        };
-    }
-    fixCodeText(text, languageId) {
-        if (languageId === 'php') {
-            if (!text.trim().startsWith('<')) {
-                return `<?php\n${text}\n?>`;
-            }
-        }
-        return text;
-    }
-    setText(newText) {
-        let currentText = this.textModel.getLinesContent().join('\n');
-        if (newText === currentText) {
-            return;
-        }
-        let removedChars = 0;
-        if (currentText.endsWith(` ${InteractiveListItemRenderer.cursorCharacter}`)) {
-            removedChars = 2;
-        }
-        else if (currentText.endsWith(InteractiveListItemRenderer.cursorCharacter)) {
-            removedChars = 1;
-        }
-        if (removedChars > 0) {
-            currentText = currentText.slice(0, currentText.length - removedChars);
-        }
-        if (newText.startsWith(currentText)) {
-            const text = newText.slice(currentText.length);
-            const lastLine = this.textModel.getLineCount();
-            const lastCol = this.textModel.getLineMaxColumn(lastLine);
-            const insertAtCol = lastCol - removedChars;
-            this.textModel.applyEdits([{ range: ( new Range(lastLine, insertAtCol, lastLine, lastCol)), text }]);
-        }
-        else {
-            this.textModel.setValue(newText);
-        }
-    }
-    setLanguage(vscodeLanguageId) {
-        this.textModel.setLanguage(vscodeLanguageId ?? PLAINTEXT_LANGUAGE_ID);
-    }
-};
-CodeBlockPart = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IContextKeyService)),
-    ( __param(3, ILanguageService)),
-    ( __param(4, IModelService))
-], CodeBlockPart));
-let EditorPool = class EditorPool extends Disposable {
-    get inUse() {
-        return this._pool.inUse;
-    }
-    constructor(options, instantiationService) {
-        super();
-        this.options = options;
-        this.instantiationService = instantiationService;
-        this._pool = this._register(( new ResourcePool(() => this.editorFactory())));
-    }
-    editorFactory() {
-        return this.instantiationService.createInstance(CodeBlockPart, this.options);
-    }
-    get() {
-        const object = this._pool.get();
-        return {
-            object,
-            dispose: () => this._pool.release(object)
-        };
-    }
-};
-EditorPool = ( __decorate([
-    ( __param(1, IInstantiationService))
-], EditorPool));
-class ResourcePool extends Disposable {
-    get inUse() {
-        return this._inUse;
-    }
-    constructor(_itemFactory) {
-        super();
-        this._itemFactory = _itemFactory;
-        this.pool = [];
-        this._inUse = ( new Set());
-    }
-    get() {
-        if (this.pool.length > 0) {
-            const item = this.pool.pop();
-            this._inUse.add(item);
-            return item;
-        }
-        const item = this._register(this._itemFactory());
-        this._inUse.add(item);
-        return item;
-    }
-    release(item) {
-        this._inUse.delete(item);
-        this.pool.push(item);
-    }
-}
-class InteractiveSessionVoteButton extends MenuEntryActionViewItem {
-    render(container) {
-        super.render(container);
-        container.classList.toggle('checked', this.action.checked);
-    }
-}
-export { InteractiveListItemRenderer, InteractiveSessionAccessibilityProvider, InteractiveSessionListDelegate, codeBlockInfosByModelUri };