@codingame/monaco-vscode-api 8.0.1 → 8.0.3

package/vscode/src/vs/editor/editor.api.d.ts

@@ -3742,6 +3742,11 @@ export namespace editor {
          * Defaults to false.
          */
         peekWidgetDefaultFocus?: 'tree' | 'editor';
+        /**
+         * Sets a placeholder for the editor.
+         * If set, the placeholder is shown if the editor is empty.
+        */
+        placeholder?: string | undefined;
         /**
          * Controls whether the definition link opens element in the peek widget.
          * Defaults to false.
@@ -3823,6 +3828,11 @@ export namespace editor {
          * and the diff editor has a width less than `renderSideBySideInlineBreakpoint`, the inline view is used.
          */
         useInlineViewWhenSpaceIsLimited?: boolean;
+        /**
+         * If set, the diff editor is optimized for small views.
+         * Defaults to `false`.
+        */
+        compactMode?: boolean;
         /**
          * Timeout in milliseconds after which diff computation is cancelled.
          * Defaults to 5000.
@@ -3885,6 +3895,10 @@ export namespace editor {
              */
             showMoves?: boolean;
             showEmptyDecorations?: boolean;
+            /**
+             * Only applies when `renderSideBySide` is set to false.
+            */
+            useTrueInlineView?: boolean;
         };
         /**
          * Is the diff editor inside another editor
@@ -4050,11 +4064,13 @@ export namespace editor {
         multipleDeclarations?: GoToLocationValues;
         multipleImplementations?: GoToLocationValues;
         multipleReferences?: GoToLocationValues;
+        multipleTests?: GoToLocationValues;
         alternativeDefinitionCommand?: string;
         alternativeTypeDefinitionCommand?: string;
         alternativeDeclarationCommand?: string;
         alternativeImplementationCommand?: string;
         alternativeReferenceCommand?: string;
+        alternativeTestsCommand?: string;
     }
 
     /**
@@ -4573,7 +4589,6 @@ export namespace editor {
          * Does not clear active inline suggestions when the editor loses focus.
          */
         keepOnBlur?: boolean;
-        backgroundColoring?: boolean;
     }
 
     export interface IBracketPairColorizationOptions {
@@ -4936,68 +4951,69 @@ export namespace editor {
         pasteAs = 85,
         parameterHints = 86,
         peekWidgetDefaultFocus = 87,
-        definitionLinkOpensInPeek = 88,
-        quickSuggestions = 89,
-        quickSuggestionsDelay = 90,
-        readOnly = 91,
-        readOnlyMessage = 92,
-        renameOnType = 93,
-        renderControlCharacters = 94,
-        renderFinalNewline = 95,
-        renderLineHighlight = 96,
-        renderLineHighlightOnlyWhenFocus = 97,
-        renderValidationDecorations = 98,
-        renderWhitespace = 99,
-        revealHorizontalRightPadding = 100,
-        roundedSelection = 101,
-        rulers = 102,
-        scrollbar = 103,
-        scrollBeyondLastColumn = 104,
-        scrollBeyondLastLine = 105,
-        scrollPredominantAxis = 106,
-        selectionClipboard = 107,
-        selectionHighlight = 108,
-        selectOnLineNumbers = 109,
-        showFoldingControls = 110,
-        showUnused = 111,
-        snippetSuggestions = 112,
-        smartSelect = 113,
-        smoothScrolling = 114,
-        stickyScroll = 115,
-        stickyTabStops = 116,
-        stopRenderingLineAfter = 117,
-        suggest = 118,
-        suggestFontSize = 119,
-        suggestLineHeight = 120,
-        suggestOnTriggerCharacters = 121,
-        suggestSelection = 122,
-        tabCompletion = 123,
-        tabIndex = 124,
-        unicodeHighlighting = 125,
-        unusualLineTerminators = 126,
-        useShadowDOM = 127,
-        useTabStops = 128,
-        wordBreak = 129,
-        wordSegmenterLocales = 130,
-        wordSeparators = 131,
-        wordWrap = 132,
-        wordWrapBreakAfterCharacters = 133,
-        wordWrapBreakBeforeCharacters = 134,
-        wordWrapColumn = 135,
-        wordWrapOverride1 = 136,
-        wordWrapOverride2 = 137,
-        wrappingIndent = 138,
-        wrappingStrategy = 139,
-        showDeprecated = 140,
-        inlayHints = 141,
-        editorClassName = 142,
-        pixelRatio = 143,
-        tabFocusMode = 144,
-        layoutInfo = 145,
-        wrappingInfo = 146,
-        defaultColorDecorators = 147,
-        colorDecoratorsActivatedOn = 148,
-        inlineCompletionsAccessibilityVerbose = 149
+        placeholder = 88,
+        definitionLinkOpensInPeek = 89,
+        quickSuggestions = 90,
+        quickSuggestionsDelay = 91,
+        readOnly = 92,
+        readOnlyMessage = 93,
+        renameOnType = 94,
+        renderControlCharacters = 95,
+        renderFinalNewline = 96,
+        renderLineHighlight = 97,
+        renderLineHighlightOnlyWhenFocus = 98,
+        renderValidationDecorations = 99,
+        renderWhitespace = 100,
+        revealHorizontalRightPadding = 101,
+        roundedSelection = 102,
+        rulers = 103,
+        scrollbar = 104,
+        scrollBeyondLastColumn = 105,
+        scrollBeyondLastLine = 106,
+        scrollPredominantAxis = 107,
+        selectionClipboard = 108,
+        selectionHighlight = 109,
+        selectOnLineNumbers = 110,
+        showFoldingControls = 111,
+        showUnused = 112,
+        snippetSuggestions = 113,
+        smartSelect = 114,
+        smoothScrolling = 115,
+        stickyScroll = 116,
+        stickyTabStops = 117,
+        stopRenderingLineAfter = 118,
+        suggest = 119,
+        suggestFontSize = 120,
+        suggestLineHeight = 121,
+        suggestOnTriggerCharacters = 122,
+        suggestSelection = 123,
+        tabCompletion = 124,
+        tabIndex = 125,
+        unicodeHighlighting = 126,
+        unusualLineTerminators = 127,
+        useShadowDOM = 128,
+        useTabStops = 129,
+        wordBreak = 130,
+        wordSegmenterLocales = 131,
+        wordSeparators = 132,
+        wordWrap = 133,
+        wordWrapBreakAfterCharacters = 134,
+        wordWrapBreakBeforeCharacters = 135,
+        wordWrapColumn = 136,
+        wordWrapOverride1 = 137,
+        wordWrapOverride2 = 138,
+        wrappingIndent = 139,
+        wrappingStrategy = 140,
+        showDeprecated = 141,
+        inlayHints = 142,
+        editorClassName = 143,
+        pixelRatio = 144,
+        tabFocusMode = 145,
+        layoutInfo = 146,
+        wrappingInfo = 147,
+        defaultColorDecorators = 148,
+        colorDecoratorsActivatedOn = 149,
+        inlineCompletionsAccessibilityVerbose = 150
     }
 
     export const EditorOptions: {
@@ -5010,8 +5026,8 @@ export namespace editor {
         screenReaderAnnounceInlineSuggestion: IEditorOption<EditorOption.screenReaderAnnounceInlineSuggestion, boolean>;
         autoClosingBrackets: IEditorOption<EditorOption.autoClosingBrackets, 'always' | 'languageDefined' | 'beforeWhitespace' | 'never'>;
         autoClosingComments: IEditorOption<EditorOption.autoClosingComments, 'always' | 'languageDefined' | 'beforeWhitespace' | 'never'>;
-        autoClosingDelete: IEditorOption<EditorOption.autoClosingDelete, 'always' | 'never' | 'auto'>;
-        autoClosingOvertype: IEditorOption<EditorOption.autoClosingOvertype, 'always' | 'never' | 'auto'>;
+        autoClosingDelete: IEditorOption<EditorOption.autoClosingDelete, 'auto' | 'always' | 'never'>;
+        autoClosingOvertype: IEditorOption<EditorOption.autoClosingOvertype, 'auto' | 'always' | 'never'>;
         autoClosingQuotes: IEditorOption<EditorOption.autoClosingQuotes, 'always' | 'languageDefined' | 'beforeWhitespace' | 'never'>;
         autoIndent: IEditorOption<EditorOption.autoIndent, EditorAutoIndentStrategy>;
         automaticLayout: IEditorOption<EditorOption.automaticLayout, boolean>;
@@ -5023,7 +5039,7 @@ export namespace editor {
         codeLensFontFamily: IEditorOption<EditorOption.codeLensFontFamily, string>;
         codeLensFontSize: IEditorOption<EditorOption.codeLensFontSize, number>;
         colorDecorators: IEditorOption<EditorOption.colorDecorators, boolean>;
-        colorDecoratorActivatedOn: IEditorOption<EditorOption.colorDecoratorsActivatedOn, 'clickAndHover' | 'click' | 'hover'>;
+        colorDecoratorActivatedOn: IEditorOption<EditorOption.colorDecoratorsActivatedOn, 'hover' | 'clickAndHover' | 'click'>;
         colorDecoratorsLimit: IEditorOption<EditorOption.colorDecoratorsLimit, number>;
         columnSelection: IEditorOption<EditorOption.columnSelection, boolean>;
         comments: IEditorOption<EditorOption.comments, Readonly<Required<IEditorCommentsOptions>>>;
@@ -5090,6 +5106,7 @@ export namespace editor {
         pasteAs: IEditorOption<EditorOption.pasteAs, Readonly<Required<IPasteAsOptions>>>;
         parameterHints: IEditorOption<EditorOption.parameterHints, Readonly<Required<IEditorParameterHintOptions>>>;
         peekWidgetDefaultFocus: IEditorOption<EditorOption.peekWidgetDefaultFocus, 'tree' | 'editor'>;
+        placeholder: IEditorOption<EditorOption.placeholder, string>;
         definitionLinkOpensInPeek: IEditorOption<EditorOption.definitionLinkOpensInPeek, boolean>;
         quickSuggestions: IEditorOption<EditorOption.quickSuggestions, InternalQuickSuggestionsOptions>;
         quickSuggestionsDelay: IEditorOption<EditorOption.quickSuggestionsDelay, number>;
@@ -5131,13 +5148,13 @@ export namespace editor {
         tabCompletion: IEditorOption<EditorOption.tabCompletion, 'on' | 'off' | 'onlySnippets'>;
         tabIndex: IEditorOption<EditorOption.tabIndex, number>;
         unicodeHighlight: IEditorOption<EditorOption.unicodeHighlighting, any>;
-        unusualLineTerminators: IEditorOption<EditorOption.unusualLineTerminators, 'auto' | 'off' | 'prompt'>;
+        unusualLineTerminators: IEditorOption<EditorOption.unusualLineTerminators, 'off' | 'auto' | 'prompt'>;
         useShadowDOM: IEditorOption<EditorOption.useShadowDOM, boolean>;
         useTabStops: IEditorOption<EditorOption.useTabStops, boolean>;
         wordBreak: IEditorOption<EditorOption.wordBreak, 'normal' | 'keepAll'>;
         wordSegmenterLocales: IEditorOption<EditorOption.wordSegmenterLocales, {}>;
         wordSeparators: IEditorOption<EditorOption.wordSeparators, string>;
-        wordWrap: IEditorOption<EditorOption.wordWrap, 'on' | 'off' | 'wordWrapColumn' | 'bounded'>;
+        wordWrap: IEditorOption<EditorOption.wordWrap, 'wordWrapColumn' | 'on' | 'off' | 'bounded'>;
         wordWrapBreakAfterCharacters: IEditorOption<EditorOption.wordWrapBreakAfterCharacters, string>;
         wordWrapBreakBeforeCharacters: IEditorOption<EditorOption.wordWrapBreakBeforeCharacters, string>;
         wordWrapColumn: IEditorOption<EditorOption.wordWrapColumn, number>;
@@ -7946,6 +7963,11 @@ export namespace languages {
         arguments?: any[];
     }
 
+    export interface CommentThreadRevealOptions {
+        preserveFocus: boolean;
+        focusReply: boolean;
+    }
+
     export interface CommentAuthorInformation {
         name: string;
         iconPath?: UriComponents;
@@ -8060,7 +8082,7 @@ export namespace languages {
          *
          * @param document The document to provide mapped edits for.
          * @param codeBlocks Code blocks that come from an LLM's reply.
-         * 						"Insert at cursor" in the panel chat only sends one edit that the user clicks on, but inline chat can send multiple blocks and let the lang server decide what to do with them.
+         * 						"Apply in Editor" in the panel chat only sends one edit that the user clicks on, but inline chat can send multiple blocks and let the lang server decide what to do with them.
          * @param context The context for providing mapped edits.
          * @param token A cancellation token.
          * @returns A provider result of text edits.

package/vscode/src/vs/platform/accessibilitySignal/browser/accessibilitySignalService.js

@@ -266,163 +266,163 @@ class AccessibilitySignal {
         return [...this._signals];
     }
     static { this.errorAtPosition = AccessibilitySignal.register({
-        name: ( localize(2242, 'Error at Position')),
+        name: ( localize(2271, 'Error at Position')),
         sound: Sound.error,
-        announcementMessage: ( localize(2243, 'Error')),
+        announcementMessage: ( localize(2272, 'Error')),
         settingsKey: 'accessibility.signals.positionHasError',
         delaySettingsKey: 'accessibility.signalOptions.delays.errorAtPosition'
     }); }
     static { this.warningAtPosition = AccessibilitySignal.register({
-        name: ( localize(2244, 'Warning at Position')),
+        name: ( localize(2273, 'Warning at Position')),
         sound: Sound.warning,
-        announcementMessage: ( localize(2245, 'Warning')),
+        announcementMessage: ( localize(2274, 'Warning')),
         settingsKey: 'accessibility.signals.positionHasWarning',
         delaySettingsKey: 'accessibility.signalOptions.delays.warningAtPosition'
     }); }
     static { this.errorOnLine = AccessibilitySignal.register({
-        name: ( localize(2246, 'Error on Line')),
+        name: ( localize(2275, 'Error on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.lineHasError',
         legacyAnnouncementSettingsKey: 'accessibility.alert.error',
-        announcementMessage: ( localize(2247, 'Error on Line')),
+        announcementMessage: ( localize(2276, 'Error on Line')),
         settingsKey: 'accessibility.signals.lineHasError',
     }); }
     static { this.warningOnLine = AccessibilitySignal.register({
-        name: ( localize(2248, 'Warning on Line')),
+        name: ( localize(2277, 'Warning on Line')),
         sound: Sound.warning,
         legacySoundSettingsKey: 'audioCues.lineHasWarning',
         legacyAnnouncementSettingsKey: 'accessibility.alert.warning',
-        announcementMessage: ( localize(2249, 'Warning on Line')),
+        announcementMessage: ( localize(2278, 'Warning on Line')),
         settingsKey: 'accessibility.signals.lineHasWarning',
     }); }
     static { this.foldedArea = AccessibilitySignal.register({
-        name: ( localize(2250, 'Folded Area on Line')),
+        name: ( localize(2279, 'Folded Area on Line')),
         sound: Sound.foldedArea,
         legacySoundSettingsKey: 'audioCues.lineHasFoldedArea',
         legacyAnnouncementSettingsKey: 'accessibility.alert.foldedArea',
-        announcementMessage: ( localize(2251, 'Folded')),
+        announcementMessage: ( localize(2280, 'Folded')),
         settingsKey: 'accessibility.signals.lineHasFoldedArea',
     }); }
     static { this.break = AccessibilitySignal.register({
-        name: ( localize(2252, 'Breakpoint on Line')),
+        name: ( localize(2281, 'Breakpoint on Line')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.lineHasBreakpoint',
         legacyAnnouncementSettingsKey: 'accessibility.alert.breakpoint',
-        announcementMessage: ( localize(2253, 'Breakpoint')),
+        announcementMessage: ( localize(2282, 'Breakpoint')),
         settingsKey: 'accessibility.signals.lineHasBreakpoint',
     }); }
     static { this.inlineSuggestion = AccessibilitySignal.register({
-        name: ( localize(2254, 'Inline Suggestion on Line')),
+        name: ( localize(2283, 'Inline Suggestion on Line')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.lineHasInlineSuggestion',
         settingsKey: 'accessibility.signals.lineHasInlineSuggestion',
     }); }
     static { this.terminalQuickFix = AccessibilitySignal.register({
-        name: ( localize(2255, 'Terminal Quick Fix')),
+        name: ( localize(2284, 'Terminal Quick Fix')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.terminalQuickFix',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalQuickFix',
-        announcementMessage: ( localize(2256, 'Quick Fix')),
+        announcementMessage: ( localize(2285, 'Quick Fix')),
         settingsKey: 'accessibility.signals.terminalQuickFix',
     }); }
     static { this.onDebugBreak = AccessibilitySignal.register({
-        name: ( localize(2257, 'Debugger Stopped on Breakpoint')),
+        name: ( localize(2286, 'Debugger Stopped on Breakpoint')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.onDebugBreak',
         legacyAnnouncementSettingsKey: 'accessibility.alert.onDebugBreak',
-        announcementMessage: ( localize(2258, 'Breakpoint')),
+        announcementMessage: ( localize(2287, 'Breakpoint')),
         settingsKey: 'accessibility.signals.onDebugBreak',
     }); }
     static { this.noInlayHints = AccessibilitySignal.register({
-        name: ( localize(2259, 'No Inlay Hints on Line')),
+        name: ( localize(2288, 'No Inlay Hints on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.noInlayHints',
         legacyAnnouncementSettingsKey: 'accessibility.alert.noInlayHints',
-        announcementMessage: ( localize(2260, 'No Inlay Hints')),
+        announcementMessage: ( localize(2289, 'No Inlay Hints')),
         settingsKey: 'accessibility.signals.noInlayHints',
     }); }
     static { this.taskCompleted = AccessibilitySignal.register({
-        name: ( localize(2261, 'Task Completed')),
+        name: ( localize(2290, 'Task Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.taskCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskCompleted',
-        announcementMessage: ( localize(2262, 'Task Completed')),
+        announcementMessage: ( localize(2291, 'Task Completed')),
         settingsKey: 'accessibility.signals.taskCompleted',
     }); }
     static { this.taskFailed = AccessibilitySignal.register({
-        name: ( localize(2263, 'Task Failed')),
+        name: ( localize(2292, 'Task Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.taskFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskFailed',
-        announcementMessage: ( localize(2264, 'Task Failed')),
+        announcementMessage: ( localize(2293, 'Task Failed')),
         settingsKey: 'accessibility.signals.taskFailed',
     }); }
     static { this.terminalCommandFailed = AccessibilitySignal.register({
-        name: ( localize(2265, 'Terminal Command Failed')),
+        name: ( localize(2294, 'Terminal Command Failed')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.terminalCommandFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalCommandFailed',
-        announcementMessage: ( localize(2266, 'Command Failed')),
+        announcementMessage: ( localize(2295, 'Command Failed')),
         settingsKey: 'accessibility.signals.terminalCommandFailed',
     }); }
     static { this.terminalCommandSucceeded = AccessibilitySignal.register({
-        name: ( localize(2267, 'Terminal Command Succeeded')),
+        name: ( localize(2296, 'Terminal Command Succeeded')),
         sound: Sound.success,
-        announcementMessage: ( localize(2268, 'Command Succeeded')),
+        announcementMessage: ( localize(2297, 'Command Succeeded')),
         settingsKey: 'accessibility.signals.terminalCommandSucceeded',
     }); }
     static { this.terminalBell = AccessibilitySignal.register({
-        name: ( localize(2269, 'Terminal Bell')),
+        name: ( localize(2298, 'Terminal Bell')),
         sound: Sound.terminalBell,
         legacySoundSettingsKey: 'audioCues.terminalBell',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalBell',
-        announcementMessage: ( localize(2270, 'Terminal Bell')),
+        announcementMessage: ( localize(2299, 'Terminal Bell')),
         settingsKey: 'accessibility.signals.terminalBell',
     }); }
     static { this.notebookCellCompleted = AccessibilitySignal.register({
-        name: ( localize(2271, 'Notebook Cell Completed')),
+        name: ( localize(2300, 'Notebook Cell Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.notebookCellCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellCompleted',
-        announcementMessage: ( localize(2272, 'Notebook Cell Completed')),
+        announcementMessage: ( localize(2301, 'Notebook Cell Completed')),
         settingsKey: 'accessibility.signals.notebookCellCompleted',
     }); }
     static { this.notebookCellFailed = AccessibilitySignal.register({
-        name: ( localize(2273, 'Notebook Cell Failed')),
+        name: ( localize(2302, 'Notebook Cell Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.notebookCellFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellFailed',
-        announcementMessage: ( localize(2274, 'Notebook Cell Failed')),
+        announcementMessage: ( localize(2303, 'Notebook Cell Failed')),
         settingsKey: 'accessibility.signals.notebookCellFailed',
     }); }
     static { this.diffLineInserted = AccessibilitySignal.register({
-        name: ( localize(2275, 'Diff Line Inserted')),
+        name: ( localize(2304, 'Diff Line Inserted')),
         sound: Sound.diffLineInserted,
         legacySoundSettingsKey: 'audioCues.diffLineInserted',
         settingsKey: 'accessibility.signals.diffLineInserted',
     }); }
     static { this.diffLineDeleted = AccessibilitySignal.register({
-        name: ( localize(2276, 'Diff Line Deleted')),
+        name: ( localize(2305, 'Diff Line Deleted')),
         sound: Sound.diffLineDeleted,
         legacySoundSettingsKey: 'audioCues.diffLineDeleted',
         settingsKey: 'accessibility.signals.diffLineDeleted',
     }); }
     static { this.diffLineModified = AccessibilitySignal.register({
-        name: ( localize(2277, 'Diff Line Modified')),
+        name: ( localize(2306, 'Diff Line Modified')),
         sound: Sound.diffLineModified,
         legacySoundSettingsKey: 'audioCues.diffLineModified',
         settingsKey: 'accessibility.signals.diffLineModified',
     }); }
     static { this.chatRequestSent = AccessibilitySignal.register({
-        name: ( localize(2278, 'Chat Request Sent')),
+        name: ( localize(2307, 'Chat Request Sent')),
         sound: Sound.chatRequestSent,
         legacySoundSettingsKey: 'audioCues.chatRequestSent',
         legacyAnnouncementSettingsKey: 'accessibility.alert.chatRequestSent',
-        announcementMessage: ( localize(2279, 'Chat Request Sent')),
+        announcementMessage: ( localize(2308, 'Chat Request Sent')),
         settingsKey: 'accessibility.signals.chatRequestSent',
     }); }
     static { this.chatResponseReceived = AccessibilitySignal.register({
-        name: ( localize(2280, 'Chat Response Received')),
+        name: ( localize(2309, 'Chat Response Received')),
         legacySoundSettingsKey: 'audioCues.chatResponseReceived',
         sound: {
             randomOneOf: [
@@ -435,45 +435,45 @@ class AccessibilitySignal {
         settingsKey: 'accessibility.signals.chatResponseReceived'
     }); }
     static { this.progress = AccessibilitySignal.register({
-        name: ( localize(2281, 'Progress')),
+        name: ( localize(2310, 'Progress')),
         sound: Sound.progress,
         legacySoundSettingsKey: 'audioCues.chatResponsePending',
         legacyAnnouncementSettingsKey: 'accessibility.alert.progress',
-        announcementMessage: ( localize(2282, 'Progress')),
+        announcementMessage: ( localize(2311, 'Progress')),
         settingsKey: 'accessibility.signals.progress'
     }); }
     static { this.clear = AccessibilitySignal.register({
-        name: ( localize(2283, 'Clear')),
+        name: ( localize(2312, 'Clear')),
         sound: Sound.clear,
         legacySoundSettingsKey: 'audioCues.clear',
         legacyAnnouncementSettingsKey: 'accessibility.alert.clear',
-        announcementMessage: ( localize(2284, 'Clear')),
+        announcementMessage: ( localize(2313, 'Clear')),
         settingsKey: 'accessibility.signals.clear'
     }); }
     static { this.save = AccessibilitySignal.register({
-        name: ( localize(2285, 'Save')),
+        name: ( localize(2314, 'Save')),
         sound: Sound.save,
         legacySoundSettingsKey: 'audioCues.save',
         legacyAnnouncementSettingsKey: 'accessibility.alert.save',
-        announcementMessage: ( localize(2286, 'Save')),
+        announcementMessage: ( localize(2315, 'Save')),
         settingsKey: 'accessibility.signals.save'
     }); }
     static { this.format = AccessibilitySignal.register({
-        name: ( localize(2287, 'Format')),
+        name: ( localize(2316, 'Format')),
         sound: Sound.format,
         legacySoundSettingsKey: 'audioCues.format',
         legacyAnnouncementSettingsKey: 'accessibility.alert.format',
-        announcementMessage: ( localize(2288, 'Format')),
+        announcementMessage: ( localize(2317, 'Format')),
         settingsKey: 'accessibility.signals.format'
     }); }
     static { this.voiceRecordingStarted = AccessibilitySignal.register({
-        name: ( localize(2289, 'Voice Recording Started')),
+        name: ( localize(2318, 'Voice Recording Started')),
         sound: Sound.voiceRecordingStarted,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStarted',
         settingsKey: 'accessibility.signals.voiceRecordingStarted'
     }); }
     static { this.voiceRecordingStopped = AccessibilitySignal.register({
-        name: ( localize(2290, 'Voice Recording Stopped')),
+        name: ( localize(2319, 'Voice Recording Stopped')),
         sound: Sound.voiceRecordingStopped,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStopped',
         settingsKey: 'accessibility.signals.voiceRecordingStopped'

package/vscode/src/vs/platform/actions/common/menuResetAction.js

@@ -7,7 +7,7 @@ class MenuHiddenStatesReset extends Action2 {
     constructor() {
         super({
             id: 'menu.resetHiddenStates',
-            title: ( localize2(4161, "Reset All Menus")),
+            title: ( localize2(4484, "Reset All Menus")),
             category: Categories.View,
             f1: true
         });

package/vscode/src/vs/platform/contextkey/common/contextkey.js

@@ -45,17 +45,17 @@ var ContextKeyExprType;
 const defaultConfig = {
     regexParsingWithErrorRecovery: true
 };
-const errorEmptyString = ( localize(480, "Empty context key expression"));
+const errorEmptyString = ( localize(556, "Empty context key expression"));
 const hintEmptyString = ( localize(
-    481,
+    557,
     "Did you forget to write an expression? You can also put 'false' or 'true' to always evaluate to false or true, respectively."
 ));
-const errorNoInAfterNot = ( localize(482, "'in' after 'not'."));
-const errorClosingParenthesis = ( localize(483, "closing parenthesis ')'"));
-const errorUnexpectedToken = ( localize(484, "Unexpected token"));
-const hintUnexpectedToken = ( localize(485, "Did you forget to put && or || before the token?"));
-const errorUnexpectedEOF = ( localize(486, "Unexpected end of expression"));
-const hintUnexpectedEOF = ( localize(487, "Did you forget to put a context key?"));
+const errorNoInAfterNot = ( localize(558, "'in' after 'not'."));
+const errorClosingParenthesis = ( localize(559, "closing parenthesis ')'"));
+const errorUnexpectedToken = ( localize(560, "Unexpected token"));
+const hintUnexpectedToken = ( localize(561, "Did you forget to put && or || before the token?"));
+const errorUnexpectedEOF = ( localize(562, "Unexpected end of expression"));
+const hintUnexpectedEOF = ( localize(563, "Did you forget to put a context key?"));
 class Parser {
     static { this._parseError = ( (new Error())); }
     get lexingErrors() {
@@ -387,7 +387,7 @@ class Parser {
         throw this._errExpectedButGot(message, this._peek());
     }
     _errExpectedButGot(expected, got, additionalInfo) {
-        const message = ( localize(488, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got)));
+        const message = ( localize(564, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got)));
         const offset = got.offset;
         const lexeme = Scanner.getLexeme(got);
         this._parsingErrors.push({ message, offset, lexeme, additionalInfo });
@@ -471,8 +471,8 @@ function validateWhenClauses(whenClauses) {
                 return (
                      (parser.lexingErrors.map((se) => ({
                         errorMessage: se.additionalInfo ?
-                            ( localize(489, "Unexpected token. Hint: {0}", se.additionalInfo)) :
-                            ( localize(490, "Unexpected token.")),
+                            ( localize(565, "Unexpected token. Hint: {0}", se.additionalInfo)) :
+                            ( localize(566, "Unexpected token.")),
                         offset: se.offset,
                         length: se.lexeme.length,
                     })))

package/vscode/src/vs/platform/files/browser/htmlFileSystemProvider.js

@@ -203,7 +203,7 @@ class HTMLFileSystemProvider {
                 await this.delete(from, { recursive: false, useTrash: false, atomic: false });
             }
             else {
-                throw this.createFileSystemProviderError(from, localize(1062, "Rename is only supported for files."), FileSystemProviderErrorCode.Unavailable);
+                throw this.createFileSystemProviderError(from, localize(1036, "Rename is only supported for files."), FileSystemProviderErrorCode.Unavailable);
             }
         }
         catch (error) {
@@ -333,7 +333,7 @@ class HTMLFileSystemProvider {
         }
         let code = FileSystemProviderErrorCode.Unknown;
         if (error.name === 'NotAllowedError') {
-            error = ( (new Error(( localize(1063, "Insufficient permissions. Please retry and allow the operation.")))));
+            error = ( (new Error(( localize(1037, "Insufficient permissions. Please retry and allow the operation.")))));
             code = FileSystemProviderErrorCode.Unavailable;
         }
         return createFileSystemProviderError(error, code);

package/vscode/src/vs/platform/keybinding/common/abstractKeybindingService.js

@@ -104,7 +104,7 @@ class AbstractKeybindingService extends Disposable {
                 throw illegalState('impossible');
             case 1:
                 this._currentChordStatusMessage = this._notificationService.status(( localize(
-                    1545,
+                    1498,
                     "({0}) was pressed. Waiting for second key of chord...",
                     keypressLabel
                 )));
@@ -112,7 +112,7 @@ class AbstractKeybindingService extends Disposable {
             default: {
                 const fullKeypressLabel = ( (this._currentChords.map(({ label }) => label))).join(', ');
                 this._currentChordStatusMessage = this._notificationService.status(( localize(
-                    1546,
+                    1499,
                     "({0}) was pressed. Waiting for next key of chord...",
                     fullKeypressLabel
                 )));
@@ -217,7 +217,7 @@ class AbstractKeybindingService extends Disposable {
                     const currentChordsLabel = ( (this._currentChords.map(({ label }) => label))).join(', ');
                     this._log(`+ Leaving multi-chord mode: Nothing bound to "${currentChordsLabel}, ${keypressLabel}".`);
                     this._notificationService.status(( localize(
-                        1547,
+                        1500,
                         "The key combination ({0}, {1}) is not a command.",
                         currentChordsLabel,
                         keypressLabel
@@ -241,7 +241,7 @@ class AbstractKeybindingService extends Disposable {
                         const currentChordsLabel = ( (this._currentChords.map(({ label }) => label))).join(', ');
                         this._log(`+ Leaving chord mode: Nothing bound to "${currentChordsLabel}, ${keypressLabel}".`);
                         this._notificationService.status(( localize(
-                            1547,
+                            1500,
                             "The key combination ({0}, {1}) is not a command.",
                             currentChordsLabel,
                             keypressLabel