@codingame/monaco-vscode-api 8.0.2 → 8.0.3

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

@@ -16,36 +16,36 @@ import '../../../../platform/theme/common/colors/quickpickColors.js';
 import '../../../../platform/theme/common/colors/searchColors.js';
 import { themeColorFromId, registerThemingParticipant } from '../../../../platform/theme/common/themeService.js';
 const wordHighlightBackground = registerColor('editor.wordHighlightBackground', { dark: '#575757B8', light: '#57575740', hcDark: null, hcLight: null }, ( localize(
-    5170,
+    5180,
     'Background color of a symbol during read-access, like reading a variable. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 registerColor('editor.wordHighlightStrongBackground', { dark: '#004972B8', light: '#0e639c40', hcDark: null, hcLight: null }, ( localize(
-    5171,
+    5181,
     'Background color of a symbol during write-access, like writing to a variable. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 registerColor('editor.wordHighlightTextBackground', wordHighlightBackground, ( localize(
-    5172,
+    5182,
     'Background color of a textual occurrence for a symbol. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const wordHighlightBorder = registerColor('editor.wordHighlightBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(
-    5173,
+    5183,
     'Border color of a symbol during read-access, like reading a variable.'
 )));
 registerColor('editor.wordHighlightStrongBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(
-    5174,
+    5184,
     'Border color of a symbol during write-access, like writing to a variable.'
 )));
-registerColor('editor.wordHighlightTextBorder', wordHighlightBorder, ( localize(5175, "Border color of a textual occurrence for a symbol.")));
+registerColor('editor.wordHighlightTextBorder', wordHighlightBorder, ( localize(5185, "Border color of a textual occurrence for a symbol.")));
 const overviewRulerWordHighlightForeground = registerColor('editorOverviewRuler.wordHighlightForeground', '#A0A0A0CC', ( localize(
-    5176,
+    5186,
     'Overview ruler marker color for symbol highlights. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const overviewRulerWordHighlightStrongForeground = registerColor('editorOverviewRuler.wordHighlightStrongForeground', '#C0A0C0CC', ( localize(
-    5177,
+    5187,
     'Overview ruler marker color for write-access symbol highlights. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const overviewRulerWordHighlightTextForeground = registerColor('editorOverviewRuler.wordHighlightTextForeground', overviewRulerSelectionHighlightForeground, ( localize(
-    5178,
+    5188,
     'Overview ruler marker color of a textual occurrence for a symbol. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const _WRITE_OPTIONS = ModelDecorationOptions.register({

package/vscode/src/vs/editor/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/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,
                     })))