@codingame/monaco-vscode-api 36.2.6 → 37.0.0

package/vscode/src/vs/platform/accessibility/browser/accessibilityService.js

@@ -57,13 +57,23 @@ let AccessibilityService = class AccessibilityService extends Disposable {
                 this._onDidChangeReducedMotion.fire();
             }
         }));
-        const updateRootClasses = () => {
+        const updateContainerClasses = container => {
             const reduce = this.isMotionReduced();
-            this._layoutService.mainContainer.classList.toggle("monaco-reduce-motion", reduce);
-            this._layoutService.mainContainer.classList.toggle("monaco-enable-motion", !reduce);
+            container.classList.toggle("monaco-reduce-motion", reduce);
+            container.classList.toggle("monaco-enable-motion", !reduce);
+        };
+        const updateRootClasses = () => {
+            for (const container of this._layoutService.containers) {
+                updateContainerClasses(container);
+            }
         };
         updateRootClasses();
         this._register(this.onDidChangeReducedMotion(() => updateRootClasses()));
+        this._register(this._layoutService.onDidAddContainer((
+            {
+                container
+            }
+        ) => updateContainerClasses(container)));
     }
     initReducedTransparencyListeners(reduceTransparencyMatcher) {
         this._register(addDisposableListener(reduceTransparencyMatcher, "change", () => {

package/vscode/src/vs/platform/accessibility/browser/accessibleView.d.ts

@@ -11,6 +11,7 @@ export declare enum AccessibleViewProviderId {
     DiffEditor = "diffEditor",
     MergeEditor = "mergeEditor",
     PanelChat = "panelChat",
+    CustomizationMigrations = "customizationMigrations",
     ChatTerminalOutput = "chatTerminalOutput",
     ChatThinking = "chatThinking",
     InlineChat = "inlineChat",
@@ -36,11 +37,14 @@ export declare enum AccessibleViewProviderId {
     TerminalFindHelp = "terminalFindHelp",
     WebviewFindHelp = "webviewFindHelp",
     OutputFindHelp = "outputFindHelp",
+    ChatFindHelp = "chatFindHelp",
     ProblemsFilterHelp = "problemsFilterHelp",
     SessionsChat = "sessionsChat",
     SessionsChanges = "sessionsChanges",
     Survey = "survey",
-    Automations = "automations"
+    Automations = "automations",
+    BrowserElementCommenting = "browserElementCommenting",
+    ChatPetAchievements = "chatPetAchievements"
 }
 export declare enum AccessibleViewType {
     Help = "help",
@@ -59,10 +63,11 @@ export interface IAccessibleViewOptions {
     type: AccessibleViewType;
     /**
      * By default, places the cursor on the top line of the accessible view.
-     * If set to 'initial-bottom', places the cursor on the bottom line of the accessible view and preserves it henceforth.
+     * If set to 'initial-bottom', places the cursor on the bottom line initially and returns it to the bottom when the content changes.
+     * If set to 'initial-bottom-preserve', places the cursor on the bottom line initially and preserves its position when the content changes.
      * If set to 'bottom', places the cursor on the bottom line of the accessible view.
      */
-    position?: "bottom" | "initial-bottom";
+    position?: "bottom" | "initial-bottom" | "initial-bottom-preserve";
     /**
      * @returns a string that will be used as the content of the help dialog
      * instead of the one provided by default.

package/vscode/src/vs/platform/accessibility/browser/accessibleView.js

@@ -9,6 +9,7 @@ var AccessibleViewProviderId;
     AccessibleViewProviderId["DiffEditor"] = "diffEditor";
     AccessibleViewProviderId["MergeEditor"] = "mergeEditor";
     AccessibleViewProviderId["PanelChat"] = "panelChat";
+    AccessibleViewProviderId["CustomizationMigrations"] = "customizationMigrations";
     AccessibleViewProviderId["ChatTerminalOutput"] = "chatTerminalOutput";
     AccessibleViewProviderId["ChatThinking"] = "chatThinking";
     AccessibleViewProviderId["InlineChat"] = "inlineChat";
@@ -34,11 +35,14 @@ var AccessibleViewProviderId;
     AccessibleViewProviderId["TerminalFindHelp"] = "terminalFindHelp";
     AccessibleViewProviderId["WebviewFindHelp"] = "webviewFindHelp";
     AccessibleViewProviderId["OutputFindHelp"] = "outputFindHelp";
+    AccessibleViewProviderId["ChatFindHelp"] = "chatFindHelp";
     AccessibleViewProviderId["ProblemsFilterHelp"] = "problemsFilterHelp";
     AccessibleViewProviderId["SessionsChat"] = "sessionsChat";
     AccessibleViewProviderId["SessionsChanges"] = "sessionsChanges";
     AccessibleViewProviderId["Survey"] = "survey";
     AccessibleViewProviderId["Automations"] = "automations";
+    AccessibleViewProviderId["BrowserElementCommenting"] = "browserElementCommenting";
+    AccessibleViewProviderId["ChatPetAchievements"] = "chatPetAchievements";
 })(AccessibleViewProviderId || (AccessibleViewProviderId = {}));
 var AccessibleViewType;
 (function (AccessibleViewType) {

package/vscode/src/vs/platform/accessibilitySignal/browser/accessibilitySignalService.d.ts

@@ -140,7 +140,9 @@ export declare class AccessibilitySignal {
     static readonly save: AccessibilitySignal;
     static readonly format: AccessibilitySignal;
     static readonly voiceRecordingStarted: AccessibilitySignal;
+    static readonly voiceModeStarted: AccessibilitySignal;
     static readonly voiceRecordingStopped: AccessibilitySignal;
+    static readonly voiceModeStopped: AccessibilitySignal;
     static readonly editsKept: AccessibilitySignal;
     static readonly editsUndone: AccessibilitySignal;
     static readonly chatUserActionRequired: AccessibilitySignal;

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

@@ -438,65 +438,65 @@ class AccessibilitySignal {
     }
     static {
         this.errorAtPosition = AccessibilitySignal.register({
-            name: ( localize(1725, "Error at Position")),
+            name: ( localize(1740, "Error at Position")),
             sound: Sound.error,
-            announcementMessage: ( localize(1726, "Error")),
+            announcementMessage: ( localize(1741, "Error")),
             settingsKey: "accessibility.signals.positionHasError",
             delaySettingsKey: "accessibility.signalOptions.delays.errorAtPosition"
         });
     }
     static {
         this.warningAtPosition = AccessibilitySignal.register({
-            name: ( localize(1727, "Warning at Position")),
+            name: ( localize(1742, "Warning at Position")),
             sound: Sound.warning,
-            announcementMessage: ( localize(1728, "Warning")),
+            announcementMessage: ( localize(1743, "Warning")),
             settingsKey: "accessibility.signals.positionHasWarning",
             delaySettingsKey: "accessibility.signalOptions.delays.warningAtPosition"
         });
     }
     static {
         this.errorOnLine = AccessibilitySignal.register({
-            name: ( localize(1729, "Error on Line")),
+            name: ( localize(1744, "Error on Line")),
             sound: Sound.error,
             legacySoundSettingsKey: "audioCues.lineHasError",
             legacyAnnouncementSettingsKey: "accessibility.alert.error",
-            announcementMessage: ( localize(1730, "Error on Line")),
+            announcementMessage: ( localize(1745, "Error on Line")),
             settingsKey: "accessibility.signals.lineHasError"
         });
     }
     static {
         this.warningOnLine = AccessibilitySignal.register({
-            name: ( localize(1731, "Warning on Line")),
+            name: ( localize(1746, "Warning on Line")),
             sound: Sound.warning,
             legacySoundSettingsKey: "audioCues.lineHasWarning",
             legacyAnnouncementSettingsKey: "accessibility.alert.warning",
-            announcementMessage: ( localize(1732, "Warning on Line")),
+            announcementMessage: ( localize(1747, "Warning on Line")),
             settingsKey: "accessibility.signals.lineHasWarning"
         });
     }
     static {
         this.foldedArea = AccessibilitySignal.register({
-            name: ( localize(1733, "Folded Area on Line")),
+            name: ( localize(1748, "Folded Area on Line")),
             sound: Sound.foldedArea,
             legacySoundSettingsKey: "audioCues.lineHasFoldedArea",
             legacyAnnouncementSettingsKey: "accessibility.alert.foldedArea",
-            announcementMessage: ( localize(1734, "Folded")),
+            announcementMessage: ( localize(1749, "Folded")),
             settingsKey: "accessibility.signals.lineHasFoldedArea"
         });
     }
     static {
         this.break = AccessibilitySignal.register({
-            name: ( localize(1735, "Breakpoint on Line")),
+            name: ( localize(1750, "Breakpoint on Line")),
             sound: Sound.break,
             legacySoundSettingsKey: "audioCues.lineHasBreakpoint",
             legacyAnnouncementSettingsKey: "accessibility.alert.breakpoint",
-            announcementMessage: ( localize(1736, "Breakpoint")),
+            announcementMessage: ( localize(1751, "Breakpoint")),
             settingsKey: "accessibility.signals.lineHasBreakpoint"
         });
     }
     static {
         this.inlineSuggestion = AccessibilitySignal.register({
-            name: ( localize(1737, "Inline Suggestion on Line")),
+            name: ( localize(1752, "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(1738, "Next Edit Suggestion on Line")),
+            name: ( localize(1753, "Next Edit Suggestion on Line")),
             sound: Sound.nextEditSuggestion,
             legacySoundSettingsKey: "audioCues.nextEditSuggestion",
             settingsKey: "accessibility.signals.nextEditSuggestion",
-            announcementMessage: ( localize(1739, "Next Edit Suggestion"))
+            announcementMessage: ( localize(1754, "Next Edit Suggestion"))
         });
     }
     static {
         this.terminalQuickFix = AccessibilitySignal.register({
-            name: ( localize(1740, "Terminal Quick Fix")),
+            name: ( localize(1755, "Terminal Quick Fix")),
             sound: Sound.quickFixes,
             legacySoundSettingsKey: "audioCues.terminalQuickFix",
             legacyAnnouncementSettingsKey: "accessibility.alert.terminalQuickFix",
-            announcementMessage: ( localize(1741, "Quick Fix")),
+            announcementMessage: ( localize(1756, "Quick Fix")),
             settingsKey: "accessibility.signals.terminalQuickFix"
         });
     }
     static {
         this.onDebugBreak = AccessibilitySignal.register({
-            name: ( localize(1742, "Debugger Stopped on Breakpoint")),
+            name: ( localize(1757, "Debugger Stopped on Breakpoint")),
             sound: Sound.break,
             legacySoundSettingsKey: "audioCues.onDebugBreak",
             legacyAnnouncementSettingsKey: "accessibility.alert.onDebugBreak",
-            announcementMessage: ( localize(1743, "Breakpoint")),
+            announcementMessage: ( localize(1758, "Breakpoint")),
             settingsKey: "accessibility.signals.onDebugBreak"
         });
     }
     static {
         this.noInlayHints = AccessibilitySignal.register({
-            name: ( localize(1744, "No Inlay Hints on Line")),
+            name: ( localize(1759, "No Inlay Hints on Line")),
             sound: Sound.error,
             legacySoundSettingsKey: "audioCues.noInlayHints",
             legacyAnnouncementSettingsKey: "accessibility.alert.noInlayHints",
-            announcementMessage: ( localize(1745, "No Inlay Hints")),
+            announcementMessage: ( localize(1760, "No Inlay Hints")),
             settingsKey: "accessibility.signals.noInlayHints"
         });
     }
     static {
         this.taskCompleted = AccessibilitySignal.register({
-            name: ( localize(1746, "Task Completed")),
+            name: ( localize(1761, "Task Completed")),
             sound: Sound.taskCompleted,
             legacySoundSettingsKey: "audioCues.taskCompleted",
             legacyAnnouncementSettingsKey: "accessibility.alert.taskCompleted",
-            announcementMessage: ( localize(1747, "Task Completed")),
+            announcementMessage: ( localize(1762, "Task Completed")),
             settingsKey: "accessibility.signals.taskCompleted"
         });
     }
     static {
         this.taskFailed = AccessibilitySignal.register({
-            name: ( localize(1748, "Task Failed")),
+            name: ( localize(1763, "Task Failed")),
             sound: Sound.taskFailed,
             legacySoundSettingsKey: "audioCues.taskFailed",
             legacyAnnouncementSettingsKey: "accessibility.alert.taskFailed",
-            announcementMessage: ( localize(1749, "Task Failed")),
+            announcementMessage: ( localize(1764, "Task Failed")),
             settingsKey: "accessibility.signals.taskFailed"
         });
     }
     static {
         this.terminalCommandFailed = AccessibilitySignal.register({
-            name: ( localize(1750, "Terminal Command Failed")),
+            name: ( localize(1765, "Terminal Command Failed")),
             sound: Sound.error,
             legacySoundSettingsKey: "audioCues.terminalCommandFailed",
             legacyAnnouncementSettingsKey: "accessibility.alert.terminalCommandFailed",
-            announcementMessage: ( localize(1751, "Command Failed")),
+            announcementMessage: ( localize(1766, "Command Failed")),
             settingsKey: "accessibility.signals.terminalCommandFailed"
         });
     }
     static {
         this.terminalCommandSucceeded = AccessibilitySignal.register({
-            name: ( localize(1752, "Terminal Command Succeeded")),
+            name: ( localize(1767, "Terminal Command Succeeded")),
             sound: Sound.terminalCommandSucceeded,
-            announcementMessage: ( localize(1753, "Command Succeeded")),
+            announcementMessage: ( localize(1768, "Command Succeeded")),
             settingsKey: "accessibility.signals.terminalCommandSucceeded"
         });
     }
     static {
         this.terminalBell = AccessibilitySignal.register({
-            name: ( localize(1754, "Terminal Bell")),
+            name: ( localize(1769, "Terminal Bell")),
             sound: Sound.terminalBell,
             legacySoundSettingsKey: "audioCues.terminalBell",
             legacyAnnouncementSettingsKey: "accessibility.alert.terminalBell",
-            announcementMessage: ( localize(1755, "Terminal Bell")),
+            announcementMessage: ( localize(1770, "Terminal Bell")),
             settingsKey: "accessibility.signals.terminalBell"
         });
     }
     static {
         this.notebookCellCompleted = AccessibilitySignal.register({
-            name: ( localize(1756, "Notebook Cell Completed")),
+            name: ( localize(1771, "Notebook Cell Completed")),
             sound: Sound.taskCompleted,
             legacySoundSettingsKey: "audioCues.notebookCellCompleted",
             legacyAnnouncementSettingsKey: "accessibility.alert.notebookCellCompleted",
-            announcementMessage: ( localize(1757, "Notebook Cell Completed")),
+            announcementMessage: ( localize(1772, "Notebook Cell Completed")),
             settingsKey: "accessibility.signals.notebookCellCompleted"
         });
     }
     static {
         this.notebookCellFailed = AccessibilitySignal.register({
-            name: ( localize(1758, "Notebook Cell Failed")),
+            name: ( localize(1773, "Notebook Cell Failed")),
             sound: Sound.taskFailed,
             legacySoundSettingsKey: "audioCues.notebookCellFailed",
             legacyAnnouncementSettingsKey: "accessibility.alert.notebookCellFailed",
-            announcementMessage: ( localize(1759, "Notebook Cell Failed")),
+            announcementMessage: ( localize(1774, "Notebook Cell Failed")),
             settingsKey: "accessibility.signals.notebookCellFailed"
         });
     }
     static {
         this.diffLineInserted = AccessibilitySignal.register({
-            name: ( localize(1760, "Diff Line Inserted")),
+            name: ( localize(1775, "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(1761, "Diff Line Deleted")),
+            name: ( localize(1776, "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(1762, "Diff Line Modified")),
+            name: ( localize(1777, "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(1763, "Chat Edit Modified File")),
+            name: ( localize(1778, "Chat Edit Modified File")),
             sound: Sound.chatEditModifiedFile,
-            announcementMessage: ( localize(1764, "File Modified from Chat Edits")),
+            announcementMessage: ( localize(1779, "File Modified from Chat Edits")),
             settingsKey: "accessibility.signals.chatEditModifiedFile"
         });
     }
     static {
         this.chatRequestSent = AccessibilitySignal.register({
-            name: ( localize(1765, "Chat Request Sent")),
+            name: ( localize(1780, "Chat Request Sent")),
             sound: Sound.requestSent,
             legacySoundSettingsKey: "audioCues.chatRequestSent",
             legacyAnnouncementSettingsKey: "accessibility.alert.chatRequestSent",
-            announcementMessage: ( localize(1766, "Chat Request Sent")),
+            announcementMessage: ( localize(1781, "Chat Request Sent")),
             settingsKey: "accessibility.signals.chatRequestSent"
         });
     }
     static {
         this.chatResponseReceived = AccessibilitySignal.register({
-            name: ( localize(1767, "Chat Response Received")),
+            name: ( localize(1782, "Chat Response Received")),
             legacySoundSettingsKey: "audioCues.chatResponseReceived",
             sound: {
                 randomOneOf: [
@@ -668,17 +668,17 @@ class AccessibilitySignal {
     }
     static {
         this.codeActionTriggered = AccessibilitySignal.register({
-            name: ( localize(1768, "Code Action Request Triggered")),
+            name: ( localize(1783, "Code Action Request Triggered")),
             sound: Sound.codeActionTriggered,
             legacySoundSettingsKey: "audioCues.codeActionRequestTriggered",
             legacyAnnouncementSettingsKey: "accessibility.alert.codeActionRequestTriggered",
-            announcementMessage: ( localize(1769, "Code Action Request Triggered")),
+            announcementMessage: ( localize(1784, "Code Action Request Triggered")),
             settingsKey: "accessibility.signals.codeActionTriggered"
         });
     }
     static {
         this.codeActionApplied = AccessibilitySignal.register({
-            name: ( localize(1770, "Code Action Applied")),
+            name: ( localize(1785, "Code Action Applied")),
             legacySoundSettingsKey: "audioCues.codeActionApplied",
             sound: Sound.codeActionApplied,
             settingsKey: "accessibility.signals.codeActionApplied"
@@ -686,81 +686,97 @@ class AccessibilitySignal {
     }
     static {
         this.progress = AccessibilitySignal.register({
-            name: ( localize(1771, "Progress")),
+            name: ( localize(1786, "Progress")),
             sound: Sound.progress,
             legacySoundSettingsKey: "audioCues.chatResponsePending",
             legacyAnnouncementSettingsKey: "accessibility.alert.progress",
-            announcementMessage: ( localize(1772, "Progress")),
+            announcementMessage: ( localize(1787, "Progress")),
             settingsKey: "accessibility.signals.progress"
         });
     }
     static {
         this.clear = AccessibilitySignal.register({
-            name: ( localize(1773, "Clear")),
+            name: ( localize(1788, "Clear")),
             sound: Sound.clear,
             legacySoundSettingsKey: "audioCues.clear",
             legacyAnnouncementSettingsKey: "accessibility.alert.clear",
-            announcementMessage: ( localize(1774, "Clear")),
+            announcementMessage: ( localize(1789, "Clear")),
             settingsKey: "accessibility.signals.clear"
         });
     }
     static {
         this.save = AccessibilitySignal.register({
-            name: ( localize(1775, "Save")),
+            name: ( localize(1790, "Save")),
             sound: Sound.save,
             legacySoundSettingsKey: "audioCues.save",
             legacyAnnouncementSettingsKey: "accessibility.alert.save",
-            announcementMessage: ( localize(1776, "Save")),
+            announcementMessage: ( localize(1791, "Save")),
             settingsKey: "accessibility.signals.save"
         });
     }
     static {
         this.format = AccessibilitySignal.register({
-            name: ( localize(1777, "Format")),
+            name: ( localize(1792, "Format")),
             sound: Sound.format,
             legacySoundSettingsKey: "audioCues.format",
             legacyAnnouncementSettingsKey: "accessibility.alert.format",
-            announcementMessage: ( localize(1778, "Format")),
+            announcementMessage: ( localize(1793, "Format")),
             settingsKey: "accessibility.signals.format"
         });
     }
     static {
         this.voiceRecordingStarted = AccessibilitySignal.register({
-            name: ( localize(1779, "Voice Recording Started")),
+            name: ( localize(1794, "Voice Recording Started")),
             sound: Sound.voiceRecordingStarted,
             legacySoundSettingsKey: "audioCues.voiceRecordingStarted",
             settingsKey: "accessibility.signals.voiceRecordingStarted"
         });
     }
+    static {
+        this.voiceModeStarted = AccessibilitySignal.register({
+            name: ( localize(1795, "Voice Mode Started")),
+            sound: Sound.voiceRecordingStarted,
+            announcementMessage: ( localize(1796, "Voice Mode Started")),
+            settingsKey: "accessibility.signals.voiceModeStarted"
+        });
+    }
     static {
         this.voiceRecordingStopped = AccessibilitySignal.register({
-            name: ( localize(1780, "Voice Recording Stopped")),
+            name: ( localize(1797, "Voice Recording Stopped")),
             sound: Sound.voiceRecordingStopped,
             legacySoundSettingsKey: "audioCues.voiceRecordingStopped",
             settingsKey: "accessibility.signals.voiceRecordingStopped"
         });
     }
+    static {
+        this.voiceModeStopped = AccessibilitySignal.register({
+            name: ( localize(1798, "Voice Mode Stopped")),
+            sound: Sound.voiceRecordingStopped,
+            announcementMessage: ( localize(1799, "Voice Mode Stopped")),
+            settingsKey: "accessibility.signals.voiceModeStopped"
+        });
+    }
     static {
         this.editsKept = AccessibilitySignal.register({
-            name: ( localize(1781, "Edits Kept")),
+            name: ( localize(1800, "Edits Kept")),
             sound: Sound.editsKept,
-            announcementMessage: ( localize(1782, "Edits Kept")),
+            announcementMessage: ( localize(1801, "Edits Kept")),
             settingsKey: "accessibility.signals.editsKept"
         });
     }
     static {
         this.editsUndone = AccessibilitySignal.register({
-            name: ( localize(1783, "Undo Edits")),
+            name: ( localize(1802, "Undo Edits")),
             sound: Sound.editsUndone,
-            announcementMessage: ( localize(1784, "Edits Undone")),
+            announcementMessage: ( localize(1803, "Edits Undone")),
             settingsKey: "accessibility.signals.editsUndone"
         });
     }
     static {
         this.chatUserActionRequired = AccessibilitySignal.register({
-            name: ( localize(1785, "Chat User Action Required")),
+            name: ( localize(1804, "Chat User Action Required")),
             sound: Sound.chatUserActionRequired,
-            announcementMessage: ( localize(1786, "Chat User Action Required")),
+            announcementMessage: ( localize(1805, "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(1787, "View")),
-    Help: ( localize2(1788, "Help")),
-    Test: ( localize2(1789, "Test")),
-    File: ( localize2(1790, "File")),
-    Preferences: ( localize2(1791, "Preferences")),
-    Developer: ( localize2(1792, "Developer"))
+    View: ( localize2(1806, "View")),
+    Help: ( localize2(1807, "Help")),
+    Test: ( localize2(1808, "Test")),
+    File: ( localize2(1809, "File")),
+    Preferences: ( localize2(1810, "Preferences")),
+    Developer: ( localize2(1811, "Developer"))
 }));
 
 export { Categories };