@codingame/monaco-vscode-api 15.0.3 → 16.0.1

package/vscode/src/vs/workbench/contrib/chat/common/tools/editFileTool.js

@@ -2,14 +2,18 @@
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
 import { MarkdownString } from '../../../../../base/common/htmlContent.js';
 import '../../../../../base/common/observableInternal/index.js';
+import { isEqual } from '../../../../../base/common/resources.js';
 import { URI } from '../../../../../base/common/uri.js';
 import { generateUuid } from '../../../../../base/common/uuid.js';
 import { localize } from '../../../../../nls.js';
 import { IWorkspaceContextService } from '../../../../../platform/workspace/common/workspace.service.js';
 import { SaveReason } from '../../../../common/editor.js';
+import { GroupsOrder } from '../../../../services/editor/common/editorGroupsService.js';
+import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.service.js';
 import { ITextFileService } from '../../../../services/textfile/common/textfiles.service.js';
+import { CellUri } from '../../../notebook/common/notebookCommon.js';
+import { INotebookService } from '../../../notebook/common/notebookService.service.js';
 import { ICodeMapperService } from '../chatCodeMapperService.service.js';
-import { IChatEditingService } from '../chatEditingService.service.js';
 import { IChatService } from '../chatService.service.js';
 import { ILanguageModelIgnoredFilesService } from '../ignoredFiles.service.js';
 import { autorun } from '../../../../../base/common/observableInternal/autorun.js';
@@ -37,8 +41,9 @@ const ExtensionEditToolId = 'vscode_editFile';
 const InternalEditToolId = 'vscode_editFile_internal';
 const EditToolData = {
     id: InternalEditToolId,
-    displayName: ( localize(4872, "Edit File")),
+    displayName: ( localize(5006, "Edit File")),
     modelDescription: `Edit a file in the workspace. Use this tool once per file that needs to be modified, even if there are multiple changes for a file. Generate the "explanation" property first. ${codeInstructions}`,
+    source: { type: 'internal' },
     inputSchema: {
         type: 'object',
         properties: {
@@ -59,24 +64,34 @@ const EditToolData = {
     }
 };
 let EditTool = class EditTool {
-    constructor(chatService, chatEditingService, codeMapperService, workspaceContextService, ignoredFilesService, textFileService) {
+    constructor(chatService, codeMapperService, workspaceContextService, ignoredFilesService, textFileService, notebookService, editorGroupsService) {
         this.chatService = chatService;
-        this.chatEditingService = chatEditingService;
         this.codeMapperService = codeMapperService;
         this.workspaceContextService = workspaceContextService;
         this.ignoredFilesService = ignoredFilesService;
         this.textFileService = textFileService;
+        this.notebookService = notebookService;
+        this.editorGroupsService = editorGroupsService;
     }
     async invoke(invocation, countTokens, token) {
         if (!invocation.context) {
             throw ( new Error('toolInvocationToken is required for this tool'));
         }
         const parameters = invocation.parameters;
-        const uri = URI.revive(parameters.file);
-        if (!this.workspaceContextService.isInsideWorkspace(uri)) {
-            throw ( new Error(
-                `File ${uri.fsPath} can't be edited because it's not inside the current workspace`
-            ));
+        const fileUri = URI.revive(parameters.file);
+        const uri = CellUri.parse(fileUri)?.notebook || fileUri;
+        if (!this.workspaceContextService.isInsideWorkspace(uri) && !this.notebookService.getNotebookTextModel(uri)) {
+            const groupsByLastActive = this.editorGroupsService.getGroups(GroupsOrder.MOST_RECENTLY_ACTIVE);
+            const uriIsOpenInSomeEditor = ( groupsByLastActive.some((group) => {
+                return ( group.editors.some((editor) => {
+                    return isEqual(editor.resource, uri);
+                }));
+            }));
+            if (!uriIsOpenInSomeEditor) {
+                throw ( new Error(
+                    `File ${uri.fsPath} can't be edited because it's not inside the current workspace`
+                ));
+            }
         }
         if (await this.ignoredFilesService.fileIsIgnored(uri, token)) {
             throw ( new Error(
@@ -97,18 +112,28 @@ let EditTool = class EditTool {
         });
         model.acceptResponseProgress(request, {
             kind: 'codeblockUri',
-            uri
+            uri,
+            isEdit: true
         });
         model.acceptResponseProgress(request, {
             kind: 'markdownContent',
             content: ( new MarkdownString(parameters.code + '\n````\n'))
         });
-        model.acceptResponseProgress(request, {
-            kind: 'textEdit',
-            edits: [],
-            uri
-        });
-        const editSession = this.chatEditingService.getEditingSession(model.sessionId);
+        if (this.notebookService.hasSupportedNotebooks(uri) && (this.notebookService.getNotebookTextModel(uri))) {
+            model.acceptResponseProgress(request, {
+                kind: 'notebookEdit',
+                edits: [],
+                uri
+            });
+        }
+        else {
+            model.acceptResponseProgress(request, {
+                kind: 'textEdit',
+                edits: [],
+                uri
+            });
+        }
+        const editSession = model.editingSession;
         if (!editSession) {
             throw ( new Error('This tool must be called from within an editing session'));
         }
@@ -124,7 +149,12 @@ let EditTool = class EditTool {
                 model.acceptResponseProgress(request, { kind: 'notebookEdit', uri: target, edits });
             },
         }, token);
-        model.acceptResponseProgress(request, { kind: 'textEdit', uri, edits: [], done: true });
+        if (this.notebookService.hasSupportedNotebooks(uri) && (this.notebookService.getNotebookTextModel(uri))) {
+            model.acceptResponseProgress(request, { kind: 'notebookEdit', uri, edits: [], done: true });
+        }
+        else {
+            model.acceptResponseProgress(request, { kind: 'textEdit', uri, edits: [], done: true });
+        }
         if (result?.errorMessage) {
             throw ( new Error(result.errorMessage));
         }
@@ -162,11 +192,12 @@ let EditTool = class EditTool {
 };
 EditTool = ( __decorate([
     ( __param(0, IChatService)),
-    ( __param(1, IChatEditingService)),
-    ( __param(2, ICodeMapperService)),
-    ( __param(3, IWorkspaceContextService)),
-    ( __param(4, ILanguageModelIgnoredFilesService)),
-    ( __param(5, ITextFileService))
+    ( __param(1, ICodeMapperService)),
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, ILanguageModelIgnoredFilesService)),
+    ( __param(4, ITextFileService)),
+    ( __param(5, INotebookService)),
+    ( __param(6, IEditorGroupsService))
 ], EditTool));
 class EditToolInputProcessor {
     processInput(input) {

package/vscode/src/vs/workbench/contrib/chat/common/tools/promptTsxTypes.d.ts

@@ -0,0 +1,34 @@
+export declare enum PromptNodeType {
+    Piece = 1,
+    Text = 2
+}
+export interface TextJSON {
+    type: PromptNodeType.Text;
+    text: string;
+    lineBreakBefore: boolean | undefined;
+}
+export declare enum PieceCtorKind {
+    BaseChatMessage = 1,
+    Other = 2,
+    ImageChatMessage = 3
+}
+export interface BasePieceJSON {
+    type: PromptNodeType.Piece;
+    ctor: PieceCtorKind.BaseChatMessage | PieceCtorKind.Other;
+    children: PromptNodeJSON[];
+}
+export interface ImageChatMessagePieceJSON {
+    type: PromptNodeType.Piece;
+    ctor: PieceCtorKind.ImageChatMessage;
+    children: PromptNodeJSON[];
+    props: {
+        src: string;
+        detail?: "low" | "high";
+    };
+}
+export type PieceJSON = BasePieceJSON | ImageChatMessagePieceJSON;
+export type PromptNodeJSON = PieceJSON | TextJSON;
+export interface PromptElementJSON {
+    node: PieceJSON;
+}
+export declare function stringifyPromptElementJSON(element: PromptElementJSON): string;

package/vscode/src/vs/workbench/contrib/chat/common/tools/promptTsxTypes.js

@@ -0,0 +1,27 @@
+
+
+function stringifyPromptElementJSON(element) {
+    const strs = [];
+    stringifyPromptNodeJSON(element.node, strs);
+    return strs.join('');
+}
+function stringifyPromptNodeJSON(node, strs) {
+    if (node.type === PromptNodeType.Text) {
+        if (node.lineBreakBefore) {
+            strs.push('\n');
+        }
+        if (typeof node.text === 'string') {
+            strs.push(node.text);
+        }
+    }
+    else if (node.ctor === PieceCtorKind.ImageChatMessage) {
+        strs.push('<image>');
+    }
+    else if (node.ctor === PieceCtorKind.BaseChatMessage || node.ctor === PieceCtorKind.Other) {
+        for (const child of node.children) {
+            stringifyPromptNodeJSON(child, strs);
+        }
+    }
+}
+
+export { stringifyPromptElementJSON };

package/vscode/src/vs/workbench/contrib/chat/common/tools/tools.d.ts

@@ -0,0 +1,12 @@
+import { Disposable } from "../../../../../base/common/lifecycle.js";
+import { IInstantiationService } from "../../../../../platform/instantiation/common/instantiation.js";
+import { IWorkbenchContribution } from "../../../../common/contributions.js";
+import { ILanguageModelToolsService } from "../languageModelToolsService.service.js";
+export declare class BuiltinToolsContribution extends Disposable implements IWorkbenchContribution {
+    static readonly ID = "chat.builtinTools";
+    constructor(toolsService: ILanguageModelToolsService, instantiationService: IInstantiationService);
+}
+export interface IToolInputProcessor {
+    processInput(input: any): any;
+}
+export declare const InternalFetchWebPageToolId = "vscode_fetchWebPage_internal";

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

@@ -0,0 +1,23 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { ILanguageModelToolsService } from '../languageModelToolsService.service.js';
+import { EditTool, EditToolData } from './editFileTool.js';
+
+let BuiltinToolsContribution = class BuiltinToolsContribution extends Disposable {
+    static { this.ID = 'chat.builtinTools'; }
+    constructor(toolsService, instantiationService) {
+        super();
+        const editTool = instantiationService.createInstance(EditTool);
+        this._register(toolsService.registerToolData(EditToolData));
+        this._register(toolsService.registerToolImplementation(EditToolData.id, editTool));
+    }
+};
+BuiltinToolsContribution = ( __decorate([
+    ( __param(0, ILanguageModelToolsService)),
+    ( __param(1, IInstantiationService))
+], BuiltinToolsContribution));
+const InternalFetchWebPageToolId = 'vscode_fetchWebPage_internal';
+
+export { BuiltinToolsContribution, InternalFetchWebPageToolId };

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

@@ -18,17 +18,17 @@ const createCodeActionsAutoSave = (description) => {
         enum: ['always', 'explicit', 'never', true, false],
         enumDescriptions: [
             ( localize(
-            4891,
+            5025,
             'Triggers Code Actions on explicit saves and auto saves triggered by window or focus changes.'
         )),
-            ( localize(4892, 'Triggers Code Actions only when explicitly saved')),
-            ( localize(4893, 'Never triggers Code Actions on save')),
+            ( localize(5026, 'Triggers Code Actions only when explicitly saved')),
+            ( localize(5027, 'Never triggers Code Actions on save')),
             ( localize(
-            4894,
+            5028,
             'Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of "explicit".'
         )),
             ( localize(
-            4895,
+            5029,
             'Never triggers Code Actions on save. This value will be deprecated in favor of "never".'
         ))
         ],
@@ -41,14 +41,14 @@ const createNotebookCodeActionsAutoSave = (description) => {
         type: ['string', 'boolean'],
         enum: ['explicit', 'never', true, false],
         enumDescriptions: [
-            ( localize(4896, 'Triggers Code Actions only when explicitly saved.')),
-            ( localize(4897, 'Never triggers Code Actions on save.')),
+            ( localize(5030, 'Triggers Code Actions only when explicitly saved.')),
+            ( localize(5031, 'Never triggers Code Actions on save.')),
             ( localize(
-            4898,
+            5032,
             'Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of "explicit".'
         )),
             ( localize(
-            4899,
+            5033,
             'Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of "never".'
         ))
         ],
@@ -70,7 +70,7 @@ const codeActionsOnSaveSchema = {
         }
     ],
     markdownDescription: ( localize(
-        4900,
+        5034,
         'Run Code Actions for the editor on save. Code Actions must be specified and the editor must not be shutting down. When {0} is set to `afterDelay`, Code Actions will only be run when the file is saved explicitly. Example: `"source.organizeImports": "explicit" `',
         '`#files.autoSave#`'
     )),
@@ -102,7 +102,7 @@ const notebookCodeActionsOnSaveSchema = {
         }
     ],
     markdownDescription: ( localize(
-        4901,
+        5035,
         'Run a series of Code Actions for a notebook on save. Code Actions must be specified and the editor must not be shutting down. When {0} is set to `afterDelay`, Code Actions will only be run when the file is saved explicitly. Example: `"notebook.source.organizeImports": "explicit"`',
         '`#files.autoSave#`'
     )),
@@ -150,12 +150,12 @@ let CodeActionsContribution = class CodeActionsContribution extends Disposable {
         for (const codeActionKind of allProvidedKinds) {
             if (CodeActionKind.Source.contains(codeActionKind) && !properties[codeActionKind.value]) {
                 properties[codeActionKind.value] = createCodeActionsAutoSave(( localize(
-                    4902,
+                    5036,
                     "Controls whether '{0}' actions should be run on file save.",
                     codeActionKind.value
                 )));
                 notebookProperties[codeActionKind.value] = createNotebookCodeActionsAutoSave(( localize(
-                    4902,
+                    5036,
                     "Controls whether '{0}' actions should be run on file save.",
                     codeActionKind.value
                 )));

package/vscode/src/vs/workbench/contrib/codeEditor/browser/dictation/editorDictation.css

@@ -0,0 +1,27 @@
+.monaco-editor .editor-dictation-widget {
+	background-color: var(--vscode-editor-background);
+	padding: 2px;
+	border-radius: 8px;
+	display: flex;
+	align-items: center;
+	box-shadow: 0 4px 8px var(--vscode-widget-shadow);
+	z-index: 1000;
+	min-height: var(--vscode-editor-dictation-widget-height);
+	line-height: var(--vscode-editor-dictation-widget-height);
+	max-width: var(--vscode-editor-dictation-widget-width);
+}
+.monaco-editor .editor-dictation-widget.recording .codicon.codicon-mic-filled {
+	color: var(--vscode-activityBarBadge-background);
+	animation: editor-dictation-animation 1s infinite;
+}
+@keyframes editor-dictation-animation {
+	0% {
+		color: var(--vscode-editorCursor-background);
+	}
+	50% {
+		color: var(--vscode-activityBarBadge-background);
+	}
+	100% {
+		color: var(--vscode-editorCursor-background);
+	}
+}

package/vscode/src/vs/workbench/contrib/codeEditor/browser/dictation/editorDictation.d.ts

@@ -34,8 +34,6 @@ export declare class DictationWidget extends Disposable implements IContentWidge
 export declare class EditorDictation extends Disposable implements IEditorContribution {
     private readonly editor;
     private readonly speechService;
-    private readonly contextKeyService;
-    private readonly keybindingService;
     static readonly ID = "editorDictation";
     static get(editor: ICodeEditor): EditorDictation | null;
     private readonly widget;

package/vscode/src/vs/workbench/contrib/codeEditor/browser/dictation/editorDictation.js

@@ -1,6 +1,6 @@
 
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import './editorDictation.css.js';
+import './editorDictation.css';
 import { localize2, localize } from '../../../../../nls.js';
 import { CancellationTokenSource } from '../../../../../base/common/cancellation.js';
 import { Disposable, MutableDisposable, DisposableStore, toDisposable } from '../../../../../base/common/lifecycle.js';
@@ -29,12 +29,12 @@ import { isWindows } from '../../../../../base/common/platform.js';
 
 var EditorDictation_1;
 const EDITOR_DICTATION_IN_PROGRESS = ( new RawContextKey('editorDictation.inProgress', false));
-const VOICE_CATEGORY = ( localize2(4905, "Voice"));
+const VOICE_CATEGORY = ( localize2(5039, "Voice"));
 class EditorDictationStartAction extends EditorAction2 {
     constructor() {
         super({
             id: 'workbench.action.editorDictation.start',
-            title: ( localize2(4906, "Start Dictation in Editor")),
+            title: ( localize2(5040, "Start Dictation in Editor")),
             category: VOICE_CATEGORY,
             precondition: ( ContextKeyExpr.and(HasSpeechProvider, ( SpeechToTextInProgress.toNegated()), (
             EditorContextKeys.readOnly.toNegated()))),
@@ -71,7 +71,7 @@ class EditorDictationStopAction extends EditorAction2 {
     constructor() {
         super({
             id: EditorDictationStopAction.ID,
-            title: ( localize2(4907, "Stop Dictation in Editor")),
+            title: ( localize2(5041, "Stop Dictation in Editor")),
             category: VOICE_CATEGORY,
             precondition: EDITOR_DICTATION_IN_PROGRESS,
             f1: true,
@@ -96,7 +96,7 @@ class DictationWidget extends Disposable {
         const stopActionKeybinding = keybindingService.lookupKeybinding(EditorDictationStopAction.ID)?.getLabel();
         actionBar.push(toAction({
             id: EditorDictationStopAction.ID,
-            label: stopActionKeybinding ? ( localize(4908, "Stop Dictation ({0})", stopActionKeybinding)) : ( localize(4909, "Stop Dictation")),
+            label: stopActionKeybinding ? ( localize(5042, "Stop Dictation ({0})", stopActionKeybinding)) : ( localize(5043, "Stop Dictation")),
             class: ThemeIcon.asClassName(Codicon.micFilled),
             run: () => EditorDictation.get(editor)?.stop()
         }), { icon: true, label: false, keybinding: stopActionKeybinding });
@@ -153,11 +153,9 @@ let EditorDictation = class EditorDictation extends Disposable {
         super();
         this.editor = editor;
         this.speechService = speechService;
-        this.contextKeyService = contextKeyService;
-        this.keybindingService = keybindingService;
-        this.widget = this._register(( new DictationWidget(this.editor, this.keybindingService)));
-        this.editorDictationInProgress = EDITOR_DICTATION_IN_PROGRESS.bindTo(this.contextKeyService);
         this.sessionDisposables = this._register(( new MutableDisposable()));
+        this.widget = this._register(( new DictationWidget(this.editor, keybindingService)));
+        this.editorDictationInProgress = EDITOR_DICTATION_IN_PROGRESS.bindTo(contextKeyService);
     }
     async start() {
         const disposables = ( new DisposableStore());

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

@@ -31,19 +31,19 @@ class DiffEditorAccessibilityHelp {
             return;
         }
         const switchSides = ( localize(
-            4910,
+            5044,
             "Run the command Diff Editor: Switch Side{0} to toggle between the original and modified editors.",
             '<keybinding:diffEditor.switchSide>'
         ));
         const diffEditorActiveAnnouncement = ( localize(
-            4911,
+            5045,
             "The setting, accessibility.verbosity.diffEditorActive, controls if a diff editor announcement is made when it becomes the active editor."
         ));
         const keys = ['accessibility.signals.diffLineDeleted', 'accessibility.signals.diffLineInserted', 'accessibility.signals.diffLineModified'];
         const content = [
-            ( localize(4912, "You are in a diff editor.")),
+            ( localize(5046, "You are in a diff editor.")),
             ( localize(
-            4913,
+            5047,
             "View the next{0} or previous{1} diff in diff review mode, which is optimized for screen readers.",
             '<keybinding:' + AccessibleDiffViewerNext.id + '>',
             '<keybinding:' + AccessibleDiffViewerPrev.id + '>'
@@ -51,7 +51,7 @@ class DiffEditorAccessibilityHelp {
             switchSides,
             diffEditorActiveAnnouncement,
             ( localize(
-            4914,
+            5048,
             "To control which accessibility signals should be played, the following settings can be configured: {0}.",
             keys.join(', ')
         )),

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

@@ -32,7 +32,7 @@ let DiffEditorHelperContribution = class DiffEditorHelperContribution extends Di
             const onlyWhiteSpaceChange = ( computationResult.map(r => r && !r.identical && r.changes2.length === 0));
             this._register(autorunWithStore((reader, store) => {
                 if (onlyWhiteSpaceChange.read(reader)) {
-                    const helperWidget = store.add(this._instantiationService.createInstance(FloatingEditorClickWidget, this._diffEditor.getModifiedEditor(), ( localize(4915, "Show Whitespace Differences")), null));
+                    const helperWidget = store.add(this._instantiationService.createInstance(FloatingEditorClickWidget, this._diffEditor.getModifiedEditor(), ( localize(5049, "Show Whitespace Differences")), null));
                     store.add(helperWidget.onClick(() => {
                         this._textResourceConfigurationService.updateValue(this._diffEditor.getModel().modified.uri, 'diffEditor.ignoreTrimWhitespace', false);
                     }));
@@ -43,11 +43,11 @@ let DiffEditorHelperContribution = class DiffEditorHelperContribution extends Di
                 const diffComputationResult = this._diffEditor.getDiffComputationResult();
                 if (diffComputationResult && diffComputationResult.quitEarly) {
                     this._notificationService.prompt(Severity$1.Warning, ( localize(
-                        4916,
+                        5050,
                         "The diff algorithm was stopped early (after {0} ms.)",
                         this._diffEditor.maxComputationTime
                     )), [{
-                            label: ( localize(4917, "Remove Limit")),
+                            label: ( localize(5051, "Remove Limit")),
                             run: () => {
                                 this._textResourceConfigurationService.updateValue(this._diffEditor.getModel().modified.uri, 'diffEditor.maxComputationTime', 0);
                             }

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

@@ -26,16 +26,16 @@ let LargeFileOptimizationsWarner = class LargeFileOptimizationsWarner extends Di
         }
         if (model.isTooLargeForTokenization()) {
             const message = ( localize(
-                4937,
+                5071,
                 "{0}: tokenization, wrapping, folding, codelens, word highlighting and sticky scroll have been turned off for this large file in order to reduce memory usage and avoid freezing or crashing.",
                 basename(model.uri.path)
             ));
             this._notificationService.prompt(Severity$1.Info, message, [
                 {
-                    label: ( localize(4938, "Forcefully Enable Features")),
+                    label: ( localize(5072, "Forcefully Enable Features")),
                     run: () => {
                         this._configurationService.updateValue(`editor.largeFileOptimizations`, false).then(() => {
-                            this._notificationService.info(( localize(4939, "Please reopen file in order for this setting to take effect.")));
+                            this._notificationService.info(( localize(5073, "Please reopen file in order for this setting to take effect.")));
                         }, (err) => {
                             this._notificationService.error(err);
                         });

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

@@ -192,7 +192,7 @@ let FormatOnSaveParticipant = class FormatOnSaveParticipant {
         const nestedProgress = ( new Progress(provider => {
             progress.report({
                 message: ( localize(
-                    4954,
+                    5088,
                     "Running '{0}' Formatter ([configure]({1})).",
                     provider.displayName || provider.extensionId && provider.extensionId.value || '???',
                     'command:workbench.action.openSettings?%5B%22editor.formatOnSave%22%5D'
@@ -301,7 +301,7 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant extends Disp
             : ( ( Object.keys(setting))
                 .filter(x => setting[x] === 'never' || false)
                 .map(x => ( new HierarchicalKind(x))));
-        progress.report({ message: ( localize(4955, "Quick Fixes")) });
+        progress.report({ message: ( localize(5089, "Quick Fixes")) });
         const filteredSaveList = Array.isArray(setting) ? codeActionsOnSave : codeActionsOnSave.filter(x => setting[x.value] === 'always' || ((setting[x.value] === 'explicit' || setting[x.value] === true) && context.reason === SaveReason.EXPLICIT));
         await this.applyOnSaveActions(textEditorModel, filteredSaveList, excludedActions, progress, token);
     }
@@ -319,7 +319,7 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant extends Disp
             _report() {
                 progress.report({
                     message: ( localize(
-                        4956,
+                        5090,
                         "Getting code actions from {0} ([configure]({1})).",
                         ( [...this._names].map(name => `'${name}'`)).join(', '),
                         'command:workbench.action.openSettings?%5B%22editor.codeActionsOnSave%22%5D'
@@ -341,7 +341,7 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant extends Disp
             }
             try {
                 for (const action of actionsToRun.validActions) {
-                    progress.report({ message: ( localize(4957, "Applying code action '{0}'.", action.action.title)) });
+                    progress.report({ message: ( localize(5091, "Applying code action '{0}'.", action.action.title)) });
                     await this.instantiationService.invokeFunction(applyCodeAction, action, ApplyCodeActionReason.OnSave, {}, token);
                     if (token.isCancellationRequested) {
                         return;

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

@@ -11,8 +11,8 @@ class ToggleMinimapAction extends Action2 {
         super({
             id: ToggleMinimapAction.ID,
             title: {
-                ...( localize2(4958, "Toggle Minimap")),
-                mnemonicTitle: ( localize(4959, "&&Minimap")),
+                ...( localize2(5092, "Toggle Minimap")),
+                mnemonicTitle: ( localize(5093, "&&Minimap")),
             },
             category: Categories.View,
             f1: true,

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

@@ -17,7 +17,7 @@ class ToggleMultiCursorModifierAction extends Action2 {
     constructor() {
         super({
             id: ToggleMultiCursorModifierAction.ID,
-            title: ( localize2(4960, 'Toggle Multi-Cursor Modifier')),
+            title: ( localize2(5094, 'Toggle Multi-Cursor Modifier')),
             f1: true
         });
     }
@@ -57,7 +57,7 @@ MenuRegistry.appendMenuItem(MenuId.MenubarSelectionMenu, {
     group: '4_config',
     command: {
         id: ToggleMultiCursorModifierAction.ID,
-        title: ( localize(4961, "Switch to Alt+Click for Multi-Cursor"))
+        title: ( localize(5095, "Switch to Alt+Click for Multi-Cursor"))
     },
     when: ( multiCursorModifier.isEqualTo('ctrlCmd')),
     order: 1
@@ -67,8 +67,8 @@ MenuRegistry.appendMenuItem(MenuId.MenubarSelectionMenu, {
     command: {
         id: ToggleMultiCursorModifierAction.ID,
         title: (isMacintosh
-            ? ( localize(4962, "Switch to Cmd+Click for Multi-Cursor"))
-            : ( localize(4963, "Switch to Ctrl+Click for Multi-Cursor")))
+            ? ( localize(5096, "Switch to Cmd+Click for Multi-Cursor"))
+            : ( localize(5097, "Switch to Ctrl+Click for Multi-Cursor")))
     },
     when: ( multiCursorModifier.isEqualTo('altKey')),
     order: 1

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

@@ -11,8 +11,8 @@ class ToggleRenderControlCharacterAction extends Action2 {
         super({
             id: ToggleRenderControlCharacterAction.ID,
             title: {
-                ...( localize2(4964, "Toggle Control Characters")),
-                mnemonicTitle: ( localize(4965, "Render &&Control Characters")),
+                ...( localize2(5098, "Toggle Control Characters")),
+                mnemonicTitle: ( localize(5099, "Render &&Control Characters")),
             },
             category: Categories.View,
             f1: true,

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

@@ -11,8 +11,8 @@ class ToggleRenderWhitespaceAction extends Action2 {
         super({
             id: ToggleRenderWhitespaceAction.ID,
             title: {
-                ...( localize2(4966, "Toggle Render Whitespace")),
-                mnemonicTitle: ( localize(4967, "&&Render Whitespace")),
+                ...( localize2(5100, "Toggle Render Whitespace")),
+                mnemonicTitle: ( localize(5101, "&&Render Whitespace")),
             },
             category: Categories.View,
             f1: true,

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

@@ -24,7 +24,7 @@ const transientWordWrapState = 'transientWordWrapState';
 const isWordWrapMinifiedKey = 'isWordWrapMinified';
 const isDominatedByLongLinesKey = 'isDominatedByLongLines';
 const CAN_TOGGLE_WORD_WRAP = ( new RawContextKey('canToggleWordWrap', false, true));
-const EDITOR_WORD_WRAP = ( new RawContextKey('editorWordWrap', false, ( localize(4968, 'Whether the editor is currently using word wrapping.'))));
+const EDITOR_WORD_WRAP = ( new RawContextKey('editorWordWrap', false, ( localize(5102, 'Whether the editor is currently using word wrapping.'))));
 function writeTransientState(model, state, codeEditorService) {
     codeEditorService.setTransientModelProperty(model, transientWordWrapState, state);
 }
@@ -36,7 +36,7 @@ class ToggleWordWrapAction extends EditorAction {
     constructor() {
         super({
             id: TOGGLE_WORD_WRAP_ID,
-            label: ( localize2(4969, "View: Toggle Word Wrap")),
+            label: ( localize2(5103, "View: Toggle Word Wrap")),
             precondition: undefined,
             kbOpts: {
                 kbExpr: null,
@@ -242,7 +242,7 @@ registerEditorAction(ToggleWordWrapAction);
 MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
     command: {
         id: TOGGLE_WORD_WRAP_ID,
-        title: ( localize(4970, "Disable wrapping for this file")),
+        title: ( localize(5104, "Disable wrapping for this file")),
         icon: Codicon.wordWrap
     },
     group: 'navigation',
@@ -252,7 +252,7 @@ MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
 MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
     command: {
         id: TOGGLE_WORD_WRAP_ID,
-        title: ( localize(4971, "Enable wrapping for this file")),
+        title: ( localize(5105, "Enable wrapping for this file")),
         icon: Codicon.wordWrap
     },
     group: 'navigation',
@@ -262,7 +262,7 @@ MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
 MenuRegistry.appendMenuItem(MenuId.MenubarViewMenu, {
     command: {
         id: TOGGLE_WORD_WRAP_ID,
-        title: ( localize(4972, "&&Word Wrap")),
+        title: ( localize(5106, "&&Word Wrap")),
         toggled: EDITOR_WORD_WRAP,
         precondition: CAN_TOGGLE_WORD_WRAP
     },

package/vscode/src/vs/workbench/contrib/comments/browser/commentService.service.d.ts

@@ -27,6 +27,7 @@ export interface ICommentService {
     readonly onDidSetDataProvider: Event<void>;
     readonly onDidDeleteDataProvider: Event<string | undefined>;
     readonly onDidChangeCommentingEnabled: Event<boolean>;
+    readonly onResourceHasCommentingRanges: Event<void>;
     readonly isCommentingEnabled: boolean;
     readonly commentsModel: ICommentsModel;
     readonly lastActiveCommentcontroller: ICommentController | undefined;