@codingame/monaco-vscode-katex-common 24.1.0

package/vscode/src/vs/workbench/contrib/inlineChat/browser/utils.js

@@ -0,0 +1,66 @@
+
+import { EditOperation } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/editOperation';
+import { TrackedRangeStickiness } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { AsyncIterableSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { getNWords } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatWordCounter';
+
+async function performAsyncTextEdit(model, edit, progress, obs, editSource) {
+    const [id] = model.deltaDecorations([], [{
+            range: edit.range,
+            options: {
+                description: 'asyncTextEdit',
+                stickiness: TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges
+            }
+        }]);
+    let first = true;
+    for await (const part of edit.newText) {
+        if (model.isDisposed()) {
+            break;
+        }
+        const range = model.getDecorationRange(id);
+        if (!range) {
+            throw ( new Error(
+                'FAILED to perform async replace edit because the anchor decoration was removed'
+            ));
+        }
+        const edit = first
+            ? EditOperation.replace(range, part)
+            : EditOperation.insert(range.getEndPosition(), part);
+        obs?.start();
+        model.pushEditOperations(null, [edit], (undoEdits) => {
+            progress?.report(undoEdits);
+            return null;
+        }, undefined, editSource);
+        obs?.stop();
+        first = false;
+    }
+}
+function asProgressiveEdit(interval, edit, wordsPerSec, token) {
+    wordsPerSec = Math.max(30, wordsPerSec);
+    const stream = ( new AsyncIterableSource());
+    let newText = edit.text ?? '';
+    interval.cancelAndSet(() => {
+        if (token.isCancellationRequested) {
+            return;
+        }
+        const r = getNWords(newText, 1);
+        stream.emitOne(r.value);
+        newText = newText.substring(r.value.length);
+        if (r.isFullString) {
+            interval.cancel();
+            stream.resolve();
+            d.dispose();
+        }
+    }, 1000 / wordsPerSec);
+    const d = token.onCancellationRequested(() => {
+        interval.cancel();
+        stream.resolve();
+        d.dispose();
+    });
+    return {
+        range: edit.range,
+        newText: stream.asyncIterable
+    };
+}
+
+export { asProgressiveEdit, performAsyncTextEdit };

package/vscode/src/vs/workbench/contrib/inlineChat/common/inlineChat.d.ts

@@ -0,0 +1,61 @@
+import { MenuId } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { RawContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+export declare enum InlineChatConfigKeys {
+    FinishOnType = "inlineChat.finishOnType",
+    StartWithOverlayWidget = "inlineChat.startWithOverlayWidget",
+    HoldToSpeech = "inlineChat.holdToSpeech",
+    AccessibleDiffView = "inlineChat.accessibleDiffView",
+    /** @deprecated do not read on client */
+    EnableV2 = "inlineChat.enableV2",
+    notebookAgent = "inlineChat.notebookAgent"
+}
+export declare const INLINE_CHAT_ID = "interactiveEditor";
+export declare const INTERACTIVE_EDITOR_ACCESSIBILITY_HELP_ID = "interactiveEditorAccessiblityHelp";
+export declare enum InlineChatResponseType {
+    None = "none",
+    Messages = "messages",
+    MessagesAndEdits = "messagesAndEdits"
+}
+export declare const CTX_INLINE_CHAT_POSSIBLE: RawContextKey<boolean>;
+export declare const CTX_INLINE_CHAT_HAS_AGENT2: RawContextKey<boolean>;
+export declare const CTX_INLINE_CHAT_HAS_NOTEBOOK_INLINE: RawContextKey<boolean>;
+export declare const CTX_INLINE_CHAT_HAS_NOTEBOOK_AGENT: RawContextKey<boolean>;
+export declare const CTX_INLINE_CHAT_VISIBLE: RawContextKey<boolean>;
+export declare const CTX_INLINE_CHAT_FOCUSED: RawContextKey<boolean>;
+export declare const CTX_INLINE_CHAT_EDITING: RawContextKey<boolean>;
+export declare const CTX_INLINE_CHAT_RESPONSE_FOCUSED: RawContextKey<boolean>;
+export declare const CTX_INLINE_CHAT_EMPTY: RawContextKey<boolean>;
+export declare const CTX_INLINE_CHAT_INNER_CURSOR_FIRST: RawContextKey<boolean>;
+export declare const CTX_INLINE_CHAT_INNER_CURSOR_LAST: RawContextKey<boolean>;
+export declare const CTX_INLINE_CHAT_OUTER_CURSOR_POSITION: RawContextKey<"" | "above" | "below">;
+export declare const CTX_INLINE_CHAT_HAS_STASHED_SESSION: RawContextKey<boolean>;
+export declare const CTX_INLINE_CHAT_CHANGE_HAS_DIFF: RawContextKey<boolean>;
+export declare const CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF: RawContextKey<boolean>;
+export declare const CTX_INLINE_CHAT_REQUEST_IN_PROGRESS: RawContextKey<boolean>;
+export declare const CTX_INLINE_CHAT_RESPONSE_TYPE: RawContextKey<InlineChatResponseType>;
+export declare const CTX_INLINE_CHAT_V1_ENABLED: import("@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey").ContextKeyExpression | undefined;
+export declare const CTX_INLINE_CHAT_V2_ENABLED: import("@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey").ContextKeyExpression | undefined;
+export declare const ACTION_START = "inlineChat.start";
+export declare const ACTION_ACCEPT_CHANGES = "inlineChat.acceptChanges";
+export declare const ACTION_DISCARD_CHANGES = "inlineChat.discardHunkChange";
+export declare const ACTION_REGENERATE_RESPONSE = "inlineChat.regenerate";
+export declare const ACTION_VIEW_IN_CHAT = "inlineChat.viewInChat";
+export declare const ACTION_TOGGLE_DIFF = "inlineChat.toggleDiff";
+export declare const ACTION_REPORT_ISSUE = "inlineChat.reportIssue";
+export declare const MENU_INLINE_CHAT_WIDGET_STATUS: MenuId;
+export declare const MENU_INLINE_CHAT_WIDGET_SECONDARY: MenuId;
+export declare const MENU_INLINE_CHAT_ZONE: MenuId;
+export declare const MENU_INLINE_CHAT_SIDE: MenuId;
+export declare const inlineChatForeground: string;
+export declare const inlineChatBackground: string;
+export declare const inlineChatBorder: string;
+export declare const inlineChatShadow: string;
+export declare const inlineChatInputBorder: string;
+export declare const inlineChatInputFocusBorder: string;
+export declare const inlineChatInputPlaceholderForeground: string;
+export declare const inlineChatInputBackground: string;
+export declare const inlineChatDiffInserted: string;
+export declare const overviewRulerInlineChatDiffInserted: string;
+export declare const minimapInlineChatDiffInserted: string;
+export declare const inlineChatDiffRemoved: string;
+export declare const overviewRulerInlineChatDiffRemoved: string;

package/vscode/src/vs/workbench/contrib/inlineChat/common/inlineChat.js

@@ -0,0 +1,154 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import { RawContextKey, ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { registerColor, transparent } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import { focusBorder } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import { editorWidgetForeground, editorWidgetBackground, editorWidgetBorder, widgetShadow, diffInserted, diffRemoved } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import { inputPlaceholderForeground, inputBackground } 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 { NOTEBOOK_IS_ACTIVE_EDITOR } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+
+var InlineChatConfigKeys;
+(function (InlineChatConfigKeys) {
+    InlineChatConfigKeys["FinishOnType"] = "inlineChat.finishOnType";
+    InlineChatConfigKeys["StartWithOverlayWidget"] = "inlineChat.startWithOverlayWidget";
+    InlineChatConfigKeys["HoldToSpeech"] = "inlineChat.holdToSpeech";
+    InlineChatConfigKeys["AccessibleDiffView"] = "inlineChat.accessibleDiffView";
+    InlineChatConfigKeys["EnableV2"] = "inlineChat.enableV2";
+    InlineChatConfigKeys["notebookAgent"] = "inlineChat.notebookAgent";
+})(InlineChatConfigKeys || (InlineChatConfigKeys = {}));
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    id: 'editor',
+    properties: {
+        [InlineChatConfigKeys.FinishOnType]: {
+            description: ( localize(
+                8326,
+                "Whether to finish an inline chat session when typing outside of changed regions."
+            )),
+            default: false,
+            type: 'boolean'
+        },
+        [InlineChatConfigKeys.HoldToSpeech]: {
+            description: ( localize(
+                8327,
+                "Whether holding the inline chat keybinding will automatically enable speech recognition."
+            )),
+            default: true,
+            type: 'boolean'
+        },
+        [InlineChatConfigKeys.AccessibleDiffView]: {
+            description: ( localize(
+                8328,
+                "Whether the inline chat also renders an accessible diff viewer for its changes."
+            )),
+            default: 'auto',
+            type: 'string',
+            enum: ['auto', 'on', 'off'],
+            markdownEnumDescriptions: [
+                ( localize(
+                8329,
+                "The accessible diff viewer is based on screen reader mode being enabled."
+            )),
+                ( localize(8330, "The accessible diff viewer is always enabled.")),
+                ( localize(8331, "The accessible diff viewer is never enabled.")),
+            ],
+        },
+        [InlineChatConfigKeys.EnableV2]: {
+            description: ( localize(8332, "Whether to use the next version of inline chat.")),
+            default: false,
+            type: 'boolean',
+            tags: ['preview'],
+            experiment: {
+                mode: 'auto'
+            }
+        },
+        [InlineChatConfigKeys.notebookAgent]: {
+            markdownDescription: ( localize(8333, "Enable agent-like behavior for inline chat widget in notebooks.")),
+            default: false,
+            type: 'boolean',
+            tags: ['experimental'],
+            experiment: {
+                mode: 'startup'
+            }
+        }
+    }
+});
+const INLINE_CHAT_ID = 'interactiveEditor';
+var InlineChatResponseType;
+(function (InlineChatResponseType) {
+    InlineChatResponseType["None"] = "none";
+    InlineChatResponseType["Messages"] = "messages";
+    InlineChatResponseType["MessagesAndEdits"] = "messagesAndEdits";
+})(InlineChatResponseType || (InlineChatResponseType = {}));
+const CTX_INLINE_CHAT_POSSIBLE = ( new RawContextKey('inlineChatPossible', false, ( localize(
+    8334,
+    "Whether a provider for inline chat exists and whether an editor for inline chat is open"
+))));
+const CTX_INLINE_CHAT_HAS_AGENT = ( new RawContextKey('inlineChatHasProvider', false, ( localize(8335, "Whether a provider for interactive editors exists"))));
+const CTX_INLINE_CHAT_HAS_AGENT2 = ( new RawContextKey('inlineChatHasEditsAgent', false, ( localize(8336, "Whether an agent for inline for interactive editors exists"))));
+const CTX_INLINE_CHAT_HAS_NOTEBOOK_INLINE = ( new RawContextKey('inlineChatHasNotebookInline', false, ( localize(8337, "Whether an agent for notebook cells exists"))));
+const CTX_INLINE_CHAT_HAS_NOTEBOOK_AGENT = ( new RawContextKey('inlineChatHasNotebookAgent', false, ( localize(8338, "Whether an agent for notebook cells exists"))));
+const CTX_INLINE_CHAT_VISIBLE = ( new RawContextKey('inlineChatVisible', false, ( localize(8339, "Whether the interactive editor input is visible"))));
+const CTX_INLINE_CHAT_FOCUSED = ( new RawContextKey('inlineChatFocused', false, ( localize(8340, "Whether the interactive editor input is focused"))));
+const CTX_INLINE_CHAT_EDITING = ( new RawContextKey('inlineChatEditing', true, ( localize(
+    8341,
+    "Whether the user is currently editing or generating code in the inline chat"
+))));
+const CTX_INLINE_CHAT_RESPONSE_FOCUSED = ( new RawContextKey('inlineChatResponseFocused', false, ( localize(8342, "Whether the interactive widget's response is focused"))));
+const CTX_INLINE_CHAT_INNER_CURSOR_FIRST = ( new RawContextKey('inlineChatInnerCursorFirst', false, ( localize(
+    8343,
+    "Whether the cursor of the iteractive editor input is on the first line"
+))));
+const CTX_INLINE_CHAT_INNER_CURSOR_LAST = ( new RawContextKey('inlineChatInnerCursorLast', false, ( localize(
+    8344,
+    "Whether the cursor of the iteractive editor input is on the last line"
+))));
+const CTX_INLINE_CHAT_OUTER_CURSOR_POSITION = ( new RawContextKey('inlineChatOuterCursorPosition', '', ( localize(
+    8345,
+    "Whether the cursor of the outer editor is above or below the interactive editor input"
+))));
+const CTX_INLINE_CHAT_HAS_STASHED_SESSION = ( new RawContextKey('inlineChatHasStashedSession', false, ( localize(8346, "Whether interactive editor has kept a session for quick restore"))));
+const CTX_INLINE_CHAT_CHANGE_HAS_DIFF = ( new RawContextKey('inlineChatChangeHasDiff', false, ( localize(8347, "Whether the current change supports showing a diff"))));
+const CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF = ( new RawContextKey('inlineChatChangeShowsDiff', false, ( localize(8348, "Whether the current change showing a diff"))));
+const CTX_INLINE_CHAT_REQUEST_IN_PROGRESS = ( new RawContextKey('inlineChatRequestInProgress', false, ( localize(8349, "Whether an inline chat request is currently in progress"))));
+const CTX_INLINE_CHAT_RESPONSE_TYPE = ( new RawContextKey('inlineChatResponseType', InlineChatResponseType.None, ( localize(
+    8350,
+    "What type was the responses have been receieved, nothing yet, just messages, or messaged and local edits"
+))));
+const CTX_INLINE_CHAT_V1_ENABLED = ( ContextKeyExpr.or(( ContextKeyExpr.and(( NOTEBOOK_IS_ACTIVE_EDITOR.negate()), CTX_INLINE_CHAT_HAS_AGENT)), ( ContextKeyExpr.and(NOTEBOOK_IS_ACTIVE_EDITOR, CTX_INLINE_CHAT_HAS_NOTEBOOK_INLINE))));
+const CTX_INLINE_CHAT_V2_ENABLED = ( ContextKeyExpr.or(( ContextKeyExpr.and(( NOTEBOOK_IS_ACTIVE_EDITOR.negate()), CTX_INLINE_CHAT_HAS_AGENT2)), ( ContextKeyExpr.and(NOTEBOOK_IS_ACTIVE_EDITOR, CTX_INLINE_CHAT_HAS_NOTEBOOK_AGENT))));
+const ACTION_START = 'inlineChat.start';
+const ACTION_ACCEPT_CHANGES = 'inlineChat.acceptChanges';
+const ACTION_DISCARD_CHANGES = 'inlineChat.discardHunkChange';
+const ACTION_REGENERATE_RESPONSE = 'inlineChat.regenerate';
+const ACTION_VIEW_IN_CHAT = 'inlineChat.viewInChat';
+const ACTION_TOGGLE_DIFF = 'inlineChat.toggleDiff';
+const ACTION_REPORT_ISSUE = 'inlineChat.reportIssue';
+const MENU_INLINE_CHAT_WIDGET_STATUS = MenuId.for('inlineChatWidget.status');
+const MENU_INLINE_CHAT_WIDGET_SECONDARY = MenuId.for('inlineChatWidget.secondary');
+const MENU_INLINE_CHAT_ZONE = MenuId.for('inlineChatWidget.changesZone');
+const MENU_INLINE_CHAT_SIDE = MenuId.for('inlineChatWidget.side');
+const inlineChatForeground = registerColor('inlineChat.foreground', editorWidgetForeground, ( localize(8351, "Foreground color of the interactive editor widget")));
+const inlineChatBackground = registerColor('inlineChat.background', editorWidgetBackground, ( localize(8352, "Background color of the interactive editor widget")));
+registerColor('inlineChat.border', editorWidgetBorder, ( localize(8353, "Border color of the interactive editor widget")));
+registerColor('inlineChat.shadow', widgetShadow, ( localize(8354, "Shadow color of the interactive editor widget")));
+registerColor('inlineChatInput.border', editorWidgetBorder, ( localize(8355, "Border color of the interactive editor input")));
+registerColor('inlineChatInput.focusBorder', focusBorder, ( localize(8356, "Border color of the interactive editor input when focused")));
+registerColor('inlineChatInput.placeholderForeground', inputPlaceholderForeground, ( localize(8357, "Foreground color of the interactive editor input placeholder")));
+registerColor('inlineChatInput.background', inputBackground, ( localize(8358, "Background color of the interactive editor input")));
+registerColor('inlineChatDiff.inserted', ( transparent(diffInserted, .5)), ( localize(8359, "Background color of inserted text in the interactive editor input")));
+const overviewRulerInlineChatDiffInserted = registerColor('editorOverviewRuler.inlineChatInserted', { dark: ( transparent(diffInserted, 0.6)), light: ( transparent(diffInserted, 0.8)), hcDark: ( transparent(diffInserted, 0.6)), hcLight: ( transparent(diffInserted, 0.8)) }, ( localize(8360, 'Overview ruler marker color for inline chat inserted content.')));
+const minimapInlineChatDiffInserted = registerColor('editorMinimap.inlineChatInserted', { dark: ( transparent(diffInserted, 0.6)), light: ( transparent(diffInserted, 0.8)), hcDark: ( transparent(diffInserted, 0.6)), hcLight: ( transparent(diffInserted, 0.8)) }, ( localize(8361, 'Minimap marker color for inline chat inserted content.')));
+registerColor('inlineChatDiff.removed', ( transparent(diffRemoved, .5)), ( localize(8362, "Background color of removed text in the interactive editor input")));
+registerColor('editorOverviewRuler.inlineChatRemoved', { dark: ( transparent(diffRemoved, 0.6)), light: ( transparent(diffRemoved, 0.8)), hcDark: ( transparent(diffRemoved, 0.6)), hcLight: ( transparent(diffRemoved, 0.8)) }, ( localize(8363, 'Overview ruler marker color for inline chat removed content.')));
+
+export { ACTION_ACCEPT_CHANGES, ACTION_DISCARD_CHANGES, ACTION_REGENERATE_RESPONSE, ACTION_REPORT_ISSUE, ACTION_START, ACTION_TOGGLE_DIFF, ACTION_VIEW_IN_CHAT, CTX_INLINE_CHAT_CHANGE_HAS_DIFF, CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF, CTX_INLINE_CHAT_EDITING, CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_HAS_AGENT2, CTX_INLINE_CHAT_HAS_NOTEBOOK_AGENT, CTX_INLINE_CHAT_HAS_NOTEBOOK_INLINE, CTX_INLINE_CHAT_HAS_STASHED_SESSION, CTX_INLINE_CHAT_INNER_CURSOR_FIRST, CTX_INLINE_CHAT_INNER_CURSOR_LAST, CTX_INLINE_CHAT_OUTER_CURSOR_POSITION, CTX_INLINE_CHAT_POSSIBLE, CTX_INLINE_CHAT_REQUEST_IN_PROGRESS, CTX_INLINE_CHAT_RESPONSE_FOCUSED, CTX_INLINE_CHAT_RESPONSE_TYPE, CTX_INLINE_CHAT_V1_ENABLED, CTX_INLINE_CHAT_V2_ENABLED, CTX_INLINE_CHAT_VISIBLE, INLINE_CHAT_ID, InlineChatConfigKeys, InlineChatResponseType, MENU_INLINE_CHAT_SIDE, MENU_INLINE_CHAT_WIDGET_SECONDARY, MENU_INLINE_CHAT_WIDGET_STATUS, MENU_INLINE_CHAT_ZONE, inlineChatBackground, inlineChatForeground, minimapInlineChatDiffInserted, overviewRulerInlineChatDiffInserted };

package/vscode/src/vs/workbench/contrib/markdown/browser/markedKatexSupport.d.ts

@@ -0,0 +1,19 @@
+import * as domSanitize from "@codingame/monaco-vscode-api/vscode/vs/base/browser/domSanitize";
+import { MarkdownSanitizerConfig } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/markdownRenderer";
+import { CodeWindow } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/window";
+import type * as marked from "@codingame/monaco-vscode-api/vscode/vs/base/common/marked/marked";
+import { MarkedKatexExtension } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/markdown/common/markedKatexExtension";
+export declare class MarkedKatexSupport {
+    static getSanitizerOptions(baseConfig: {
+        readonly allowedTags: readonly string[];
+        readonly allowedAttributes: ReadonlyArray<string | domSanitize.SanitizeAttributeRule>;
+    }): MarkdownSanitizerConfig;
+    private static tempSanitizerRule;
+    private static sanitizeStyles;
+    private static sanitizeKatexStyles;
+    private static _katex?;
+    private static _katexPromise;
+    static getExtension(window: CodeWindow, options?: MarkedKatexExtension.MarkedKatexOptions): marked.MarkedExtension | undefined;
+    static loadExtension(window: CodeWindow, options?: MarkedKatexExtension.MarkedKatexOptions): Promise<marked.MarkedExtension>;
+    static ensureKatexStyles(window: CodeWindow): void;
+}

package/vscode/src/vs/workbench/contrib/markdown/browser/markedKatexSupport.js

@@ -0,0 +1,201 @@
+
+import { createLinkElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { katexContainerLatexAttributeName, MarkedKatexExtension } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/markdown/common/markedKatexExtension';
+
+class MarkedKatexSupport {
+    static getSanitizerOptions(baseConfig) {
+        return {
+            allowedTags: {
+                override: [
+                    ...baseConfig.allowedTags,
+                    ...trustedMathMlTags,
+                ]
+            },
+            allowedAttributes: {
+                override: [
+                    ...baseConfig.allowedAttributes,
+                    'stretchy',
+                    'encoding',
+                    'accent',
+                    katexContainerLatexAttributeName,
+                    'd',
+                    'viewBox',
+                    'preserveAspectRatio',
+                    'class',
+                    {
+                        attributeName: 'style',
+                        shouldKeep: (_el, data) => this.sanitizeKatexStyles(data.attrValue),
+                    },
+                ]
+            },
+        };
+    }
+    static { this.tempSanitizerRule = ( new Lazy(() => {
+        const styleSheet = ( new CSSStyleSheet());
+        styleSheet.insertRule(`.temp{}`);
+        const rule = styleSheet.cssRules[0];
+        if (!(rule instanceof CSSStyleRule)) {
+            throw ( new Error('Invalid CSS rule'));
+        }
+        return rule.style;
+    })); }
+    static sanitizeStyles(styleString, allowedProperties) {
+        const style = this.tempSanitizerRule.value;
+        style.cssText = styleString;
+        const sanitizedProps = [];
+        for (let i = 0; i < style.length; i++) {
+            const prop = style[i];
+            if (allowedProperties.includes(prop)) {
+                const value = style.getPropertyValue(prop);
+                if (/^(([\d\.\-]+\w*\s?)+|\w+)$/.test(value)) {
+                    sanitizedProps.push(`${prop}: ${value}`);
+                }
+            }
+        }
+        return sanitizedProps.join('; ');
+    }
+    static sanitizeKatexStyles(styleString) {
+        const allowedProperties = [
+            'display',
+            'position',
+            'font-family',
+            'font-style',
+            'font-weight',
+            'font-size',
+            'height',
+            'min-height',
+            'max-height',
+            'width',
+            'min-width',
+            'max-width',
+            'margin',
+            'margin-top',
+            'margin-right',
+            'margin-bottom',
+            'margin-left',
+            'padding',
+            'padding-top',
+            'padding-right',
+            'padding-bottom',
+            'padding-left',
+            'top',
+            'left',
+            'right',
+            'bottom',
+            'vertical-align',
+            'transform',
+            'border',
+            'border-top-width',
+            'border-right-width',
+            'border-bottom-width',
+            'border-left-width',
+            'color',
+            'white-space',
+            'text-align',
+            'line-height',
+            'float',
+            'clear',
+        ];
+        return this.sanitizeStyles(styleString, allowedProperties);
+    }
+    static { this._katexPromise = ( new Lazy(async () => {
+        this._katex = (await import('katex').then(module => module.default ?? module)).default;
+        return this._katex;
+    })); }
+    static getExtension(window, options = {}) {
+        if (!this._katex) {
+            return undefined;
+        }
+        this.ensureKatexStyles(window);
+        return MarkedKatexExtension.extension(this._katex, options);
+    }
+    static async loadExtension(window, options = {}) {
+        const katex = await this._katexPromise.value;
+        this.ensureKatexStyles(window);
+        return MarkedKatexExtension.extension(katex, options);
+    }
+    static ensureKatexStyles(window) {
+        const doc = window.document;
+        if (!doc.querySelector('link.katex')) {
+            const katexStyle = createLinkElement();
+            katexStyle.classList.add('katex');
+            katexStyle.rel = 'stylesheet';
+            katexStyle.href = ( new URL('katex/dist/katex.min.css', import.meta.url)).href;
+        }
+    }
+}
+const trustedMathMlTags = ( Object.freeze([
+    'semantics',
+    'annotation',
+    'math',
+    'menclose',
+    'merror',
+    'mfenced',
+    'mfrac',
+    'mglyph',
+    'mi',
+    'mlabeledtr',
+    'mmultiscripts',
+    'mn',
+    'mo',
+    'mover',
+    'mpadded',
+    'mphantom',
+    'mroot',
+    'mrow',
+    'ms',
+    'mspace',
+    'msqrt',
+    'mstyle',
+    'msub',
+    'msup',
+    'msubsup',
+    'mtable',
+    'mtd',
+    'mtext',
+    'mtr',
+    'munder',
+    'munderover',
+    'mprescripts',
+    'svg',
+    'altglyph',
+    'altglyphdef',
+    'altglyphitem',
+    'circle',
+    'clippath',
+    'defs',
+    'desc',
+    'ellipse',
+    'filter',
+    'font',
+    'g',
+    'glyph',
+    'glyphref',
+    'hkern',
+    'line',
+    'lineargradient',
+    'marker',
+    'mask',
+    'metadata',
+    'mpath',
+    'path',
+    'pattern',
+    'polygon',
+    'polyline',
+    'radialgradient',
+    'rect',
+    'stop',
+    'style',
+    'switch',
+    'symbol',
+    'text',
+    'textpath',
+    'title',
+    'tref',
+    'tspan',
+    'view',
+    'vkern',
+]));
+
+export { MarkedKatexSupport };

package/vscode/src/vs/workbench/contrib/mcp/browser/mcpPromptArgumentPick.d.ts

@@ -0,0 +1,41 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ICodeEditorService } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+import { IQuickInputService } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { ISearchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search.service";
+import { ITerminalGroupService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { IMcpPrompt } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
+export declare class McpPromptArgumentPick extends Disposable {
+    private readonly prompt;
+    private readonly _quickInputService;
+    private readonly _terminalService;
+    private readonly _searchService;
+    private readonly _workspaceContextService;
+    private readonly _labelService;
+    private readonly _fileService;
+    private readonly _modelService;
+    private readonly _languageService;
+    private readonly _terminalGroupService;
+    private readonly _instantiationService;
+    private readonly _codeEditorService;
+    private readonly _editorService;
+    private readonly quickPick;
+    private _terminal?;
+    constructor(prompt: IMcpPrompt, _quickInputService: IQuickInputService, _terminalService: ITerminalService, _searchService: ISearchService, _workspaceContextService: IWorkspaceContextService, _labelService: ILabelService, _fileService: IFileService, _modelService: IModelService, _languageService: ILanguageService, _terminalGroupService: ITerminalGroupService, _instantiationService: IInstantiationService, _codeEditorService: ICodeEditorService, _editorService: IEditorService);
+    createArgs(token?: CancellationToken): Promise<Record<string, string | undefined> | undefined>;
+    private _getArg;
+    private _promptCompletions;
+    private _fileCompletions;
+    private _activeFileCompletions;
+    private _asyncCompletions;
+    private _getTerminalOutput;
+    private _getTerminalOutputInner;
+}