@codingame/monaco-vscode-api 11.0.0 → 11.0.2

package/vscode/src/vs/editor/common/config/editorConfigurationSchema.js

@@ -9,7 +9,7 @@ const editorConfigurationBaseNode = ( (Object.freeze({
     id: 'editor',
     order: 5,
     type: 'object',
-    title: ( localize(690, "Editor")),
+    title: ( localize(1192, "Editor")),
     scope: 5 ,
 })));
 const editorConfiguration = {
@@ -20,7 +20,7 @@ const editorConfiguration = {
             default: EDITOR_MODEL_DEFAULTS.tabSize,
             minimum: 1,
             markdownDescription: ( localize(
-                691,
+                1193,
                 "The number of spaces a tab is equal to. This setting is overridden based on the file contents when {0} is on.",
                 '`#editor.detectIndentation#`'
             ))
@@ -38,7 +38,7 @@ const editorConfiguration = {
             ],
             default: 'tabSize',
             markdownDescription: ( localize(
-                692,
+                1194,
                 "The number of spaces used for indentation or `\"tabSize\"` to use the value from `#editor.tabSize#`. This setting is overridden based on the file contents when `#editor.detectIndentation#` is on."
             ))
         },
@@ -46,7 +46,7 @@ const editorConfiguration = {
             type: 'boolean',
             default: EDITOR_MODEL_DEFAULTS.insertSpaces,
             markdownDescription: ( localize(
-                693,
+                1195,
                 "Insert spaces when pressing `Tab`. This setting is overridden based on the file contents when {0} is on.",
                 '`#editor.detectIndentation#`'
             ))
@@ -55,7 +55,7 @@ const editorConfiguration = {
             type: 'boolean',
             default: EDITOR_MODEL_DEFAULTS.detectIndentation,
             markdownDescription: ( localize(
-                694,
+                1196,
                 "Controls whether {0} and {1} will be automatically detected when a file is opened based on the file contents.",
                 '`#editor.tabSize#`',
                 '`#editor.insertSpaces#`'
@@ -64,13 +64,13 @@ const editorConfiguration = {
         'editor.trimAutoWhitespace': {
             type: 'boolean',
             default: EDITOR_MODEL_DEFAULTS.trimAutoWhitespace,
-            description: ( localize(695, "Remove trailing auto inserted whitespace."))
+            description: ( localize(1197, "Remove trailing auto inserted whitespace."))
         },
         'editor.largeFileOptimizations': {
             type: 'boolean',
             default: EDITOR_MODEL_DEFAULTS.largeFileOptimizations,
             description: ( localize(
-                696,
+                1198,
                 "Special handling for large files to disable certain memory intensive features."
             ))
         },
@@ -78,29 +78,29 @@ const editorConfiguration = {
             enum: ['off', 'currentDocument', 'matchingDocuments', 'allDocuments'],
             default: 'matchingDocuments',
             enumDescriptions: [
-                ( localize(697, 'Turn off Word Based Suggestions.')),
-                ( localize(698, 'Only suggest words from the active document.')),
-                ( localize(699, 'Suggest words from all open documents of the same language.')),
-                ( localize(700, 'Suggest words from all open documents.'))
+                ( localize(1199, 'Turn off Word Based Suggestions.')),
+                ( localize(1200, 'Only suggest words from the active document.')),
+                ( localize(1201, 'Suggest words from all open documents of the same language.')),
+                ( localize(1202, 'Suggest words from all open documents.'))
             ],
             description: ( localize(
-                701,
+                1203,
                 "Controls whether completions should be computed based on words in the document and from which documents they are computed."
             ))
         },
         'editor.semanticHighlighting.enabled': {
             enum: [true, false, 'configuredByTheme'],
             enumDescriptions: [
-                ( localize(702, 'Semantic highlighting enabled for all color themes.')),
-                ( localize(703, 'Semantic highlighting disabled for all color themes.')),
+                ( localize(1204, 'Semantic highlighting enabled for all color themes.')),
+                ( localize(1205, 'Semantic highlighting disabled for all color themes.')),
                 ( localize(
-                    704,
+                    1206,
                     'Semantic highlighting is configured by the current color theme\'s `semanticHighlighting` setting.'
                 ))
             ],
             default: 'configuredByTheme',
             description: ( localize(
-                705,
+                1207,
                 "Controls whether the semanticHighlighting is shown for the languages that support it."
             ))
         },
@@ -108,7 +108,7 @@ const editorConfiguration = {
             type: 'boolean',
             default: false,
             markdownDescription: ( localize(
-                706,
+                1208,
                 "Keep peek editors open even when double-clicking their content or when hitting `Escape`."
             ))
         },
@@ -116,7 +116,7 @@ const editorConfiguration = {
             type: 'integer',
             default: 20_000,
             description: ( localize(
-                707,
+                1209,
                 "Lines above this length will not be tokenized for performance reasons"
             ))
         },
@@ -124,7 +124,7 @@ const editorConfiguration = {
             type: 'boolean',
             default: true,
             description: ( localize(
-                708,
+                1210,
                 "Controls whether the tokenization should happen asynchronously on a web worker."
             )),
             tags: ['experimental'],
@@ -133,7 +133,7 @@ const editorConfiguration = {
             type: 'boolean',
             default: false,
             description: ( localize(
-                709,
+                1211,
                 "Controls whether async tokenization should be logged. For debugging only."
             )),
         },
@@ -141,7 +141,7 @@ const editorConfiguration = {
             type: 'boolean',
             default: false,
             description: ( localize(
-                710,
+                1212,
                 "Controls whether async tokenization should be verified against legacy background tokenization. Might slow down tokenization. For debugging only."
             )),
             tags: ['experimental'],
@@ -150,7 +150,7 @@ const editorConfiguration = {
             type: 'boolean',
             default: false,
             markdownDescription: ( localize(
-                711,
+                1213,
                 "Controls whether tree sitter parsing should be turned on and telemetry collected. Setting `editor.experimental.preferTreeSitter` for specific languages will take precedence."
             )),
             tags: ['experimental', 'onExP']
@@ -163,7 +163,7 @@ const editorConfiguration = {
             },
             default: [],
             markdownDescription: ( localize(
-                712,
+                1214,
                 "Controls whether tree sitter parsing should be turned on for specific languages. This will take precedence over `editor.experimental.treeSitterTelemetry` for the specified languages."
             )),
             tags: ['experimental']
@@ -172,7 +172,7 @@ const editorConfiguration = {
             type: ['array', 'null'],
             default: null,
             description: ( localize(
-                713,
+                1215,
                 'Defines the bracket symbols that increase or decrease the indentation.'
             )),
             items: {
@@ -180,11 +180,11 @@ const editorConfiguration = {
                 items: [
                     {
                         type: 'string',
-                        description: ( localize(714, 'The opening bracket character or string sequence.'))
+                        description: ( localize(1216, 'The opening bracket character or string sequence.'))
                     },
                     {
                         type: 'string',
-                        description: ( localize(715, 'The closing bracket character or string sequence.'))
+                        description: ( localize(1217, 'The closing bracket character or string sequence.'))
                     }
                 ]
             }
@@ -193,7 +193,7 @@ const editorConfiguration = {
             type: ['array', 'null'],
             default: null,
             description: ( localize(
-                716,
+                1218,
                 'Defines the bracket pairs that are colorized by their nesting level if bracket pair colorization is enabled.'
             )),
             items: {
@@ -201,11 +201,11 @@ const editorConfiguration = {
                 items: [
                     {
                         type: 'string',
-                        description: ( localize(714, 'The opening bracket character or string sequence.'))
+                        description: ( localize(1216, 'The opening bracket character or string sequence.'))
                     },
                     {
                         type: 'string',
-                        description: ( localize(715, 'The closing bracket character or string sequence.'))
+                        description: ( localize(1217, 'The closing bracket character or string sequence.'))
                     }
                 ]
             }
@@ -214,7 +214,7 @@ const editorConfiguration = {
             type: 'number',
             default: diffEditorDefaultOptions.maxComputationTime,
             description: ( localize(
-                717,
+                1219,
                 "Timeout in milliseconds after which diff computation is cancelled. Use 0 for no timeout."
             ))
         },
@@ -222,7 +222,7 @@ const editorConfiguration = {
             type: 'number',
             default: diffEditorDefaultOptions.maxFileSize,
             description: ( localize(
-                718,
+                1220,
                 "Maximum file size in MB for which to compute diffs. Use 0 for no limit."
             ))
         },
@@ -230,7 +230,7 @@ const editorConfiguration = {
             type: 'boolean',
             default: diffEditorDefaultOptions.renderSideBySide,
             description: ( localize(
-                719,
+                1221,
                 "Controls whether the diff editor shows the diff side by side or inline."
             ))
         },
@@ -238,7 +238,7 @@ const editorConfiguration = {
             type: 'number',
             default: diffEditorDefaultOptions.renderSideBySideInlineBreakpoint,
             description: ( localize(
-                720,
+                1222,
                 "If the diff editor width is smaller than this value, the inline view is used."
             ))
         },
@@ -246,7 +246,7 @@ const editorConfiguration = {
             type: 'boolean',
             default: diffEditorDefaultOptions.useInlineViewWhenSpaceIsLimited,
             description: ( localize(
-                721,
+                1223,
                 "If enabled and the editor width is too small, the inline view is used."
             ))
         },
@@ -254,7 +254,7 @@ const editorConfiguration = {
             type: 'boolean',
             default: diffEditorDefaultOptions.renderMarginRevertIcon,
             description: ( localize(
-                722,
+                1224,
                 "When enabled, the diff editor shows arrows in its glyph margin to revert changes."
             ))
         },
@@ -262,7 +262,7 @@ const editorConfiguration = {
             type: 'boolean',
             default: diffEditorDefaultOptions.renderGutterMenu,
             description: ( localize(
-                723,
+                1225,
                 "When enabled, the diff editor shows a special gutter for revert and stage actions."
             ))
         },
@@ -270,7 +270,7 @@ const editorConfiguration = {
             type: 'boolean',
             default: diffEditorDefaultOptions.ignoreTrimWhitespace,
             description: ( localize(
-                724,
+                1226,
                 "When enabled, the diff editor ignores changes in leading or trailing whitespace."
             ))
         },
@@ -278,24 +278,24 @@ const editorConfiguration = {
             type: 'boolean',
             default: diffEditorDefaultOptions.renderIndicators,
             description: ( localize(
-                725,
+                1227,
                 "Controls whether the diff editor shows +/- indicators for added/removed changes."
             ))
         },
         'diffEditor.codeLens': {
             type: 'boolean',
             default: diffEditorDefaultOptions.diffCodeLens,
-            description: ( localize(726, "Controls whether the editor shows CodeLens."))
+            description: ( localize(1228, "Controls whether the editor shows CodeLens."))
         },
         'diffEditor.wordWrap': {
             type: 'string',
             enum: ['off', 'on', 'inherit'],
             default: diffEditorDefaultOptions.diffWordWrap,
             markdownEnumDescriptions: [
-                ( localize(727, "Lines will never wrap.")),
-                ( localize(728, "Lines will wrap at the viewport width.")),
+                ( localize(1229, "Lines will never wrap.")),
+                ( localize(1230, "Lines will wrap at the viewport width.")),
                 ( localize(
-                    729,
+                    1231,
                     "Lines will wrap according to the {0} setting.",
                     '`#editor.wordWrap#`'
                 )),
@@ -306,26 +306,26 @@ const editorConfiguration = {
             enum: ['legacy', 'advanced'],
             default: diffEditorDefaultOptions.diffAlgorithm,
             markdownEnumDescriptions: [
-                ( localize(730, "Uses the legacy diffing algorithm.")),
-                ( localize(731, "Uses the advanced diffing algorithm.")),
+                ( localize(1232, "Uses the legacy diffing algorithm.")),
+                ( localize(1233, "Uses the advanced diffing algorithm.")),
             ]
         },
         'diffEditor.hideUnchangedRegions.enabled': {
             type: 'boolean',
             default: diffEditorDefaultOptions.hideUnchangedRegions.enabled,
-            markdownDescription: ( localize(732, "Controls whether the diff editor shows unchanged regions.")),
+            markdownDescription: ( localize(1234, "Controls whether the diff editor shows unchanged regions.")),
         },
         'diffEditor.hideUnchangedRegions.revealLineCount': {
             type: 'integer',
             default: diffEditorDefaultOptions.hideUnchangedRegions.revealLineCount,
-            markdownDescription: ( localize(733, "Controls how many lines are used for unchanged regions.")),
+            markdownDescription: ( localize(1235, "Controls how many lines are used for unchanged regions.")),
             minimum: 1,
         },
         'diffEditor.hideUnchangedRegions.minimumLineCount': {
             type: 'integer',
             default: diffEditorDefaultOptions.hideUnchangedRegions.minimumLineCount,
             markdownDescription: ( localize(
-                734,
+                1236,
                 "Controls how many lines are used as a minimum for unchanged regions."
             )),
             minimum: 1,
@@ -334,7 +334,7 @@ const editorConfiguration = {
             type: 'integer',
             default: diffEditorDefaultOptions.hideUnchangedRegions.contextLineCount,
             markdownDescription: ( localize(
-                735,
+                1237,
                 "Controls how many lines are used as context when comparing unchanged regions."
             )),
             minimum: 1,
@@ -342,13 +342,13 @@ const editorConfiguration = {
         'diffEditor.experimental.showMoves': {
             type: 'boolean',
             default: diffEditorDefaultOptions.experimental.showMoves,
-            markdownDescription: ( localize(736, "Controls whether the diff editor should show detected code moves."))
+            markdownDescription: ( localize(1238, "Controls whether the diff editor should show detected code moves."))
         },
         'diffEditor.experimental.showEmptyDecorations': {
             type: 'boolean',
             default: diffEditorDefaultOptions.experimental.showEmptyDecorations,
             description: ( localize(
-                737,
+                1239,
                 "Controls whether the diff editor shows empty decorations to see where characters got inserted or deleted."
             )),
         },
@@ -356,7 +356,7 @@ const editorConfiguration = {
             type: 'boolean',
             default: diffEditorDefaultOptions.experimental.useTrueInlineView,
             description: ( localize(
-                738,
+                1240,
                 "If enabled and the editor uses the inline view, word changes are rendered inline."
             )),
         },

package/vscode/src/vs/editor/common/core/editorColorRegistry.js

@@ -13,174 +13,174 @@ import '../../../platform/theme/common/colors/quickpickColors.js';
 import '../../../platform/theme/common/colors/searchColors.js';
 import { registerThemingParticipant } from '../../../platform/theme/common/themeService.js';
 
-const editorLineHighlight = registerColor('editor.lineHighlightBackground', null, ( localize(4476, 'Background color for the highlight of line at the cursor position.')));
+const editorLineHighlight = registerColor('editor.lineHighlightBackground', null, ( localize(4906, 'Background color for the highlight of line at the cursor position.')));
 const editorLineHighlightBorder = registerColor('editor.lineHighlightBorder', { dark: '#282828', light: '#eeeeee', hcDark: '#f38518', hcLight: contrastBorder }, ( localize(
- 4477,
+ 4907,
  'Background color for the border around the line at the cursor position.'
 )));
 const editorRangeHighlight = registerColor('editor.rangeHighlightBackground', { dark: '#ffffff0b', light: '#fdff0033', hcDark: null, hcLight: null }, ( localize(
- 4478,
+ 4908,
  'Background color of highlighted ranges, like by quick open and find features. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
-registerColor('editor.rangeHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(4479, 'Background color of the border around highlighted ranges.')));
+registerColor('editor.rangeHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(4909, 'Background color of the border around highlighted ranges.')));
 registerColor('editor.symbolHighlightBackground', { dark: editorFindMatchHighlight, light: editorFindMatchHighlight, hcDark: null, hcLight: null }, ( localize(
- 4480,
+ 4910,
  'Background color of highlighted symbol, like for go to definition or go next/previous symbol. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
-registerColor('editor.symbolHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(4481, 'Background color of the border around highlighted symbols.')));
-const editorCursorForeground = registerColor('editorCursor.foreground', { dark: '#AEAFAD', light: Color.black, hcDark: Color.white, hcLight: '#0F4A85' }, ( localize(4482, 'Color of the editor cursor.')));
+registerColor('editor.symbolHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(4911, 'Background color of the border around highlighted symbols.')));
+const editorCursorForeground = registerColor('editorCursor.foreground', { dark: '#AEAFAD', light: Color.black, hcDark: Color.white, hcLight: '#0F4A85' }, ( localize(4912, 'Color of the editor cursor.')));
 const editorCursorBackground = registerColor('editorCursor.background', null, ( localize(
- 4483,
+ 4913,
  'The background color of the editor cursor. Allows customizing the color of a character overlapped by a block cursor.'
 )));
 const editorMultiCursorPrimaryForeground = registerColor('editorMultiCursor.primary.foreground', editorCursorForeground, ( localize(
- 4484,
+ 4914,
  'Color of the primary editor cursor when multiple cursors are present.'
 )));
 const editorMultiCursorPrimaryBackground = registerColor('editorMultiCursor.primary.background', editorCursorBackground, ( localize(
- 4485,
+ 4915,
  'The background color of the primary editor cursor when multiple cursors are present. Allows customizing the color of a character overlapped by a block cursor.'
 )));
 const editorMultiCursorSecondaryForeground = registerColor('editorMultiCursor.secondary.foreground', editorCursorForeground, ( localize(
- 4486,
+ 4916,
  'Color of secondary editor cursors when multiple cursors are present.'
 )));
 const editorMultiCursorSecondaryBackground = registerColor('editorMultiCursor.secondary.background', editorCursorBackground, ( localize(
- 4487,
+ 4917,
  'The background color of secondary editor cursors when multiple cursors are present. Allows customizing the color of a character overlapped by a block cursor.'
 )));
-const editorWhitespaces = registerColor('editorWhitespace.foreground', { dark: '#e3e4e229', light: '#33333333', hcDark: '#e3e4e229', hcLight: '#CCCCCC' }, ( localize(4488, 'Color of whitespace characters in the editor.')));
-const editorLineNumbers = registerColor('editorLineNumber.foreground', { dark: '#858585', light: '#237893', hcDark: Color.white, hcLight: '#292929' }, ( localize(4489, 'Color of editor line numbers.')));
-const deprecatedEditorIndentGuides = registerColor('editorIndentGuide.background', editorWhitespaces, ( localize(4490, 'Color of the editor indentation guides.')), false, ( localize(
- 4491,
+const editorWhitespaces = registerColor('editorWhitespace.foreground', { dark: '#e3e4e229', light: '#33333333', hcDark: '#e3e4e229', hcLight: '#CCCCCC' }, ( localize(4918, 'Color of whitespace characters in the editor.')));
+const editorLineNumbers = registerColor('editorLineNumber.foreground', { dark: '#858585', light: '#237893', hcDark: Color.white, hcLight: '#292929' }, ( localize(4919, 'Color of editor line numbers.')));
+const deprecatedEditorIndentGuides = registerColor('editorIndentGuide.background', editorWhitespaces, ( localize(4920, 'Color of the editor indentation guides.')), false, ( localize(
+ 4921,
  '\'editorIndentGuide.background\' is deprecated. Use \'editorIndentGuide.background1\' instead.'
 )));
-const deprecatedEditorActiveIndentGuides = registerColor('editorIndentGuide.activeBackground', editorWhitespaces, ( localize(4492, 'Color of the active editor indentation guides.')), false, ( localize(
- 4493,
+const deprecatedEditorActiveIndentGuides = registerColor('editorIndentGuide.activeBackground', editorWhitespaces, ( localize(4922, 'Color of the active editor indentation guides.')), false, ( localize(
+ 4923,
  '\'editorIndentGuide.activeBackground\' is deprecated. Use \'editorIndentGuide.activeBackground1\' instead.'
 )));
-const editorIndentGuide1 = registerColor('editorIndentGuide.background1', deprecatedEditorIndentGuides, ( localize(4494, 'Color of the editor indentation guides (1).')));
-const editorIndentGuide2 = registerColor('editorIndentGuide.background2', '#00000000', ( localize(4495, 'Color of the editor indentation guides (2).')));
-const editorIndentGuide3 = registerColor('editorIndentGuide.background3', '#00000000', ( localize(4496, 'Color of the editor indentation guides (3).')));
-const editorIndentGuide4 = registerColor('editorIndentGuide.background4', '#00000000', ( localize(4497, 'Color of the editor indentation guides (4).')));
-const editorIndentGuide5 = registerColor('editorIndentGuide.background5', '#00000000', ( localize(4498, 'Color of the editor indentation guides (5).')));
-const editorIndentGuide6 = registerColor('editorIndentGuide.background6', '#00000000', ( localize(4499, 'Color of the editor indentation guides (6).')));
-const editorActiveIndentGuide1 = registerColor('editorIndentGuide.activeBackground1', deprecatedEditorActiveIndentGuides, ( localize(4500, 'Color of the active editor indentation guides (1).')));
-const editorActiveIndentGuide2 = registerColor('editorIndentGuide.activeBackground2', '#00000000', ( localize(4501, 'Color of the active editor indentation guides (2).')));
-const editorActiveIndentGuide3 = registerColor('editorIndentGuide.activeBackground3', '#00000000', ( localize(4502, 'Color of the active editor indentation guides (3).')));
-const editorActiveIndentGuide4 = registerColor('editorIndentGuide.activeBackground4', '#00000000', ( localize(4503, 'Color of the active editor indentation guides (4).')));
-const editorActiveIndentGuide5 = registerColor('editorIndentGuide.activeBackground5', '#00000000', ( localize(4504, 'Color of the active editor indentation guides (5).')));
-const editorActiveIndentGuide6 = registerColor('editorIndentGuide.activeBackground6', '#00000000', ( localize(4505, 'Color of the active editor indentation guides (6).')));
-const deprecatedEditorActiveLineNumber = registerColor('editorActiveLineNumber.foreground', { dark: '#c6c6c6', light: '#0B216F', hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(4506, 'Color of editor active line number')), false, ( localize(
- 4507,
+const editorIndentGuide1 = registerColor('editorIndentGuide.background1', deprecatedEditorIndentGuides, ( localize(4924, 'Color of the editor indentation guides (1).')));
+const editorIndentGuide2 = registerColor('editorIndentGuide.background2', '#00000000', ( localize(4925, 'Color of the editor indentation guides (2).')));
+const editorIndentGuide3 = registerColor('editorIndentGuide.background3', '#00000000', ( localize(4926, 'Color of the editor indentation guides (3).')));
+const editorIndentGuide4 = registerColor('editorIndentGuide.background4', '#00000000', ( localize(4927, 'Color of the editor indentation guides (4).')));
+const editorIndentGuide5 = registerColor('editorIndentGuide.background5', '#00000000', ( localize(4928, 'Color of the editor indentation guides (5).')));
+const editorIndentGuide6 = registerColor('editorIndentGuide.background6', '#00000000', ( localize(4929, 'Color of the editor indentation guides (6).')));
+const editorActiveIndentGuide1 = registerColor('editorIndentGuide.activeBackground1', deprecatedEditorActiveIndentGuides, ( localize(4930, 'Color of the active editor indentation guides (1).')));
+const editorActiveIndentGuide2 = registerColor('editorIndentGuide.activeBackground2', '#00000000', ( localize(4931, 'Color of the active editor indentation guides (2).')));
+const editorActiveIndentGuide3 = registerColor('editorIndentGuide.activeBackground3', '#00000000', ( localize(4932, 'Color of the active editor indentation guides (3).')));
+const editorActiveIndentGuide4 = registerColor('editorIndentGuide.activeBackground4', '#00000000', ( localize(4933, 'Color of the active editor indentation guides (4).')));
+const editorActiveIndentGuide5 = registerColor('editorIndentGuide.activeBackground5', '#00000000', ( localize(4934, 'Color of the active editor indentation guides (5).')));
+const editorActiveIndentGuide6 = registerColor('editorIndentGuide.activeBackground6', '#00000000', ( localize(4935, 'Color of the active editor indentation guides (6).')));
+const deprecatedEditorActiveLineNumber = registerColor('editorActiveLineNumber.foreground', { dark: '#c6c6c6', light: '#0B216F', hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(4936, 'Color of editor active line number')), false, ( localize(
+ 4937,
  'Id is deprecated. Use \'editorLineNumber.activeForeground\' instead.'
 )));
-registerColor('editorLineNumber.activeForeground', deprecatedEditorActiveLineNumber, ( localize(4506, 'Color of editor active line number')));
+registerColor('editorLineNumber.activeForeground', deprecatedEditorActiveLineNumber, ( localize(4936, 'Color of editor active line number')));
 const editorDimmedLineNumber = registerColor('editorLineNumber.dimmedForeground', null, ( localize(
- 4508,
+ 4938,
  'Color of the final editor line when editor.renderFinalNewline is set to dimmed.'
 )));
-const editorRuler = registerColor('editorRuler.foreground', { dark: '#5A5A5A', light: Color.lightgrey, hcDark: Color.white, hcLight: '#292929' }, ( localize(4509, 'Color of the editor rulers.')));
-registerColor('editorCodeLens.foreground', { dark: '#999999', light: '#919191', hcDark: '#999999', hcLight: '#292929' }, ( localize(4510, 'Foreground color of editor CodeLens')));
-registerColor('editorBracketMatch.background', { dark: '#0064001a', light: '#0064001a', hcDark: '#0064001a', hcLight: '#0000' }, ( localize(4511, 'Background color behind matching brackets')));
-registerColor('editorBracketMatch.border', { dark: '#888', light: '#B9B9B9', hcDark: contrastBorder, hcLight: contrastBorder }, ( localize(4512, 'Color for matching brackets boxes')));
-const editorOverviewRulerBorder = registerColor('editorOverviewRuler.border', { dark: '#7f7f7f4d', light: '#7f7f7f4d', hcDark: '#7f7f7f4d', hcLight: '#666666' }, ( localize(4513, 'Color of the overview ruler border.')));
-const editorOverviewRulerBackground = registerColor('editorOverviewRuler.background', null, ( localize(4514, 'Background color of the editor overview ruler.')));
+const editorRuler = registerColor('editorRuler.foreground', { dark: '#5A5A5A', light: Color.lightgrey, hcDark: Color.white, hcLight: '#292929' }, ( localize(4939, 'Color of the editor rulers.')));
+registerColor('editorCodeLens.foreground', { dark: '#999999', light: '#919191', hcDark: '#999999', hcLight: '#292929' }, ( localize(4940, 'Foreground color of editor CodeLens')));
+registerColor('editorBracketMatch.background', { dark: '#0064001a', light: '#0064001a', hcDark: '#0064001a', hcLight: '#0000' }, ( localize(4941, 'Background color behind matching brackets')));
+registerColor('editorBracketMatch.border', { dark: '#888', light: '#B9B9B9', hcDark: contrastBorder, hcLight: contrastBorder }, ( localize(4942, 'Color for matching brackets boxes')));
+const editorOverviewRulerBorder = registerColor('editorOverviewRuler.border', { dark: '#7f7f7f4d', light: '#7f7f7f4d', hcDark: '#7f7f7f4d', hcLight: '#666666' }, ( localize(4943, 'Color of the overview ruler border.')));
+const editorOverviewRulerBackground = registerColor('editorOverviewRuler.background', null, ( localize(4944, 'Background color of the editor overview ruler.')));
 registerColor('editorGutter.background', editorBackground, ( localize(
- 4515,
+ 4945,
  'Background color of the editor gutter. The gutter contains the glyph margins and the line numbers.'
 )));
-registerColor('editorUnnecessaryCode.border', { dark: null, light: null, hcDark: ( (( (Color.fromHex('#fff'))).transparent(0.8))), hcLight: contrastBorder }, ( localize(4516, 'Border color of unnecessary (unused) source code in the editor.')));
+registerColor('editorUnnecessaryCode.border', { dark: null, light: null, hcDark: ( (( (Color.fromHex('#fff'))).transparent(0.8))), hcLight: contrastBorder }, ( localize(4946, 'Border color of unnecessary (unused) source code in the editor.')));
 const editorUnnecessaryCodeOpacity = registerColor('editorUnnecessaryCode.opacity', { dark: ( (Color.fromHex('#000a'))), light: ( (Color.fromHex('#0007'))), hcDark: null, hcLight: null }, ( localize(
- 4517,
+ 4947,
  'Opacity of unnecessary (unused) source code in the editor. For example, "#000000c0" will render the code with 75% opacity. For high contrast themes, use the  \'editorUnnecessaryCode.border\' theme color to underline unnecessary code instead of fading it out.'
 )));
-registerColor('editorGhostText.border', { dark: null, light: null, hcDark: ( (( (Color.fromHex('#fff'))).transparent(0.8))), hcLight: ( (( (Color.fromHex('#292929'))).transparent(0.8))) }, ( localize(4518, 'Border color of ghost text in the editor.')));
-const ghostTextForeground = registerColor('editorGhostText.foreground', { dark: ( (Color.fromHex('#ffffff56'))), light: ( (Color.fromHex('#0007'))), hcDark: null, hcLight: null }, ( localize(4519, 'Foreground color of the ghost text in the editor.')));
-registerColor('editorGhostText.background', null, ( localize(4520, 'Background color of the ghost text in the editor.')));
+registerColor('editorGhostText.border', { dark: null, light: null, hcDark: ( (( (Color.fromHex('#fff'))).transparent(0.8))), hcLight: ( (( (Color.fromHex('#292929'))).transparent(0.8))) }, ( localize(4948, 'Border color of ghost text in the editor.')));
+const ghostTextForeground = registerColor('editorGhostText.foreground', { dark: ( (Color.fromHex('#ffffff56'))), light: ( (Color.fromHex('#0007'))), hcDark: null, hcLight: null }, ( localize(4949, 'Foreground color of the ghost text in the editor.')));
+registerColor('editorGhostText.background', null, ( localize(4950, 'Background color of the ghost text in the editor.')));
 const rulerRangeDefault = ( (new Color( (new RGBA(0, 122, 204, 0.6)))));
 const overviewRulerRangeHighlight = registerColor('editorOverviewRuler.rangeHighlightForeground', rulerRangeDefault, ( localize(
- 4521,
+ 4951,
  'Overview ruler marker color for range highlights. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
-const overviewRulerError = registerColor('editorOverviewRuler.errorForeground', { dark: ( (new Color( (new RGBA(255, 18, 18, 0.7))))), light: ( (new Color( (new RGBA(255, 18, 18, 0.7))))), hcDark: ( (new Color( (new RGBA(255, 50, 50, 1))))), hcLight: '#B5200D' }, ( localize(4522, 'Overview ruler marker color for errors.')));
-const overviewRulerWarning = registerColor('editorOverviewRuler.warningForeground', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningBorder, hcLight: editorWarningBorder }, ( localize(4523, 'Overview ruler marker color for warnings.')));
-const overviewRulerInfo = registerColor('editorOverviewRuler.infoForeground', { dark: editorInfoForeground, light: editorInfoForeground, hcDark: editorInfoBorder, hcLight: editorInfoBorder }, ( localize(4524, 'Overview ruler marker color for infos.')));
+const overviewRulerError = registerColor('editorOverviewRuler.errorForeground', { dark: ( (new Color( (new RGBA(255, 18, 18, 0.7))))), light: ( (new Color( (new RGBA(255, 18, 18, 0.7))))), hcDark: ( (new Color( (new RGBA(255, 50, 50, 1))))), hcLight: '#B5200D' }, ( localize(4952, 'Overview ruler marker color for errors.')));
+const overviewRulerWarning = registerColor('editorOverviewRuler.warningForeground', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningBorder, hcLight: editorWarningBorder }, ( localize(4953, 'Overview ruler marker color for warnings.')));
+const overviewRulerInfo = registerColor('editorOverviewRuler.infoForeground', { dark: editorInfoForeground, light: editorInfoForeground, hcDark: editorInfoBorder, hcLight: editorInfoBorder }, ( localize(4954, 'Overview ruler marker color for infos.')));
 const editorBracketHighlightingForeground1 = registerColor('editorBracketHighlight.foreground1', { dark: '#FFD700', light: '#0431FAFF', hcDark: '#FFD700', hcLight: '#0431FAFF' }, ( localize(
- 4525,
+ 4955,
  'Foreground color of brackets (1). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground2 = registerColor('editorBracketHighlight.foreground2', { dark: '#DA70D6', light: '#319331FF', hcDark: '#DA70D6', hcLight: '#319331FF' }, ( localize(
- 4526,
+ 4956,
  'Foreground color of brackets (2). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground3 = registerColor('editorBracketHighlight.foreground3', { dark: '#179FFF', light: '#7B3814FF', hcDark: '#87CEFA', hcLight: '#7B3814FF' }, ( localize(
- 4527,
+ 4957,
  'Foreground color of brackets (3). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground4 = registerColor('editorBracketHighlight.foreground4', '#00000000', ( localize(
- 4528,
+ 4958,
  'Foreground color of brackets (4). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground5 = registerColor('editorBracketHighlight.foreground5', '#00000000', ( localize(
- 4529,
+ 4959,
  'Foreground color of brackets (5). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground6 = registerColor('editorBracketHighlight.foreground6', '#00000000', ( localize(
- 4530,
+ 4960,
  'Foreground color of brackets (6). Requires enabling bracket pair colorization.'
 )));
-const editorBracketHighlightingUnexpectedBracketForeground = registerColor('editorBracketHighlight.unexpectedBracket.foreground', { dark: ( (new Color( (new RGBA(255, 18, 18, 0.8))))), light: ( (new Color( (new RGBA(255, 18, 18, 0.8))))), hcDark: 'new Color(new RGBA(255, 50, 50, 1))', hcLight: '#B5200D' }, ( localize(4531, 'Foreground color of unexpected brackets.')));
+const editorBracketHighlightingUnexpectedBracketForeground = registerColor('editorBracketHighlight.unexpectedBracket.foreground', { dark: ( (new Color( (new RGBA(255, 18, 18, 0.8))))), light: ( (new Color( (new RGBA(255, 18, 18, 0.8))))), hcDark: 'new Color(new RGBA(255, 50, 50, 1))', hcLight: '#B5200D' }, ( localize(4961, 'Foreground color of unexpected brackets.')));
 const editorBracketPairGuideBackground1 = registerColor('editorBracketPairGuide.background1', '#00000000', ( localize(
- 4532,
+ 4962,
  'Background color of inactive bracket pair guides (1). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground2 = registerColor('editorBracketPairGuide.background2', '#00000000', ( localize(
- 4533,
+ 4963,
  'Background color of inactive bracket pair guides (2). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground3 = registerColor('editorBracketPairGuide.background3', '#00000000', ( localize(
- 4534,
+ 4964,
  'Background color of inactive bracket pair guides (3). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground4 = registerColor('editorBracketPairGuide.background4', '#00000000', ( localize(
- 4535,
+ 4965,
  'Background color of inactive bracket pair guides (4). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground5 = registerColor('editorBracketPairGuide.background5', '#00000000', ( localize(
- 4536,
+ 4966,
  'Background color of inactive bracket pair guides (5). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground6 = registerColor('editorBracketPairGuide.background6', '#00000000', ( localize(
- 4537,
+ 4967,
  'Background color of inactive bracket pair guides (6). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground1 = registerColor('editorBracketPairGuide.activeBackground1', '#00000000', ( localize(
- 4538,
+ 4968,
  'Background color of active bracket pair guides (1). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground2 = registerColor('editorBracketPairGuide.activeBackground2', '#00000000', ( localize(
- 4539,
+ 4969,
  'Background color of active bracket pair guides (2). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground3 = registerColor('editorBracketPairGuide.activeBackground3', '#00000000', ( localize(
- 4540,
+ 4970,
  'Background color of active bracket pair guides (3). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground4 = registerColor('editorBracketPairGuide.activeBackground4', '#00000000', ( localize(
- 4541,
+ 4971,
  'Background color of active bracket pair guides (4). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground5 = registerColor('editorBracketPairGuide.activeBackground5', '#00000000', ( localize(
- 4542,
+ 4972,
  'Background color of active bracket pair guides (5). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground6 = registerColor('editorBracketPairGuide.activeBackground6', '#00000000', ( localize(
- 4543,
+ 4973,
  'Background color of active bracket pair guides (6). Requires enabling bracket pair guides.'
 )));
-registerColor('editorUnicodeHighlight.border', editorWarningForeground, ( localize(4544, 'Border color used to highlight unicode characters.')));
-registerColor('editorUnicodeHighlight.background', editorWarningBackground, ( localize(4545, 'Background color used to highlight unicode characters.')));
+registerColor('editorUnicodeHighlight.border', editorWarningForeground, ( localize(4974, 'Border color used to highlight unicode characters.')));
+registerColor('editorUnicodeHighlight.background', editorWarningBackground, ( localize(4975, 'Background color used to highlight unicode characters.')));
 registerThemingParticipant((theme, collector) => {
     const background = theme.getColor(editorBackground);
     const lineHighlight = theme.getColor(editorLineHighlight);