@codingame/monaco-vscode-api 4.5.1 → 4.5.2

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

@@ -12,359 +12,216 @@ import '../../../platform/theme/common/colors/miscColors.js';
 import '../../../platform/theme/common/colors/quickpickColors.js';
 import '../../../platform/theme/common/colors/searchColors.js';
 import { registerThemingParticipant } from '../../../platform/theme/common/themeService.js';
+const _moduleId = "vs/editor/common/core/editorColorRegistry";
 const editorLineHighlight = registerColor('editor.lineHighlightBackground', { dark: null, light: null, hcDark: null, hcLight: null }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'lineHighlight',
+ _moduleId,
+ 0,
  'Background color for the highlight of line at the cursor position.'
 )));
 const editorLineHighlightBorder = registerColor('editor.lineHighlightBorder', { dark: '#282828', light: '#eeeeee', hcDark: '#f38518', hcLight: contrastBorder }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'lineHighlightBorderBox',
+ _moduleId,
+ 1,
  '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 }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'rangeHighlight',
+ _moduleId,
+ 2,
  '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 }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'rangeHighlightBorder',
- 'Background color of the border around highlighted ranges.'
-)), true);
+registerColor('editor.rangeHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localizeWithPath(_moduleId, 3, 'Background color of the border around highlighted ranges.')), true);
 registerColor('editor.symbolHighlightBackground', { dark: editorFindMatchHighlight, light: editorFindMatchHighlight, hcDark: null, hcLight: null }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'symbolHighlight',
+ _moduleId,
+ 4,
  '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 }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'symbolHighlightBorder',
- 'Background color of the border around highlighted symbols.'
-)), true);
-const editorCursorForeground = registerColor('editorCursor.foreground', { dark: '#AEAFAD', light: Color.black, hcDark: Color.white, hcLight: '#0F4A85' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'caret',
- 'Color of the editor cursor.'
-)));
+registerColor('editor.symbolHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localizeWithPath(_moduleId, 5, 'Background color of the border around highlighted symbols.')), true);
+const editorCursorForeground = registerColor('editorCursor.foreground', { dark: '#AEAFAD', light: Color.black, hcDark: Color.white, hcLight: '#0F4A85' }, ( localizeWithPath(_moduleId, 6, 'Color of the editor cursor.')));
 const editorCursorBackground = registerColor('editorCursor.background', null, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorCursorBackground',
+ _moduleId,
+ 7,
  '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', { dark: editorCursorForeground, light: editorCursorForeground, hcDark: editorCursorForeground, hcLight: editorCursorForeground }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorMultiCursorPrimaryForeground',
+ _moduleId,
+ 8,
  'Color of the primary editor cursor when multiple cursors are present.'
 )));
 const editorMultiCursorPrimaryBackground = registerColor('editorMultiCursor.primary.background', { dark: editorCursorBackground, light: editorCursorBackground, hcDark: editorCursorBackground, hcLight: editorCursorBackground }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorMultiCursorPrimaryBackground',
+ _moduleId,
+ 9,
  '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', { dark: editorCursorForeground, light: editorCursorForeground, hcDark: editorCursorForeground, hcLight: editorCursorForeground }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorMultiCursorSecondaryForeground',
+ _moduleId,
+ 10,
  'Color of secondary editor cursors when multiple cursors are present.'
 )));
 const editorMultiCursorSecondaryBackground = registerColor('editorMultiCursor.secondary.background', { dark: editorCursorBackground, light: editorCursorBackground, hcDark: editorCursorBackground, hcLight: editorCursorBackground }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorMultiCursorSecondaryBackground',
+ _moduleId,
+ 11,
  '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' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorWhitespaces',
- 'Color of whitespace characters in the editor.'
-)));
-const editorLineNumbers = registerColor('editorLineNumber.foreground', { dark: '#858585', light: '#237893', hcDark: Color.white, hcLight: '#292929' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorLineNumbers',
- 'Color of editor line numbers.'
-)));
-const deprecatedEditorIndentGuides = registerColor('editorIndentGuide.background', { dark: editorWhitespaces, light: editorWhitespaces, hcDark: editorWhitespaces, hcLight: editorWhitespaces }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorIndentGuides',
- 'Color of the editor indentation guides.'
-)), false, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'deprecatedEditorIndentGuides',
+const editorWhitespaces = registerColor('editorWhitespace.foreground', { dark: '#e3e4e229', light: '#33333333', hcDark: '#e3e4e229', hcLight: '#CCCCCC' }, ( localizeWithPath(_moduleId, 12, 'Color of whitespace characters in the editor.')));
+const editorLineNumbers = registerColor('editorLineNumber.foreground', { dark: '#858585', light: '#237893', hcDark: Color.white, hcLight: '#292929' }, ( localizeWithPath(_moduleId, 13, 'Color of editor line numbers.')));
+const deprecatedEditorIndentGuides = registerColor('editorIndentGuide.background', { dark: editorWhitespaces, light: editorWhitespaces, hcDark: editorWhitespaces, hcLight: editorWhitespaces }, ( localizeWithPath(_moduleId, 14, 'Color of the editor indentation guides.')), false, ( localizeWithPath(
+ _moduleId,
+ 15,
  '\'editorIndentGuide.background\' is deprecated. Use \'editorIndentGuide.background1\' instead.'
 )));
-const deprecatedEditorActiveIndentGuides = registerColor('editorIndentGuide.activeBackground', { dark: editorWhitespaces, light: editorWhitespaces, hcDark: editorWhitespaces, hcLight: editorWhitespaces }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorActiveIndentGuide',
- 'Color of the active editor indentation guides.'
-)), false, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'deprecatedEditorActiveIndentGuide',
+const deprecatedEditorActiveIndentGuides = registerColor('editorIndentGuide.activeBackground', { dark: editorWhitespaces, light: editorWhitespaces, hcDark: editorWhitespaces, hcLight: editorWhitespaces }, ( localizeWithPath(_moduleId, 16, 'Color of the active editor indentation guides.')), false, ( localizeWithPath(
+ _moduleId,
+ 17,
  '\'editorIndentGuide.activeBackground\' is deprecated. Use \'editorIndentGuide.activeBackground1\' instead.'
 )));
-const editorIndentGuide1 = registerColor('editorIndentGuide.background1', { dark: deprecatedEditorIndentGuides, light: deprecatedEditorIndentGuides, hcDark: deprecatedEditorIndentGuides, hcLight: deprecatedEditorIndentGuides }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorIndentGuides1',
- 'Color of the editor indentation guides (1).'
-)));
-const editorIndentGuide2 = registerColor('editorIndentGuide.background2', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorIndentGuides2',
- 'Color of the editor indentation guides (2).'
-)));
-const editorIndentGuide3 = registerColor('editorIndentGuide.background3', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorIndentGuides3',
- 'Color of the editor indentation guides (3).'
-)));
-const editorIndentGuide4 = registerColor('editorIndentGuide.background4', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorIndentGuides4',
- 'Color of the editor indentation guides (4).'
-)));
-const editorIndentGuide5 = registerColor('editorIndentGuide.background5', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorIndentGuides5',
- 'Color of the editor indentation guides (5).'
-)));
-const editorIndentGuide6 = registerColor('editorIndentGuide.background6', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorIndentGuides6',
- 'Color of the editor indentation guides (6).'
-)));
-const editorActiveIndentGuide1 = registerColor('editorIndentGuide.activeBackground1', { dark: deprecatedEditorActiveIndentGuides, light: deprecatedEditorActiveIndentGuides, hcDark: deprecatedEditorActiveIndentGuides, hcLight: deprecatedEditorActiveIndentGuides }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorActiveIndentGuide1',
- 'Color of the active editor indentation guides (1).'
-)));
-const editorActiveIndentGuide2 = registerColor('editorIndentGuide.activeBackground2', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorActiveIndentGuide2',
- 'Color of the active editor indentation guides (2).'
-)));
-const editorActiveIndentGuide3 = registerColor('editorIndentGuide.activeBackground3', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorActiveIndentGuide3',
- 'Color of the active editor indentation guides (3).'
-)));
-const editorActiveIndentGuide4 = registerColor('editorIndentGuide.activeBackground4', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorActiveIndentGuide4',
- 'Color of the active editor indentation guides (4).'
-)));
-const editorActiveIndentGuide5 = registerColor('editorIndentGuide.activeBackground5', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorActiveIndentGuide5',
- 'Color of the active editor indentation guides (5).'
-)));
-const editorActiveIndentGuide6 = registerColor('editorIndentGuide.activeBackground6', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorActiveIndentGuide6',
- 'Color of the active editor indentation guides (6).'
-)));
-const deprecatedEditorActiveLineNumber = registerColor('editorActiveLineNumber.foreground', { dark: '#c6c6c6', light: '#0B216F', hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorActiveLineNumber',
- 'Color of editor active line number'
-)), false, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'deprecatedEditorActiveLineNumber',
+const editorIndentGuide1 = registerColor('editorIndentGuide.background1', { dark: deprecatedEditorIndentGuides, light: deprecatedEditorIndentGuides, hcDark: deprecatedEditorIndentGuides, hcLight: deprecatedEditorIndentGuides }, ( localizeWithPath(_moduleId, 18, 'Color of the editor indentation guides (1).')));
+const editorIndentGuide2 = registerColor('editorIndentGuide.background2', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(_moduleId, 19, 'Color of the editor indentation guides (2).')));
+const editorIndentGuide3 = registerColor('editorIndentGuide.background3', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(_moduleId, 20, 'Color of the editor indentation guides (3).')));
+const editorIndentGuide4 = registerColor('editorIndentGuide.background4', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(_moduleId, 21, 'Color of the editor indentation guides (4).')));
+const editorIndentGuide5 = registerColor('editorIndentGuide.background5', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(_moduleId, 22, 'Color of the editor indentation guides (5).')));
+const editorIndentGuide6 = registerColor('editorIndentGuide.background6', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(_moduleId, 23, 'Color of the editor indentation guides (6).')));
+const editorActiveIndentGuide1 = registerColor('editorIndentGuide.activeBackground1', { dark: deprecatedEditorActiveIndentGuides, light: deprecatedEditorActiveIndentGuides, hcDark: deprecatedEditorActiveIndentGuides, hcLight: deprecatedEditorActiveIndentGuides }, ( localizeWithPath(_moduleId, 24, 'Color of the active editor indentation guides (1).')));
+const editorActiveIndentGuide2 = registerColor('editorIndentGuide.activeBackground2', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(_moduleId, 25, 'Color of the active editor indentation guides (2).')));
+const editorActiveIndentGuide3 = registerColor('editorIndentGuide.activeBackground3', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(_moduleId, 26, 'Color of the active editor indentation guides (3).')));
+const editorActiveIndentGuide4 = registerColor('editorIndentGuide.activeBackground4', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(_moduleId, 27, 'Color of the active editor indentation guides (4).')));
+const editorActiveIndentGuide5 = registerColor('editorIndentGuide.activeBackground5', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(_moduleId, 28, 'Color of the active editor indentation guides (5).')));
+const editorActiveIndentGuide6 = registerColor('editorIndentGuide.activeBackground6', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(_moduleId, 29, 'Color of the active editor indentation guides (6).')));
+const deprecatedEditorActiveLineNumber = registerColor('editorActiveLineNumber.foreground', { dark: '#c6c6c6', light: '#0B216F', hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localizeWithPath(_moduleId, 30, 'Color of editor active line number')), false, ( localizeWithPath(
+ _moduleId,
+ 31,
  'Id is deprecated. Use \'editorLineNumber.activeForeground\' instead.'
 )));
-registerColor('editorLineNumber.activeForeground', { dark: deprecatedEditorActiveLineNumber, light: deprecatedEditorActiveLineNumber, hcDark: deprecatedEditorActiveLineNumber, hcLight: deprecatedEditorActiveLineNumber }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorActiveLineNumber',
- 'Color of editor active line number'
-)));
+registerColor('editorLineNumber.activeForeground', { dark: deprecatedEditorActiveLineNumber, light: deprecatedEditorActiveLineNumber, hcDark: deprecatedEditorActiveLineNumber, hcLight: deprecatedEditorActiveLineNumber }, ( localizeWithPath(_moduleId, 30, 'Color of editor active line number')));
 const editorDimmedLineNumber = registerColor('editorLineNumber.dimmedForeground', { dark: null, light: null, hcDark: null, hcLight: null }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorDimmedLineNumber',
+ _moduleId,
+ 32,
  'Color of the final editor line when editor.renderFinalNewline is set to dimmed.'
 )));
-registerColor('editorRuler.foreground', { dark: '#5A5A5A', light: Color.lightgrey, hcDark: Color.white, hcLight: '#292929' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorRuler',
- 'Color of the editor rulers.'
-)));
-registerColor('editorCodeLens.foreground', { dark: '#999999', light: '#919191', hcDark: '#999999', hcLight: '#292929' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorCodeLensForeground',
- 'Foreground color of editor CodeLens'
-)));
-registerColor('editorBracketMatch.background', { dark: '#0064001a', light: '#0064001a', hcDark: '#0064001a', hcLight: '#0000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketMatchBackground',
- 'Background color behind matching brackets'
-)));
-registerColor('editorBracketMatch.border', { dark: '#888', light: '#B9B9B9', hcDark: contrastBorder, hcLight: contrastBorder }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketMatchBorder',
- 'Color for matching brackets boxes'
-)));
-const editorOverviewRulerBorder = registerColor('editorOverviewRuler.border', { dark: '#7f7f7f4d', light: '#7f7f7f4d', hcDark: '#7f7f7f4d', hcLight: '#666666' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorOverviewRulerBorder',
- 'Color of the overview ruler border.'
-)));
-const editorOverviewRulerBackground = registerColor('editorOverviewRuler.background', null, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorOverviewRulerBackground',
- 'Background color of the editor overview ruler.'
-)));
+registerColor('editorRuler.foreground', { dark: '#5A5A5A', light: Color.lightgrey, hcDark: Color.white, hcLight: '#292929' }, ( localizeWithPath(_moduleId, 33, 'Color of the editor rulers.')));
+registerColor('editorCodeLens.foreground', { dark: '#999999', light: '#919191', hcDark: '#999999', hcLight: '#292929' }, ( localizeWithPath(_moduleId, 34, 'Foreground color of editor CodeLens')));
+registerColor('editorBracketMatch.background', { dark: '#0064001a', light: '#0064001a', hcDark: '#0064001a', hcLight: '#0000' }, ( localizeWithPath(_moduleId, 35, 'Background color behind matching brackets')));
+registerColor('editorBracketMatch.border', { dark: '#888', light: '#B9B9B9', hcDark: contrastBorder, hcLight: contrastBorder }, ( localizeWithPath(_moduleId, 36, 'Color for matching brackets boxes')));
+const editorOverviewRulerBorder = registerColor('editorOverviewRuler.border', { dark: '#7f7f7f4d', light: '#7f7f7f4d', hcDark: '#7f7f7f4d', hcLight: '#666666' }, ( localizeWithPath(_moduleId, 37, 'Color of the overview ruler border.')));
+const editorOverviewRulerBackground = registerColor('editorOverviewRuler.background', null, ( localizeWithPath(_moduleId, 38, 'Background color of the editor overview ruler.')));
 const editorGutter = registerColor('editorGutter.background', { dark: editorBackground, light: editorBackground, hcDark: editorBackground, hcLight: editorBackground }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorGutter',
+ _moduleId,
+ 39,
  '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 }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'unnecessaryCodeBorder',
+registerColor('editorUnnecessaryCode.border', { dark: null, light: null, hcDark: ( (( (Color.fromHex('#fff'))).transparent(0.8))), hcLight: contrastBorder }, ( localizeWithPath(
+ _moduleId,
+ 40,
  '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 }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'unnecessaryCodeOpacity',
+const editorUnnecessaryCodeOpacity = registerColor('editorUnnecessaryCode.opacity', { dark: ( (Color.fromHex('#000a'))), light: ( (Color.fromHex('#0007'))), hcDark: null, hcLight: null }, ( localizeWithPath(
+ _moduleId,
+ 41,
  '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)) }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorGhostTextBorder',
- 'Border color of ghost text in the editor.'
-)));
-registerColor('editorGhostText.foreground', { dark: ( Color.fromHex('#ffffff56')), light: ( Color.fromHex('#0007')), hcDark: null, hcLight: null }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorGhostTextForeground',
- 'Foreground color of the ghost text in the editor.'
-)));
-registerColor('editorGhostText.background', { dark: null, light: null, hcDark: null, hcLight: null }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorGhostTextBackground',
- 'Background color of the ghost text in the editor.'
-)));
-const rulerRangeDefault = ( new Color(( new RGBA(0, 122, 204, 0.6))));
+registerColor('editorGhostText.border', { dark: null, light: null, hcDark: ( (( (Color.fromHex('#fff'))).transparent(0.8))), hcLight: ( (( (Color.fromHex('#292929'))).transparent(0.8))) }, ( localizeWithPath(_moduleId, 42, 'Border color of ghost text in the editor.')));
+registerColor('editorGhostText.foreground', { dark: ( (Color.fromHex('#ffffff56'))), light: ( (Color.fromHex('#0007'))), hcDark: null, hcLight: null }, ( localizeWithPath(_moduleId, 43, 'Foreground color of the ghost text in the editor.')));
+registerColor('editorGhostText.background', { dark: null, light: null, hcDark: null, hcLight: null }, ( localizeWithPath(_moduleId, 44, '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', { dark: rulerRangeDefault, light: rulerRangeDefault, hcDark: rulerRangeDefault, hcLight: rulerRangeDefault }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'overviewRulerRangeHighlight',
+ _moduleId,
+ 45,
  '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' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'overviewRuleError',
- 'Overview ruler marker color for errors.'
-)));
-const overviewRulerWarning = registerColor('editorOverviewRuler.warningForeground', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningBorder, hcLight: editorWarningBorder }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'overviewRuleWarning',
- 'Overview ruler marker color for warnings.'
-)));
-const overviewRulerInfo = registerColor('editorOverviewRuler.infoForeground', { dark: editorInfoForeground, light: editorInfoForeground, hcDark: editorInfoBorder, hcLight: editorInfoBorder }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'overviewRuleInfo',
- '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' }, ( localizeWithPath(_moduleId, 46, 'Overview ruler marker color for errors.')));
+const overviewRulerWarning = registerColor('editorOverviewRuler.warningForeground', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningBorder, hcLight: editorWarningBorder }, ( localizeWithPath(_moduleId, 47, 'Overview ruler marker color for warnings.')));
+const overviewRulerInfo = registerColor('editorOverviewRuler.infoForeground', { dark: editorInfoForeground, light: editorInfoForeground, hcDark: editorInfoBorder, hcLight: editorInfoBorder }, ( localizeWithPath(_moduleId, 48, 'Overview ruler marker color for infos.')));
 const editorBracketHighlightingForeground1 = registerColor('editorBracketHighlight.foreground1', { dark: '#FFD700', light: '#0431FAFF', hcDark: '#FFD700', hcLight: '#0431FAFF' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketHighlightForeground1',
+ _moduleId,
+ 49,
  'Foreground color of brackets (1). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground2 = registerColor('editorBracketHighlight.foreground2', { dark: '#DA70D6', light: '#319331FF', hcDark: '#DA70D6', hcLight: '#319331FF' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketHighlightForeground2',
+ _moduleId,
+ 50,
  'Foreground color of brackets (2). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground3 = registerColor('editorBracketHighlight.foreground3', { dark: '#179FFF', light: '#7B3814FF', hcDark: '#87CEFA', hcLight: '#7B3814FF' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketHighlightForeground3',
+ _moduleId,
+ 51,
  'Foreground color of brackets (3). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground4 = registerColor('editorBracketHighlight.foreground4', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketHighlightForeground4',
+ _moduleId,
+ 52,
  'Foreground color of brackets (4). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground5 = registerColor('editorBracketHighlight.foreground5', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketHighlightForeground5',
+ _moduleId,
+ 53,
  'Foreground color of brackets (5). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground6 = registerColor('editorBracketHighlight.foreground6', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketHighlightForeground6',
+ _moduleId,
+ 54,
  '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: '' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketHighlightUnexpectedBracketForeground',
- '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: '' }, ( localizeWithPath(_moduleId, 55, 'Foreground color of unexpected brackets.')));
 const editorBracketPairGuideBackground1 = registerColor('editorBracketPairGuide.background1', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketPairGuide.background1',
+ _moduleId,
+ 56,
  'Background color of inactive bracket pair guides (1). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground2 = registerColor('editorBracketPairGuide.background2', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketPairGuide.background2',
+ _moduleId,
+ 57,
  'Background color of inactive bracket pair guides (2). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground3 = registerColor('editorBracketPairGuide.background3', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketPairGuide.background3',
+ _moduleId,
+ 58,
  'Background color of inactive bracket pair guides (3). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground4 = registerColor('editorBracketPairGuide.background4', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketPairGuide.background4',
+ _moduleId,
+ 59,
  'Background color of inactive bracket pair guides (4). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground5 = registerColor('editorBracketPairGuide.background5', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketPairGuide.background5',
+ _moduleId,
+ 60,
  'Background color of inactive bracket pair guides (5). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground6 = registerColor('editorBracketPairGuide.background6', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketPairGuide.background6',
+ _moduleId,
+ 61,
  'Background color of inactive bracket pair guides (6). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground1 = registerColor('editorBracketPairGuide.activeBackground1', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketPairGuide.activeBackground1',
+ _moduleId,
+ 62,
  'Background color of active bracket pair guides (1). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground2 = registerColor('editorBracketPairGuide.activeBackground2', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketPairGuide.activeBackground2',
+ _moduleId,
+ 63,
  'Background color of active bracket pair guides (2). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground3 = registerColor('editorBracketPairGuide.activeBackground3', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketPairGuide.activeBackground3',
+ _moduleId,
+ 64,
  'Background color of active bracket pair guides (3). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground4 = registerColor('editorBracketPairGuide.activeBackground4', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketPairGuide.activeBackground4',
+ _moduleId,
+ 65,
  'Background color of active bracket pair guides (4). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground5 = registerColor('editorBracketPairGuide.activeBackground5', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketPairGuide.activeBackground5',
+ _moduleId,
+ 66,
  'Background color of active bracket pair guides (5). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground6 = registerColor('editorBracketPairGuide.activeBackground6', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorBracketPairGuide.activeBackground6',
+ _moduleId,
+ 67,
  'Background color of active bracket pair guides (6). Requires enabling bracket pair guides.'
 )));
-registerColor('editorUnicodeHighlight.border', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningForeground, hcLight: editorWarningForeground }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorUnicodeHighlight.border',
- 'Border color used to highlight unicode characters.'
-)));
-registerColor('editorUnicodeHighlight.background', { dark: editorWarningBackground, light: editorWarningBackground, hcDark: editorWarningBackground, hcLight: editorWarningBackground }, ( localizeWithPath(
- 'vs/editor/common/core/editorColorRegistry',
- 'editorUnicodeHighlight.background',
- 'Background color used to highlight unicode characters.'
-)));
+registerColor('editorUnicodeHighlight.border', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningForeground, hcLight: editorWarningForeground }, ( localizeWithPath(_moduleId, 68, 'Border color used to highlight unicode characters.')));
+registerColor('editorUnicodeHighlight.background', { dark: editorWarningBackground, light: editorWarningBackground, hcDark: editorWarningBackground, hcLight: editorWarningBackground }, ( localizeWithPath(_moduleId, 69, 'Background color used to highlight unicode characters.')));
 registerThemingParticipant((theme, collector) => {
     const background = theme.getColor(editorBackground);
     const lineHighlight = theme.getColor(editorLineHighlight);

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

@@ -44,7 +44,7 @@ class LineRange {
     }
     static join(lineRanges) {
         if (lineRanges.length === 0) {
-            throw new BugIndicatingError('lineRanges cannot be empty');
+            throw ( new BugIndicatingError('lineRanges cannot be empty'));
         }
         let startLineNumber = lineRanges[0].startLineNumber;
         let endLineNumberExclusive = lineRanges[0].endLineNumberExclusive;
@@ -62,7 +62,9 @@ class LineRange {
     }
     constructor(startLineNumber, endLineNumberExclusive) {
         if (startLineNumber > endLineNumberExclusive) {
-            throw new BugIndicatingError(`startLineNumber ${startLineNumber} cannot be after endLineNumberExclusive ${endLineNumberExclusive}`);
+            throw ( new BugIndicatingError(
+                `startLineNumber ${startLineNumber} cannot be after endLineNumberExclusive ${endLineNumberExclusive}`
+            ));
         }
         this.startLineNumber = startLineNumber;
         this.endLineNumberExclusive = endLineNumberExclusive;

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

@@ -34,7 +34,7 @@ class OffsetRange {
         this.start = start;
         this.endExclusive = endExclusive;
         if (start > endExclusive) {
-            throw new BugIndicatingError(`Invalid range: ${this.toString()}`);
+            throw ( new BugIndicatingError(`Invalid range: ${( this.toString())}`));
         }
     }
     get isEmpty() {
@@ -102,13 +102,13 @@ class OffsetRange {
     }
     clip(value) {
         if (this.isEmpty) {
-            throw new BugIndicatingError(`Invalid clipping range: ${this.toString()}`);
+            throw ( new BugIndicatingError(`Invalid clipping range: ${( this.toString())}`));
         }
         return Math.max(this.start, Math.min(this.endExclusive - 1, value));
     }
     clipCyclic(value) {
         if (this.isEmpty) {
-            throw new BugIndicatingError(`Invalid clipping range: ${this.toString()}`);
+            throw ( new BugIndicatingError(`Invalid clipping range: ${( this.toString())}`));
         }
         if (value < this.start) {
             return this.endExclusive - ((this.start - value) % this.length);

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

@@ -141,7 +141,7 @@ class SingleTextEdit {
 }
 function rangeFromPositions(start, end) {
     if (!start.isBeforeOrEqual(end)) {
-        throw new BugIndicatingError('start must be before end');
+        throw ( new BugIndicatingError('start must be before end'));
     }
     return ( new Range(start.lineNumber, start.column, end.lineNumber, end.column));
 }

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/diffAlgorithm.js

@@ -109,7 +109,7 @@ class DateTimeout {
         this.startTime = Date.now();
         this.valid = true;
         if (timeout <= 0) {
-            throw new BugIndicatingError('timeout must be positive');
+            throw ( new BugIndicatingError('timeout must be positive'));
         }
     }
     isValid() {

package/vscode/src/vs/editor/common/diff/legacyLinesDiffComputer.js

@@ -137,7 +137,7 @@ class CharSequence {
     }
     _assertIndex(index, arr) {
         if (index < 0 || index >= arr.length) {
-            throw new Error(`Illegal index`);
+            throw ( new Error(`Illegal index`));
         }
     }
     getElements() {