@codingame/monaco-vscode-api 22.1.9 → 23.0.1

package/vscode/src/vs/editor/contrib/hover/browser/markdownHoverParticipant.js

@@ -5,14 +5,12 @@ import { asArray, compareBy, numberComparator } from '../../../../base/common/ar
 import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
 import { MarkdownString, isEmptyMarkdownString } from '../../../../base/common/htmlContent.js';
 import { DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
-import { MarkdownRenderer } from '../../../browser/widget/markdownRenderer/browser/markdownRenderer.js';
+import { IMarkdownRendererService } from '../../../../platform/markdown/browser/markdownRenderer.service.js';
 import { INCREASE_HOVER_VERBOSITY_ACTION_ID, DECREASE_HOVER_VERBOSITY_ACTION_ID } from './hoverActionIds.js';
 import { Range } from '../../../common/core/range.js';
-import { ILanguageService } from '../../../common/languages/language.service.js';
 import { HoverAnchorType, RenderedHoverParts } from './hoverTypes.js';
 import { localize } from '../../../../nls.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
-import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.service.js';
 import { EditorOption } from '../../../common/config/editorOptions.js';
 import { HoverVerbosityAction } from '../../../common/languages.js';
@@ -30,8 +28,8 @@ import { getHoverProviderResultsAsAsyncIterable } from './getHover.js';
 import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
 
 const $ = $$1;
-const increaseHoverVerbosityIcon = registerIcon('hover-increase-verbosity', Codicon.add, ( localize(1220, 'Icon for increaseing hover verbosity.')));
-const decreaseHoverVerbosityIcon = registerIcon('hover-decrease-verbosity', Codicon.remove, ( localize(1221, 'Icon for decreasing hover verbosity.')));
+const increaseHoverVerbosityIcon = registerIcon('hover-increase-verbosity', Codicon.add, ( localize(1221, 'Icon for increaseing hover verbosity.')));
+const decreaseHoverVerbosityIcon = registerIcon('hover-decrease-verbosity', Codicon.remove, ( localize(1222, 'Icon for decreasing hover verbosity.')));
 class MarkdownHover {
     constructor(owner, range, contents, isBeforeContent, ordinal, source = undefined) {
         this.owner = owner;
@@ -63,10 +61,9 @@ class HoverSource {
     }
 }
 let MarkdownHoverParticipant = class MarkdownHoverParticipant {
-    constructor(_editor, _languageService, _openerService, _configurationService, _languageFeaturesService, _keybindingService, _hoverService, _commandService) {
+    constructor(_editor, _markdownRendererService, _configurationService, _languageFeaturesService, _keybindingService, _hoverService, _commandService) {
         this._editor = _editor;
-        this._languageService = _languageService;
-        this._openerService = _openerService;
+        this._markdownRendererService = _markdownRendererService;
         this._configurationService = _configurationService;
         this._languageFeaturesService = _languageFeaturesService;
         this._keybindingService = _keybindingService;
@@ -78,7 +75,7 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
         return (new MarkdownHover(
             this,
             anchor.range,
-            [( new MarkdownString()).appendText(( localize(1222, "Loading...")))],
+            [( new MarkdownString()).appendText(( localize(1223, "Loading...")))],
             false,
             2000
         ));
@@ -103,7 +100,7 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
             stopRenderingMessage = true;
             result.push(( new MarkdownHover(this, anchor.range, [{
                     value: ( localize(
-                        1223,
+                        1224,
                         "Rendering paused for long line for performance reasons. This can be configured via `editor.stopRenderingLineAfter`."
                     ))
                 }], false, index++)));
@@ -111,7 +108,7 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
         if (!stopRenderingMessage && typeof maxTokenizationLineLength === 'number' && lineLength >= maxTokenizationLineLength) {
             result.push(( new MarkdownHover(this, anchor.range, [{
                     value: ( localize(
-                        1224,
+                        1225,
                         "Tokenization is skipped for long lines for performance reasons. This can be configured via `editor.maxTokenizationLineLength`."
                     ))
                 }], false, index++)));
@@ -165,12 +162,11 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
             context.fragment,
             this,
             this._editor,
-            this._languageService,
-            this._openerService,
             this._commandService,
             this._keybindingService,
             this._hoverService,
             this._configurationService,
+            this._markdownRendererService,
             context.onContentsChanged
         ));
         return this._renderedHoverParts;
@@ -189,13 +185,12 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
     }
 };
 MarkdownHoverParticipant = ( __decorate([
-    ( __param(1, ILanguageService)),
-    ( __param(2, IOpenerService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, ILanguageFeaturesService)),
-    ( __param(5, IKeybindingService)),
-    ( __param(6, IHoverService)),
-    ( __param(7, ICommandService))
+    ( __param(1, IMarkdownRendererService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, ILanguageFeaturesService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IHoverService)),
+    ( __param(6, ICommandService))
 ], MarkdownHoverParticipant));
 class RenderedMarkdownHoverPart {
     constructor(hoverPart, hoverElement, disposables, actionsContainer) {
@@ -212,15 +207,14 @@ class RenderedMarkdownHoverPart {
     }
 }
 class MarkdownRenderedHoverParts {
-    constructor(hoverParts, hoverPartsContainer, _hoverParticipant, _editor, _languageService, _openerService, _commandService, _keybindingService, _hoverService, _configurationService, _onFinishedRendering) {
+    constructor(hoverParts, hoverPartsContainer, _hoverParticipant, _editor, _commandService, _keybindingService, _hoverService, _configurationService, _markdownRendererService, _onFinishedRendering) {
         this._hoverParticipant = _hoverParticipant;
         this._editor = _editor;
-        this._languageService = _languageService;
-        this._openerService = _openerService;
         this._commandService = _commandService;
         this._keybindingService = _keybindingService;
         this._hoverService = _hoverService;
         this._configurationService = _configurationService;
+        this._markdownRendererService = _markdownRendererService;
         this._onFinishedRendering = _onFinishedRendering;
         this._ongoingHoverOperations = ( new Map());
         this._disposables = ( new DisposableStore());
@@ -265,7 +259,7 @@ class MarkdownRenderedHoverParts {
         return ( new RenderedMarkdownHoverPart(hoverPart, renderedMarkdownElement, disposables, actionsContainerInner));
     }
     _renderMarkdownHover(markdownHover, onFinishedRendering) {
-        const renderedMarkdownHover = renderMarkdown(this._editor, markdownHover, this._languageService, this._openerService, onFinishedRendering);
+        const renderedMarkdownHover = renderMarkdown(this._editor, markdownHover, this._markdownRendererService, onFinishedRendering);
         return renderedMarkdownHover;
     }
     _renderHoverExpansionAction(container, action, actionEnabled) {
@@ -417,17 +411,17 @@ class MarkdownRenderedHoverParts {
         this._disposables.dispose();
     }
 }
-function renderMarkdownHovers(context, markdownHovers, editor, languageService, openerService) {
+function renderMarkdownHovers(context, markdownHovers, editor, markdownRendererService) {
     markdownHovers.sort(compareBy(hover => hover.ordinal, numberComparator));
     const renderedHoverParts = [];
     for (const markdownHover of markdownHovers) {
-        const renderedHoverPart = renderMarkdown(editor, markdownHover, languageService, openerService, context.onContentsChanged);
+        const renderedHoverPart = renderMarkdown(editor, markdownHover, markdownRendererService, context.onContentsChanged);
         context.fragment.appendChild(renderedHoverPart.hoverElement);
         renderedHoverParts.push(renderedHoverPart);
     }
     return ( new RenderedHoverParts(renderedHoverParts));
 }
-function renderMarkdown(editor, markdownHover, languageService, openerService, onFinishedRendering) {
+function renderMarkdown(editor, markdownHover, markdownRendererService, onFinishedRendering) {
     const disposables = ( new DisposableStore());
     const renderedMarkdown = $('div.hover-row');
     const renderedMarkdownContents = $('div.hover-row-contents');
@@ -439,8 +433,8 @@ function renderMarkdown(editor, markdownHover, languageService, openerService, o
         }
         const markdownHoverElement = $('div.markdown-hover');
         const hoverContentsElement = append(markdownHoverElement, $('div.hover-contents'));
-        const renderer = ( new MarkdownRenderer({ editor }, languageService, openerService));
-        const renderedContents = disposables.add(renderer.render(markdownString, {
+        const renderedContents = disposables.add(markdownRendererService.render(markdownString, {
+            context: editor,
             asyncRenderCallback: () => {
                 hoverContentsElement.className = 'hover-contents code-hover-contents';
                 onFinishedRendering();
@@ -461,14 +455,14 @@ function labelForHoverVerbosityAction(keybindingService, action) {
         case HoverVerbosityAction.Increase: {
             const kb = keybindingService.lookupKeybinding(INCREASE_HOVER_VERBOSITY_ACTION_ID);
             return kb ?
-                ( localize(1225, "Increase Hover Verbosity ({0})", kb.getLabel())) :
-                ( localize(1226, "Increase Hover Verbosity"));
+                ( localize(1226, "Increase Hover Verbosity ({0})", kb.getLabel())) :
+                ( localize(1227, "Increase Hover Verbosity"));
         }
         case HoverVerbosityAction.Decrease: {
             const kb = keybindingService.lookupKeybinding(DECREASE_HOVER_VERBOSITY_ACTION_ID);
             return kb ?
-                ( localize(1227, "Decrease Hover Verbosity ({0})", kb.getLabel())) :
-                ( localize(1228, "Decrease Hover Verbosity"));
+                ( localize(1228, "Decrease Hover Verbosity ({0})", kb.getLabel())) :
+                ( localize(1229, "Decrease Hover Verbosity"));
         }
     }
 }

package/vscode/src/vs/editor/contrib/hover/browser/markerHoverParticipant.js

@@ -168,7 +168,7 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
             const markerController = MarkerController.get(this._editor);
             if (markerController) {
                 context.statusBar.addAction({
-                    label: ( localize(1229, "View Problem")),
+                    label: ( localize(1230, "View Problem")),
                     commandId: NextMarkerAction.ID,
                     run: () => {
                         context.hide();
@@ -183,14 +183,14 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
             if (this.recentMarkerCodeActionsInfo) {
                 if (IMarkerData.makeKey(this.recentMarkerCodeActionsInfo.marker) === IMarkerData.makeKey(markerHover.marker)) {
                     if (!this.recentMarkerCodeActionsInfo.hasCodeActions) {
-                        quickfixPlaceholderElement.textContent = ( localize(1230, "No quick fixes available"));
+                        quickfixPlaceholderElement.textContent = ( localize(1231, "No quick fixes available"));
                     }
                 }
                 else {
                     this.recentMarkerCodeActionsInfo = undefined;
                 }
             }
-            const updatePlaceholderDisposable = this.recentMarkerCodeActionsInfo && !this.recentMarkerCodeActionsInfo.hasCodeActions ? Disposable.None : disposableTimeout(() => quickfixPlaceholderElement.textContent = ( localize(1231, "Checking for quick fixes...")), 200, disposables);
+            const updatePlaceholderDisposable = this.recentMarkerCodeActionsInfo && !this.recentMarkerCodeActionsInfo.hasCodeActions ? Disposable.None : disposableTimeout(() => quickfixPlaceholderElement.textContent = ( localize(1232, "Checking for quick fixes...")), 200, disposables);
             if (!quickfixPlaceholderElement.textContent) {
                 quickfixPlaceholderElement.textContent = String.fromCharCode(0xA0);
             }
@@ -201,7 +201,7 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
                 this.recentMarkerCodeActionsInfo = { marker: markerHover.marker, hasCodeActions: actions.validActions.length > 0 };
                 if (!this.recentMarkerCodeActionsInfo.hasCodeActions) {
                     actions.dispose();
-                    quickfixPlaceholderElement.textContent = ( localize(1230, "No quick fixes available"));
+                    quickfixPlaceholderElement.textContent = ( localize(1231, "No quick fixes available"));
                     return;
                 }
                 quickfixPlaceholderElement.style.display = 'none';
@@ -212,7 +212,7 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
                     }
                 }));
                 context.statusBar.addAction({
-                    label: ( localize(1232, "Quick Fix...")),
+                    label: ( localize(1233, "Quick Fix...")),
                     commandId: quickFixCommandId,
                     run: (target) => {
                         showing = true;

package/vscode/src/vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace.js

@@ -97,7 +97,7 @@ class InPlaceReplaceUp extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.inPlaceReplace.up',
-            label: ( localize2(1233, "Replace with Previous Value")),
+            label: ( localize2(1234, "Replace with Previous Value")),
             precondition: EditorContextKeys.writable,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -118,7 +118,7 @@ class InPlaceReplaceDown extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.inPlaceReplace.down',
-            label: ( localize2(1234, "Replace with Next Value")),
+            label: ( localize2(1235, "Replace with Next Value")),
             precondition: EditorContextKeys.writable,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,

package/vscode/src/vs/editor/contrib/indentation/browser/indentation.d.ts

@@ -3,9 +3,9 @@ import { EditorAction, IActionOptions, ServicesAccessor } from "../../../browser
 import { Range } from "../../../common/core/range.js";
 import { Selection } from "../../../common/core/selection.js";
 import { ICommand, ICursorStateComputerData, IEditOperationBuilder, IEditorContribution } from "../../../common/editorCommon.js";
-import { ITextModel } from "../../../common/model.js";
 import { TextEdit } from "../../../common/languages.js";
 import { ILanguageConfigurationService } from "../../../common/languages/languageConfigurationRegistry.service.js";
+import { ITextModel } from "../../../common/model.js";
 export declare class IndentationToSpacesAction extends EditorAction {
     static readonly ID = "editor.action.indentationToSpaces";
     constructor();

package/vscode/src/vs/editor/contrib/indentation/browser/indentation.js

@@ -2,31 +2,31 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { DisposableStore } from '../../../../base/common/lifecycle.js';
 import { getLeadingWhitespace } from '../../../../base/common/strings.js';
+import { localize2, localize } from '../../../../nls.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
 import { EditorAction, registerEditorContribution, EditorContributionInstantiation, registerEditorAction } from '../../../browser/editorExtensions.js';
 import { ShiftCommand } from '../../../common/commands/shiftCommand.js';
 import { EditorOption, EditorAutoIndentStrategy } from '../../../common/config/editorOptions.js';
 import { Range } from '../../../common/core/range.js';
 import { EditorContextKeys } from '../../../common/editorContextKeys.js';
 import { StandardTokenType } from '../../../common/encodedTokenAttributes.js';
+import { getGoodIndentForLine, getIndentMetadata } from '../../../common/languages/autoIndent.js';
 import { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.service.js';
 import { IndentConsts } from '../../../common/languages/supports/indentRules.js';
 import { IModelService } from '../../../common/services/model.service.js';
-import { getSpaceCnt, generateIndent } from '../common/indentUtils.js';
-import { localize2, localize } from '../../../../nls.js';
-import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
-import { getGoodIndentForLine, getIndentMetadata } from '../../../common/languages/autoIndent.js';
-import { getReindentEditOperations } from '../common/indentation.js';
 import { getStandardTokenTypeAtPosition } from '../../../common/tokens/lineTokens.js';
+import { getReindentEditOperations } from '../common/indentation.js';
+import { getSpaceCnt, generateIndent } from '../common/indentUtils.js';
 
 class IndentationToSpacesAction extends EditorAction {
     static { this.ID = 'editor.action.indentationToSpaces'; }
     constructor() {
         super({
             id: IndentationToSpacesAction.ID,
-            label: ( localize2(1235, "Convert Indentation to Spaces")),
+            label: ( localize2(1236, "Convert Indentation to Spaces")),
             precondition: EditorContextKeys.writable,
             metadata: {
-                description: ( localize2(1236, "Convert the tab indentation to spaces.")),
+                description: ( localize2(1237, "Convert the tab indentation to spaces.")),
             }
         });
     }
@@ -54,10 +54,10 @@ class IndentationToTabsAction extends EditorAction {
     constructor() {
         super({
             id: IndentationToTabsAction.ID,
-            label: ( localize2(1237, "Convert Indentation to Tabs")),
+            label: ( localize2(1238, "Convert Indentation to Tabs")),
             precondition: EditorContextKeys.writable,
             metadata: {
-                description: ( localize2(1238, "Convert the spaces indentation to tabs.")),
+                description: ( localize2(1239, "Convert the spaces indentation to tabs.")),
             }
         });
     }
@@ -99,16 +99,16 @@ class ChangeIndentationSizeAction extends EditorAction {
             id: ( n.toString()),
             label: ( n.toString()),
             description: (n === creationOpts.tabSize && n === modelOpts.tabSize
-                ? ( localize(1239, "Configured Tab Size"))
+                ? ( localize(1240, "Configured Tab Size"))
                 : n === creationOpts.tabSize
-                    ? ( localize(1240, "Default Tab Size"))
+                    ? ( localize(1241, "Default Tab Size"))
                     : n === modelOpts.tabSize
-                        ? ( localize(1241, "Current Tab Size"))
+                        ? ( localize(1242, "Current Tab Size"))
                         : undefined)
         })));
         const autoFocusIndex = Math.min(model.getOptions().tabSize - 1, 7);
         setTimeout(() => {
-            quickInputService.pick(picks, { placeHolder: ( localize(1242, "Select Tab Size for Current File")), activeItem: picks[autoFocusIndex] }).then(pick => {
+            quickInputService.pick(picks, { placeHolder: ( localize(1243, "Select Tab Size for Current File")), activeItem: picks[autoFocusIndex] }).then(pick => {
                 if (pick) {
                     if (model && !model.isDisposed()) {
                         const pickedVal = parseInt(pick.label, 10);
@@ -135,10 +135,10 @@ class IndentUsingTabs extends ChangeIndentationSizeAction {
     constructor() {
         super(false, false, {
             id: IndentUsingTabs.ID,
-            label: ( localize2(1243, "Indent Using Tabs")),
+            label: ( localize2(1244, "Indent Using Tabs")),
             precondition: undefined,
             metadata: {
-                description: ( localize2(1244, "Use indentation with tabs.")),
+                description: ( localize2(1245, "Use indentation with tabs.")),
             }
         });
     }
@@ -148,10 +148,10 @@ class IndentUsingSpaces extends ChangeIndentationSizeAction {
     constructor() {
         super(true, false, {
             id: IndentUsingSpaces.ID,
-            label: ( localize2(1245, "Indent Using Spaces")),
+            label: ( localize2(1246, "Indent Using Spaces")),
             precondition: undefined,
             metadata: {
-                description: ( localize2(1246, "Use indentation with spaces.")),
+                description: ( localize2(1247, "Use indentation with spaces.")),
             }
         });
     }
@@ -161,10 +161,10 @@ class ChangeTabDisplaySize extends ChangeIndentationSizeAction {
     constructor() {
         super(true, true, {
             id: ChangeTabDisplaySize.ID,
-            label: ( localize2(1247, "Change Tab Display Size")),
+            label: ( localize2(1248, "Change Tab Display Size")),
             precondition: undefined,
             metadata: {
-                description: ( localize2(1248, "Change the space size equivalent of the tab.")),
+                description: ( localize2(1249, "Change the space size equivalent of the tab.")),
             }
         });
     }
@@ -174,10 +174,10 @@ class DetectIndentation extends EditorAction {
     constructor() {
         super({
             id: DetectIndentation.ID,
-            label: ( localize2(1249, "Detect Indentation from Content")),
+            label: ( localize2(1250, "Detect Indentation from Content")),
             precondition: undefined,
             metadata: {
-                description: ( localize2(1250, "Detect the indentation from content.")),
+                description: ( localize2(1251, "Detect the indentation from content.")),
             }
         });
     }
@@ -195,11 +195,12 @@ class ReindentLinesAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.reindentlines',
-            label: ( localize2(1251, "Reindent Lines")),
+            label: ( localize2(1252, "Reindent Lines")),
             precondition: EditorContextKeys.writable,
             metadata: {
-                description: ( localize2(1252, "Reindent the lines of the editor.")),
-            }
+                description: ( localize2(1253, "Reindent the lines of the editor.")),
+            },
+            canTriggerInlineEdits: true,
         });
     }
     run(accessor, editor) {
@@ -220,11 +221,12 @@ class ReindentSelectedLinesAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.reindentselectedlines',
-            label: ( localize2(1253, "Reindent Selected Lines")),
+            label: ( localize2(1254, "Reindent Selected Lines")),
             precondition: EditorContextKeys.writable,
             metadata: {
-                description: ( localize2(1254, "Reindent the selected lines of the editor.")),
-            }
+                description: ( localize2(1255, "Reindent the selected lines of the editor.")),
+            },
+            canTriggerInlineEdits: true,
         });
     }
     run(accessor, editor) {

package/vscode/src/vs/editor/contrib/inlayHints/browser/inlayHintsController.js

@@ -5,14 +5,15 @@ import { isNonEmptyArray } from '../../../../base/common/arrays.js';
 import { RunOnceScheduler, disposableTimeout } from '../../../../base/common/async.js';
 import { CancellationTokenSource, CancellationToken } from '../../../../base/common/cancellation.js';
 import { onUnexpectedError } from '../../../../base/common/errors.js';
-import { DisposableStore, toDisposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { MutableDisposable, DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
 import { LRUCache } from '../../../../base/common/map.js';
 import { assertType } from '../../../../base/common/types.js';
 import { URI } from '../../../../base/common/uri.js';
 import { MouseTargetType } from '../../../browser/editorBrowser.js';
 import { DynamicCssRules } from '../../../browser/editorDom.js';
 import { StableEditorScrollState } from '../../../browser/stableEditorScroll.js';
-import { EditorOption, EDITOR_FONT_DEFAULTS } from '../../../common/config/editorOptions.js';
+import { EditorOption } from '../../../common/config/editorOptions.js';
+import { EDITOR_FONT_DEFAULTS } from '../../../common/config/fontInfo.js';
 import { EditOperation } from '../../../common/core/editOperation.js';
 import { Range } from '../../../common/core/range.js';
 import { Command, InlayHintKind } from '../../../common/languages.js';
@@ -88,6 +89,25 @@ var RenderMode;
     RenderMode[RenderMode["Normal"] = 0] = "Normal";
     RenderMode[RenderMode["Invisible"] = 1] = "Invisible";
 })(RenderMode || (RenderMode = {}));
+class CancellationStore {
+    constructor() {
+        this._store = ( new MutableDisposable());
+        this._tokenSource = ( new CancellationTokenSource());
+    }
+    dispose() {
+        this._store.dispose();
+        this._tokenSource.dispose(true);
+    }
+    reset() {
+        this._tokenSource.dispose(true);
+        this._tokenSource = ( new CancellationTokenSource());
+        this._store.value = ( new DisposableStore());
+        return {
+            store: this._store.value,
+            token: this._tokenSource.token
+        };
+    }
+}
 let InlayHintsController = class InlayHintsController {
     static { InlayHintsController_1 = this; }
     static { this.ID = 'editor.contrib.InlayHints'; }
@@ -175,43 +195,37 @@ let InlayHintsController = class InlayHintsController {
         }));
         let cts;
         const watchedProviders = ( new Set());
+        this._sessionDisposables.add(model.onWillDispose(() => cts?.cancel()));
+        const cancellationStore = this._sessionDisposables.add(( new CancellationStore()));
         const scheduler = ( new RunOnceScheduler(async () => {
             const t1 = Date.now();
-            cts?.dispose(true);
-            cts = ( new CancellationTokenSource());
-            const listener = model.onWillDispose(() => cts?.cancel());
+            const { store, token } = cancellationStore.reset();
             try {
-                const myToken = cts.token;
-                const inlayHints = await InlayHintsFragments.create(this._languageFeaturesService.inlayHintsProvider, model, this._getHintsRanges(), myToken);
+                const inlayHints = await InlayHintsFragments.create(this._languageFeaturesService.inlayHintsProvider, model, this._getHintsRanges(), token);
                 scheduler.delay = this._debounceInfo.update(model, Date.now() - t1);
-                if (myToken.isCancellationRequested) {
+                if (token.isCancellationRequested) {
                     inlayHints.dispose();
                     return;
                 }
                 for (const provider of inlayHints.provider) {
                     if (typeof provider.onDidChangeInlayHints === 'function' && !( watchedProviders.has(provider))) {
                         watchedProviders.add(provider);
-                        this._sessionDisposables.add(provider.onDidChangeInlayHints(() => {
+                        store.add(provider.onDidChangeInlayHints(() => {
                             if (!scheduler.isScheduled()) {
                                 scheduler.schedule();
                             }
                         }));
                     }
                 }
-                this._sessionDisposables.add(inlayHints);
+                store.add(inlayHints);
                 this._updateHintsDecorators(inlayHints.ranges, inlayHints.items);
                 this._cacheHintsForFastRestore(model);
             }
             catch (err) {
                 onUnexpectedError(err);
             }
-            finally {
-                cts.dispose();
-                listener.dispose();
-            }
         }, this._debounceInfo.get(model)));
         this._sessionDisposables.add(scheduler);
-        this._sessionDisposables.add(toDisposable(() => cts?.dispose(true)));
         scheduler.schedule(0);
         this._sessionDisposables.add(this._editor.onDidScrollChange((e) => {
             if (e.scrollTopChanged || !scheduler.isScheduled()) {
@@ -220,7 +234,6 @@ let InlayHintsController = class InlayHintsController {
         }));
         const cursor = this._sessionDisposables.add(( new MutableDisposable()));
         this._sessionDisposables.add(this._editor.onDidChangeModelContent((e) => {
-            cts?.cancel();
             const delay = Math.max(scheduler.delay, 800);
             this._cursorInfo = { position: this._editor.getPosition(), notEarlierThan: Date.now() + delay };
             cursor.value = disposableTimeout(() => scheduler.schedule(0), delay);

package/vscode/src/vs/editor/contrib/inlayHints/browser/inlayHintsHover.d.ts

@@ -3,20 +3,19 @@ import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { ICodeEditor, IEditorMouseEvent } from "../../../browser/editorBrowser.js";
 import { IModelDecoration } from "../../../common/model.js";
 import { HoverAnchor, IEditorHoverParticipant } from "../../hover/browser/hoverTypes.js";
-import { ILanguageService } from "../../../common/languages/language.service.js";
 import { ITextModelService } from "../../../common/services/resolverService.service.js";
 import { MarkdownHover, MarkdownHoverParticipant } from "../../hover/browser/markdownHoverParticipant.js";
 import { IConfigurationService } from "../../../../platform/configuration/common/configuration.service.js";
-import { IOpenerService } from "../../../../platform/opener/common/opener.service.js";
 import { ILanguageFeaturesService } from "../../../common/services/languageFeatures.service.js";
 import { IKeybindingService } from "../../../../platform/keybinding/common/keybinding.service.js";
 import { IHoverService } from "../../../../platform/hover/browser/hover.service.js";
 import { ICommandService } from "../../../../platform/commands/common/commands.service.js";
 import { HoverStartSource } from "../../hover/browser/hoverOperation.js";
+import { IMarkdownRendererService } from "../../../../platform/markdown/browser/markdownRenderer.service.js";
 export declare class InlayHintsHover extends MarkdownHoverParticipant implements IEditorHoverParticipant<MarkdownHover> {
     private readonly _resolverService;
     readonly hoverOrdinal: number;
-    constructor(editor: ICodeEditor, languageService: ILanguageService, openerService: IOpenerService, keybindingService: IKeybindingService, hoverService: IHoverService, configurationService: IConfigurationService, _resolverService: ITextModelService, languageFeaturesService: ILanguageFeaturesService, commandService: ICommandService);
+    constructor(editor: ICodeEditor, markdownRendererService: IMarkdownRendererService, keybindingService: IKeybindingService, hoverService: IHoverService, configurationService: IConfigurationService, _resolverService: ITextModelService, languageFeaturesService: ILanguageFeaturesService, commandService: ICommandService);
     suggestHoverAnchor(mouseEvent: IEditorMouseEvent): HoverAnchor | null;
     computeSync(): MarkdownHover[];
     computeAsync(anchor: HoverAnchor, _lineDecorations: IModelDecoration[], source: HoverStartSource, token: CancellationToken): AsyncIterableProducer<MarkdownHover>;

package/vscode/src/vs/editor/contrib/inlayHints/browser/inlayHintsHover.js

@@ -6,13 +6,11 @@ import { MouseTargetType } from '../../../browser/editorBrowser.js';
 import { Position } from '../../../common/core/position.js';
 import { ModelDecorationInjectedTextOptions } from '../../../common/model/textModel.js';
 import { HoverForeignElementAnchor } from '../../hover/browser/hoverTypes.js';
-import { ILanguageService } from '../../../common/languages/language.service.js';
 import { ITextModelService } from '../../../common/services/resolverService.service.js';
 import { getHoverProviderResultsAsAsyncIterable } from '../../hover/browser/getHover.js';
 import { MarkdownHoverParticipant, MarkdownHover } from '../../hover/browser/markdownHoverParticipant.js';
 import { InlayHintsController, RenderedInlayHintLabelPart } from './inlayHintsController.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
-import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.service.js';
 import { EditorOption } from '../../../common/config/editorOptions.js';
 import { localize } from '../../../../nls.js';
@@ -22,6 +20,7 @@ import { isNonEmptyArray } from '../../../../base/common/arrays.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
 import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
 import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
+import { IMarkdownRendererService } from '../../../../platform/markdown/browser/markdownRenderer.service.js';
 
 class InlayHintsHoverAnchor extends HoverForeignElementAnchor {
     constructor(part, owner, initialMousePosX, initialMousePosY) {
@@ -30,8 +29,8 @@ class InlayHintsHoverAnchor extends HoverForeignElementAnchor {
     }
 }
 let InlayHintsHover = class InlayHintsHover extends MarkdownHoverParticipant {
-    constructor(editor, languageService, openerService, keybindingService, hoverService, configurationService, _resolverService, languageFeaturesService, commandService) {
-        super(editor, languageService, openerService, configurationService, languageFeaturesService, keybindingService, hoverService, commandService);
+    constructor(editor, markdownRendererService, keybindingService, hoverService, configurationService, _resolverService, languageFeaturesService, commandService) {
+        super(editor, markdownRendererService, configurationService, languageFeaturesService, keybindingService, hoverService, commandService);
         this._resolverService = _resolverService;
         this.hoverOrdinal = 6;
     }
@@ -73,7 +72,7 @@ let InlayHintsHover = class InlayHintsHover extends MarkdownHoverParticipant {
                 executor.emitOne(( new MarkdownHover(this, anchor.range, [itemTooltip], false, 0)));
             }
             if (isNonEmptyArray(part.item.hint.textEdits)) {
-                executor.emitOne(( new MarkdownHover(this, anchor.range, [( new MarkdownString()).appendText(( localize(1255, "Double-click to insert")))], false, 10001)));
+                executor.emitOne(( new MarkdownHover(this, anchor.range, [( new MarkdownString()).appendText(( localize(1256, "Double-click to insert")))], false, 10001)));
             }
             let partTooltip;
             if (typeof part.part.tooltip === 'string') {
@@ -90,19 +89,19 @@ let InlayHintsHover = class InlayHintsHover extends MarkdownHoverParticipant {
                 const useMetaKey = this._editor.getOption(EditorOption.multiCursorModifier) === 'altKey';
                 const kb = useMetaKey
                     ? isMacintosh
-                        ? ( localize(1256, "cmd + click"))
-                        : ( localize(1257, "ctrl + click"))
+                        ? ( localize(1257, "cmd + click"))
+                        : ( localize(1258, "ctrl + click"))
                     : isMacintosh
-                        ? ( localize(1258, "option + click"))
-                        : ( localize(1259, "alt + click"));
+                        ? ( localize(1259, "option + click"))
+                        : ( localize(1260, "alt + click"));
                 if (part.part.location && part.part.command) {
-                    linkHint = ( new MarkdownString()).appendText(( localize(1260, 'Go to Definition ({0}), right click for more', kb)));
+                    linkHint = ( new MarkdownString()).appendText(( localize(1261, 'Go to Definition ({0}), right click for more', kb)));
                 }
                 else if (part.part.location) {
-                    linkHint = ( new MarkdownString()).appendText(( localize(1261, 'Go to Definition ({0})', kb)));
+                    linkHint = ( new MarkdownString()).appendText(( localize(1262, 'Go to Definition ({0})', kb)));
                 }
                 else if (part.part.command) {
-                    linkHint = ( new MarkdownString(`[${( localize(1262, "Execute Command"))}](${asCommandLink(part.part.command)} "${part.part.command.title}") (${kb})`, { isTrusted: true }));
+                    linkHint = ( new MarkdownString(`[${( localize(1263, "Execute Command"))}](${asCommandLink(part.part.command)} "${part.part.command.title}") (${kb})`, { isTrusted: true }));
                 }
                 if (linkHint) {
                     executor.emitOne(( new MarkdownHover(this, anchor.range, [linkHint], false, 10000)));
@@ -137,14 +136,13 @@ let InlayHintsHover = class InlayHintsHover extends MarkdownHoverParticipant {
     }
 };
 InlayHintsHover = ( __decorate([
-    ( __param(1, ILanguageService)),
-    ( __param(2, IOpenerService)),
-    ( __param(3, IKeybindingService)),
-    ( __param(4, IHoverService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, ITextModelService)),
-    ( __param(7, ILanguageFeaturesService)),
-    ( __param(8, ICommandService))
+    ( __param(1, IMarkdownRendererService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IHoverService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, ITextModelService)),
+    ( __param(6, ILanguageFeaturesService)),
+    ( __param(7, ICommandService))
 ], InlayHintsHover));
 
 export { InlayHintsHover };