@codingame/monaco-vscode-api 1.83.16 → 1.85.0-next.1

package/vscode/src/vs/workbench/contrib/chat/common/chatAgents.js

@@ -1,149 +1,72 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
-import { Disposable, toDisposable, combinedDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions } from '../../../common/contributions.js';
-import { isProposedApiEnabled } from '../../../services/extensions/common/extensions.js';
-import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
-const agentItem = {
-    type: 'object',
-    required: ['agent', 'detail'],
-    properties: {
-        agent: {
-            type: 'string',
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/chat/common/chatAgents',
-                'agent',
-                "The name of the agent which will be used as prefix."
-            ))
-        },
-        detail: {
-            type: 'string',
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/chat/common/chatAgents',
-                'details',
-                "The details of the agent."
-            ))
-        },
-    }
-};
-const agentItems = {
-    description: ( localizeWithPath(
-        'vs/workbench/contrib/chat/common/chatAgents',
-        'vscode.extension.contributes.slashes',
-        "Contributes agents to chat"
-    )),
-    oneOf: [
-        agentItem,
-        {
-            type: 'array',
-            items: agentItem
-        }
-    ]
-};
-const agentsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'agents',
-    jsonSchema: agentItems
-}));
-function isAgentData(data) {
-    return typeof data === 'object' && data &&
-        typeof data.id === 'string' &&
-        typeof data.detail === 'string';
-}
 const IChatAgentService = ( createDecorator('chatAgentService'));
-(class ChatAgentService extends Disposable {
-    static { this.AGENT_LEADER = '@'; }
-    constructor(_extensionService) {
-        super();
-        this._extensionService = _extensionService;
+class ChatAgentService extends Disposable {
+    constructor() {
+        super(...arguments);
         this._agents = ( new Map());
         this._onDidChangeAgents = this._register(( new Emitter()));
         this.onDidChangeAgents = this._onDidChangeAgents.event;
     }
+    static { this.AGENT_LEADER = '@'; }
     dispose() {
         super.dispose();
         this._agents.clear();
     }
-    registerAgentData(data) {
-        if (( this._agents.has(data.id))) {
-            throw new Error(`Already registered an agent with id ${data.id}}`);
+    registerAgent(agent) {
+        if (( this._agents.has(agent.id))) {
+            throw new Error(`Already registered an agent with id ${agent.id}`);
         }
-        this._agents.set(data.id, { data });
+        this._agents.set(agent.id, { agent });
         this._onDidChangeAgents.fire();
         return toDisposable(() => {
-            if (this._agents.delete(data.id)) {
+            if (this._agents.delete(agent.id)) {
                 this._onDidChangeAgents.fire();
             }
         });
     }
-    registerAgentCallback(id, agentCallback) {
+    updateAgent(id, updateMetadata) {
         const data = this._agents.get(id);
         if (!data) {
             throw new Error(`No agent with id ${id} registered`);
         }
-        data.callback = agentCallback;
-        return toDisposable(() => data.callback = undefined);
+        data.agent.metadata = { ...data.agent.metadata, ...updateMetadata };
+        this._onDidChangeAgents.fire();
+    }
+    getDefaultAgent() {
+        return Iterable.find(( this._agents.values()), a => !!a.agent.metadata.isDefault)?.agent;
     }
-    registerAgent(data, callback) {
-        return combinedDisposable(this.registerAgentData(data), this.registerAgentCallback(data.id, callback));
+    getSecondaryAgent() {
+        return Iterable.find(( this._agents.values()), a => !!a.agent.metadata.isSecondary)?.agent;
     }
     getAgents() {
-        return Array.from(( this._agents.values()), v => v.data);
+        return Array.from(( this._agents.values()), v => v.agent);
     }
     hasAgent(id) {
         return ( this._agents.has(id));
     }
     getAgent(id) {
         const data = this._agents.get(id);
-        return data?.data;
+        return data?.agent;
     }
-    async invokeAgent(id, prompt, progress, history, token) {
+    async invokeAgent(id, request, progress, history, token) {
         const data = this._agents.get(id);
         if (!data) {
-            throw new Error('No agent with id ${id} NOT registered');
+            throw new Error(`No agent with id ${id}`);
         }
-        if (!data.callback) {
-            await this._extensionService.activateByEvent(`onChatAgent:${id}`);
+        return await data.agent.invoke(request, progress, history, token);
+    }
+    async getFollowups(id, sessionId, token) {
+        const data = this._agents.get(id);
+        if (!data) {
+            throw new Error(`No agent with id ${id}`);
         }
-        if (!data.callback) {
-            throw new Error(`No agent with id ${id} NOT resolved`);
+        if (!data.agent.provideFollowups) {
+            return [];
         }
-        return await data.callback(prompt, progress, history, token);
+        return data.agent.provideFollowups(sessionId, token);
     }
-});
-let ChatAgentContribution = class ChatAgentContribution {
-    constructor(chatAgentService) {
-        const contributions = ( new DisposableStore());
-        agentsExtPoint.setHandler(extensions => {
-            contributions.clear();
-            for (const entry of extensions) {
-                if (!isProposedApiEnabled(entry.description, 'chatAgents')) {
-                    entry.collector.error(`The ${agentsExtPoint.name} is proposed API`);
-                    continue;
-                }
-                const { value } = entry;
-                for (const candidate of Iterable.wrap(value)) {
-                    if (!isAgentData(candidate)) {
-                        entry.collector.error(( localizeWithPath(
-                            'vs/workbench/contrib/chat/common/chatAgents',
-                            'invalid',
-                            "Invalid {0}: {1}",
-                            agentsExtPoint.name,
-                            JSON.stringify(candidate)
-                        )));
-                        continue;
-                    }
-                    contributions.add(chatAgentService.registerAgentData({ ...candidate }));
-                }
-            }
-        });
-    }
-};
-ChatAgentContribution = ( __decorate([
-    ( __param(0, IChatAgentService))
-], ChatAgentContribution));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ChatAgentContribution, 3 );
-export { IChatAgentService, agentsExtPoint };
+}
+export { ChatAgentService, IChatAgentService };

package/vscode/src/vs/workbench/contrib/chat/common/chatContextKeys.js

@@ -0,0 +1,64 @@
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+const CONTEXT_RESPONSE_VOTE = ( new RawContextKey(
+ 'chatSessionResponseVote',
+ '',
+ { type: 'string', description: ( localizeWithPath(
+  'vs/workbench/contrib/chat/common/chatContextKeys',
+  'interactiveSessionResponseVote',
+  "When the response has been voted up, is set to 'up'. When voted down, is set to 'down'. Otherwise an empty string."
+ )) }
+));
+const CONTEXT_CHAT_RESPONSE_SUPPORT_ISSUE_REPORTING = ( new RawContextKey(
+ 'chatResponseSupportsIssueReporting',
+ false,
+ { type: 'boolean', description: ( localizeWithPath(
+  'vs/workbench/contrib/chat/common/chatContextKeys',
+  'chatResponseSupportsIssueReporting',
+  "True when the current chat response supports issue reporting."
+ )) }
+));
+const CONTEXT_RESPONSE_FILTERED = ( new RawContextKey(
+ 'chatSessionResponseFiltered',
+ false,
+ { type: 'boolean', description: ( localizeWithPath(
+  'vs/workbench/contrib/chat/common/chatContextKeys',
+  'chatResponseFiltered',
+  "True when the chat response was filtered out by the server."
+ )) }
+));
+const CONTEXT_CHAT_REQUEST_IN_PROGRESS = ( new RawContextKey(
+ 'chatSessionRequestInProgress',
+ false,
+ { type: 'boolean', description: ( localizeWithPath(
+  'vs/workbench/contrib/chat/common/chatContextKeys',
+  'interactiveSessionRequestInProgress',
+  "True when the current request is still in progress."
+ )) }
+));
+const CONTEXT_RESPONSE = ( new RawContextKey('chatResponse', false, { type: 'boolean', description: ( localizeWithPath(
+ 'vs/workbench/contrib/chat/common/chatContextKeys',
+ 'chatResponse',
+ "The chat item is a response."
+)) }));
+const CONTEXT_REQUEST = ( new RawContextKey('chatRequest', false, { type: 'boolean', description: ( localizeWithPath(
+ 'vs/workbench/contrib/chat/common/chatContextKeys',
+ 'chatRequest',
+ "The chat item is a request"
+)) }));
+const CONTEXT_CHAT_INPUT_HAS_TEXT = ( new RawContextKey('chatInputHasText', false, { type: 'boolean', description: ( localizeWithPath(
+ 'vs/workbench/contrib/chat/common/chatContextKeys',
+ 'interactiveInputHasText',
+ "True when the chat input has text."
+)) }));
+const CONTEXT_IN_CHAT_INPUT = ( new RawContextKey('inChatInput', false, { type: 'boolean', description: ( localizeWithPath(
+ 'vs/workbench/contrib/chat/common/chatContextKeys',
+ 'inInteractiveInput',
+ "True when focus is in the chat input, false otherwise."
+)) }));
+const CONTEXT_IN_CHAT_SESSION = ( new RawContextKey('inChat', false, { type: 'boolean', description: ( localizeWithPath(
+ 'vs/workbench/contrib/chat/common/chatContextKeys',
+ 'inChat',
+ "True when focus is in the chat widget, false otherwise."
+)) }));
+export { CONTEXT_CHAT_INPUT_HAS_TEXT, CONTEXT_CHAT_REQUEST_IN_PROGRESS, CONTEXT_CHAT_RESPONSE_SUPPORT_ISSUE_REPORTING, CONTEXT_IN_CHAT_INPUT, CONTEXT_IN_CHAT_SESSION, CONTEXT_REQUEST, CONTEXT_RESPONSE, CONTEXT_RESPONSE_FILTERED, CONTEXT_RESPONSE_VOTE };

package/vscode/src/vs/workbench/contrib/chat/common/chatParserTypes.js

@@ -0,0 +1,94 @@
+class ChatRequestTextPart {
+    static { this.Kind = 'text'; }
+    constructor(range, editorRange, text) {
+        this.range = range;
+        this.editorRange = editorRange;
+        this.text = text;
+        this.kind = ChatRequestTextPart.Kind;
+    }
+    get promptText() {
+        return this.text;
+    }
+}
+const chatVariableLeader = '#';
+const chatAgentLeader = '@';
+const chatSubcommandLeader = '/';
+class ChatRequestVariablePart {
+    static { this.Kind = 'var'; }
+    constructor(range, editorRange, variableName, variableArg) {
+        this.range = range;
+        this.editorRange = editorRange;
+        this.variableName = variableName;
+        this.variableArg = variableArg;
+        this.kind = ChatRequestVariablePart.Kind;
+    }
+    get text() {
+        const argPart = this.variableArg ? `:${this.variableArg}` : '';
+        return `${chatVariableLeader}${this.variableName}${argPart}`;
+    }
+    get promptText() {
+        return this.text;
+    }
+}
+class ChatRequestAgentPart {
+    static { this.Kind = 'agent'; }
+    constructor(range, editorRange, agent) {
+        this.range = range;
+        this.editorRange = editorRange;
+        this.agent = agent;
+        this.kind = ChatRequestAgentPart.Kind;
+    }
+    get text() {
+        return `${chatAgentLeader}${this.agent.id}`;
+    }
+    get promptText() {
+        return '';
+    }
+}
+class ChatRequestAgentSubcommandPart {
+    static { this.Kind = 'subcommand'; }
+    constructor(range, editorRange, command) {
+        this.range = range;
+        this.editorRange = editorRange;
+        this.command = command;
+        this.kind = ChatRequestAgentSubcommandPart.Kind;
+    }
+    get text() {
+        return `${chatSubcommandLeader}${this.command.name}`;
+    }
+    get promptText() {
+        return '';
+    }
+}
+class ChatRequestSlashCommandPart {
+    static { this.Kind = 'slash'; }
+    constructor(range, editorRange, slashCommand) {
+        this.range = range;
+        this.editorRange = editorRange;
+        this.slashCommand = slashCommand;
+        this.kind = ChatRequestSlashCommandPart.Kind;
+    }
+    get text() {
+        return `${chatSubcommandLeader}${this.slashCommand.command}`;
+    }
+    get promptText() {
+        return `${chatSubcommandLeader}${this.slashCommand.command}`;
+    }
+}
+class ChatRequestDynamicVariablePart {
+    static { this.Kind = 'dynamic'; }
+    constructor(range, editorRange, text, data) {
+        this.range = range;
+        this.editorRange = editorRange;
+        this.text = text;
+        this.data = data;
+        this.kind = ChatRequestDynamicVariablePart.Kind;
+    }
+    get referenceText() {
+        return this.text;
+    }
+    get promptText() {
+        return ``;
+    }
+}
+export { ChatRequestAgentPart, ChatRequestAgentSubcommandPart, ChatRequestDynamicVariablePart, ChatRequestSlashCommandPart, ChatRequestTextPart, ChatRequestVariablePart, chatAgentLeader, chatSubcommandLeader, chatVariableLeader };

package/vscode/src/vs/workbench/contrib/chat/common/chatService.js

@@ -1,3 +1,8 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+var InteractiveSessionVoteDirection;
+( (function(InteractiveSessionVoteDirection) {
+    InteractiveSessionVoteDirection[InteractiveSessionVoteDirection["Down"] = 0] = "Down";
+    InteractiveSessionVoteDirection[InteractiveSessionVoteDirection["Up"] = 1] = "Up";
+})(InteractiveSessionVoteDirection || (InteractiveSessionVoteDirection = {})));
 const IChatService = ( createDecorator('IChatService'));
-export { IChatService };
+export { IChatService, InteractiveSessionVoteDirection };

package/vscode/src/vs/workbench/contrib/chat/common/chatSlashCommands.js

@@ -1,90 +1,3 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions } from '../../../common/contributions.js';
-import { isProposedApiEnabled } from '../../../services/extensions/common/extensions.js';
-import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
-const slashItem = {
-    type: 'object',
-    required: ['command', 'detail'],
-    properties: {
-        command: {
-            type: 'string',
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/chat/common/chatSlashCommands',
-                'command',
-                "The name of the slash command which will be used as prefix."
-            ))
-        },
-        detail: {
-            type: 'string',
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/chat/common/chatSlashCommands',
-                'details',
-                "The details of the slash command."
-            ))
-        },
-    }
-};
-const slashItems = {
-    description: ( localizeWithPath(
-        'vs/workbench/contrib/chat/common/chatSlashCommands',
-        'vscode.extension.contributes.slashes',
-        "Contributes slash commands to chat"
-    )),
-    oneOf: [
-        slashItem,
-        {
-            type: 'array',
-            items: slashItem
-        }
-    ]
-};
-const slashesExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'slashes',
-    jsonSchema: slashItems
-}));
-function isChatSlashData(data) {
-    return typeof data === 'object' && data &&
-        typeof data.command === 'string' &&
-        typeof data.detail === 'string' &&
-        (typeof data.sortText === 'undefined' || typeof data.sortText === 'string') &&
-        (typeof data.executeImmediately === 'undefined' || typeof data.executeImmediately === 'boolean');
-}
 const IChatSlashCommandService = ( createDecorator('chatSlashCommandService'));
-let ChatSlashCommandContribution = class ChatSlashCommandContribution {
-    constructor(slashCommandService) {
-        const contributions = ( new DisposableStore());
-        slashesExtPoint.setHandler(extensions => {
-            contributions.clear();
-            for (const entry of extensions) {
-                if (!isProposedApiEnabled(entry.description, 'chatSlashCommands')) {
-                    entry.collector.error(`The ${slashesExtPoint.name} is proposed API`);
-                    continue;
-                }
-                const { value } = entry;
-                for (const candidate of Iterable.wrap(value)) {
-                    if (!isChatSlashData(candidate)) {
-                        entry.collector.error(( localizeWithPath(
-                            'vs/workbench/contrib/chat/common/chatSlashCommands',
-                            'invalid',
-                            "Invalid {0}: {1}",
-                            slashesExtPoint.name,
-                            JSON.stringify(candidate)
-                        )));
-                        continue;
-                    }
-                    contributions.add(slashCommandService.registerSlashData({ ...candidate }));
-                }
-            }
-        });
-    }
-};
-ChatSlashCommandContribution = ( __decorate([
-    ( __param(0, IChatSlashCommandService))
-], ChatSlashCommandContribution));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ChatSlashCommandContribution, 3 );
-export { IChatSlashCommandService, slashesExtPoint };
+export { IChatSlashCommandService };

package/vscode/src/vs/workbench/contrib/codeActions/browser/codeActionsContribution.js

@@ -67,9 +67,9 @@ const codeActionsOnSaveSchema = {
     markdownDescription: ( nls.localizeWithPath(
         'vs/workbench/contrib/codeActions/browser/codeActionsContribution',
         'editor.codeActionsOnSave',
-        'Run CodeActions for the editor on save. CodeActions must be specified and the editor must not be shutting down. Example: `"source.organizeImports": "explicit" `'
+        'Run Code Actions for the editor on save. Code Actions must be specified and the editor must not be shutting down. Example: `"source.organizeImports": "explicit" `'
     )),
-    type: 'object',
+    type: ['object', 'array'],
     additionalProperties: {
         type: ['string', 'boolean'],
         enum: ['always', 'explicit', 'never', true, false],
@@ -89,7 +89,7 @@ let CodeActionsContribution = class CodeActionsContribution extends Disposable {
         this._contributedCodeActions = [];
         this._onDidChangeContributions = this._register(( new Emitter()));
         codeActionsExtensionPoint.setHandler(extensionPoints => {
-            this._contributedCodeActions = ( extensionPoints.map(x => x.value)).flat();
+            this._contributedCodeActions = extensionPoints.flatMap(x => x.value).filter(x => Array.isArray(x.actions));
             this.updateConfigurationSchema(this._contributedCodeActions);
             this._onDidChangeContributions.fire();
         });
@@ -156,7 +156,7 @@ let CodeActionsContribution = class CodeActionsContribution extends Disposable {
             };
         };
         const getActions = (ofKind) => {
-            const allActions = ( this._contributedCodeActions.map(desc => desc.actions)).flat();
+            const allActions = this._contributedCodeActions.flatMap(desc => desc.actions);
             const out = ( new Map());
             for (const action of allActions) {
                 if (!( out.has(action.kind)) && ofKind.contains(( new CodeActionKind(action.kind)))) {

package/vscode/src/vs/workbench/contrib/codeEditor/browser/diffEditorHelper.js

@@ -15,9 +15,9 @@ import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/no
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { FloatingEditorClickWidget } from '../../../browser/codeeditor.js';
 import { Extensions } from '../../../common/configuration.js';
-import { getCommentCommandInfo } from '../../accessibility/browser/accessibilityContributions.js';
 import { IAccessibleViewService } from '../../accessibility/browser/accessibleView.js';
 import { AccessibilityHelpAction } from '../../accessibility/browser/accessibleViewActions.js';
+import { getCommentCommandInfo } from '../../accessibility/browser/editorAccessibilityHelp.js';
 import { IEditorService } from '../../../services/editor/common/editorService.js';
 let DiffEditorHelperContribution = class DiffEditorHelperContribution extends Disposable {
     static { this.ID = 'editor.contrib.diffEditorHelper'; }
@@ -30,7 +30,7 @@ let DiffEditorHelperContribution = class DiffEditorHelperContribution extends Di
         this._register(createScreenReaderHelp());
         const isEmbeddedDiffEditor = this._diffEditor instanceof EmbeddedDiffEditorWidget;
         if (!isEmbeddedDiffEditor) {
-            const computationResult = observableFromEvent(e => this._diffEditor.onDidUpdateDiff(e), () => this._diffEditor.getDiffComputationResult());
+            const computationResult = observableFromEvent(e => this._diffEditor.onDidUpdateDiff(e), () =>  this._diffEditor.getDiffComputationResult());
             const onlyWhiteSpaceChange = ( computationResult.map(r => r && !r.identical && r.changes2.length === 0));
             this._register(autorunWithStore((reader, store) => {
                 if (onlyWhiteSpaceChange.read(reader)) {
@@ -115,6 +115,7 @@ function createScreenReaderHelp() {
             content.push(commentCommandInfo);
         }
         accessibleViewService.show({
+            id: "diffEditor" ,
             verbositySettingKey: "accessibility.verbosity.diffEditor" ,
             provideContent: () => content.join('\n\n'),
             onClose: () => {

package/vscode/src/vs/workbench/contrib/codeEditor/browser/quickaccess/gotoSymbolQuickAccess.js

@@ -18,6 +18,8 @@ import { isCompositeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBro
 import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.js';
 import { IOutlineModelService } from 'monaco-editor/esm/vs/editor/contrib/documentSymbols/browser/outlineModel.js';
 import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { accessibleViewIsShown, accessibilityHelpIsShown } from '../../../accessibility/browser/accessibilityConfiguration.js';
 var GotoSymbolQuickAccessProvider_1;
 let GotoSymbolQuickAccessProvider = class GotoSymbolQuickAccessProvider extends AbstractGotoSymbolQuickAccessProvider {
     static { GotoSymbolQuickAccessProvider_1 = this; }
@@ -199,7 +201,7 @@ class GotoSymbolAction extends Action2 {
             },
             f1: true,
             keybinding: {
-                when: undefined,
+                when: ( ContextKeyExpr.and(( accessibleViewIsShown.negate()), ( accessibilityHelpIsShown.negate()))),
                 weight: 200 ,
                 primary: 2048  | 1024  | 45
             },

package/vscode/src/vs/workbench/contrib/codeEditor/browser/saveParticipants.js

@@ -123,8 +123,8 @@ let TrimFinalNewLinesParticipant = class TrimFinalNewLinesParticipant {
     }
     findLastNonEmptyLine(model) {
         for (let lineNumber = model.getLineCount(); lineNumber >= 1; lineNumber--) {
-            const lineContent = model.getLineContent(lineNumber);
-            if (lineContent.length > 0) {
+            const lineLength = model.getLineLength(lineNumber);
+            if (lineLength > 0) {
                 return lineNumber;
             }
         }
@@ -204,7 +204,7 @@ let FormatOnSaveParticipant = class FormatOnSaveParticipant {
                 await this.instantiationService.invokeFunction(formatDocumentWithSelectedProvider, editorOrModel, 2 , nestedProgress, token);
             }
             else if (ranges) {
-                await this.instantiationService.invokeFunction(formatDocumentRangesWithSelectedProvider, editorOrModel, ranges, 2 , nestedProgress, token);
+                await this.instantiationService.invokeFunction(formatDocumentRangesWithSelectedProvider, editorOrModel, ranges, 2 , nestedProgress, token, false);
             }
         }
     }
@@ -233,16 +233,13 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
         if (env.reason === 2 ) {
             return undefined;
         }
-        const convertedSetting = {};
-        for (const key in setting) {
-            if (typeof setting[key] === 'boolean') {
-                convertedSetting[key] = setting[key] ? 'explicit' : 'never';
-            }
-            else if (typeof setting[key] === 'string') {
-                convertedSetting[key] = setting[key];
-            }
+        if (env.reason !== 1  && Array.isArray(setting)) {
+            return undefined;
         }
-        const codeActionsOnSave = this.createCodeActionsOnSave(( Object.keys(convertedSetting)));
+        const settingItems = Array.isArray(setting)
+            ? setting
+            : ( Object.keys(setting)).filter(x => setting[x] && setting[x] !== 'never');
+        const codeActionsOnSave = this.createCodeActionsOnSave(settingItems);
         if (!Array.isArray(setting)) {
             codeActionsOnSave.sort((a, b) => {
                 if (CodeActionKind.SourceFixAll.contains(a)) {
@@ -260,15 +257,17 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
         if (!codeActionsOnSave.length) {
             return undefined;
         }
-        const excludedActions = ( ( Object.keys(setting))
-            .filter(x => convertedSetting[x] === 'never' || false)
-            .map(x => ( new CodeActionKind(x))));
+        const excludedActions = Array.isArray(setting)
+            ? []
+            : ( ( Object.keys(setting))
+                .filter(x => setting[x] === 'never' || false)
+                .map(x => ( new CodeActionKind(x))));
         progress.report({ message: ( localizeWithPath(
             'vs/workbench/contrib/codeEditor/browser/saveParticipants',
             'codeaction',
             "Quick Fixes"
         )) });
-        const filteredSaveList = codeActionsOnSave.filter(x => convertedSetting[x.value] === 'always' || (convertedSetting[x.value] === 'explicit') && env.reason === 1 );
+        const filteredSaveList = Array.isArray(setting) ? codeActionsOnSave : codeActionsOnSave.filter(x => setting[x.value] === 'always' || (((setting[x.value] === 'explicit' || setting[x.value] === true) && env.reason === 1) ));
         await this.applyOnSaveActions(textEditorModel, filteredSaveList, excludedActions, progress, token);
     }
     createCodeActionsOnSave(settingItems) {

package/vscode/src/vs/workbench/contrib/codeEditor/browser/toggleWordWrap.js

@@ -10,6 +10,9 @@ import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Extensions } from '../../../common/contributions.js';
 import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { onDidRegisterWindow, addDisposableListener } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { mainWindow } from 'monaco-editor/esm/vs/base/browser/window.js';
 const transientWordWrapState = 'transientWordWrapState';
 const isWordWrapMinifiedKey = 'isWordWrapMinified';
 const isDominatedByLongLinesKey = 'isDominatedByLongLines';
@@ -195,13 +198,16 @@ function canToggleWordWrap(codeEditorService, editor) {
     }
     return true;
 }
-let EditorWordWrapContextKeyTracker = class EditorWordWrapContextKeyTracker {
+let EditorWordWrapContextKeyTracker = class EditorWordWrapContextKeyTracker extends Disposable {
     constructor(_editorService, _codeEditorService, _contextService) {
+        super();
         this._editorService = _editorService;
         this._codeEditorService = _codeEditorService;
         this._contextService = _contextService;
-        window.addEventListener('focus', () => this._update(), true);
-        window.addEventListener('blur', () => this._update(), true);
+        this._register(Event.runAndSubscribe(onDidRegisterWindow, ({ window, disposables }) => {
+            disposables.add(addDisposableListener(window, 'focus', () => this._update(), true));
+            disposables.add(addDisposableListener(window, 'blur', () => this._update(), true));
+        }, { window: mainWindow, disposables: this._store }));
         this._editorService.onDidActiveEditorChange(() => this._update());
         this._canToggleWordWrap = CAN_TOGGLE_WORD_WRAP.bindTo(this._contextService);
         this._editorWordWrap = EDITOR_WORD_WRAP.bindTo(this._contextService);

package/vscode/src/vs/workbench/contrib/comments/browser/comments.contribution.js

@@ -12,6 +12,7 @@ import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { CommentContextKeys } from '../common/commentContextKeys.js';
 import { ToggleTabFocusModeAction } from 'monaco-editor/esm/vs/editor/contrib/toggleTabFocusMode/browser/toggleTabFocusMode.js';
+import { getActiveElement } from 'monaco-editor/esm/vs/base/browser/dom.js';
 ( Registry.as(Extensions.Configuration)).registerConfiguration({
     id: 'comments',
     order: 20,
@@ -204,6 +205,7 @@ class CommentsAccessibilityHelpContribution extends Disposable {
 let CommentsAccessibilityHelpProvider = class CommentsAccessibilityHelpProvider {
     constructor(_keybindingService) {
         this._keybindingService = _keybindingService;
+        this.id = "comments" ;
         this.verbositySettingKey = "accessibility.verbosity.comments" ;
         this.options = { type: "help"  };
     }
@@ -215,7 +217,7 @@ let CommentsAccessibilityHelpProvider = class CommentsAccessibilityHelpProvider
         return strings.format(noKbMsg, commandId);
     }
     provideContent() {
-        this._element = document.activeElement;
+        this._element = getActiveElement();
         const content = [];
         content.push(this._descriptionForCommand(ToggleTabFocusModeAction.ID, CommentAccessibilityHelpNLS.introWidget, CommentAccessibilityHelpNLS.introWidgetNoKb) + '\n');
         content.push(CommentAccessibilityHelpNLS.commentCommands);