@codingame/monaco-vscode-api 22.1.9 → 23.0.1

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

@@ -15,7 +15,6 @@ import { TrackedRangeStickiness } from '../../../common/model.js';
 import { ModelDecorationOptions } from '../../../common/model/textModel.js';
 import { UnicodeTextModelHighlighter, UnicodeHighlighterReasonKind } from '../../../common/services/unicodeTextModelHighlighter.js';
 import { IEditorWorkerService } from '../../../common/services/editorWorker.service.js';
-import { ILanguageService } from '../../../common/languages/language.service.js';
 import { HoverAnchorType, HoverParticipantRegistry } from '../../hover/browser/hoverTypes.js';
 import { MarkdownHover, renderMarkdownHovers } from '../../hover/browser/markdownHoverParticipant.js';
 import { BannerController } from './bannerController.js';
@@ -23,16 +22,16 @@ import { localize, localize2 } from '../../../../nls.js';
 import { ConfigurationTarget } from '../../../../platform/configuration/common/configuration.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
 import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
 import { IWorkspaceTrustManagementService } from '../../../../platform/workspace/common/workspaceTrust.service.js';
 import { Action2, registerAction2 } from '../../../../platform/actions/common/actions.js';
 import { safeIntl } from '../../../../base/common/date.js';
 import { isModelDecorationVisible, isModelDecorationInString, isModelDecorationInComment } from '../../../common/viewModel/viewModelDecoration.js';
+import { IMarkdownRendererService } from '../../../../platform/markdown/browser/markdownRenderer.service.js';
 
 registerCss(unicodeHighlighter);
-const warningIcon = registerIcon('extensions-warning-message', Codicon.warning, ( localize(1610, 'Icon shown with a warning message in the extensions editor.')));
+const warningIcon = registerIcon('extensions-warning-message', Codicon.warning, ( localize(1617, 'Icon shown with a warning message in the extensions editor.')));
 let UnicodeHighlighter = class UnicodeHighlighter extends Disposable {
     static { this.ID = 'editor.contrib.unicodeHighlighter'; }
     constructor(_editor, _editorWorkerService, _workspaceTrustService, instantiationService) {
@@ -51,19 +50,19 @@ let UnicodeHighlighter = class UnicodeHighlighter extends Disposable {
                 let data;
                 if (state.nonBasicAsciiCharacterCount >= max) {
                     data = {
-                        message: ( localize(1611, 'This document contains many non-basic ASCII unicode characters')),
+                        message: ( localize(1618, 'This document contains many non-basic ASCII unicode characters')),
                         command: ( new DisableHighlightingOfNonBasicAsciiCharactersAction()),
                     };
                 }
                 else if (state.ambiguousCharacterCount >= max) {
                     data = {
-                        message: ( localize(1612, 'This document contains many ambiguous unicode characters')),
+                        message: ( localize(1619, 'This document contains many ambiguous unicode characters')),
                         command: ( new DisableHighlightingOfAmbiguousCharactersAction()),
                     };
                 }
                 else if (state.invisibleCharacterCount >= max) {
                     data = {
-                        message: ( localize(1613, 'This document contains many invisible unicode characters')),
+                        message: ( localize(1620, 'This document contains many invisible unicode characters')),
                         command: ( new DisableHighlightingOfInvisibleCharactersAction()),
                     };
                 }
@@ -330,12 +329,11 @@ class ViewportUnicodeHighlighter extends Disposable {
         };
     }
 }
-const configureUnicodeHighlightOptionsStr = ( localize(1614, 'Configure Unicode Highlight Options'));
+const configureUnicodeHighlightOptionsStr = ( localize(1621, 'Configure Unicode Highlight Options'));
 let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipant {
-    constructor(_editor, _languageService, _openerService) {
+    constructor(_editor, _markdownRendererService) {
         this._editor = _editor;
-        this._languageService = _languageService;
-        this._openerService = _openerService;
+        this._markdownRendererService = _markdownRendererService;
         this.hoverOrdinal = 5;
     }
     computeSync(anchor, lineDecorations) {
@@ -363,7 +361,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                 case UnicodeHighlighterReasonKind.Ambiguous: {
                     if (isBasicASCII(highlightInfo.reason.confusableWith)) {
                         reason = ( localize(
-                            1615,
+                            1622,
                             'The character {0} could be confused with the ASCII character {1}, which is more common in source code.',
                             codePointStr,
                             formatCodePointMarkdown(highlightInfo.reason.confusableWith.codePointAt(0))
@@ -371,7 +369,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                     }
                     else {
                         reason = ( localize(
-                            1616,
+                            1623,
                             'The character {0} could be confused with the character {1}, which is more common in source code.',
                             codePointStr,
                             formatCodePointMarkdown(highlightInfo.reason.confusableWith.codePointAt(0))
@@ -380,10 +378,10 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                     break;
                 }
                 case UnicodeHighlighterReasonKind.Invisible:
-                    reason = ( localize(1617, 'The character {0} is invisible.', codePointStr));
+                    reason = ( localize(1624, 'The character {0} is invisible.', codePointStr));
                     break;
                 case UnicodeHighlighterReasonKind.NonBasicAscii:
-                    reason = ( localize(1618, 'The character {0} is not a basic ASCII character.', codePointStr));
+                    reason = ( localize(1625, 'The character {0} is not a basic ASCII character.', codePointStr));
                     break;
             }
             if (( existedReason.has(reason))) {
@@ -396,7 +394,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                 inComment: highlightInfo.inComment,
                 inString: highlightInfo.inString,
             };
-            const adjustSettings = ( localize(1619, 'Adjust settings'));
+            const adjustSettings = ( localize(1626, 'Adjust settings'));
             const uri = createCommandUri(ShowExcludeOptions.ID, adjustSettingsArgs);
             const markdown = ( new MarkdownString('', true))
                 .appendMarkdown(reason)
@@ -407,15 +405,14 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
         return result;
     }
     renderHoverParts(context, hoverParts) {
-        return renderMarkdownHovers(context, hoverParts, this._editor, this._languageService, this._openerService);
+        return renderMarkdownHovers(context, hoverParts, this._editor, this._markdownRendererService);
     }
     getAccessibleContent(hoverPart) {
         return ( hoverPart.contents.map(c => c.value)).join('\n');
     }
 };
 UnicodeHighlighterHoverParticipant = ( __decorate([
-    ( __param(1, ILanguageService)),
-    ( __param(2, IOpenerService))
+    ( __param(1, IMarkdownRendererService))
 ], UnicodeHighlighterHoverParticipant));
 function codePointToHex(codePoint) {
     return `U+${( codePoint.toString(16)).padStart(4, '0')}`;
@@ -468,10 +465,10 @@ class DisableHighlightingInCommentsAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localize2(1620, "Disable highlighting of characters in comments")),
+            label: ( localize2(1627, "Disable highlighting of characters in comments")),
             precondition: undefined
         });
-        this.shortLabel = ( localize(1621, 'Disable Highlight In Comments'));
+        this.shortLabel = ( localize(1628, 'Disable Highlight In Comments'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor.get(IConfigurationService);
@@ -488,10 +485,10 @@ class DisableHighlightingInStringsAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localize2(1622, "Disable highlighting of characters in strings")),
+            label: ( localize2(1629, "Disable highlighting of characters in strings")),
             precondition: undefined
         });
-        this.shortLabel = ( localize(1623, 'Disable Highlight In Strings'));
+        this.shortLabel = ( localize(1630, 'Disable Highlight In Strings'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor.get(IConfigurationService);
@@ -508,11 +505,11 @@ class DisableHighlightingOfAmbiguousCharactersAction extends Action2 {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            title: ( localize2(1624, "Disable highlighting of ambiguous characters")),
+            title: ( localize2(1631, "Disable highlighting of ambiguous characters")),
             precondition: undefined,
             f1: false,
         });
-        this.shortLabel = ( localize(1625, 'Disable Ambiguous Highlight'));
+        this.shortLabel = ( localize(1632, 'Disable Ambiguous Highlight'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor.get(IConfigurationService);
@@ -529,11 +526,11 @@ class DisableHighlightingOfInvisibleCharactersAction extends Action2 {
     constructor() {
         super({
             id: DisableHighlightingOfInvisibleCharactersAction.ID,
-            title: ( localize2(1626, "Disable highlighting of invisible characters")),
+            title: ( localize2(1633, "Disable highlighting of invisible characters")),
             precondition: undefined,
             f1: false,
         });
-        this.shortLabel = ( localize(1627, 'Disable Invisible Highlight'));
+        this.shortLabel = ( localize(1634, 'Disable Invisible Highlight'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor.get(IConfigurationService);
@@ -550,11 +547,11 @@ class DisableHighlightingOfNonBasicAsciiCharactersAction extends Action2 {
     constructor() {
         super({
             id: DisableHighlightingOfNonBasicAsciiCharactersAction.ID,
-            title: ( localize2(1628, "Disable highlighting of non basic ASCII characters")),
+            title: ( localize2(1635, "Disable highlighting of non basic ASCII characters")),
             precondition: undefined,
             f1: false,
         });
-        this.shortLabel = ( localize(1629, 'Disable Non ASCII Highlight'));
+        this.shortLabel = ( localize(1636, 'Disable Non ASCII Highlight'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor.get(IConfigurationService);
@@ -571,7 +568,7 @@ class ShowExcludeOptions extends Action2 {
     constructor() {
         super({
             id: ShowExcludeOptions.ID,
-            title: ( localize2(1630, "Show Exclude Options")),
+            title: ( localize2(1637, "Show Exclude Options")),
             precondition: undefined,
             f1: false,
         });
@@ -584,13 +581,13 @@ class ShowExcludeOptions extends Action2 {
         function getExcludeCharFromBeingHighlightedLabel(codePoint) {
             if (InvisibleCharacters.isInvisibleCharacter(codePoint)) {
                 return localize(
-                    1631,
+                    1638,
                     'Exclude {0} (invisible character) from being highlighted',
                     codePointToHex(codePoint)
                 );
             }
             return localize(
-                1632,
+                1639,
                 'Exclude {0} from being highlighted',
                 `${codePointToHex(codePoint)} "${char}"`
             );
@@ -600,7 +597,7 @@ class ShowExcludeOptions extends Action2 {
             for (const locale of reason.notAmbiguousInLocales) {
                 options.push({
                     label: ( localize(
-                        1633,
+                        1640,
                         "Allow unicode characters that are more common in the language \"{0}\".",
                         locale
                     )),

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

@@ -70,15 +70,15 @@ let UnusualLineTerminatorsDetector = class UnusualLineTerminatorsDetector extend
         try {
             this._isPresentingDialog = true;
             result = await this._dialogService.confirm({
-                title: ( localize(1634, "Unusual Line Terminators")),
-                message: ( localize(1635, "Detected unusual line terminators")),
+                title: ( localize(1641, "Unusual Line Terminators")),
+                message: ( localize(1642, "Detected unusual line terminators")),
                 detail: ( localize(
-                    1636,
+                    1643,
                     "The file '{0}' contains one or more unusual line terminator characters, like Line Separator (LS) or Paragraph Separator (PS).\n\nIt is recommended to remove them from the file. This can be configured via `editor.unusualLineTerminators`.",
                     basename(model.uri)
                 )),
-                primaryButton: ( localize(1637, "&&Remove Unusual Line Terminators")),
-                cancelButton: ( localize(1638, "Ignore"))
+                primaryButton: ( localize(1644, "&&Remove Unusual Line Terminators")),
+                cancelButton: ( localize(1645, "Ignore"))
             });
         }
         finally {

package/vscode/src/vs/editor/contrib/wordHighlighter/browser/highlightDecorations.js

@@ -20,36 +20,36 @@ import { themeColorFromId, registerThemingParticipant } from '../../../../platfo
 
 registerCss(highlightDecorations);
 const wordHighlightBackground = registerColor('editor.wordHighlightBackground', { dark: '#575757B8', light: '#57575740', hcDark: null, hcLight: null }, ( localize(
-    1639,
+    1646,
     'Background color of a symbol during read-access, like reading a variable. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 registerColor('editor.wordHighlightStrongBackground', { dark: '#004972B8', light: '#0e639c40', hcDark: null, hcLight: null }, ( localize(
-    1640,
+    1647,
     'Background color of a symbol during write-access, like writing to a variable. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 registerColor('editor.wordHighlightTextBackground', wordHighlightBackground, ( localize(
-    1641,
+    1648,
     'Background color of a textual occurrence for a symbol. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const wordHighlightBorder = registerColor('editor.wordHighlightBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(
-    1642,
+    1649,
     'Border color of a symbol during read-access, like reading a variable.'
 )));
 registerColor('editor.wordHighlightStrongBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(
-    1643,
+    1650,
     'Border color of a symbol during write-access, like writing to a variable.'
 )));
-registerColor('editor.wordHighlightTextBorder', wordHighlightBorder, ( localize(1644, "Border color of a textual occurrence for a symbol.")));
+registerColor('editor.wordHighlightTextBorder', wordHighlightBorder, ( localize(1651, "Border color of a textual occurrence for a symbol.")));
 const overviewRulerWordHighlightForeground = registerColor('editorOverviewRuler.wordHighlightForeground', '#A0A0A0CC', ( localize(
-    1645,
+    1652,
     'Overview ruler marker color for symbol highlights. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const overviewRulerWordHighlightStrongForeground = registerColor('editorOverviewRuler.wordHighlightStrongForeground', '#C0A0C0CC', ( localize(
-    1646,
+    1653,
     'Overview ruler marker color for write-access symbol highlights. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const overviewRulerWordHighlightTextForeground = registerColor('editorOverviewRuler.wordHighlightTextForeground', overviewRulerSelectionHighlightForeground, ( localize(
-    1647,
+    1654,
     'Overview ruler marker color of a textual occurrence for a symbol. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const _WRITE_OPTIONS = ModelDecorationOptions.register({

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

@@ -718,7 +718,7 @@ class NextWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(true, {
             id: 'editor.action.wordHighlight.next',
-            label: ( localize2(1648, "Go to Next Symbol Highlight")),
+            label: ( localize2(1655, "Go to Next Symbol Highlight")),
             precondition: ctxHasWordHighlights,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -732,7 +732,7 @@ class PrevWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(false, {
             id: 'editor.action.wordHighlight.prev',
-            label: ( localize2(1649, "Go to Previous Symbol Highlight")),
+            label: ( localize2(1656, "Go to Previous Symbol Highlight")),
             precondition: ctxHasWordHighlights,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -746,7 +746,7 @@ class TriggerWordHighlightAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.wordHighlight.trigger',
-            label: ( localize2(1650, "Trigger Symbol Highlight")),
+            label: ( localize2(1657, "Trigger Symbol Highlight")),
             precondition: undefined,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,

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

@@ -1,9 +1,9 @@
 import { ICodeEditor } from "../../../browser/editorBrowser.js";
 import { EditorAction, EditorCommand, ICommandOptions, ServicesAccessor } from "../../../browser/editorExtensions.js";
-import { DeleteWordContext, WordNavigationType } from "../../../common/cursor/cursorWordOperations.js";
-import { WordCharacterClassifier } from "../../../common/core/wordCharacterClassifier.js";
 import { Position } from "../../../common/core/position.js";
 import { Range } from "../../../common/core/range.js";
+import { WordCharacterClassifier } from "../../../common/core/wordCharacterClassifier.js";
+import { DeleteWordContext, WordNavigationType } from "../../../common/cursor/cursorWordOperations.js";
 import { ITextModel } from "../../../common/model.js";
 export interface MoveWordOptions extends ICommandOptions {
     inSelectionMode: boolean;
@@ -13,7 +13,7 @@ export declare abstract class MoveWordCommand extends EditorCommand {
     private readonly _inSelectionMode;
     private readonly _wordNavigationType;
     constructor(opts: MoveWordOptions);
-    runEditorCommand(accessor: ServicesAccessor, editor: ICodeEditor, args: any): void;
+    runEditorCommand(accessor: ServicesAccessor, editor: ICodeEditor, args: unknown): void;
     private _moveTo;
     protected abstract _move(wordSeparators: WordCharacterClassifier, model: ITextModel, position: Position, wordNavigationType: WordNavigationType, hasMulticursor: boolean): Position;
 }
@@ -83,7 +83,7 @@ export declare abstract class DeleteWordCommand extends EditorCommand {
     private readonly _whitespaceHeuristics;
     private readonly _wordNavigationType;
     constructor(opts: DeleteWordOptions);
-    runEditorCommand(accessor: ServicesAccessor, editor: ICodeEditor, args: any): void;
+    runEditorCommand(accessor: ServicesAccessor, editor: ICodeEditor, args: unknown): void;
     protected abstract _delete(ctx: DeleteWordContext, wordNavigationType: WordNavigationType): Range;
 }
 export declare class DeleteWordLeftCommand extends DeleteWordCommand {
@@ -112,5 +112,5 @@ export declare class DeleteWordRight extends DeleteWordRightCommand {
 }
 export declare class DeleteInsideWord extends EditorAction {
     constructor();
-    run(accessor: ServicesAccessor, editor: ICodeEditor, args: any): void;
+    run(accessor: ServicesAccessor, editor: ICodeEditor, args: unknown): void;
 }

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

@@ -1,23 +1,23 @@
 
 import { KeyMod as KeyMod$1, KeyCode } from '../../../../base/common/keyCodes.js';
+import { localize2 } from '../../../../nls.js';
+import { CONTEXT_ACCESSIBILITY_MODE_ENABLED } from '../../../../platform/accessibility/common/accessibility.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { IsWindowsContext } from '../../../../platform/contextkey/common/contextkeys.js';
+import { KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
 import { EditorCommand, EditorAction, registerEditorCommand, registerEditorAction } from '../../../browser/editorExtensions.js';
 import { ReplaceCommand } from '../../../common/commands/replaceCommand.js';
 import { EditorOption, EditorOptions } from '../../../common/config/editorOptions.js';
-import { CursorState } from '../../../common/cursorCommon.js';
-import { CursorChangeReason } from '../../../common/cursorEvents.js';
-import { WordOperations, WordNavigationType } from '../../../common/cursor/cursorWordOperations.js';
-import { getMapForWordSeparators } from '../../../common/core/wordCharacterClassifier.js';
 import { Position } from '../../../common/core/position.js';
 import { Range } from '../../../common/core/range.js';
 import { Selection } from '../../../common/core/selection.js';
+import { getMapForWordSeparators } from '../../../common/core/wordCharacterClassifier.js';
+import { WordOperations, WordNavigationType } from '../../../common/cursor/cursorWordOperations.js';
+import { CursorState } from '../../../common/cursorCommon.js';
+import { CursorChangeReason } from '../../../common/cursorEvents.js';
 import { ScrollType } from '../../../common/editorCommon.js';
 import { EditorContextKeys } from '../../../common/editorContextKeys.js';
 import { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.service.js';
-import { localize2 } from '../../../../nls.js';
-import { CONTEXT_ACCESSIBILITY_MODE_ENABLED } from '../../../../platform/accessibility/common/accessibility.js';
-import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
-import { IsWindowsContext } from '../../../../platform/contextkey/common/contextkeys.js';
-import { KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
 
 class MoveWordCommand extends EditorCommand {
     constructor(opts) {
@@ -267,7 +267,7 @@ class CursorWordAccessibilityRightSelect extends WordRightCommand {
 }
 class DeleteWordCommand extends EditorCommand {
     constructor(opts) {
-        super(opts);
+        super({ canTriggerInlineEdits: true, ...opts });
         this._whitespaceHeuristics = opts.whitespaceHeuristics;
         this._wordNavigationType = opts.wordNavigationType;
     }
@@ -399,7 +399,7 @@ class DeleteInsideWord extends EditorAction {
         super({
             id: 'deleteInsideWord',
             precondition: EditorContextKeys.writable,
-            label: ( localize2(1651, "Delete Word")),
+            label: ( localize2(1658, "Delete Word")),
         });
     }
     run(accessor, editor, args) {

package/vscode/src/vs/editor/standalone/browser/standaloneCodeEditor.d.ts

@@ -27,6 +27,7 @@ import { ILanguageFeaturesService } from "../../common/services/languageFeatures
 import { DiffEditorWidget } from "../../browser/widget/diffEditor/diffEditorWidget.js";
 import { IAccessibilitySignalService } from "../../../platform/accessibilitySignal/browser/accessibilitySignalService.service.js";
 import { IHoverService } from "../../../platform/hover/browser/hover.service.js";
+import { IMarkdownRendererService } from "../../../platform/markdown/browser/markdownRenderer.service.js";
 /**
  * Description of an action contribution
  */
@@ -118,17 +119,17 @@ export type IStandaloneDiffEditor = import("monaco-editor").editor.IStandaloneDi
  */
 export declare class StandaloneCodeEditor extends CodeEditorWidget implements IStandaloneCodeEditor {
     private readonly _standaloneKeybindingService;
-    constructor(domElement: HTMLElement, _options: Readonly<IStandaloneEditorConstructionOptions>, instantiationService: IInstantiationService, codeEditorService: ICodeEditorService, commandService: ICommandService, contextKeyService: IContextKeyService, hoverService: IHoverService, keybindingService: IKeybindingService, themeService: IThemeService, notificationService: INotificationService, accessibilityService: IAccessibilityService, languageConfigurationService: ILanguageConfigurationService, languageFeaturesService: ILanguageFeaturesService);
+    constructor(domElement: HTMLElement, _options: Readonly<IStandaloneEditorConstructionOptions>, instantiationService: IInstantiationService, codeEditorService: ICodeEditorService, commandService: ICommandService, contextKeyService: IContextKeyService, hoverService: IHoverService, keybindingService: IKeybindingService, themeService: IThemeService, notificationService: INotificationService, accessibilityService: IAccessibilityService, languageConfigurationService: ILanguageConfigurationService, languageFeaturesService: ILanguageFeaturesService, markdownRendererService: IMarkdownRendererService);
     addCommand(keybinding: number, handler: ICommandHandler, context?: string): string | null;
     createContextKey<T extends ContextKeyValue = ContextKeyValue>(key: string, defaultValue: T): IContextKey<T>;
     addAction(_descriptor: IActionDescriptor): IDisposable;
-    protected _triggerCommand(handlerId: string, payload: any): void;
+    protected _triggerCommand(handlerId: string, payload: unknown): void;
 }
 export declare class StandaloneEditor extends StandaloneCodeEditor implements IStandaloneCodeEditor {
     private readonly _configurationService;
     private readonly _standaloneThemeService;
     private _ownsModel;
-    constructor(domElement: HTMLElement, _options: Readonly<IStandaloneEditorConstructionOptions> | undefined, instantiationService: IInstantiationService, codeEditorService: ICodeEditorService, commandService: ICommandService, contextKeyService: IContextKeyService, hoverService: IHoverService, keybindingService: IKeybindingService, themeService: IStandaloneThemeService, notificationService: INotificationService, configurationService: IConfigurationService, accessibilityService: IAccessibilityService, modelService: IModelService, languageService: ILanguageService, languageConfigurationService: ILanguageConfigurationService, languageFeaturesService: ILanguageFeaturesService);
+    constructor(domElement: HTMLElement, _options: Readonly<IStandaloneEditorConstructionOptions> | undefined, instantiationService: IInstantiationService, codeEditorService: ICodeEditorService, commandService: ICommandService, contextKeyService: IContextKeyService, hoverService: IHoverService, keybindingService: IKeybindingService, themeService: IStandaloneThemeService, notificationService: INotificationService, configurationService: IConfigurationService, accessibilityService: IAccessibilityService, modelService: IModelService, languageService: ILanguageService, languageConfigurationService: ILanguageConfigurationService, languageFeaturesService: ILanguageFeaturesService, markdownRendererService: IMarkdownRendererService);
     dispose(): void;
     updateOptions(newOptions: Readonly<IEditorOptions & IGlobalEditorOptions>): void;
     protected _postDetachModelCleanup(detachedModel: ITextModel): void;

package/vscode/src/vs/editor/standalone/browser/standaloneCodeEditor.js

@@ -35,6 +35,8 @@ import { setHoverDelegateFactory } from '../../../base/browser/ui/hover/hoverDel
 import { WorkbenchHoverDelegate } from '../../../platform/hover/browser/hover.js';
 import { IHoverService } from '../../../platform/hover/browser/hover.service.js';
 import { setBaseLayerHoverDelegate } from '../../../base/browser/ui/hover/hoverDelegate2.js';
+import { IMarkdownRendererService } from '../../../platform/markdown/browser/markdownRenderer.service.js';
+import { EditorMarkdownCodeBlockRenderer } from '../../browser/widget/markdownRenderer/browser/editorMarkdownCodeBlockRenderer.js';
 
 let LAST_GENERATED_COMMAND_ID = 0;
 let ariaDomNodeCreated = false;
@@ -48,7 +50,7 @@ function createAriaDomNode(parent) {
     setARIAContainer(parent || mainWindow.document.body);
 }
 let StandaloneCodeEditor = class StandaloneCodeEditor extends CodeEditorWidget {
-    constructor(domElement, _options, instantiationService, codeEditorService, commandService, contextKeyService, hoverService, keybindingService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService) {
+    constructor(domElement, _options, instantiationService, codeEditorService, commandService, contextKeyService, hoverService, keybindingService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService, markdownRendererService) {
         const options = { ..._options };
         options.ariaLabel = options.ariaLabel || StandaloneCodeEditorNLS.editorViewAccessibleLabel;
         super(domElement, options, { isStandaloneEditor: true }, instantiationService, codeEditorService, commandService, contextKeyService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService, keybindingService);
@@ -61,6 +63,7 @@ let StandaloneCodeEditor = class StandaloneCodeEditor extends CodeEditorWidget {
         createAriaDomNode(options.ariaContainerElement);
         setHoverDelegateFactory((placement, enableInstantHover) => instantiationService.createInstance(WorkbenchHoverDelegate, placement, { instantHover: enableInstantHover }, {}));
         setBaseLayerHoverDelegate(hoverService);
+        markdownRendererService.setDefaultCodeBlockRenderer(instantiationService.createInstance(EditorMarkdownCodeBlockRenderer));
     }
     addCommand(keybinding, handler, context) {
         if (!this._standaloneKeybindingService) {
@@ -156,10 +159,11 @@ StandaloneCodeEditor = ( __decorate([
     ( __param(9, INotificationService)),
     ( __param(10, IAccessibilityService)),
     ( __param(11, ILanguageConfigurationService)),
-    ( __param(12, ILanguageFeaturesService))
+    ( __param(12, ILanguageFeaturesService)),
+    ( __param(13, IMarkdownRendererService))
 ], StandaloneCodeEditor));
 let StandaloneEditor = class StandaloneEditor extends StandaloneCodeEditor {
-    constructor(domElement, _options, instantiationService, codeEditorService, commandService, contextKeyService, hoverService, keybindingService, themeService, notificationService, configurationService, accessibilityService, modelService, languageService, languageConfigurationService, languageFeaturesService) {
+    constructor(domElement, _options, instantiationService, codeEditorService, commandService, contextKeyService, hoverService, keybindingService, themeService, notificationService, configurationService, accessibilityService, modelService, languageService, languageConfigurationService, languageFeaturesService, markdownRendererService) {
         const options = { ..._options };
         updateConfigurationService(configurationService, options, false);
         const themeDomRegistration = themeService.registerEditorContainer(domElement);
@@ -171,7 +175,7 @@ let StandaloneEditor = class StandaloneEditor extends StandaloneCodeEditor {
         }
         const _model = options.model;
         delete options.model;
-        super(domElement, options, instantiationService, codeEditorService, commandService, contextKeyService, hoverService, keybindingService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService);
+        super(domElement, options, instantiationService, codeEditorService, commandService, contextKeyService, hoverService, keybindingService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService, markdownRendererService);
         this._configurationService = configurationService;
         this._standaloneThemeService = themeService;
         this._register(themeDomRegistration);
@@ -229,7 +233,8 @@ StandaloneEditor = ( __decorate([
     ( __param(12, IModelService)),
     ( __param(13, ILanguageService)),
     ( __param(14, ILanguageConfigurationService)),
-    ( __param(15, ILanguageFeaturesService))
+    ( __param(15, ILanguageFeaturesService)),
+    ( __param(16, IMarkdownRendererService))
 ], StandaloneEditor));
 let StandaloneDiffEditor2 = class StandaloneDiffEditor2 extends DiffEditorWidget {
     constructor(domElement, _options, instantiationService, contextKeyService, codeEditorService, themeService, notificationService, configurationService, contextMenuService, editorProgressService, clipboardService, accessibilitySignalService, keybindingService) {

package/vscode/src/vs/editor/standalone/browser/standaloneServices.d.ts

@@ -41,12 +41,12 @@ export declare class StandaloneCommandService implements ICommandService {
     readonly onWillExecuteCommand: Event<ICommandEvent>;
     readonly onDidExecuteCommand: Event<ICommandEvent>;
     constructor(instantiationService: IInstantiationService);
-    executeCommand<T>(id: string, ...args: any[]): Promise<T>;
+    executeCommand<T>(id: string, ...args: unknown[]): Promise<T>;
 }
 export interface IKeybindingRule {
     keybinding: number;
     command?: string | null;
-    commandArgs?: any;
+    commandArgs?: unknown;
     when?: ContextKeyExpression | null;
 }
 export declare class StandaloneKeybindingService extends AbstractKeybindingService {
@@ -86,12 +86,13 @@ export declare class StandaloneConfigurationService implements IConfigurationSer
     getValue<T>(section: string, overrides: IConfigurationOverrides): T;
     updateValues(values: [
         string,
-        any
+        unknown
     ][]): Promise<void>;
-    updateValue(key: string, value: any, arg3?: any, arg4?: any): Promise<void>;
+    updateValue(key: string, value: unknown, arg3?: unknown, arg4?: unknown): Promise<void>;
     inspect<C>(key: string, options?: IConfigurationOverrides): IConfigurationValue<C>;
     keys(): {
         default: string[];
+        policy: string[];
         user: string[];
         workspace: string[];
         workspaceFolder: string[];

package/vscode/src/vs/editor/standalone/browser/standaloneServices.js

@@ -18,7 +18,7 @@ import '../../../base/common/errors.js';
 import { ResourceMap } from '../../../base/common/map.js';
 import { ILanguageFeaturesService } from '../../common/services/languageFeatures.service.js';
 import { registerSingleton, InstantiationType, getSingletonServiceDescriptors } from '../../../platform/instantiation/common/extensions.js';
-import '../../browser/services/hoverService/hoverService.js';
+import '../../../platform/hover/browser/hoverService.js';
 import '../../browser/services/inlineCompletionsService.js';
 import { addDisposableListener, EventType } from '../../../base/browser/dom.js';
 import { StandardKeyboardEvent } from '../../../base/browser/keyboardEvent.js';
@@ -491,7 +491,7 @@ class DomNodeListeners extends Disposable {
     }
 }
 function isConfigurationOverrides(thing) {
-    return thing
+    return !!thing
         && typeof thing === 'object'
         && (!thing.overrideIdentifier || typeof thing.overrideIdentifier === 'string')
         && (!thing.resource || thing.resource instanceof URI);

package/vscode/src/vs/editor/standalone/browser/standaloneTreeSitterLibraryService.d.ts

@@ -5,17 +5,9 @@ export declare class StandaloneTreeSitterLibraryService implements ITreeSitterLi
     readonly _serviceBrand: undefined;
     getParserClass(): Promise<typeof Parser>;
     supportsLanguage(languageId: string, reader: IReader | undefined): boolean;
-    getLanguage(languageId: string, reader: IReader | undefined): Language | undefined;
-    /**
-     * Return value of null indicates that there are no injection queries for this language.
-     * @param languageId
-     * @param reader
-     */
+    getLanguage(languageId: string, ignoreSupportsCheck: boolean, reader: IReader | undefined): Language | undefined;
+    getLanguagePromise(languageId: string): Promise<Language | undefined>;
     getInjectionQueries(languageId: string, reader: IReader | undefined): Query | null | undefined;
-    /**
-     * Return value of null indicates that there are no highlights queries for this language.
-     * @param languageId
-     * @param reader
-     */
     getHighlightingQueries(languageId: string, reader: IReader | undefined): Query | null | undefined;
+    createQuery(language: Language, querySource: string): Promise<Query>;
 }

package/vscode/src/vs/editor/standalone/browser/standaloneTreeSitterLibraryService.js

@@ -2,12 +2,15 @@
 
 class StandaloneTreeSitterLibraryService {
     getParserClass() {
-        throw ( new Error('getParserClass is not implemented in StandaloneTreeSitterLibraryService'));
+        throw ( new Error('not implemented in StandaloneTreeSitterLibraryService'));
     }
     supportsLanguage(languageId, reader) {
         return false;
     }
-    getLanguage(languageId, reader) {
+    getLanguage(languageId, ignoreSupportsCheck, reader) {
+        return undefined;
+    }
+    async getLanguagePromise(languageId) {
         return undefined;
     }
     getInjectionQueries(languageId, reader) {
@@ -16,6 +19,9 @@ class StandaloneTreeSitterLibraryService {
     getHighlightingQueries(languageId, reader) {
         return null;
     }
+    async createQuery(language, querySource) {
+        throw ( new Error('not implemented in StandaloneTreeSitterLibraryService'));
+    }
 }
 
 export { StandaloneTreeSitterLibraryService };

package/vscode/src/vs/platform/accessibility/browser/accessibilityService.js

@@ -50,8 +50,8 @@ let AccessibilityService = class AccessibilityService extends Disposable {
         }));
         const updateRootClasses = () => {
             const reduce = this.isMotionReduced();
-            this._layoutService.mainContainer.classList.toggle('reduce-motion', reduce);
-            this._layoutService.mainContainer.classList.toggle('enable-motion', !reduce);
+            this._layoutService.mainContainer.classList.toggle('monaco-reduce-motion', reduce);
+            this._layoutService.mainContainer.classList.toggle('monaco-enable-motion', !reduce);
         };
         updateRootClasses();
         this._register(this.onDidChangeReducedMotion(() => updateRootClasses()));