@codingame/monaco-vscode-katex-common 24.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/codeBlockPart.js

@@ -0,0 +1,797 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as codeBlockPart from './codeBlockPart.css';
+import { $ as $$1, append, hide, show, clearNode, getTotalHeight, Dimension, reset } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { renderFormattedText } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/formattedTextRenderer';
+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, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, MutableDisposable, combinedDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { EditorExtensionsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions';
+import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
+import { CodeEditorWidget } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/codeEditor/codeEditorWidget';
+import { DiffEditorWidget } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/diffEditor/diffEditorWidget';
+import { EditorOption } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions';
+import { EDITOR_FONT_DEFAULTS } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/fontInfo';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { ScrollType } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorCommon';
+import { TextEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { EndOfLinePreference } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { TextModelText } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModelText';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { DefaultModelSHA1Computer } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/modelService';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { BracketMatchingController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/bracketMatching/browser/bracketMatching';
+import { ColorDetector } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/colorPicker/browser/colorDetector';
+import { ContextMenuController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/contextmenu/browser/contextmenu';
+import { GotoDefinitionAtPositionEditorContribution } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/gotoSymbol/browser/link/goToDefinitionAtPosition';
+import { ContentHoverController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/hover/browser/contentHoverController';
+import { GlyphHoverController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/hover/browser/glyphHoverController';
+import { LinkDetector } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/links/browser/links';
+import { MessageController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/message/browser/messageController';
+import { ViewportSemanticTokensContribution } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/semanticTokens/browser/viewportSemanticTokens';
+import { SmartSelectController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/smartSelect/browser/smartSelect';
+import { WordHighlighterContribution } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/wordHighlighter/browser/wordHighlighter';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service';
+import { MenuWorkbenchToolBar } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+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 { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { FileKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+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 { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { ResourceLabel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/labels';
+import { ResourceContextKey } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { AccessibilityVerbositySettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { InspectEditorTokensController } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/codeEditor/browser/inspectEditorTokens/inspectEditorTokens';
+import { MenuPreventer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/codeEditor/browser/menuPreventer';
+import { SelectionClipboardContributionID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/codeEditor/browser/selectionClipboard';
+import { getSimpleEditorOptions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/codeEditor/browser/simpleEditorOptions';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { isRequestVM, isResponseVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+import { emptyProgressRunner } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress';
+import { IEditorProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
+import { SuggestController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/suggest/browser/suggestController';
+import { SnippetController2 } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/snippet/browser/snippetController2';
+
+registerCss(codeBlockPart);
+const $ = $$1;
+const localFileLanguageId = 'vscode-local-file';
+function parseLocalFileData(text) {
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch (e) {
+        throw ( new Error('Could not parse code block local file data'));
+    }
+    let uri;
+    try {
+        uri = URI.revive(data?.uri);
+    }
+    catch (e) {
+        throw ( new Error('Invalid code block local file data URI'));
+    }
+    let range;
+    if (data.range) {
+        range = ( new Range(
+            data.range.startLineNumber + 1,
+            data.range.startColumn + 1,
+            data.range.endLineNumber + 1,
+            data.range.endColumn + 1
+        ));
+    }
+    return { uri, range };
+}
+const defaultCodeblockPadding = 10;
+let CodeBlockPart = class CodeBlockPart extends Disposable {
+    get verticalPadding() {
+        return this.currentCodeBlockData?.renderOptions?.verticalPadding ?? defaultCodeblockPadding;
+    }
+    constructor(editorOptions, menuId, delegate, overflowWidgetsDomNode, isSimpleWidget = false, instantiationService, contextKeyService, modelService, configurationService, accessibilityService) {
+        super();
+        this.editorOptions = editorOptions;
+        this.menuId = menuId;
+        this.isSimpleWidget = isSimpleWidget;
+        this.modelService = modelService;
+        this.configurationService = configurationService;
+        this.accessibilityService = accessibilityService;
+        this._onDidChangeContentHeight = this._register(( new Emitter()));
+        this.onDidChangeContentHeight = this._onDidChangeContentHeight.event;
+        this.currentScrollWidth = 0;
+        this.isDisposed = false;
+        this.element = $('.interactive-result-code-block');
+        this.resourceContextKey = this._register(instantiationService.createInstance(ResourceContextKey));
+        this.contextKeyService = this._register(contextKeyService.createScoped(this.element));
+        const scopedInstantiationService = this._register(instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.contextKeyService]))));
+        const editorElement = append(this.element, $('.interactive-result-editor'));
+        this.editor = this.createEditor(scopedInstantiationService, editorElement, {
+            ...getSimpleEditorOptions(this.configurationService),
+            readOnly: true,
+            lineNumbers: 'off',
+            selectOnLineNumbers: true,
+            scrollBeyondLastLine: false,
+            lineDecorationsWidth: 8,
+            dragAndDrop: false,
+            padding: { top: this.verticalPadding, bottom: this.verticalPadding },
+            mouseWheelZoom: false,
+            scrollbar: {
+                vertical: 'hidden',
+                alwaysConsumeMouseWheel: false
+            },
+            definitionLinkOpensInPeek: false,
+            gotoLocation: {
+                multiple: 'goto',
+                multipleDeclarations: 'goto',
+                multipleDefinitions: 'goto',
+                multipleImplementations: 'goto',
+            },
+            ariaLabel: ( localize(5673, 'Code block')),
+            overflowWidgetsDomNode,
+            tabFocusMode: true,
+            ...this.getEditorOptionsFromConfig(),
+        });
+        const toolbarElement = append(this.element, $('.interactive-result-code-block-toolbar'));
+        const editorScopedService = this.editor.contextKeyService.createScoped(toolbarElement);
+        const editorScopedInstantiationService = this._register(scopedInstantiationService.createChild(( new ServiceCollection([IContextKeyService, editorScopedService]))));
+        this.toolbar = this._register(editorScopedInstantiationService.createInstance(MenuWorkbenchToolBar, toolbarElement, menuId, {
+            menuOptions: {
+                shouldForwardArgs: true
+            }
+        }));
+        const vulnsContainer = append(this.element, $('.interactive-result-vulns'));
+        const vulnsHeaderElement = append(vulnsContainer, $('.interactive-result-vulns-header', undefined));
+        this.vulnsButton = this._register(( new Button(vulnsHeaderElement, {
+            buttonBackground: undefined,
+            buttonBorder: undefined,
+            buttonForeground: undefined,
+            buttonHoverBackground: undefined,
+            buttonSecondaryBackground: undefined,
+            buttonSecondaryForeground: undefined,
+            buttonSecondaryHoverBackground: undefined,
+            buttonSeparator: undefined,
+            supportIcons: true
+        })));
+        this.vulnsListElement = append(vulnsContainer, $('ul.interactive-result-vulns-list'));
+        this._register(this.vulnsButton.onDidClick(() => {
+            const element = this.currentCodeBlockData.element;
+            element.vulnerabilitiesListExpanded = !element.vulnerabilitiesListExpanded;
+            this.vulnsButton.label = this.getVulnerabilitiesLabel();
+            this.element.classList.toggle('chat-vulnerabilities-collapsed', !element.vulnerabilitiesListExpanded);
+            this._onDidChangeContentHeight.fire();
+        }));
+        this._register(this.toolbar.onDidChangeDropdownVisibility(e => {
+            toolbarElement.classList.toggle('force-visibility', e);
+        }));
+        this._configureForScreenReader();
+        this._register(this.accessibilityService.onDidChangeScreenReaderOptimized(() => this._configureForScreenReader()));
+        this._register(this.configurationService.onDidChangeConfiguration((e) => {
+            if (( e.affectedKeys.has(AccessibilityVerbositySettingId.Chat))) {
+                this._configureForScreenReader();
+            }
+        }));
+        this._register(this.editorOptions.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();
+            }
+        }));
+        this._register(this.editor.onDidBlurEditorWidget(() => {
+            this.element.classList.remove('focused');
+            WordHighlighterContribution.get(this.editor)?.stopHighlighting();
+            this.clearWidgets();
+        }));
+        this._register(this.editor.onDidFocusEditorWidget(() => {
+            this.element.classList.add('focused');
+            WordHighlighterContribution.get(this.editor)?.restoreViewState(true);
+        }));
+        this._register(Event.any(this.editor.onDidChangeModel, this.editor.onDidChangeModelContent)(() => {
+            if (this.currentCodeBlockData) {
+                this.updateContexts(this.currentCodeBlockData);
+            }
+        }));
+        if (delegate.onDidScroll) {
+            this._register(delegate.onDidScroll(e => {
+                this.clearWidgets();
+            }));
+        }
+    }
+    dispose() {
+        this.isDisposed = true;
+        super.dispose();
+    }
+    get uri() {
+        return this.editor.getModel()?.uri;
+    }
+    createEditor(instantiationService, parent, options) {
+        return this._register(instantiationService.createInstance(CodeEditorWidget, parent, options, {
+            isSimpleWidget: this.isSimpleWidget,
+            contributions: EditorExtensionsRegistry.getSomeEditorContributions([
+                MenuPreventer.ID,
+                SelectionClipboardContributionID,
+                ContextMenuController.ID,
+                WordHighlighterContribution.ID,
+                ViewportSemanticTokensContribution.ID,
+                BracketMatchingController.ID,
+                SmartSelectController.ID,
+                ContentHoverController.ID,
+                GlyphHoverController.ID,
+                MessageController.ID,
+                GotoDefinitionAtPositionEditorContribution.ID,
+                SuggestController.ID,
+                SnippetController2.ID,
+                ColorDetector.ID,
+                LinkDetector.ID,
+                InspectEditorTokensController.ID,
+            ])
+        }));
+    }
+    focus() {
+        this.editor.focus();
+    }
+    updatePaddingForLayout() {
+        const horizontalScrollbarVisible = this.currentScrollWidth > this.editor.getLayoutInfo().contentWidth;
+        const scrollbarHeight = this.editor.getLayoutInfo().horizontalScrollbarHeight;
+        const bottomPadding = horizontalScrollbarVisible ?
+            Math.max(this.verticalPadding - scrollbarHeight, 2) :
+            this.verticalPadding;
+        this.editor.updateOptions({ padding: { top: this.verticalPadding, bottom: bottomPadding } });
+    }
+    _configureForScreenReader() {
+        const toolbarElt = this.toolbar.getElement();
+        if (this.accessibilityService.isScreenReaderOptimized()) {
+            toolbarElt.style.display = 'block';
+        }
+        else {
+            toolbarElt.style.display = '';
+        }
+    }
+    getEditorOptionsFromConfig() {
+        return {
+            wordWrap: this.editorOptions.configuration.resultEditor.wordWrap,
+            fontLigatures: this.editorOptions.configuration.resultEditor.fontLigatures,
+            bracketPairColorization: this.editorOptions.configuration.resultEditor.bracketPairColorization,
+            fontFamily: this.editorOptions.configuration.resultEditor.fontFamily === 'default' ?
+                EDITOR_FONT_DEFAULTS.fontFamily :
+                this.editorOptions.configuration.resultEditor.fontFamily,
+            fontSize: this.editorOptions.configuration.resultEditor.fontSize,
+            fontWeight: this.editorOptions.configuration.resultEditor.fontWeight,
+            lineHeight: this.editorOptions.configuration.resultEditor.lineHeight,
+            ...this.currentCodeBlockData?.renderOptions?.editorOptions,
+        };
+    }
+    layout(width) {
+        const contentHeight = this.getContentHeight();
+        let height = contentHeight;
+        if (this.currentCodeBlockData?.renderOptions?.maxHeightInLines) {
+            height = Math.min(contentHeight, this.editor.getOption(EditorOption.lineHeight) * this.currentCodeBlockData?.renderOptions?.maxHeightInLines);
+        }
+        const editorBorder = 2;
+        width = width - editorBorder - (this.currentCodeBlockData?.renderOptions?.reserveWidth ?? 0);
+        this.editor.layout({ width: isRequestVM(this.currentCodeBlockData?.element) ? width * 0.9 : width, height });
+        this.updatePaddingForLayout();
+    }
+    getContentHeight() {
+        if (this.currentCodeBlockData?.range) {
+            const lineCount = this.currentCodeBlockData.range.endLineNumber - this.currentCodeBlockData.range.startLineNumber + 1;
+            const lineHeight = this.editor.getOption(EditorOption.lineHeight);
+            return lineCount * lineHeight;
+        }
+        return this.editor.getContentHeight();
+    }
+    async render(data, width) {
+        this.currentCodeBlockData = data;
+        if (data.parentContextKeyService) {
+            this.contextKeyService.updateParent(data.parentContextKeyService);
+        }
+        if (this.getEditorOptionsFromConfig().wordWrap === 'on') {
+            this.layout(width);
+        }
+        const didUpdate = await this.updateEditor(data);
+        if (!didUpdate || this.isDisposed || this.currentCodeBlockData !== data) {
+            return;
+        }
+        this.editor.updateOptions({
+            ...this.getEditorOptionsFromConfig(),
+        });
+        if (!this.editor.getOption(EditorOption.ariaLabel)) {
+            this.editor.updateOptions({
+                ariaLabel: ( localize(5674, "Code block {0}", data.codeBlockIndex + 1)),
+            });
+        }
+        this.layout(width);
+        this.toolbar.setAriaLabel(( localize(5675, "Code block {0}", data.codeBlockIndex + 1)));
+        if (data.renderOptions?.hideToolbar) {
+            hide(this.toolbar.getElement());
+        }
+        else {
+            show(this.toolbar.getElement());
+        }
+        if (data.vulns?.length && isResponseVM(data.element)) {
+            clearNode(this.vulnsListElement);
+            this.element.classList.remove('no-vulns');
+            this.element.classList.toggle('chat-vulnerabilities-collapsed', !data.element.vulnerabilitiesListExpanded);
+            append(this.vulnsListElement, ...( data.vulns.map(
+                v => $('li', undefined, $('span.chat-vuln-title', undefined, v.title), ' ' + v.description)
+            )));
+            this.vulnsButton.label = this.getVulnerabilitiesLabel();
+        }
+        else {
+            this.element.classList.add('no-vulns');
+        }
+    }
+    reset() {
+        this.clearWidgets();
+        this.currentCodeBlockData = undefined;
+    }
+    clearWidgets() {
+        ContentHoverController.get(this.editor)?.hideContentHover();
+        GlyphHoverController.get(this.editor)?.hideGlyphHover();
+    }
+    async updateEditor(data) {
+        const textModel = await data.textModel;
+        if (this.isDisposed || this.currentCodeBlockData !== data || !textModel || textModel.isDisposed()) {
+            return false;
+        }
+        this.editor.setModel(textModel);
+        if (data.range) {
+            this.editor.setSelection(data.range);
+            this.editor.revealRangeInCenter(data.range, ScrollType.Immediate);
+        }
+        this.updateContexts(data);
+        return true;
+    }
+    getVulnerabilitiesLabel() {
+        if (!this.currentCodeBlockData || !this.currentCodeBlockData.vulns) {
+            return '';
+        }
+        const referencesLabel = this.currentCodeBlockData.vulns.length > 1 ?
+            ( localize(5676, "{0} vulnerabilities", this.currentCodeBlockData.vulns.length)) :
+            ( localize(5677, "{0} vulnerability", 1));
+        const icon = (element) => element.vulnerabilitiesListExpanded ? Codicon.chevronDown : Codicon.chevronRight;
+        return `${referencesLabel} $(${icon(this.currentCodeBlockData.element).id})`;
+    }
+    updateContexts(data) {
+        const textModel = this.editor.getModel();
+        if (!textModel) {
+            return;
+        }
+        this.toolbar.context = {
+            code: textModel.getTextBuffer().getValueInRange(data.range ?? textModel.getFullModelRange(), EndOfLinePreference.TextDefined),
+            codeBlockIndex: data.codeBlockIndex,
+            element: data.element,
+            languageId: textModel.getLanguageId(),
+            codemapperUri: data.codemapperUri,
+            chatSessionResource: data.chatSessionResource
+        };
+        this.resourceContextKey.set(textModel.uri);
+    }
+};
+CodeBlockPart = ( __decorate([
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IModelService)),
+    ( __param(8, IConfigurationService)),
+    ( __param(9, IAccessibilityService))
+], CodeBlockPart));
+let ChatCodeBlockContentProvider = class ChatCodeBlockContentProvider extends Disposable {
+    constructor(textModelService, _modelService) {
+        super();
+        this._modelService = _modelService;
+        this._register(textModelService.registerTextModelContentProvider(Schemas.vscodeChatCodeBlock, this));
+    }
+    async provideTextContent(resource) {
+        const existing = this._modelService.getModel(resource);
+        if (existing) {
+            return existing;
+        }
+        return this._modelService.createModel('', null, resource);
+    }
+};
+ChatCodeBlockContentProvider = ( __decorate([
+    ( __param(0, ITextModelService)),
+    ( __param(1, IModelService))
+], ChatCodeBlockContentProvider));
+let CodeCompareBlockPart = class CodeCompareBlockPart extends Disposable {
+    constructor(options, menuId, delegate, overflowWidgetsDomNode, isSimpleWidget = false, instantiationService, contextKeyService, modelService, configurationService, accessibilityService, labelService, openerService) {
+        super();
+        this.options = options;
+        this.menuId = menuId;
+        this.isSimpleWidget = isSimpleWidget;
+        this.modelService = modelService;
+        this.configurationService = configurationService;
+        this.accessibilityService = accessibilityService;
+        this.labelService = labelService;
+        this.openerService = openerService;
+        this._onDidChangeContentHeight = this._register(( new Emitter()));
+        this.onDidChangeContentHeight = this._onDidChangeContentHeight.event;
+        this._lastDiffEditorViewModel = this._store.add(( new MutableDisposable()));
+        this.currentScrollWidth = 0;
+        this.currentHorizontalPadding = 0;
+        this.element = $('.interactive-result-code-block');
+        this.element.classList.add('compare');
+        this.messageElement = append(this.element, $('.message'));
+        this.messageElement.setAttribute('role', 'status');
+        this.messageElement.tabIndex = 0;
+        this.contextKeyService = this._register(contextKeyService.createScoped(this.element));
+        const scopedInstantiationService = this._register(instantiationService.createChild(( new ServiceCollection(
+            [IContextKeyService, this.contextKeyService],
+            [IEditorProgressService, new class {
+                    show(_total, _delay) {
+                        return emptyProgressRunner;
+                    }
+                    async showWhile(promise, _delay) {
+                        await promise;
+                    }
+                }]
+        ))));
+        const editorHeader = this.editorHeader = append(this.element, $('.interactive-result-header.show-file-icons'));
+        const editorElement = append(this.element, $('.interactive-result-editor'));
+        this.diffEditor = this.createDiffEditor(scopedInstantiationService, editorElement, {
+            ...getSimpleEditorOptions(this.configurationService),
+            lineNumbers: 'on',
+            selectOnLineNumbers: true,
+            scrollBeyondLastLine: false,
+            lineDecorationsWidth: 12,
+            dragAndDrop: false,
+            padding: { top: defaultCodeblockPadding, bottom: defaultCodeblockPadding },
+            mouseWheelZoom: false,
+            scrollbar: {
+                vertical: 'hidden',
+                alwaysConsumeMouseWheel: false
+            },
+            definitionLinkOpensInPeek: false,
+            gotoLocation: {
+                multiple: 'goto',
+                multipleDeclarations: 'goto',
+                multipleDefinitions: 'goto',
+                multipleImplementations: 'goto',
+            },
+            ariaLabel: ( localize(5673, 'Code block')),
+            overflowWidgetsDomNode,
+            ...this.getEditorOptionsFromConfig(),
+        });
+        this.resourceLabel = this._register(scopedInstantiationService.createInstance(ResourceLabel, editorHeader, { supportIcons: true }));
+        const editorScopedService = this.diffEditor.getModifiedEditor().contextKeyService.createScoped(editorHeader);
+        const editorScopedInstantiationService = this._register(scopedInstantiationService.createChild(( new ServiceCollection([IContextKeyService, editorScopedService]))));
+        this.toolbar = this._register(editorScopedInstantiationService.createInstance(MenuWorkbenchToolBar, editorHeader, menuId, {
+            menuOptions: {
+                shouldForwardArgs: true
+            }
+        }));
+        this._configureForScreenReader();
+        this._register(this.accessibilityService.onDidChangeScreenReaderOptimized(() => this._configureForScreenReader()));
+        this._register(this.configurationService.onDidChangeConfiguration((e) => {
+            if (( e.affectedKeys.has(AccessibilityVerbositySettingId.Chat))) {
+                this._configureForScreenReader();
+            }
+        }));
+        this._register(this.options.onDidChange(() => {
+            this.diffEditor.updateOptions(this.getEditorOptionsFromConfig());
+        }));
+        this._register(this.diffEditor.getModifiedEditor().onDidScrollChange(e => {
+            this.currentScrollWidth = e.scrollWidth;
+        }));
+        this._register(this.diffEditor.onDidContentSizeChange(e => {
+            if (e.contentHeightChanged) {
+                this._onDidChangeContentHeight.fire();
+            }
+        }));
+        this._register(this.diffEditor.getModifiedEditor().onDidBlurEditorWidget(() => {
+            this.element.classList.remove('focused');
+            WordHighlighterContribution.get(this.diffEditor.getModifiedEditor())?.stopHighlighting();
+            this.clearWidgets();
+        }));
+        this._register(this.diffEditor.getModifiedEditor().onDidFocusEditorWidget(() => {
+            this.element.classList.add('focused');
+            WordHighlighterContribution.get(this.diffEditor.getModifiedEditor())?.restoreViewState(true);
+        }));
+        if (delegate.onDidScroll) {
+            this._register(delegate.onDidScroll(e => {
+                this.clearWidgets();
+            }));
+        }
+    }
+    get uri() {
+        return this.diffEditor.getModifiedEditor().getModel()?.uri;
+    }
+    createDiffEditor(instantiationService, parent, options) {
+        const widgetOptions = {
+            isSimpleWidget: this.isSimpleWidget,
+            contributions: EditorExtensionsRegistry.getSomeEditorContributions([
+                MenuPreventer.ID,
+                SelectionClipboardContributionID,
+                ContextMenuController.ID,
+                WordHighlighterContribution.ID,
+                ViewportSemanticTokensContribution.ID,
+                BracketMatchingController.ID,
+                SmartSelectController.ID,
+                ContentHoverController.ID,
+                GlyphHoverController.ID,
+                GotoDefinitionAtPositionEditorContribution.ID,
+            ])
+        };
+        return this._register(instantiationService.createInstance(DiffEditorWidget, parent, {
+            scrollbar: { useShadows: false, alwaysConsumeMouseWheel: false, ignoreHorizontalScrollbarInContentHeight: true, },
+            renderMarginRevertIcon: false,
+            diffCodeLens: false,
+            scrollBeyondLastLine: false,
+            stickyScroll: { enabled: false },
+            originalAriaLabel: ( localize(5678, 'Original')),
+            modifiedAriaLabel: ( localize(5679, 'Modified')),
+            diffAlgorithm: 'advanced',
+            readOnly: false,
+            isInEmbeddedEditor: true,
+            useInlineViewWhenSpaceIsLimited: true,
+            experimental: {
+                useTrueInlineView: true,
+            },
+            renderSideBySideInlineBreakpoint: 300,
+            renderOverviewRuler: false,
+            compactMode: true,
+            hideUnchangedRegions: { enabled: true, contextLineCount: 1 },
+            renderGutterMenu: false,
+            lineNumbersMinChars: 1,
+            ...options
+        }, { originalEditor: widgetOptions, modifiedEditor: widgetOptions }));
+    }
+    focus() {
+        this.diffEditor.focus();
+    }
+    updatePaddingForLayout() {
+        const horizontalScrollbarVisible = this.currentScrollWidth > this.diffEditor.getModifiedEditor().getLayoutInfo().contentWidth;
+        const scrollbarHeight = this.diffEditor.getModifiedEditor().getLayoutInfo().horizontalScrollbarHeight;
+        const bottomPadding = horizontalScrollbarVisible ?
+            Math.max(defaultCodeblockPadding - scrollbarHeight, 2) :
+            defaultCodeblockPadding;
+        this.diffEditor.updateOptions({ padding: { top: defaultCodeblockPadding, bottom: bottomPadding } });
+    }
+    _configureForScreenReader() {
+        const toolbarElt = this.toolbar.getElement();
+        if (this.accessibilityService.isScreenReaderOptimized()) {
+            toolbarElt.style.display = 'block';
+            toolbarElt.ariaLabel = ( localize(5680, 'Code block toolbar'));
+        }
+        else {
+            toolbarElt.style.display = '';
+        }
+    }
+    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 editorBorder = 2;
+        const toolbar = getTotalHeight(this.editorHeader);
+        const content = this.diffEditor.getModel()
+            ? this.diffEditor.getContentHeight()
+            : getTotalHeight(this.messageElement);
+        const dimension = new Dimension(width - editorBorder - this.currentHorizontalPadding * 2, toolbar + content);
+        this.element.style.height = `${dimension.height}px`;
+        this.element.style.width = `${dimension.width}px`;
+        this.diffEditor.layout(dimension.with(undefined, content - editorBorder));
+        this.updatePaddingForLayout();
+    }
+    async render(data, width, token) {
+        this.currentHorizontalPadding = data.horizontalPadding || 0;
+        if (data.parentContextKeyService) {
+            this.contextKeyService.updateParent(data.parentContextKeyService);
+        }
+        if (this.options.configuration.resultEditor.wordWrap === 'on') {
+            this.layout(width);
+        }
+        await this.updateEditor(data, token);
+        this.layout(width);
+        this.diffEditor.updateOptions({
+            ariaLabel: ( localize(5681, "Code Edits")),
+            readOnly: !!data.isReadOnly,
+        });
+        this.resourceLabel.element.setFile(data.edit.uri, {
+            fileKind: FileKind.FILE,
+            fileDecorations: { colors: true, badges: false }
+        });
+        this._onDidChangeContentHeight.fire();
+    }
+    reset() {
+        this.clearWidgets();
+    }
+    clearWidgets() {
+        ContentHoverController.get(this.diffEditor.getOriginalEditor())?.hideContentHover();
+        ContentHoverController.get(this.diffEditor.getModifiedEditor())?.hideContentHover();
+        GlyphHoverController.get(this.diffEditor.getOriginalEditor())?.hideGlyphHover();
+        GlyphHoverController.get(this.diffEditor.getModifiedEditor())?.hideGlyphHover();
+    }
+    async updateEditor(data, token) {
+        if (!isResponseVM(data.element)) {
+            return;
+        }
+        const isEditApplied = Boolean(data.edit.state?.applied ?? 0);
+        ChatContextKeys.editApplied.bindTo(this.contextKeyService).set(isEditApplied);
+        this.element.classList.toggle('no-diff', isEditApplied);
+        if (isEditApplied) {
+            assertType(data.edit.state?.applied);
+            const uriLabel = this.labelService.getUriLabel(data.edit.uri, { relative: true, noPrefix: true });
+            let template;
+            if (data.edit.state.applied === 1) {
+                template = ( localize(5682, "Applied 1 change in [[``{0}``]]", uriLabel));
+            }
+            else if (data.edit.state.applied < 0) {
+                template = ( localize(5683, "Edits in [[``{0}``]] have been rejected", uriLabel));
+            }
+            else {
+                template = ( localize(
+                    5684,
+                    "Applied {0} changes in [[``{1}``]]",
+                    data.edit.state.applied,
+                    uriLabel
+                ));
+            }
+            const message = renderFormattedText(template, {
+                renderCodeSegments: true,
+                actionHandler: {
+                    callback: () => {
+                        this.openerService.open(data.edit.uri, { fromUserGesture: true, allowCommands: false });
+                    },
+                    disposables: this._store,
+                }
+            });
+            reset(this.messageElement, message);
+        }
+        const diffData = await data.diffData;
+        if (!isEditApplied && diffData) {
+            const viewModel = this.diffEditor.createViewModel({
+                original: diffData.original,
+                modified: diffData.modified
+            });
+            await viewModel.waitForDiff();
+            if (token.isCancellationRequested) {
+                return;
+            }
+            const listener = Event.any(diffData.original.onWillDispose, diffData.modified.onWillDispose)(() => {
+                this.diffEditor.setModel(null);
+            });
+            this.diffEditor.setModel(viewModel);
+            this._lastDiffEditorViewModel.value = combinedDisposable(listener, viewModel);
+        }
+        else {
+            this.diffEditor.setModel(null);
+            this._lastDiffEditorViewModel.value = undefined;
+            this._onDidChangeContentHeight.fire();
+        }
+        this.toolbar.context = {
+            edit: data.edit,
+            element: data.element,
+            diffEditor: this.diffEditor,
+        };
+    }
+};
+CodeCompareBlockPart = ( __decorate([
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IModelService)),
+    ( __param(8, IConfigurationService)),
+    ( __param(9, IAccessibilityService)),
+    ( __param(10, ILabelService)),
+    ( __param(11, IOpenerService))
+], CodeCompareBlockPart));
+let DefaultChatTextEditor = class DefaultChatTextEditor {
+    constructor(modelService, editorService, dialogService) {
+        this.modelService = modelService;
+        this.editorService = editorService;
+        this.dialogService = dialogService;
+        this._sha1 = ( new DefaultModelSHA1Computer());
+    }
+    async apply(response, item, diffEditor) {
+        if (!response.response.value.includes(item)) {
+            return;
+        }
+        if (item.state?.applied) {
+            return;
+        }
+        if (!diffEditor) {
+            for (const candidate of this.editorService.listDiffEditors()) {
+                if (!candidate.getContainerDomNode().isConnected) {
+                    continue;
+                }
+                const model = candidate.getModel();
+                if (!model || !isEqual(model.original.uri, item.uri) || model.modified.uri.scheme !== Schemas.vscodeChatCodeCompareBlock) {
+                    diffEditor = candidate;
+                    break;
+                }
+            }
+        }
+        const edits = diffEditor
+            ? await this._applyWithDiffEditor(diffEditor, item)
+            : await this._apply(item);
+        response.setEditApplied(item, edits);
+    }
+    async _applyWithDiffEditor(diffEditor, item) {
+        const model = diffEditor.getModel();
+        if (!model) {
+            return 0;
+        }
+        const diff = diffEditor.getDiffComputationResult();
+        if (!diff || diff.identical) {
+            return 0;
+        }
+        if (!(await this._checkSha1(model.original, item))) {
+            return 0;
+        }
+        const modified = ( new TextModelText(model.modified));
+        const edits = ( diff.changes2.map(i => i.toRangeMapping().toTextEdit(modified).toSingleEditOperation()));
+        model.original.pushStackElement();
+        model.original.pushEditOperations(null, edits, () => null);
+        model.original.pushStackElement();
+        return edits.length;
+    }
+    async _apply(item) {
+        const ref = await this.modelService.createModelReference(item.uri);
+        try {
+            if (!(await this._checkSha1(ref.object.textEditorModel, item))) {
+                return 0;
+            }
+            ref.object.textEditorModel.pushStackElement();
+            let total = 0;
+            for (const group of item.edits) {
+                const edits = ( group.map(TextEdit.asEditOperation));
+                ref.object.textEditorModel.pushEditOperations(null, edits, () => null);
+                total += edits.length;
+            }
+            ref.object.textEditorModel.pushStackElement();
+            return total;
+        }
+        finally {
+            ref.dispose();
+        }
+    }
+    async _checkSha1(model, item) {
+        if (item.state?.sha1 && this._sha1.computeSHA1(model) && this._sha1.computeSHA1(model) !== item.state.sha1) {
+            const result = await this.dialogService.confirm({
+                message: ( localize(5685, "The original file has been modified.")),
+                detail: ( localize(5686, "Do you want to apply the changes anyway?")),
+            });
+            if (!result.confirmed) {
+                return false;
+            }
+        }
+        return true;
+    }
+    discard(response, item) {
+        if (!response.response.value.includes(item)) {
+            return;
+        }
+        if (item.state?.applied) {
+            return;
+        }
+        response.setEditApplied(item, -1);
+    }
+};
+DefaultChatTextEditor = ( __decorate([
+    ( __param(0, ITextModelService)),
+    ( __param(1, ICodeEditorService)),
+    ( __param(2, IDialogService))
+], DefaultChatTextEditor));
+
+export { ChatCodeBlockContentProvider, CodeBlockPart, CodeCompareBlockPart, DefaultChatTextEditor, localFileLanguageId, parseLocalFileData };