@codingame/monaco-vscode-api 28.4.1 → 29.0.0

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

@@ -25,7 +25,7 @@ const wordHighlightBackground = registerColor("editor.wordHighlightBackground",
     hcDark: null,
     hcLight: null
 }, ( localize(
-    1690,
+    1695,
     "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", {
@@ -34,14 +34,14 @@ registerColor("editor.wordHighlightStrongBackground", {
     hcDark: null,
     hcLight: null
 }, ( localize(
-    1691,
+    1696,
     "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(
-    1692,
+    1697,
     "Background color of a textual occurrence for a symbol. The color must not be opaque so as not to hide underlying decorations."
 )),
     true
@@ -52,7 +52,7 @@ const wordHighlightBorder = registerColor("editor.wordHighlightBorder", {
     hcDark: activeContrastBorder,
     hcLight: activeContrastBorder
 }, ( localize(
-    1693,
+    1698,
     "Border color of a symbol during read-access, like reading a variable."
 )));
 registerColor("editor.wordHighlightStrongBorder", {
@@ -61,19 +61,19 @@ registerColor("editor.wordHighlightStrongBorder", {
     hcDark: activeContrastBorder,
     hcLight: activeContrastBorder
 }, ( localize(
-    1694,
+    1699,
     "Border color of a symbol during write-access, like writing to a variable."
 )));
-registerColor("editor.wordHighlightTextBorder", wordHighlightBorder, ( localize(1695, "Border color of a textual occurrence for a symbol.")));
+registerColor("editor.wordHighlightTextBorder", wordHighlightBorder, ( localize(1700, "Border color of a textual occurrence for a symbol.")));
 const overviewRulerWordHighlightForeground = registerColor("editorOverviewRuler.wordHighlightForeground", "#A0A0A0CC", ( localize(
-    1696,
+    1701,
     "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(
-    1697,
+    1702,
     "Overview ruler marker color for write-access symbol highlights. The color must not be opaque so as not to hide underlying decorations."
 )),
     true
@@ -82,7 +82,7 @@ const overviewRulerWordHighlightTextForeground = registerColor(
     "editorOverviewRuler.wordHighlightTextForeground",
     overviewRulerSelectionHighlightForeground,
     ( localize(
-    1698,
+    1703,
     "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

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

@@ -758,7 +758,7 @@ class NextWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(true, {
             id: "editor.action.wordHighlight.next",
-            label: ( localize2(1699, "Go to Next Symbol Highlight")),
+            label: ( localize2(1704, "Go to Next Symbol Highlight")),
             precondition: ctxHasWordHighlights,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -772,7 +772,7 @@ class PrevWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(false, {
             id: "editor.action.wordHighlight.prev",
-            label: ( localize2(1700, "Go to Previous Symbol Highlight")),
+            label: ( localize2(1705, "Go to Previous Symbol Highlight")),
             precondition: ctxHasWordHighlights,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -786,7 +786,7 @@ class TriggerWordHighlightAction extends EditorAction {
     constructor() {
         super({
             id: "editor.action.wordHighlight.trigger",
-            label: ( localize2(1701, "Trigger Symbol Highlight")),
+            label: ( localize2(1706, "Trigger Symbol Highlight")),
             precondition: undefined,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,

package/vscode/src/vs/editor/contrib/wordOperations/browser/wordOperations.js

@@ -461,9 +461,9 @@ class DeleteInsideWord extends EditorAction {
         super({
             id: "deleteInsideWord",
             precondition: EditorContextKeys.writable,
-            label: ( localize2(1702, "Delete Word")),
+            label: ( localize2(1707, "Delete Word")),
             metadata: {
-                description: ( localize2(1703, "Delete the word at the cursor")),
+                description: ( localize2(1708, "Delete the word at the cursor")),
                 args: [{
                     name: "args",
                     schema: {
@@ -472,7 +472,7 @@ class DeleteInsideWord extends EditorAction {
                             "onlyWord": {
                                 type: "boolean",
                                 default: false,
-                                description: ( localize(1704, "Delete only the word and leave surrounding whitespace"))
+                                description: ( localize(1709, "Delete only the word and leave surrounding whitespace"))
                             }
                         }
                     }

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

@@ -438,65 +438,65 @@ class AccessibilitySignal {
     }
     static {
         this.errorAtPosition = AccessibilitySignal.register({
-            name: ( localize(1705, "Error at Position")),
+            name: ( localize(1710, "Error at Position")),
             sound: Sound.error,
-            announcementMessage: ( localize(1706, "Error")),
+            announcementMessage: ( localize(1711, "Error")),
             settingsKey: "accessibility.signals.positionHasError",
             delaySettingsKey: "accessibility.signalOptions.delays.errorAtPosition"
         });
     }
     static {
         this.warningAtPosition = AccessibilitySignal.register({
-            name: ( localize(1707, "Warning at Position")),
+            name: ( localize(1712, "Warning at Position")),
             sound: Sound.warning,
-            announcementMessage: ( localize(1708, "Warning")),
+            announcementMessage: ( localize(1713, "Warning")),
             settingsKey: "accessibility.signals.positionHasWarning",
             delaySettingsKey: "accessibility.signalOptions.delays.warningAtPosition"
         });
     }
     static {
         this.errorOnLine = AccessibilitySignal.register({
-            name: ( localize(1709, "Error on Line")),
+            name: ( localize(1714, "Error on Line")),
             sound: Sound.error,
             legacySoundSettingsKey: "audioCues.lineHasError",
             legacyAnnouncementSettingsKey: "accessibility.alert.error",
-            announcementMessage: ( localize(1710, "Error on Line")),
+            announcementMessage: ( localize(1715, "Error on Line")),
             settingsKey: "accessibility.signals.lineHasError"
         });
     }
     static {
         this.warningOnLine = AccessibilitySignal.register({
-            name: ( localize(1711, "Warning on Line")),
+            name: ( localize(1716, "Warning on Line")),
             sound: Sound.warning,
             legacySoundSettingsKey: "audioCues.lineHasWarning",
             legacyAnnouncementSettingsKey: "accessibility.alert.warning",
-            announcementMessage: ( localize(1712, "Warning on Line")),
+            announcementMessage: ( localize(1717, "Warning on Line")),
             settingsKey: "accessibility.signals.lineHasWarning"
         });
     }
     static {
         this.foldedArea = AccessibilitySignal.register({
-            name: ( localize(1713, "Folded Area on Line")),
+            name: ( localize(1718, "Folded Area on Line")),
             sound: Sound.foldedArea,
             legacySoundSettingsKey: "audioCues.lineHasFoldedArea",
             legacyAnnouncementSettingsKey: "accessibility.alert.foldedArea",
-            announcementMessage: ( localize(1714, "Folded")),
+            announcementMessage: ( localize(1719, "Folded")),
             settingsKey: "accessibility.signals.lineHasFoldedArea"
         });
     }
     static {
         this.break = AccessibilitySignal.register({
-            name: ( localize(1715, "Breakpoint on Line")),
+            name: ( localize(1720, "Breakpoint on Line")),
             sound: Sound.break,
             legacySoundSettingsKey: "audioCues.lineHasBreakpoint",
             legacyAnnouncementSettingsKey: "accessibility.alert.breakpoint",
-            announcementMessage: ( localize(1716, "Breakpoint")),
+            announcementMessage: ( localize(1721, "Breakpoint")),
             settingsKey: "accessibility.signals.lineHasBreakpoint"
         });
     }
     static {
         this.inlineSuggestion = AccessibilitySignal.register({
-            name: ( localize(1717, "Inline Suggestion on Line")),
+            name: ( localize(1722, "Inline Suggestion on Line")),
             sound: Sound.quickFixes,
             legacySoundSettingsKey: "audioCues.lineHasInlineSuggestion",
             settingsKey: "accessibility.signals.lineHasInlineSuggestion"
@@ -504,114 +504,114 @@ class AccessibilitySignal {
     }
     static {
         this.nextEditSuggestion = AccessibilitySignal.register({
-            name: ( localize(1718, "Next Edit Suggestion on Line")),
+            name: ( localize(1723, "Next Edit Suggestion on Line")),
             sound: Sound.nextEditSuggestion,
             legacySoundSettingsKey: "audioCues.nextEditSuggestion",
             settingsKey: "accessibility.signals.nextEditSuggestion",
-            announcementMessage: ( localize(1719, "Next Edit Suggestion"))
+            announcementMessage: ( localize(1724, "Next Edit Suggestion"))
         });
     }
     static {
         this.terminalQuickFix = AccessibilitySignal.register({
-            name: ( localize(1720, "Terminal Quick Fix")),
+            name: ( localize(1725, "Terminal Quick Fix")),
             sound: Sound.quickFixes,
             legacySoundSettingsKey: "audioCues.terminalQuickFix",
             legacyAnnouncementSettingsKey: "accessibility.alert.terminalQuickFix",
-            announcementMessage: ( localize(1721, "Quick Fix")),
+            announcementMessage: ( localize(1726, "Quick Fix")),
             settingsKey: "accessibility.signals.terminalQuickFix"
         });
     }
     static {
         this.onDebugBreak = AccessibilitySignal.register({
-            name: ( localize(1722, "Debugger Stopped on Breakpoint")),
+            name: ( localize(1727, "Debugger Stopped on Breakpoint")),
             sound: Sound.break,
             legacySoundSettingsKey: "audioCues.onDebugBreak",
             legacyAnnouncementSettingsKey: "accessibility.alert.onDebugBreak",
-            announcementMessage: ( localize(1723, "Breakpoint")),
+            announcementMessage: ( localize(1728, "Breakpoint")),
             settingsKey: "accessibility.signals.onDebugBreak"
         });
     }
     static {
         this.noInlayHints = AccessibilitySignal.register({
-            name: ( localize(1724, "No Inlay Hints on Line")),
+            name: ( localize(1729, "No Inlay Hints on Line")),
             sound: Sound.error,
             legacySoundSettingsKey: "audioCues.noInlayHints",
             legacyAnnouncementSettingsKey: "accessibility.alert.noInlayHints",
-            announcementMessage: ( localize(1725, "No Inlay Hints")),
+            announcementMessage: ( localize(1730, "No Inlay Hints")),
             settingsKey: "accessibility.signals.noInlayHints"
         });
     }
     static {
         this.taskCompleted = AccessibilitySignal.register({
-            name: ( localize(1726, "Task Completed")),
+            name: ( localize(1731, "Task Completed")),
             sound: Sound.taskCompleted,
             legacySoundSettingsKey: "audioCues.taskCompleted",
             legacyAnnouncementSettingsKey: "accessibility.alert.taskCompleted",
-            announcementMessage: ( localize(1727, "Task Completed")),
+            announcementMessage: ( localize(1732, "Task Completed")),
             settingsKey: "accessibility.signals.taskCompleted"
         });
     }
     static {
         this.taskFailed = AccessibilitySignal.register({
-            name: ( localize(1728, "Task Failed")),
+            name: ( localize(1733, "Task Failed")),
             sound: Sound.taskFailed,
             legacySoundSettingsKey: "audioCues.taskFailed",
             legacyAnnouncementSettingsKey: "accessibility.alert.taskFailed",
-            announcementMessage: ( localize(1729, "Task Failed")),
+            announcementMessage: ( localize(1734, "Task Failed")),
             settingsKey: "accessibility.signals.taskFailed"
         });
     }
     static {
         this.terminalCommandFailed = AccessibilitySignal.register({
-            name: ( localize(1730, "Terminal Command Failed")),
+            name: ( localize(1735, "Terminal Command Failed")),
             sound: Sound.error,
             legacySoundSettingsKey: "audioCues.terminalCommandFailed",
             legacyAnnouncementSettingsKey: "accessibility.alert.terminalCommandFailed",
-            announcementMessage: ( localize(1731, "Command Failed")),
+            announcementMessage: ( localize(1736, "Command Failed")),
             settingsKey: "accessibility.signals.terminalCommandFailed"
         });
     }
     static {
         this.terminalCommandSucceeded = AccessibilitySignal.register({
-            name: ( localize(1732, "Terminal Command Succeeded")),
+            name: ( localize(1737, "Terminal Command Succeeded")),
             sound: Sound.terminalCommandSucceeded,
-            announcementMessage: ( localize(1733, "Command Succeeded")),
+            announcementMessage: ( localize(1738, "Command Succeeded")),
             settingsKey: "accessibility.signals.terminalCommandSucceeded"
         });
     }
     static {
         this.terminalBell = AccessibilitySignal.register({
-            name: ( localize(1734, "Terminal Bell")),
+            name: ( localize(1739, "Terminal Bell")),
             sound: Sound.terminalBell,
             legacySoundSettingsKey: "audioCues.terminalBell",
             legacyAnnouncementSettingsKey: "accessibility.alert.terminalBell",
-            announcementMessage: ( localize(1735, "Terminal Bell")),
+            announcementMessage: ( localize(1740, "Terminal Bell")),
             settingsKey: "accessibility.signals.terminalBell"
         });
     }
     static {
         this.notebookCellCompleted = AccessibilitySignal.register({
-            name: ( localize(1736, "Notebook Cell Completed")),
+            name: ( localize(1741, "Notebook Cell Completed")),
             sound: Sound.taskCompleted,
             legacySoundSettingsKey: "audioCues.notebookCellCompleted",
             legacyAnnouncementSettingsKey: "accessibility.alert.notebookCellCompleted",
-            announcementMessage: ( localize(1737, "Notebook Cell Completed")),
+            announcementMessage: ( localize(1742, "Notebook Cell Completed")),
             settingsKey: "accessibility.signals.notebookCellCompleted"
         });
     }
     static {
         this.notebookCellFailed = AccessibilitySignal.register({
-            name: ( localize(1738, "Notebook Cell Failed")),
+            name: ( localize(1743, "Notebook Cell Failed")),
             sound: Sound.taskFailed,
             legacySoundSettingsKey: "audioCues.notebookCellFailed",
             legacyAnnouncementSettingsKey: "accessibility.alert.notebookCellFailed",
-            announcementMessage: ( localize(1739, "Notebook Cell Failed")),
+            announcementMessage: ( localize(1744, "Notebook Cell Failed")),
             settingsKey: "accessibility.signals.notebookCellFailed"
         });
     }
     static {
         this.diffLineInserted = AccessibilitySignal.register({
-            name: ( localize(1740, "Diff Line Inserted")),
+            name: ( localize(1745, "Diff Line Inserted")),
             sound: Sound.diffLineInserted,
             legacySoundSettingsKey: "audioCues.diffLineInserted",
             settingsKey: "accessibility.signals.diffLineInserted"
@@ -619,7 +619,7 @@ class AccessibilitySignal {
     }
     static {
         this.diffLineDeleted = AccessibilitySignal.register({
-            name: ( localize(1741, "Diff Line Deleted")),
+            name: ( localize(1746, "Diff Line Deleted")),
             sound: Sound.diffLineDeleted,
             legacySoundSettingsKey: "audioCues.diffLineDeleted",
             settingsKey: "accessibility.signals.diffLineDeleted"
@@ -627,7 +627,7 @@ class AccessibilitySignal {
     }
     static {
         this.diffLineModified = AccessibilitySignal.register({
-            name: ( localize(1742, "Diff Line Modified")),
+            name: ( localize(1747, "Diff Line Modified")),
             sound: Sound.diffLineModified,
             legacySoundSettingsKey: "audioCues.diffLineModified",
             settingsKey: "accessibility.signals.diffLineModified"
@@ -635,25 +635,25 @@ class AccessibilitySignal {
     }
     static {
         this.chatEditModifiedFile = AccessibilitySignal.register({
-            name: ( localize(1743, "Chat Edit Modified File")),
+            name: ( localize(1748, "Chat Edit Modified File")),
             sound: Sound.chatEditModifiedFile,
-            announcementMessage: ( localize(1744, "File Modified from Chat Edits")),
+            announcementMessage: ( localize(1749, "File Modified from Chat Edits")),
             settingsKey: "accessibility.signals.chatEditModifiedFile"
         });
     }
     static {
         this.chatRequestSent = AccessibilitySignal.register({
-            name: ( localize(1745, "Chat Request Sent")),
+            name: ( localize(1750, "Chat Request Sent")),
             sound: Sound.requestSent,
             legacySoundSettingsKey: "audioCues.chatRequestSent",
             legacyAnnouncementSettingsKey: "accessibility.alert.chatRequestSent",
-            announcementMessage: ( localize(1746, "Chat Request Sent")),
+            announcementMessage: ( localize(1751, "Chat Request Sent")),
             settingsKey: "accessibility.signals.chatRequestSent"
         });
     }
     static {
         this.chatResponseReceived = AccessibilitySignal.register({
-            name: ( localize(1747, "Chat Response Received")),
+            name: ( localize(1752, "Chat Response Received")),
             legacySoundSettingsKey: "audioCues.chatResponseReceived",
             sound: {
                 randomOneOf: [
@@ -668,17 +668,17 @@ class AccessibilitySignal {
     }
     static {
         this.codeActionTriggered = AccessibilitySignal.register({
-            name: ( localize(1748, "Code Action Request Triggered")),
+            name: ( localize(1753, "Code Action Request Triggered")),
             sound: Sound.codeActionTriggered,
             legacySoundSettingsKey: "audioCues.codeActionRequestTriggered",
             legacyAnnouncementSettingsKey: "accessibility.alert.codeActionRequestTriggered",
-            announcementMessage: ( localize(1749, "Code Action Request Triggered")),
+            announcementMessage: ( localize(1754, "Code Action Request Triggered")),
             settingsKey: "accessibility.signals.codeActionTriggered"
         });
     }
     static {
         this.codeActionApplied = AccessibilitySignal.register({
-            name: ( localize(1750, "Code Action Applied")),
+            name: ( localize(1755, "Code Action Applied")),
             legacySoundSettingsKey: "audioCues.codeActionApplied",
             sound: Sound.codeActionApplied,
             settingsKey: "accessibility.signals.codeActionApplied"
@@ -686,47 +686,47 @@ class AccessibilitySignal {
     }
     static {
         this.progress = AccessibilitySignal.register({
-            name: ( localize(1751, "Progress")),
+            name: ( localize(1756, "Progress")),
             sound: Sound.progress,
             legacySoundSettingsKey: "audioCues.chatResponsePending",
             legacyAnnouncementSettingsKey: "accessibility.alert.progress",
-            announcementMessage: ( localize(1752, "Progress")),
+            announcementMessage: ( localize(1757, "Progress")),
             settingsKey: "accessibility.signals.progress"
         });
     }
     static {
         this.clear = AccessibilitySignal.register({
-            name: ( localize(1753, "Clear")),
+            name: ( localize(1758, "Clear")),
             sound: Sound.clear,
             legacySoundSettingsKey: "audioCues.clear",
             legacyAnnouncementSettingsKey: "accessibility.alert.clear",
-            announcementMessage: ( localize(1754, "Clear")),
+            announcementMessage: ( localize(1759, "Clear")),
             settingsKey: "accessibility.signals.clear"
         });
     }
     static {
         this.save = AccessibilitySignal.register({
-            name: ( localize(1755, "Save")),
+            name: ( localize(1760, "Save")),
             sound: Sound.save,
             legacySoundSettingsKey: "audioCues.save",
             legacyAnnouncementSettingsKey: "accessibility.alert.save",
-            announcementMessage: ( localize(1756, "Save")),
+            announcementMessage: ( localize(1761, "Save")),
             settingsKey: "accessibility.signals.save"
         });
     }
     static {
         this.format = AccessibilitySignal.register({
-            name: ( localize(1757, "Format")),
+            name: ( localize(1762, "Format")),
             sound: Sound.format,
             legacySoundSettingsKey: "audioCues.format",
             legacyAnnouncementSettingsKey: "accessibility.alert.format",
-            announcementMessage: ( localize(1758, "Format")),
+            announcementMessage: ( localize(1763, "Format")),
             settingsKey: "accessibility.signals.format"
         });
     }
     static {
         this.voiceRecordingStarted = AccessibilitySignal.register({
-            name: ( localize(1759, "Voice Recording Started")),
+            name: ( localize(1764, "Voice Recording Started")),
             sound: Sound.voiceRecordingStarted,
             legacySoundSettingsKey: "audioCues.voiceRecordingStarted",
             settingsKey: "accessibility.signals.voiceRecordingStarted"
@@ -734,7 +734,7 @@ class AccessibilitySignal {
     }
     static {
         this.voiceRecordingStopped = AccessibilitySignal.register({
-            name: ( localize(1760, "Voice Recording Stopped")),
+            name: ( localize(1765, "Voice Recording Stopped")),
             sound: Sound.voiceRecordingStopped,
             legacySoundSettingsKey: "audioCues.voiceRecordingStopped",
             settingsKey: "accessibility.signals.voiceRecordingStopped"
@@ -742,25 +742,25 @@ class AccessibilitySignal {
     }
     static {
         this.editsKept = AccessibilitySignal.register({
-            name: ( localize(1761, "Edits Kept")),
+            name: ( localize(1766, "Edits Kept")),
             sound: Sound.editsKept,
-            announcementMessage: ( localize(1762, "Edits Kept")),
+            announcementMessage: ( localize(1767, "Edits Kept")),
             settingsKey: "accessibility.signals.editsKept"
         });
     }
     static {
         this.editsUndone = AccessibilitySignal.register({
-            name: ( localize(1763, "Undo Edits")),
+            name: ( localize(1768, "Undo Edits")),
             sound: Sound.editsUndone,
-            announcementMessage: ( localize(1764, "Edits Undone")),
+            announcementMessage: ( localize(1769, "Edits Undone")),
             settingsKey: "accessibility.signals.editsUndone"
         });
     }
     static {
         this.chatUserActionRequired = AccessibilitySignal.register({
-            name: ( localize(1765, "Chat User Action Required")),
+            name: ( localize(1770, "Chat User Action Required")),
             sound: Sound.chatUserActionRequired,
-            announcementMessage: ( localize(1766, "Chat User Action Required")),
+            announcementMessage: ( localize(1771, "Chat User Action Required")),
             settingsKey: "accessibility.signals.chatUserActionRequired"
         });
     }

package/vscode/src/vs/platform/action/common/actionCommonCategories.js

@@ -2,12 +2,12 @@
 import { localize2 } from '../../../nls.js';
 
 const Categories = ( Object.freeze({
-    View: ( localize2(1767, "View")),
-    Help: ( localize2(1768, "Help")),
-    Test: ( localize2(1769, "Test")),
-    File: ( localize2(1770, "File")),
-    Preferences: ( localize2(1771, "Preferences")),
-    Developer: ( localize2(1772, "Developer"))
+    View: ( localize2(1772, "View")),
+    Help: ( localize2(1773, "Help")),
+    Test: ( localize2(1774, "Test")),
+    File: ( localize2(1775, "File")),
+    Preferences: ( localize2(1776, "Preferences")),
+    Developer: ( localize2(1777, "Developer"))
 }));
 
 export { Categories };