@codingame/monaco-vscode-api 11.0.1 → 11.1.0

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

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

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

@@ -1,12 +1,12 @@
 import { localize2 } from '../../../nls.js';
 
 const Categories = ( (Object.freeze({
-    View: ( localize2(4499, 'View')),
-    Help: ( localize2(4500, 'Help')),
-    Test: ( localize2(4501, 'Test')),
-    File: ( localize2(4502, 'File')),
-    Preferences: ( localize2(4503, 'Preferences')),
-    Developer: ( localize2(4504, "Developer")),
+    View: ( localize2(4485, 'View')),
+    Help: ( localize2(4486, 'Help')),
+    Test: ( localize2(4487, 'Test')),
+    File: ( localize2(4488, 'File')),
+    Preferences: ( localize2(4489, 'Preferences')),
+    Developer: ( localize2(4490, "Developer")),
 })));
 
 export { Categories };

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

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

package/vscode/src/vs/platform/configuration/common/configurationModels.js

@@ -372,10 +372,14 @@ class ConfigurationModelParser {
             }
             else {
                 const propertySchema = configurationProperties[key];
+                const scope = propertySchema ? typeof propertySchema.scope !== 'undefined' ? propertySchema.scope : 3  : undefined;
                 if (propertySchema?.restricted) {
                     restricted.push(key);
                 }
-                if (this.shouldInclude(key, propertySchema, options)) {
+                if (!options.exclude?.includes(key)
+                    && (options.include?.includes(key)
+                        || ((scope === undefined || options.scopes === undefined || options.scopes.includes(scope))
+                            && !(options.skipRestricted && propertySchema?.restricted))))  {
                     raw[key] = properties[key];
                 }
                 else {
@@ -385,25 +389,6 @@ class ConfigurationModelParser {
         }
         return { raw, restricted, hasExcludedProperties };
     }
-    shouldInclude(key, propertySchema, options) {
-        if (options.exclude?.includes(key)) {
-            return false;
-        }
-        if (options.include?.includes(key)) {
-            return true;
-        }
-        if (options.skipRestricted && propertySchema?.restricted) {
-            return false;
-        }
-        if (options.skipUnregistered && !propertySchema) {
-            return false;
-        }
-        const scope = propertySchema ? typeof propertySchema.scope !== 'undefined' ? propertySchema.scope : 3  : undefined;
-        if (scope === undefined || options.scopes === undefined) {
-            return true;
-        }
-        return options.scopes.includes(scope);
-    }
     toOverrides(raw, conflictReporter) {
         const overrides = [];
         for (const key of ( Object.keys(raw))) {

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

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

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

@@ -98,7 +98,7 @@ function createFileSystemProviderError(error, code) {
 }
 function ensureFileSystemProviderError(error) {
     if (!error) {
-        return createFileSystemProviderError(( localize(0, "Unknown Error")), FileSystemProviderErrorCode.Unknown);
+        return createFileSystemProviderError(( localize(2, "Unknown Error")), FileSystemProviderErrorCode.Unknown);
     }
     return error;
 }
@@ -347,18 +347,18 @@ class ByteSize {
             size = 0;
         }
         if (size < ByteSize.KB) {
-            return ( localize(1, "{0}B", size.toFixed(0)));
+            return ( localize(3, "{0}B", size.toFixed(0)));
         }
         if (size < ByteSize.MB) {
-            return ( localize(2, "{0}KB", (size / ByteSize.KB).toFixed(2)));
+            return ( localize(4, "{0}KB", (size / ByteSize.KB).toFixed(2)));
         }
         if (size < ByteSize.GB) {
-            return ( localize(3, "{0}MB", (size / ByteSize.MB).toFixed(2)));
+            return ( localize(5, "{0}MB", (size / ByteSize.MB).toFixed(2)));
         }
         if (size < ByteSize.TB) {
-            return ( localize(4, "{0}GB", (size / ByteSize.GB).toFixed(2)));
+            return ( localize(6, "{0}GB", (size / ByteSize.GB).toFixed(2)));
         }
-        return ( localize(5, "{0}TB", (size / ByteSize.TB).toFixed(2)));
+        return ( localize(7, "{0}TB", (size / ByteSize.TB).toFixed(2)));
     }
 }
 function getLargeFileConfirmationLimit(arg) {

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

@@ -48,7 +48,7 @@ let LanguagePackBaseService = class LanguagePackBaseService extends Disposable {
         }
         if (locale.toLowerCase() === language.toLowerCase()) {
             description ??= '';
-            description += ( localize(3283, " (Current)"));
+            description += ( localize(3286, " (Current)"));
         }
         if (languagePack?.installCount) {
             description ??= '';

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

@@ -393,12 +393,12 @@ function LogLevelToString(logLevel) {
 }
 function LogLevelToLocalizedString(logLevel) {
     switch (logLevel) {
-        case LogLevel.Trace: return { original: 'Trace', value: ( localize(69, "Trace")) };
-        case LogLevel.Debug: return { original: 'Debug', value: ( localize(70, "Debug")) };
-        case LogLevel.Info: return { original: 'Info', value: ( localize(71, "Info")) };
-        case LogLevel.Warning: return { original: 'Warning', value: ( localize(72, "Warning")) };
-        case LogLevel.Error: return { original: 'Error', value: ( localize(73, "Error")) };
-        case LogLevel.Off: return { original: 'Off', value: ( localize(74, "Off")) };
+        case LogLevel.Trace: return { original: 'Trace', value: ( localize(71, "Trace")) };
+        case LogLevel.Debug: return { original: 'Debug', value: ( localize(72, "Debug")) };
+        case LogLevel.Info: return { original: 'Info', value: ( localize(73, "Info")) };
+        case LogLevel.Warning: return { original: 'Warning', value: ( localize(74, "Warning")) };
+        case LogLevel.Error: return { original: 'Error', value: ( localize(75, "Error")) };
+        case LogLevel.Off: return { original: 'Off', value: ( localize(76, "Off")) };
     }
 }
 function parseLogLevel(logLevel) {

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

@@ -14,9 +14,9 @@ var MarkerSeverity;
     }
     MarkerSeverity.compare = compare;
     const _displayStrings = Object.create(null);
-    _displayStrings[MarkerSeverity.Error] = ( localize(4572, "Error"));
-    _displayStrings[MarkerSeverity.Warning] = ( localize(4573, "Warning"));
-    _displayStrings[MarkerSeverity.Info] = ( localize(4574, "Info"));
+    _displayStrings[MarkerSeverity.Error] = ( localize(4644, "Error"));
+    _displayStrings[MarkerSeverity.Warning] = ( localize(4645, "Warning"));
+    _displayStrings[MarkerSeverity.Info] = ( localize(4646, "Info"));
     function toString(a) {
         return _displayStrings[a] || '';
     }

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

@@ -90,7 +90,7 @@ function registerProxyConfigurations(scope) {
     proxyConfiguration = {
         id: 'http',
         order: 15,
-        title: ( localize(4585, "HTTP")),
+        title: ( localize(4649, "HTTP")),
         type: 'object',
         scope,
         properties: {
@@ -98,7 +98,7 @@ function registerProxyConfigurations(scope) {
                 type: 'string',
                 pattern: '^(https?|socks|socks4a?|socks5h?)://([^:]*(:[^@]*)?@)?([^:]+|\\[[:0-9a-fA-F]+\\])(:\\d+)?/?$|^$',
                 markdownDescription: ( localize(
-                    4586,
+                    4650,
                     "The proxy setting to use. If not set, will be inherited from the `http_proxy` and `https_proxy` environment variables."
                 )),
                 restricted: true
@@ -107,7 +107,7 @@ function registerProxyConfigurations(scope) {
                 type: 'boolean',
                 default: true,
                 description: ( localize(
-                    4587,
+                    4651,
                     "Controls whether the proxy server certificate should be verified against the list of supplied CAs."
                 )),
                 restricted: true
@@ -115,7 +115,7 @@ function registerProxyConfigurations(scope) {
             'http.proxyKerberosServicePrincipal': {
                 type: 'string',
                 markdownDescription: ( localize(
-                    4588,
+                    4652,
                     "Overrides the principal service name for Kerberos authentication with the HTTP proxy. A default based on the proxy hostname is used when this is not set."
                 )),
                 restricted: true
@@ -124,7 +124,7 @@ function registerProxyConfigurations(scope) {
                 type: 'array',
                 items: { type: 'string' },
                 markdownDescription: ( localize(
-                    4589,
+                    4653,
                     "Specifies domain names for which proxy settings should be ignored for HTTP/HTTPS requests."
                 )),
                 restricted: true
@@ -133,7 +133,7 @@ function registerProxyConfigurations(scope) {
                 type: ['null', 'string'],
                 default: null,
                 markdownDescription: ( localize(
-                    4590,
+                    4654,
                     "The value to send as the `Proxy-Authorization` header for every network request."
                 )),
                 restricted: true
@@ -142,23 +142,23 @@ function registerProxyConfigurations(scope) {
                 type: 'string',
                 enum: ['off', 'on', 'fallback', 'override'],
                 enumDescriptions: [
-                    ( localize(4591, "Disable proxy support for extensions.")),
-                    ( localize(4592, "Enable proxy support for extensions.")),
+                    ( localize(4655, "Disable proxy support for extensions.")),
+                    ( localize(4656, "Enable proxy support for extensions.")),
                     ( localize(
-                        4593,
+                        4657,
                         "Enable proxy support for extensions, fall back to request options, when no proxy found."
                     )),
-                    ( localize(4594, "Enable proxy support for extensions, override request options.")),
+                    ( localize(4658, "Enable proxy support for extensions, override request options.")),
                 ],
                 default: 'override',
-                description: ( localize(4595, "Use the proxy support for extensions.")),
+                description: ( localize(4659, "Use the proxy support for extensions.")),
                 restricted: true
             },
             'http.systemCertificates': {
                 type: 'boolean',
                 default: true,
                 description: ( localize(
-                    4596,
+                    4660,
                     "Controls whether CA certificates should be loaded from the OS. (On Windows and macOS, a reload of the window is required after turning this off.)"
                 )),
                 restricted: true
@@ -168,7 +168,7 @@ function registerProxyConfigurations(scope) {
                 tags: ['experimental'],
                 default: false,
                 description: ( localize(
-                    4597,
+                    4661,
                     "Controls whether experimental loading of CA certificates from the OS should be enabled. This uses a more general approach than the default implementation."
                 )),
                 restricted: true
@@ -177,7 +177,7 @@ function registerProxyConfigurations(scope) {
                 type: 'boolean',
                 default: false,
                 description: ( localize(
-                    4598,
+                    4662,
                     "Controls whether use of Electron's fetch implementation instead of Node.js' should be enabled. All local extensions will get Electron's fetch implementation for the global fetch API."
                 )),
                 restricted: true

package/vscode/src/vs/platform/theme/common/iconRegistry.js

@@ -49,10 +49,10 @@ class IconRegistry {
                     type: 'object',
                     properties: {
                         fontId: { type: 'string', description: ( localize(
-                            4473,
+                            4551,
                             'The id of the font to use. If not set, the font that is defined first is used.'
                         )) },
-                        fontCharacter: { type: 'string', description: ( localize(4474, 'The font character associated with the icon definition.')) }
+                        fontCharacter: { type: 'string', description: ( localize(4552, 'The font character associated with the icon definition.')) }
                     },
                     additionalProperties: false,
                     defaultSnippets: [{ body: { fontCharacter: '\\\\e030' } }]
@@ -183,9 +183,9 @@ iconRegistry.onDidChange(() => {
         delayer.schedule();
     }
 });
-const widgetClose = registerIcon('widget-close', Codicon.close, ( localize(4475, 'Icon for the close action in widgets.')));
-const gotoPreviousLocation = registerIcon('goto-previous-location', Codicon.arrowUp, ( localize(4476, 'Icon for goto previous editor location.')));
-const gotoNextLocation = registerIcon('goto-next-location', Codicon.arrowDown, ( localize(4477, 'Icon for goto next editor location.')));
+const widgetClose = registerIcon('widget-close', Codicon.close, ( localize(4553, 'Icon for the close action in widgets.')));
+const gotoPreviousLocation = registerIcon('goto-previous-location', Codicon.arrowUp, ( localize(4554, 'Icon for goto previous editor location.')));
+const gotoNextLocation = registerIcon('goto-next-location', Codicon.arrowDown, ( localize(4555, 'Icon for goto next editor location.')));
 const syncing = ThemeIcon.modify(Codicon.sync, 'spin');
 const spinningLoading = ThemeIcon.modify(Codicon.loading, 'spin');