@codingame/monaco-vscode-api 13.1.7 → 14.0.0

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

@@ -0,0 +1,34 @@
+import { CancellationToken } from "../../../../../base/common/cancellation.js";
+import { UriComponents } from "../../../../../base/common/uri.js";
+import { IWorkspaceContextService } from "../../../../../platform/workspace/common/workspace.service.js";
+import { ITextFileService } from "../../../../services/textfile/common/textfiles.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 { CountTokensCallback, IToolData, IToolImpl, IToolInvocation, IToolResult } from "../languageModelToolsService.js";
+import { IToolInputProcessor } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/tools/tools";
+export declare const EditToolData: IToolData;
+export declare class EditTool implements IToolImpl {
+    private readonly chatService;
+    private readonly chatEditingService;
+    private readonly codeMapperService;
+    private readonly workspaceContextService;
+    private readonly ignoredFilesService;
+    private readonly textFileService;
+    constructor(chatService: IChatService, chatEditingService: IChatEditingService, codeMapperService: ICodeMapperService, workspaceContextService: IWorkspaceContextService, ignoredFilesService: ILanguageModelIgnoredFilesService, textFileService: ITextFileService);
+    invoke(invocation: IToolInvocation, countTokens: CountTokensCallback, token: CancellationToken): Promise<IToolResult>;
+}
+export interface EditToolParams {
+    file: UriComponents;
+    explanation: string;
+    code: string;
+}
+export interface EditToolRawParams {
+    filePath: string;
+    explanation: string;
+    code: string;
+}
+export declare class EditToolInputProcessor implements IToolInputProcessor {
+    processInput(input: EditToolRawParams): EditToolParams;
+}

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

@@ -0,0 +1,168 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { MarkdownString } from '../../../../../base/common/htmlContent.js';
+import '../../../../../base/common/arrays.js';
+import '../../../../../base/common/event.js';
+import '../../../../../base/common/lifecycle.js';
+import { autorun } from '../../../../../base/common/observableInternal/autorun.js';
+import '../../../../../base/common/observableInternal/derived.js';
+import '../../../../../base/common/cancellation.js';
+import '../../../../../base/common/observableInternal/utils.js';
+import { URI } from '../../../../../base/common/uri.js';
+import { localize } from '../../../../../nls.js';
+import { IWorkspaceContextService } from '../../../../../platform/workspace/common/workspace.service.js';
+import { SaveReason } from '../../../../common/editor.js';
+import { ITextFileService } from '../../../../services/textfile/common/textfiles.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';
+
+const codeInstructions = `
+The user is very smart and can understand how to apply your edits to their files, you just need to provide minimal hints.
+Avoid repeating existing code, instead use comments to represent regions of unchanged code. The user prefers that you are as concise as possible. For example:
+// ...existing code...
+{ changed code }
+// ...existing code...
+{ changed code }
+// ...existing code...
+
+Here is an example of how you should use format an edit to an existing Person class:
+class Person {
+	// ...existing code...
+	age: number;
+	// ...existing code...
+	getAge() {
+		return this.age;
+	}
+}
+`;
+const EditToolData = {
+    id: 'vscode_editFile',
+    tags: ['vscode_editing'],
+    displayName: ( localize(4772, "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}`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            explanation: {
+                type: 'string',
+                description: 'A short explanation of the edit being made. Can be the same as the explanation you showed to the user.',
+            },
+            filePath: {
+                type: 'string',
+                description: 'An absolute path to the file to edit',
+            },
+            code: {
+                type: 'string',
+                description: 'The code change to apply to the file. ' + codeInstructions
+            }
+        },
+        required: ['explanation', 'filePath', 'code']
+    }
+};
+let EditTool = class EditTool {
+    constructor(chatService, chatEditingService, codeMapperService, workspaceContextService, ignoredFilesService, textFileService) {
+        this.chatService = chatService;
+        this.chatEditingService = chatEditingService;
+        this.codeMapperService = codeMapperService;
+        this.workspaceContextService = workspaceContextService;
+        this.ignoredFilesService = ignoredFilesService;
+        this.textFileService = textFileService;
+    }
+    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`
+            ));
+        }
+        if (await this.ignoredFilesService.fileIsIgnored(uri, token)) {
+            throw ( new Error(
+                `File ${uri.fsPath} can't be edited because it is configured to be ignored by Copilot`
+            ));
+        }
+        const model = this.chatService.getSession(invocation.context?.sessionId);
+        const request = model.getRequests().at(-1);
+        model.acceptResponseProgress(request, {
+            kind: 'markdownContent',
+            content: ( new MarkdownString('\n````\n'))
+        });
+        model.acceptResponseProgress(request, {
+            kind: 'codeblockUri',
+            uri
+        });
+        model.acceptResponseProgress(request, {
+            kind: 'markdownContent',
+            content: ( new MarkdownString(parameters.code + '\n````\n'))
+        });
+        if (this.chatEditingService.currentEditingSession?.chatSessionId !== model.sessionId) {
+            throw ( new Error('This tool must be called from within an editing session'));
+        }
+        const result = await this.codeMapperService.mapCode({
+            codeBlocks: [{ code: parameters.code, resource: uri, markdownBeforeBlock: parameters.explanation }],
+            location: 'tool',
+            chatRequestId: invocation.chatRequestId
+        }, {
+            textEdit: (target, edits) => {
+                model.acceptResponseProgress(request, { kind: 'textEdit', uri: target, edits });
+            }
+        }, token);
+        model.acceptResponseProgress(request, { kind: 'textEdit', uri, edits: [], done: true });
+        if (result?.errorMessage) {
+            throw ( new Error(result.errorMessage));
+        }
+        let dispose;
+        await ( new Promise((resolve) => {
+            let wasFileBeingModified = false;
+            dispose = autorun((r) => {
+                const currentEditingSession = this.chatEditingService.currentEditingSessionObs.read(r);
+                const entries = currentEditingSession?.entries.read(r);
+                const currentFile = entries?.find((e) => ( e.modifiedURI.toString()) === ( uri.toString()));
+                if (currentFile) {
+                    if (currentFile.isCurrentlyBeingModified.read(r)) {
+                        wasFileBeingModified = true;
+                    }
+                    else if (wasFileBeingModified) {
+                        resolve(true);
+                    }
+                }
+            });
+        })).finally(() => {
+            dispose.dispose();
+        });
+        await this.textFileService.save(uri, {
+            reason: SaveReason.AUTO,
+            skipSaveParticipants: true,
+        });
+        return {
+            content: [{ kind: 'text', value: 'The file was edited successfully' }]
+        };
+    }
+};
+EditTool = ( __decorate([
+    ( __param(0, IChatService)),
+    ( __param(1, IChatEditingService)),
+    ( __param(2, ICodeMapperService)),
+    ( __param(3, IWorkspaceContextService)),
+    ( __param(4, ILanguageModelIgnoredFilesService)),
+    ( __param(5, ITextFileService))
+], EditTool));
+class EditToolInputProcessor {
+    processInput(input) {
+        if (!input.filePath) {
+            return input;
+        }
+        return {
+            file: URI.file(input.filePath),
+            explanation: input.explanation,
+            code: input.code,
+        };
+    }
+}
+
+export { EditTool, EditToolData, EditToolInputProcessor };

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(
-            4660,
+            4791,
             'Triggers Code Actions on explicit saves and auto saves triggered by window or focus changes.'
         )),
-            ( localize(4661, 'Triggers Code Actions only when explicitly saved')),
-            ( localize(4662, 'Never triggers Code Actions on save')),
+            ( localize(4792, 'Triggers Code Actions only when explicitly saved')),
+            ( localize(4793, 'Never triggers Code Actions on save')),
             ( localize(
-            4663,
+            4794,
             'Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of "explicit".'
         )),
             ( localize(
-            4664,
+            4795,
             '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(4665, 'Triggers Code Actions only when explicitly saved.')),
-            ( localize(4666, 'Never triggers Code Actions on save.')),
+            ( localize(4796, 'Triggers Code Actions only when explicitly saved.')),
+            ( localize(4797, 'Never triggers Code Actions on save.')),
             ( localize(
-            4667,
+            4798,
             'Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of "explicit".'
         )),
             ( localize(
-            4668,
+            4799,
             'Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of "never".'
         ))
         ],
@@ -70,7 +70,7 @@ const codeActionsOnSaveSchema = {
         }
     ],
     markdownDescription: ( localize(
-        4669,
+        4800,
         '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(
-        4670,
+        4801,
         '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(
-                    4671,
+                    4802,
                     "Controls whether '{0}' actions should be run on file save.",
                     codeActionKind.value
                 )));
                 notebookProperties[codeActionKind.value] = createNotebookCodeActionsAutoSave(( localize(
-                    4671,
+                    4802,
                     "Controls whether '{0}' actions should be run on file save.",
                     codeActionKind.value
                 )));

package/vscode/src/vs/workbench/contrib/codeEditor/browser/dictation/editorDictation.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(4674, "Voice"));
+const VOICE_CATEGORY = ( localize2(4805, "Voice"));
 class EditorDictationStartAction extends EditorAction2 {
     constructor() {
         super({
             id: 'workbench.action.editorDictation.start',
-            title: ( localize2(4675, "Start Dictation in Editor")),
+            title: ( localize2(4806, "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(4676, "Stop Dictation in Editor")),
+            title: ( localize2(4807, "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(4677, "Stop Dictation ({0})", stopActionKeybinding)) : ( localize(4678, "Stop Dictation")),
+            label: stopActionKeybinding ? ( localize(4808, "Stop Dictation ({0})", stopActionKeybinding)) : ( localize(4809, "Stop Dictation")),
             class: ThemeIcon.asClassName(Codicon.micFilled),
             run: () => EditorDictation.get(editor)?.stop()
         }), { icon: true, label: false, keybinding: stopActionKeybinding });

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

@@ -1,7 +1,7 @@
 import { AccessibleViewType, AccessibleContentProvider } from "../../../../platform/accessibility/browser/accessibleView.js";
-import { IAccessibleViewImplentation } from "../../../../platform/accessibility/browser/accessibleViewRegistry.js";
+import { IAccessibleViewImplementation } from "../../../../platform/accessibility/browser/accessibleViewRegistry.js";
 import { ServicesAccessor } from "../../../../platform/instantiation/common/instantiation.js";
-export declare class DiffEditorAccessibilityHelp implements IAccessibleViewImplentation {
+export declare class DiffEditorAccessibilityHelp implements IAccessibleViewImplementation {
     readonly priority = 105;
     readonly name = "diff-editor";
     readonly when: import("../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression;

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

@@ -31,19 +31,19 @@ class DiffEditorAccessibilityHelp {
             return;
         }
         const switchSides = ( localize(
-            4679,
+            4810,
             "Run the command Diff Editor: Switch Side{0} to toggle between the original and modified editors.",
             '<keybinding:diffEditor.switchSide>'
         ));
         const diffEditorActiveAnnouncement = ( localize(
-            4680,
+            4811,
             "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(4681, "You are in a diff editor.")),
+            ( localize(4812, "You are in a diff editor.")),
             ( localize(
-            4682,
+            4813,
             "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(
-            4683,
+            4814,
             "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

@@ -35,7 +35,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(4684, "Show Whitespace Differences")), null));
+                    const helperWidget = store.add(this._instantiationService.createInstance(FloatingEditorClickWidget, this._diffEditor.getModifiedEditor(), ( localize(4815, "Show Whitespace Differences")), null));
                     store.add(helperWidget.onClick(() => {
                         this._textResourceConfigurationService.updateValue(this._diffEditor.getModel().modified.uri, 'diffEditor.ignoreTrimWhitespace', false);
                     }));
@@ -46,11 +46,11 @@ let DiffEditorHelperContribution = class DiffEditorHelperContribution extends Di
                 const diffComputationResult = this._diffEditor.getDiffComputationResult();
                 if (diffComputationResult && diffComputationResult.quitEarly) {
                     this._notificationService.prompt(Severity$1.Warning, ( localize(
-                        4685,
+                        4816,
                         "The diff algorithm was stopped early (after {0} ms.)",
                         this._diffEditor.maxComputationTime
                     )), [{
-                            label: ( localize(4686, "Remove Limit")),
+                            label: ( localize(4817, "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(
-                4706,
+                4837,
                 "{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(4707, "Forcefully Enable Features")),
+                    label: ( localize(4838, "Forcefully Enable Features")),
                     run: () => {
                         this._configurationService.updateValue(`editor.largeFileOptimizations`, false).then(() => {
-                            this._notificationService.info(( localize(4708, "Please reopen file in order for this setting to take effect.")));
+                            this._notificationService.info(( localize(4839, "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.d.ts

@@ -3,7 +3,7 @@ import { ICodeEditorService } from "../../../../editor/browser/services/codeEdit
 import { IConfigurationService } from "../../../../platform/configuration/common/configuration.service.js";
 import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
 import { IWorkbenchContribution } from "../../../common/contributions.js";
-import { ITextFileEditorModel, ITextFileSaveParticipant, ITextFileSaveParticipantContext } from "../../../services/textfile/common/textfiles.js";
+import { ITextFileEditorModel, ITextFileSaveParticipant, ITextFileSaveParticipantContext } from "@codingame/monaco-vscode-a17f5129-e16c-5dac-857e-dcd91bfeffa2-common/vscode/vs/workbench/services/textfile/common/textfiles";
 import { ITextFileService } from "../../../services/textfile/common/textfiles.service.js";
 export declare class TrimWhitespaceParticipant implements ITextFileSaveParticipant {
     private readonly configurationService;

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

@@ -194,7 +194,7 @@ let FormatOnSaveParticipant = class FormatOnSaveParticipant {
         const nestedProgress = ( new Progress(provider => {
             progress.report({
                 message: ( localize(
-                    4723,
+                    4854,
                     "Running '{0}' Formatter ([configure]({1})).",
                     provider.displayName || provider.extensionId && provider.extensionId.value || '???',
                     'command:workbench.action.openSettings?%5B%22editor.formatOnSave%22%5D'
@@ -304,7 +304,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(4724, "Quick Fixes")) });
+        progress.report({ message: ( localize(4855, "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);
     }
@@ -322,7 +322,7 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant extends Disp
             _report() {
                 progress.report({
                     message: ( localize(
-                        4725,
+                        4856,
                         "Getting code actions from {0} ([configure]({1})).",
                         ( [...this._names].map(name => `'${name}'`)).join(', '),
                         'command:workbench.action.openSettings?%5B%22editor.codeActionsOnSave%22%5D'
@@ -349,7 +349,7 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant extends Disp
             }
             try {
                 for (const action of actionsToRun.validActions) {
-                    progress.report({ message: ( localize(4726, "Applying code action '{0}'.", action.action.title)) });
+                    progress.report({ message: ( localize(4857, "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(4727, "Toggle Minimap")),
-                mnemonicTitle: ( localize(4728, "&&Minimap")),
+                ...( localize2(4858, "Toggle Minimap")),
+                mnemonicTitle: ( localize(4859, "&&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(4729, 'Toggle Multi-Cursor Modifier')),
+            title: ( localize2(4860, 'Toggle Multi-Cursor Modifier')),
             f1: true
         });
     }
@@ -57,7 +57,7 @@ MenuRegistry.appendMenuItem(MenuId.MenubarSelectionMenu, {
     group: '4_config',
     command: {
         id: ToggleMultiCursorModifierAction.ID,
-        title: ( localize(4730, "Switch to Alt+Click for Multi-Cursor"))
+        title: ( localize(4861, "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(4731, "Switch to Cmd+Click for Multi-Cursor"))
-            : ( localize(4732, "Switch to Ctrl+Click for Multi-Cursor")))
+            ? ( localize(4862, "Switch to Cmd+Click for Multi-Cursor"))
+            : ( localize(4863, "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(4733, "Toggle Control Characters")),
-                mnemonicTitle: ( localize(4734, "Render &&Control Characters")),
+                ...( localize2(4864, "Toggle Control Characters")),
+                mnemonicTitle: ( localize(4865, "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(4735, "Toggle Render Whitespace")),
-                mnemonicTitle: ( localize(4736, "&&Render Whitespace")),
+                ...( localize2(4866, "Toggle Render Whitespace")),
+                mnemonicTitle: ( localize(4867, "&&Render Whitespace")),
             },
             category: Categories.View,
             f1: true,

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

@@ -8,12 +8,14 @@ import { KeyMod as KeyMod$1, KeyCode } from '../../../../base/common/keyCodes.js
 import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { EditorAction, registerEditorContribution, EditorContributionInstantiation, registerDiffEditorContribution, registerEditorAction } from '../../../../editor/browser/editorExtensions.js';
 import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
+import { findDiffEditorContainingCodeEditor } from '../../../../editor/browser/widget/diffEditor/commands.js';
 import { EditorOption } from '../../../../editor/common/config/editorOptions.js';
 import { EditorContextKeys } from '../../../../editor/common/editorContextKeys.js';
 import { localize, localize2 } from '../../../../nls.js';
 import { MenuRegistry, MenuId } from '../../../../platform/actions/common/actions.js';
 import { RawContextKey, ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
 import { registerWorkbenchContribution2, WorkbenchPhase } from '../../../common/contributions.js';
 import { IEditorService } from '../../../services/editor/common/editorService.service.js';
@@ -22,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(4737, 'Whether the editor is currently using word wrapping.'))));
+const EDITOR_WORD_WRAP = ( new RawContextKey('editorWordWrap', false, ( localize(4868, 'Whether the editor is currently using word wrapping.'))));
 function writeTransientState(model, state, codeEditorService) {
     codeEditorService.setTransientModelProperty(model, transientWordWrapState, state);
 }
@@ -34,7 +36,7 @@ class ToggleWordWrapAction extends EditorAction {
     constructor() {
         super({
             id: TOGGLE_WORD_WRAP_ID,
-            label: ( localize2(4738, "View: Toggle Word Wrap")),
+            label: ( localize2(4869, "View: Toggle Word Wrap")),
             precondition: undefined,
             kbOpts: {
                 kbExpr: null,
@@ -45,6 +47,7 @@ class ToggleWordWrapAction extends EditorAction {
     }
     run(accessor, editor) {
         const codeEditorService = accessor.get(ICodeEditorService);
+        const instaService = accessor.get(IInstantiationService);
         if (!canToggleWordWrap(codeEditorService, editor)) {
             return;
         }
@@ -60,7 +63,7 @@ class ToggleWordWrapAction extends EditorAction {
             newState = { wordWrapOverride };
         }
         writeTransientState(model, newState, codeEditorService);
-        const diffEditor = findDiffEditorContainingCodeEditor(editor, codeEditorService);
+        const diffEditor = instaService.invokeFunction(findDiffEditorContainingCodeEditor, editor);
         if (diffEditor) {
             const originalEditor = diffEditor.getOriginalEditor();
             const modifiedEditor = diffEditor.getModifiedEditor();
@@ -72,19 +75,6 @@ class ToggleWordWrapAction extends EditorAction {
         }
     }
 }
-function findDiffEditorContainingCodeEditor(editor, codeEditorService) {
-    if (!editor.getOption(EditorOption.inDiffEditor)) {
-        return null;
-    }
-    for (const diffEditor of codeEditorService.listDiffEditors()) {
-        const originalEditor = diffEditor.getOriginalEditor();
-        const modifiedEditor = diffEditor.getModifiedEditor();
-        if (originalEditor === editor || modifiedEditor === editor) {
-            return diffEditor;
-        }
-    }
-    return null;
-}
 let ToggleWordWrapController = class ToggleWordWrapController extends Disposable {
     static { this.ID = 'editor.contrib.toggleWordWrapController'; }
     constructor(_editor, _contextKeyService, _codeEditorService) {
@@ -252,7 +242,7 @@ registerEditorAction(ToggleWordWrapAction);
 MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
     command: {
         id: TOGGLE_WORD_WRAP_ID,
-        title: ( localize(4739, "Disable wrapping for this file")),
+        title: ( localize(4870, "Disable wrapping for this file")),
         icon: Codicon.wordWrap
     },
     group: 'navigation',
@@ -262,7 +252,7 @@ MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
 MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
     command: {
         id: TOGGLE_WORD_WRAP_ID,
-        title: ( localize(4740, "Enable wrapping for this file")),
+        title: ( localize(4871, "Enable wrapping for this file")),
         icon: Codicon.wordWrap
     },
     group: 'navigation',
@@ -272,7 +262,7 @@ MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
 MenuRegistry.appendMenuItem(MenuId.MenubarViewMenu, {
     command: {
         id: TOGGLE_WORD_WRAP_ID,
-        title: ( localize(4741, "&&Word Wrap")),
+        title: ( localize(4872, "&&Word Wrap")),
         toggled: EDITOR_WORD_WRAP,
         precondition: CAN_TOGGLE_WORD_WRAP
     },

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

@@ -3,7 +3,7 @@ import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { URI } from "../../../../base/common/uri.js";
 import { Range, IRange } from "../../../../editor/common/core/range.js";
 import { CommentThread, CommentingRanges, CommentThreadChangedEvent, CommentingRangeResourceHint, Comment, CommentReaction, PendingCommentThread } from "../../../../editor/common/languages.js";
-import { ICellRange } from "@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/common/notebookRange";
+import { ICellRange } from "../../notebook/common/notebookRange.js";
 import { ICommentThreadChangedEvent } from "@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/vscode/vs/workbench/contrib/comments/common/commentModel";
 import { CommentMenus } from "@codingame/monaco-vscode-comments-service-override/vscode/vs/workbench/contrib/comments/browser/commentMenus";
 import { IResourceCommentThreadEvent, IWorkspaceCommentThreadsEvent, INotebookCommentThreadChangedEvent, ICommentController, ICommentInfo, INotebookCommentInfo, IContinueOnCommentProvider } from "@codingame/monaco-vscode-comments-service-override/vscode/vs/workbench/contrib/comments/browser/commentService";

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

@@ -1,7 +1,7 @@
 import { ServicesAccessor } from "../../../../platform/instantiation/common/instantiation.js";
 import { AccessibilityVerbositySettingId } from "../../accessibility/browser/accessibilityConfiguration.js";
 import { IAccessibleViewContentProvider, AccessibleViewProviderId, IAccessibleViewOptions, AccessibleViewType } from "../../../../platform/accessibility/browser/accessibleView.js";
-import { IAccessibleViewImplentation } from "../../../../platform/accessibility/browser/accessibleViewRegistry.js";
+import { IAccessibleViewImplementation } from "../../../../platform/accessibility/browser/accessibleViewRegistry.js";
 import { Disposable } from "../../../../base/common/lifecycle.js";
 export declare namespace CommentAccessibilityHelpNLS {
     const intro: string;
@@ -25,7 +25,7 @@ export declare class CommentsAccessibilityHelpProvider extends Disposable implem
     provideContent(): string;
     onClose(): void;
 }
-export declare class CommentsAccessibilityHelp implements IAccessibleViewImplentation {
+export declare class CommentsAccessibilityHelp implements IAccessibleViewImplementation {
     readonly priority = 110;
     readonly name = "comments";
     readonly type = AccessibleViewType.Help;