@codingame/monaco-vscode-api 7.0.11 → 7.1.1

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

@@ -1,4 +1,4 @@
-import { localizeWithPath } from '../../../nls.js';
+import { localize } from '../../../nls.js';
 import { Color, RGBA } from '../../../base/common/color.js';
 import { registerColor } from '../../../platform/theme/common/colorUtils.js';
 import { contrastBorder, activeContrastBorder } from '../../../platform/theme/common/colors/baseColors.js';
@@ -12,216 +12,174 @@ 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', null, ( localizeWithPath(
- _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(
- _moduleId,
- 1,
+const editorLineHighlight = registerColor('editor.lineHighlightBackground', null, ( localize(4577, '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(
+ 4578,
  '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(
- _moduleId,
- 2,
+const editorRangeHighlight = registerColor('editor.rangeHighlightBackground', { dark: '#ffffff0b', light: '#fdff0033', hcDark: null, hcLight: null }, ( localize(
+ 4579,
  '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(_moduleId, 3, 'Background color of the border around highlighted ranges.')));
-registerColor('editor.symbolHighlightBackground', { dark: editorFindMatchHighlight, light: editorFindMatchHighlight, hcDark: null, hcLight: null }, ( localizeWithPath(
- _moduleId,
- 4,
+registerColor('editor.rangeHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(4580, 'Background color of the border around highlighted ranges.')));
+registerColor('editor.symbolHighlightBackground', { dark: editorFindMatchHighlight, light: editorFindMatchHighlight, hcDark: null, hcLight: null }, ( localize(
+ 4581,
  '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(_moduleId, 5, 'Background color of the border around highlighted symbols.')));
-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(
- _moduleId,
- 7,
+registerColor('editor.symbolHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(4582, 'Background color of the border around highlighted symbols.')));
+const editorCursorForeground = registerColor('editorCursor.foreground', { dark: '#AEAFAD', light: Color.black, hcDark: Color.white, hcLight: '#0F4A85' }, ( localize(4583, 'Color of the editor cursor.')));
+const editorCursorBackground = registerColor('editorCursor.background', null, ( localize(
+ 4584,
  '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, ( localizeWithPath(
- _moduleId,
- 8,
+const editorMultiCursorPrimaryForeground = registerColor('editorMultiCursor.primary.foreground', editorCursorForeground, ( localize(
+ 4585,
  'Color of the primary editor cursor when multiple cursors are present.'
 )));
-const editorMultiCursorPrimaryBackground = registerColor('editorMultiCursor.primary.background', editorCursorBackground, ( localizeWithPath(
- _moduleId,
- 9,
+const editorMultiCursorPrimaryBackground = registerColor('editorMultiCursor.primary.background', editorCursorBackground, ( localize(
+ 4586,
  '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, ( localizeWithPath(
- _moduleId,
- 10,
+const editorMultiCursorSecondaryForeground = registerColor('editorMultiCursor.secondary.foreground', editorCursorForeground, ( localize(
+ 4587,
  'Color of secondary editor cursors when multiple cursors are present.'
 )));
-const editorMultiCursorSecondaryBackground = registerColor('editorMultiCursor.secondary.background', editorCursorBackground, ( localizeWithPath(
- _moduleId,
- 11,
+const editorMultiCursorSecondaryBackground = registerColor('editorMultiCursor.secondary.background', editorCursorBackground, ( localize(
+ 4588,
  '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(_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', editorWhitespaces, ( localizeWithPath(_moduleId, 14, 'Color of the editor indentation guides.')), false, ( localizeWithPath(
- _moduleId,
- 15,
+const editorWhitespaces = registerColor('editorWhitespace.foreground', { dark: '#e3e4e229', light: '#33333333', hcDark: '#e3e4e229', hcLight: '#CCCCCC' }, ( localize(4589, 'Color of whitespace characters in the editor.')));
+const editorLineNumbers = registerColor('editorLineNumber.foreground', { dark: '#858585', light: '#237893', hcDark: Color.white, hcLight: '#292929' }, ( localize(4590, 'Color of editor line numbers.')));
+const deprecatedEditorIndentGuides = registerColor('editorIndentGuide.background', editorWhitespaces, ( localize(4591, 'Color of the editor indentation guides.')), false, ( localize(
+ 4592,
  '\'editorIndentGuide.background\' is deprecated. Use \'editorIndentGuide.background1\' instead.'
 )));
-const deprecatedEditorActiveIndentGuides = registerColor('editorIndentGuide.activeBackground', editorWhitespaces, ( localizeWithPath(_moduleId, 16, 'Color of the active editor indentation guides.')), false, ( localizeWithPath(
- _moduleId,
- 17,
+const deprecatedEditorActiveIndentGuides = registerColor('editorIndentGuide.activeBackground', editorWhitespaces, ( localize(4593, 'Color of the active editor indentation guides.')), false, ( localize(
+ 4594,
  '\'editorIndentGuide.activeBackground\' is deprecated. Use \'editorIndentGuide.activeBackground1\' instead.'
 )));
-const editorIndentGuide1 = registerColor('editorIndentGuide.background1', deprecatedEditorIndentGuides, ( localizeWithPath(_moduleId, 18, 'Color of the editor indentation guides (1).')));
-const editorIndentGuide2 = registerColor('editorIndentGuide.background2', '#00000000', ( localizeWithPath(_moduleId, 19, 'Color of the editor indentation guides (2).')));
-const editorIndentGuide3 = registerColor('editorIndentGuide.background3', '#00000000', ( localizeWithPath(_moduleId, 20, 'Color of the editor indentation guides (3).')));
-const editorIndentGuide4 = registerColor('editorIndentGuide.background4', '#00000000', ( localizeWithPath(_moduleId, 21, 'Color of the editor indentation guides (4).')));
-const editorIndentGuide5 = registerColor('editorIndentGuide.background5', '#00000000', ( localizeWithPath(_moduleId, 22, 'Color of the editor indentation guides (5).')));
-const editorIndentGuide6 = registerColor('editorIndentGuide.background6', '#00000000', ( localizeWithPath(_moduleId, 23, 'Color of the editor indentation guides (6).')));
-const editorActiveIndentGuide1 = registerColor('editorIndentGuide.activeBackground1', deprecatedEditorActiveIndentGuides, ( localizeWithPath(_moduleId, 24, 'Color of the active editor indentation guides (1).')));
-const editorActiveIndentGuide2 = registerColor('editorIndentGuide.activeBackground2', '#00000000', ( localizeWithPath(_moduleId, 25, 'Color of the active editor indentation guides (2).')));
-const editorActiveIndentGuide3 = registerColor('editorIndentGuide.activeBackground3', '#00000000', ( localizeWithPath(_moduleId, 26, 'Color of the active editor indentation guides (3).')));
-const editorActiveIndentGuide4 = registerColor('editorIndentGuide.activeBackground4', '#00000000', ( localizeWithPath(_moduleId, 27, 'Color of the active editor indentation guides (4).')));
-const editorActiveIndentGuide5 = registerColor('editorIndentGuide.activeBackground5', '#00000000', ( localizeWithPath(_moduleId, 28, 'Color of the active editor indentation guides (5).')));
-const editorActiveIndentGuide6 = registerColor('editorIndentGuide.activeBackground6', '#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,
+const editorIndentGuide1 = registerColor('editorIndentGuide.background1', deprecatedEditorIndentGuides, ( localize(4595, 'Color of the editor indentation guides (1).')));
+const editorIndentGuide2 = registerColor('editorIndentGuide.background2', '#00000000', ( localize(4596, 'Color of the editor indentation guides (2).')));
+const editorIndentGuide3 = registerColor('editorIndentGuide.background3', '#00000000', ( localize(4597, 'Color of the editor indentation guides (3).')));
+const editorIndentGuide4 = registerColor('editorIndentGuide.background4', '#00000000', ( localize(4598, 'Color of the editor indentation guides (4).')));
+const editorIndentGuide5 = registerColor('editorIndentGuide.background5', '#00000000', ( localize(4599, 'Color of the editor indentation guides (5).')));
+const editorIndentGuide6 = registerColor('editorIndentGuide.background6', '#00000000', ( localize(4600, 'Color of the editor indentation guides (6).')));
+const editorActiveIndentGuide1 = registerColor('editorIndentGuide.activeBackground1', deprecatedEditorActiveIndentGuides, ( localize(4601, 'Color of the active editor indentation guides (1).')));
+const editorActiveIndentGuide2 = registerColor('editorIndentGuide.activeBackground2', '#00000000', ( localize(4602, 'Color of the active editor indentation guides (2).')));
+const editorActiveIndentGuide3 = registerColor('editorIndentGuide.activeBackground3', '#00000000', ( localize(4603, 'Color of the active editor indentation guides (3).')));
+const editorActiveIndentGuide4 = registerColor('editorIndentGuide.activeBackground4', '#00000000', ( localize(4604, 'Color of the active editor indentation guides (4).')));
+const editorActiveIndentGuide5 = registerColor('editorIndentGuide.activeBackground5', '#00000000', ( localize(4605, 'Color of the active editor indentation guides (5).')));
+const editorActiveIndentGuide6 = registerColor('editorIndentGuide.activeBackground6', '#00000000', ( localize(4606, 'Color of the active editor indentation guides (6).')));
+const deprecatedEditorActiveLineNumber = registerColor('editorActiveLineNumber.foreground', { dark: '#c6c6c6', light: '#0B216F', hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(4607, 'Color of editor active line number')), false, ( localize(
+ 4608,
  'Id is deprecated. Use \'editorLineNumber.activeForeground\' instead.'
 )));
-registerColor('editorLineNumber.activeForeground', deprecatedEditorActiveLineNumber, ( localizeWithPath(_moduleId, 30, 'Color of editor active line number')));
-const editorDimmedLineNumber = registerColor('editorLineNumber.dimmedForeground', null, ( localizeWithPath(
- _moduleId,
- 32,
+registerColor('editorLineNumber.activeForeground', deprecatedEditorActiveLineNumber, ( localize(4608, 'Color of editor active line number')));
+const editorDimmedLineNumber = registerColor('editorLineNumber.dimmedForeground', null, ( localize(
+ 4609,
  '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(_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.')));
-registerColor('editorGutter.background', editorBackground, ( localizeWithPath(
- _moduleId,
- 39,
+registerColor('editorRuler.foreground', { dark: '#5A5A5A', light: Color.lightgrey, hcDark: Color.white, hcLight: '#292929' }, ( localize(4610, 'Color of the editor rulers.')));
+registerColor('editorCodeLens.foreground', { dark: '#999999', light: '#919191', hcDark: '#999999', hcLight: '#292929' }, ( localize(4611, 'Foreground color of editor CodeLens')));
+registerColor('editorBracketMatch.background', { dark: '#0064001a', light: '#0064001a', hcDark: '#0064001a', hcLight: '#0000' }, ( localize(4612, 'Background color behind matching brackets')));
+registerColor('editorBracketMatch.border', { dark: '#888', light: '#B9B9B9', hcDark: contrastBorder, hcLight: contrastBorder }, ( localize(4613, 'Color for matching brackets boxes')));
+const editorOverviewRulerBorder = registerColor('editorOverviewRuler.border', { dark: '#7f7f7f4d', light: '#7f7f7f4d', hcDark: '#7f7f7f4d', hcLight: '#666666' }, ( localize(4614, 'Color of the overview ruler border.')));
+const editorOverviewRulerBackground = registerColor('editorOverviewRuler.background', null, ( localize(4615, 'Background color of the editor overview ruler.')));
+registerColor('editorGutter.background', editorBackground, ( localize(
+ 4616,
  '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(
- _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(
- _moduleId,
- 41,
+registerColor('editorUnnecessaryCode.border', { dark: null, light: null, hcDark: ( (( (Color.fromHex('#fff'))).transparent(0.8))), hcLight: contrastBorder }, ( localize(4617, '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(
+ 4618,
  '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(_moduleId, 42, '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 }, ( localizeWithPath(_moduleId, 43, 'Foreground color of the ghost text in the editor.')));
-registerColor('editorGhostText.background', null, ( localizeWithPath(_moduleId, 44, '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(4619, '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(4620, 'Foreground color of the ghost text in the editor.')));
+registerColor('editorGhostText.background', null, ( localize(4621, '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, ( localizeWithPath(
- _moduleId,
- 45,
+const overviewRulerRangeHighlight = registerColor('editorOverviewRuler.rangeHighlightForeground', rulerRangeDefault, ( localize(
+ 4622,
  '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(_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(
- _moduleId,
- 49,
+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(4623, 'Overview ruler marker color for errors.')));
+const overviewRulerWarning = registerColor('editorOverviewRuler.warningForeground', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningBorder, hcLight: editorWarningBorder }, ( localize(4624, 'Overview ruler marker color for warnings.')));
+const overviewRulerInfo = registerColor('editorOverviewRuler.infoForeground', { dark: editorInfoForeground, light: editorInfoForeground, hcDark: editorInfoBorder, hcLight: editorInfoBorder }, ( localize(4625, 'Overview ruler marker color for infos.')));
+const editorBracketHighlightingForeground1 = registerColor('editorBracketHighlight.foreground1', { dark: '#FFD700', light: '#0431FAFF', hcDark: '#FFD700', hcLight: '#0431FAFF' }, ( localize(
+ 4626,
  'Foreground color of brackets (1). Requires enabling bracket pair colorization.'
 )));
-const editorBracketHighlightingForeground2 = registerColor('editorBracketHighlight.foreground2', { dark: '#DA70D6', light: '#319331FF', hcDark: '#DA70D6', hcLight: '#319331FF' }, ( localizeWithPath(
- _moduleId,
- 50,
+const editorBracketHighlightingForeground2 = registerColor('editorBracketHighlight.foreground2', { dark: '#DA70D6', light: '#319331FF', hcDark: '#DA70D6', hcLight: '#319331FF' }, ( localize(
+ 4627,
  'Foreground color of brackets (2). Requires enabling bracket pair colorization.'
 )));
-const editorBracketHighlightingForeground3 = registerColor('editorBracketHighlight.foreground3', { dark: '#179FFF', light: '#7B3814FF', hcDark: '#87CEFA', hcLight: '#7B3814FF' }, ( localizeWithPath(
- _moduleId,
- 51,
+const editorBracketHighlightingForeground3 = registerColor('editorBracketHighlight.foreground3', { dark: '#179FFF', light: '#7B3814FF', hcDark: '#87CEFA', hcLight: '#7B3814FF' }, ( localize(
+ 4628,
  'Foreground color of brackets (3). Requires enabling bracket pair colorization.'
 )));
-const editorBracketHighlightingForeground4 = registerColor('editorBracketHighlight.foreground4', '#00000000', ( localizeWithPath(
- _moduleId,
- 52,
+const editorBracketHighlightingForeground4 = registerColor('editorBracketHighlight.foreground4', '#00000000', ( localize(
+ 4629,
  'Foreground color of brackets (4). Requires enabling bracket pair colorization.'
 )));
-const editorBracketHighlightingForeground5 = registerColor('editorBracketHighlight.foreground5', '#00000000', ( localizeWithPath(
- _moduleId,
- 53,
+const editorBracketHighlightingForeground5 = registerColor('editorBracketHighlight.foreground5', '#00000000', ( localize(
+ 4630,
  'Foreground color of brackets (5). Requires enabling bracket pair colorization.'
 )));
-const editorBracketHighlightingForeground6 = registerColor('editorBracketHighlight.foreground6', '#00000000', ( localizeWithPath(
- _moduleId,
- 54,
+const editorBracketHighlightingForeground6 = registerColor('editorBracketHighlight.foreground6', '#00000000', ( localize(
+ 4631,
  '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(_moduleId, 55, 'Foreground color of unexpected brackets.')));
-const editorBracketPairGuideBackground1 = registerColor('editorBracketPairGuide.background1', '#00000000', ( localizeWithPath(
- _moduleId,
- 56,
+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: '' }, ( localize(4632, 'Foreground color of unexpected brackets.')));
+const editorBracketPairGuideBackground1 = registerColor('editorBracketPairGuide.background1', '#00000000', ( localize(
+ 4633,
  'Background color of inactive bracket pair guides (1). Requires enabling bracket pair guides.'
 )));
-const editorBracketPairGuideBackground2 = registerColor('editorBracketPairGuide.background2', '#00000000', ( localizeWithPath(
- _moduleId,
- 57,
+const editorBracketPairGuideBackground2 = registerColor('editorBracketPairGuide.background2', '#00000000', ( localize(
+ 4634,
  'Background color of inactive bracket pair guides (2). Requires enabling bracket pair guides.'
 )));
-const editorBracketPairGuideBackground3 = registerColor('editorBracketPairGuide.background3', '#00000000', ( localizeWithPath(
- _moduleId,
- 58,
+const editorBracketPairGuideBackground3 = registerColor('editorBracketPairGuide.background3', '#00000000', ( localize(
+ 4635,
  'Background color of inactive bracket pair guides (3). Requires enabling bracket pair guides.'
 )));
-const editorBracketPairGuideBackground4 = registerColor('editorBracketPairGuide.background4', '#00000000', ( localizeWithPath(
- _moduleId,
- 59,
+const editorBracketPairGuideBackground4 = registerColor('editorBracketPairGuide.background4', '#00000000', ( localize(
+ 4636,
  'Background color of inactive bracket pair guides (4). Requires enabling bracket pair guides.'
 )));
-const editorBracketPairGuideBackground5 = registerColor('editorBracketPairGuide.background5', '#00000000', ( localizeWithPath(
- _moduleId,
- 60,
+const editorBracketPairGuideBackground5 = registerColor('editorBracketPairGuide.background5', '#00000000', ( localize(
+ 4637,
  'Background color of inactive bracket pair guides (5). Requires enabling bracket pair guides.'
 )));
-const editorBracketPairGuideBackground6 = registerColor('editorBracketPairGuide.background6', '#00000000', ( localizeWithPath(
- _moduleId,
- 61,
+const editorBracketPairGuideBackground6 = registerColor('editorBracketPairGuide.background6', '#00000000', ( localize(
+ 4638,
  'Background color of inactive bracket pair guides (6). Requires enabling bracket pair guides.'
 )));
-const editorBracketPairGuideActiveBackground1 = registerColor('editorBracketPairGuide.activeBackground1', '#00000000', ( localizeWithPath(
- _moduleId,
- 62,
+const editorBracketPairGuideActiveBackground1 = registerColor('editorBracketPairGuide.activeBackground1', '#00000000', ( localize(
+ 4639,
  'Background color of active bracket pair guides (1). Requires enabling bracket pair guides.'
 )));
-const editorBracketPairGuideActiveBackground2 = registerColor('editorBracketPairGuide.activeBackground2', '#00000000', ( localizeWithPath(
- _moduleId,
- 63,
+const editorBracketPairGuideActiveBackground2 = registerColor('editorBracketPairGuide.activeBackground2', '#00000000', ( localize(
+ 4640,
  'Background color of active bracket pair guides (2). Requires enabling bracket pair guides.'
 )));
-const editorBracketPairGuideActiveBackground3 = registerColor('editorBracketPairGuide.activeBackground3', '#00000000', ( localizeWithPath(
- _moduleId,
- 64,
+const editorBracketPairGuideActiveBackground3 = registerColor('editorBracketPairGuide.activeBackground3', '#00000000', ( localize(
+ 4641,
  'Background color of active bracket pair guides (3). Requires enabling bracket pair guides.'
 )));
-const editorBracketPairGuideActiveBackground4 = registerColor('editorBracketPairGuide.activeBackground4', '#00000000', ( localizeWithPath(
- _moduleId,
- 65,
+const editorBracketPairGuideActiveBackground4 = registerColor('editorBracketPairGuide.activeBackground4', '#00000000', ( localize(
+ 4642,
  'Background color of active bracket pair guides (4). Requires enabling bracket pair guides.'
 )));
-const editorBracketPairGuideActiveBackground5 = registerColor('editorBracketPairGuide.activeBackground5', '#00000000', ( localizeWithPath(
- _moduleId,
- 66,
+const editorBracketPairGuideActiveBackground5 = registerColor('editorBracketPairGuide.activeBackground5', '#00000000', ( localize(
+ 4643,
  'Background color of active bracket pair guides (5). Requires enabling bracket pair guides.'
 )));
-const editorBracketPairGuideActiveBackground6 = registerColor('editorBracketPairGuide.activeBackground6', '#00000000', ( localizeWithPath(
- _moduleId,
- 67,
+const editorBracketPairGuideActiveBackground6 = registerColor('editorBracketPairGuide.activeBackground6', '#00000000', ( localize(
+ 4644,
  'Background color of active bracket pair guides (6). Requires enabling bracket pair guides.'
 )));
-registerColor('editorUnicodeHighlight.border', editorWarningForeground, ( localizeWithPath(_moduleId, 68, 'Border color used to highlight unicode characters.')));
-registerColor('editorUnicodeHighlight.background', editorWarningBackground, ( localizeWithPath(_moduleId, 69, 'Background color used to highlight unicode characters.')));
+registerColor('editorUnicodeHighlight.border', editorWarningForeground, ( localize(4645, 'Border color used to highlight unicode characters.')));
+registerColor('editorUnicodeHighlight.background', editorWarningBackground, ( localize(4646, '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

@@ -1,7 +1,7 @@
 import { BugIndicatingError } from '../../../base/common/errors.js';
 import { OffsetRange } from './offsetRange.js';
 import { Range } from './range.js';
-import { findFirstIdxMonotonousOrArrLen, findLastMonotonous, findLastIdxMonotonous } from '../../../base/common/arraysFind.js';
+import { findFirstIdxMonotonousOrArrLen, findLastIdxMonotonous, findLastMonotonous } from '../../../base/common/arraysFind.js';
 class LineRange {
     static fromRange(range) {
         return ( new LineRange(range.startLineNumber, range.endLineNumber));

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

@@ -28,6 +28,17 @@ class SequenceDiff {
     static fromOffsetPairs(start, endExclusive) {
         return ( new SequenceDiff(( new OffsetRange(start.offset1, endExclusive.offset1)), ( new OffsetRange(start.offset2, endExclusive.offset2))));
     }
+    static assertSorted(sequenceDiffs) {
+        let last = undefined;
+        for (const cur of sequenceDiffs) {
+            if (last) {
+                if (!(last.seq1Range.endExclusive <= cur.seq1Range.start && last.seq2Range.endExclusive <= cur.seq2Range.start)) {
+                    throw ( new BugIndicatingError('Sequence diffs must be sorted'));
+                }
+            }
+            last = cur;
+        }
+    }
     constructor(seq1Range, seq2Range) {
         this.seq1Range = seq1Range;
         this.seq2Range = seq2Range;

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/computeMovedLines.js

@@ -4,10 +4,10 @@ import { pushMany, compareBy, numberComparator, reverseOrder } from '../../../..
 import { findLastMonotonous, MonotonousArray } from '../../../../base/common/arraysFind.js';
 import { SetMap } from '../../../../base/common/map.js';
 import { LineRange, LineRangeSet } from '../../core/lineRange.js';
-import { OffsetRange } from '../../core/offsetRange.js';
 import { LinesSliceCharSequence } from './linesSliceCharSequence.js';
 import { isSpace, LineRangeFragment } from './utils.js';
 import { MyersDiffAlgorithm } from './algorithms/myersDiffAlgorithm.js';
+import { Range } from '../../core/range.js';
 function computeMovedLines(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout) {
     let { moves, excludedChanges } = computeMovesFromSimpleDeletionsToSimpleInsertions(changes, originalLines, modifiedLines, timeout);
     if (!timeout.isValid()) {
@@ -202,7 +202,7 @@ function areLinesSimilar(line1, line2, timeout) {
         return false;
     }
     const myersDiffingAlgorithm = ( new MyersDiffAlgorithm());
-    const result = myersDiffingAlgorithm.compute(( new LinesSliceCharSequence([line1], ( new OffsetRange(0, 1)), false)), ( new LinesSliceCharSequence([line2], ( new OffsetRange(0, 1)), false)), timeout);
+    const result = myersDiffingAlgorithm.compute(( new LinesSliceCharSequence([line1], ( new Range(1, 1, 1, line1.length)), false)), ( new LinesSliceCharSequence([line2], ( new Range(1, 1, 1, line2.length)), false)), timeout);
     let commonNonSpaceCharCount = 0;
     const inverted = SequenceDiff.invert(result.diffs, line1.length);
     for (const seq of inverted) {

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

@@ -11,7 +11,7 @@ import { optimizeSequenceDiffs, removeVeryShortMatchingLinesBetweenDiffs, extend
 import { LineSequence } from './lineSequence.js';
 import { LinesSliceCharSequence } from './linesSliceCharSequence.js';
 import { LinesDiff, MovedText } from '../linesDiffComputer.js';
-import { DetailedLineRangeMapping, RangeMapping } from '../rangeMapping.js';
+import { DetailedLineRangeMapping, RangeMapping, LineRangeMapping } from '../rangeMapping.js';
 class DefaultLinesDiffComputer {
     constructor() {
         this.dynamicProgrammingDiffing = ( new DynamicProgrammingDiffing());
@@ -157,8 +157,10 @@ class DefaultLinesDiffComputer {
         return movesWithDiffs;
     }
     refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges) {
-        const slice1 = ( new LinesSliceCharSequence(originalLines, diff.seq1Range, considerWhitespaceChanges));
-        const slice2 = ( new LinesSliceCharSequence(modifiedLines, diff.seq2Range, considerWhitespaceChanges));
+        const lineRangeMapping = toLineRangeMapping(diff);
+        const rangeMapping = lineRangeMapping.toRangeMapping2(originalLines, modifiedLines);
+        const slice1 = ( new LinesSliceCharSequence(originalLines, rangeMapping.originalRange, considerWhitespaceChanges));
+        const slice2 = ( new LinesSliceCharSequence(modifiedLines, rangeMapping.modifiedRange, considerWhitespaceChanges));
         const diffResult = slice1.length + slice2.length < 500
             ? this.dynamicProgrammingDiffing.compute(slice1, slice2, timeout)
             : this.myersDiffingAlgorithm.compute(slice1, slice2, timeout);
@@ -225,4 +227,7 @@ function getLineRangeMapping(rangeMapping, originalLines, modifiedLines) {
     ));
     return ( new DetailedLineRangeMapping(originalLineRange, modifiedLineRange, [rangeMapping]));
 }
+function toLineRangeMapping(sequenceDiff) {
+    return ( new LineRangeMapping(( new LineRange(sequenceDiff.seq1Range.start + 1, sequenceDiff.seq1Range.endExclusive + 1)), ( new LineRange(sequenceDiff.seq2Range.start + 1, sequenceDiff.seq2Range.endExclusive + 1))));
+}
 export { DefaultLinesDiffComputer, getLineRangeMapping, lineRangeMappingFromRangeMappings };

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/linesSliceCharSequence.js

@@ -5,42 +5,39 @@ import { Position } from '../../core/position.js';
 import { Range } from '../../core/range.js';
 import { isSpace } from './utils.js';
 class LinesSliceCharSequence {
-    constructor(lines, lineRange, considerWhitespaceChanges) {
+    constructor(lines, range, considerWhitespaceChanges) {
         this.lines = lines;
+        this.range = range;
         this.considerWhitespaceChanges = considerWhitespaceChanges;
         this.elements = [];
-        this.firstCharOffsetByLine = [];
-        this.additionalOffsetByLine = [];
-        let trimFirstLineFully = false;
-        if (lineRange.start > 0 && lineRange.endExclusive >= lines.length) {
-            lineRange = ( new OffsetRange(lineRange.start - 1, lineRange.endExclusive));
-            trimFirstLineFully = true;
-        }
-        this.lineRange = lineRange;
-        this.firstCharOffsetByLine[0] = 0;
-        for (let i = this.lineRange.start; i < this.lineRange.endExclusive; i++) {
-            let line = lines[i];
-            let offset = 0;
-            if (trimFirstLineFully) {
-                offset = line.length;
-                line = '';
-                trimFirstLineFully = false;
+        this.firstElementOffsetByLineIdx = [];
+        this.lineStartOffsets = [];
+        this.trimmedWsLengthsByLineIdx = [];
+        this.firstElementOffsetByLineIdx.push(0);
+        for (let lineNumber = this.range.startLineNumber; lineNumber <= this.range.endLineNumber; lineNumber++) {
+            let line = lines[lineNumber - 1];
+            let lineStartOffset = 0;
+            if (lineNumber === this.range.startLineNumber && this.range.startColumn > 1) {
+                lineStartOffset = this.range.startColumn - 1;
+                line = line.substring(lineStartOffset);
             }
-            else if (!considerWhitespaceChanges) {
+            this.lineStartOffsets.push(lineStartOffset);
+            let trimmedWsLength = 0;
+            if (!considerWhitespaceChanges) {
                 const trimmedStartLine = line.trimStart();
-                offset = line.length - trimmedStartLine.length;
+                trimmedWsLength = line.length - trimmedStartLine.length;
                 line = trimmedStartLine.trimEnd();
             }
-            this.additionalOffsetByLine.push(offset);
-            for (let i = 0; i < line.length; i++) {
+            this.trimmedWsLengthsByLineIdx.push(trimmedWsLength);
+            const lineLength = lineNumber === this.range.endLineNumber ? Math.min(this.range.endColumn - 1 - lineStartOffset - trimmedWsLength, line.length) : line.length;
+            for (let i = 0; i < lineLength; i++) {
                 this.elements.push(line.charCodeAt(i));
             }
-            if (i < lines.length - 1) {
+            if (lineNumber < this.range.endLineNumber) {
                 this.elements.push('\n'.charCodeAt(0));
-                this.firstCharOffsetByLine[i - this.lineRange.start + 1] = this.elements.length;
+                this.firstElementOffsetByLineIdx.push(this.elements.length);
             }
         }
-        this.additionalOffsetByLine.push(0);
     }
     toString() {
         return `Slice: "${this.text}"`;
@@ -77,18 +74,21 @@ class LinesSliceCharSequence {
         score += getCategoryBoundaryScore(nextCategory);
         return score;
     }
-    translateOffset(offset) {
-        if (this.lineRange.isEmpty) {
-            return ( new Position(this.lineRange.start + 1, 1));
-        }
-        const i = findLastIdxMonotonous(this.firstCharOffsetByLine, (value) => value <= offset);
+    translateOffset(offset, preference = 'right') {
+        const i = findLastIdxMonotonous(this.firstElementOffsetByLineIdx, (value) => value <= offset);
+        const lineOffset = offset - this.firstElementOffsetByLineIdx[i];
         return ( new Position(
-            this.lineRange.start + i + 1,
-            offset - this.firstCharOffsetByLine[i] + this.additionalOffsetByLine[i] + 1
+            this.range.startLineNumber + i,
+            1 + this.lineStartOffsets[i] + lineOffset + ((lineOffset === 0 && preference === 'left') ? 0 : this.trimmedWsLengthsByLineIdx[i])
         ));
     }
     translateRange(range) {
-        return Range.fromPositions(this.translateOffset(range.start), this.translateOffset(range.endExclusive));
+        const pos1 = this.translateOffset(range.start, 'right');
+        const pos2 = this.translateOffset(range.endExclusive, 'left');
+        if (pos2.isBefore(pos1)) {
+            return Range.fromPositions(pos2, pos2);
+        }
+        return Range.fromPositions(pos1, pos2);
     }
     findWordContaining(offset) {
         if (offset < 0 || offset >= this.elements.length) {
@@ -114,8 +114,8 @@ class LinesSliceCharSequence {
         return this.elements[offset1] === this.elements[offset2];
     }
     extendToFullLines(range) {
-        const start = findLastMonotonous(this.firstCharOffsetByLine, x => x <= range.start) ?? 0;
-        const end = findFirstMonotonous(this.firstCharOffsetByLine, x => range.endExclusive <= x) ?? this.elements.length;
+        const start = findLastMonotonous(this.firstElementOffsetByLineIdx, x => x <= range.start) ?? 0;
+        const end = findFirstMonotonous(this.firstElementOffsetByLineIdx, x => range.endExclusive <= x) ?? this.elements.length;
         return ( new OffsetRange(start, end));
     }
 }

package/vscode/src/vs/editor/common/diff/rangeMapping.d.ts

@@ -27,6 +27,12 @@ declare class LineRangeMapping {
      * It avoids various problems when the line range points to non-existing line-numbers.
     */
     toRangeMapping(): RangeMapping;
+    /**
+     * This method assumes that the LineRangeMapping describes a valid diff!
+     * I.e. if one range is empty, the other range cannot be the entire document.
+     * It avoids various problems when the line range points to non-existing line-numbers.
+    */
+    toRangeMapping2(original: string[], modified: string[]): RangeMapping;
 }
 /**
  * Maps a line range in the original text model to a line range in the modified text model.
@@ -49,6 +55,7 @@ declare class DetailedLineRangeMapping extends LineRangeMapping {
  * Maps a range in the original text model to a range in the modified text model.
  */
 declare class RangeMapping {
+    static assertSorted(rangeMappings: RangeMapping[]): void;
     /**
      * The original range.
      */

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

@@ -1,5 +1,6 @@
 import { BugIndicatingError } from '../../../base/common/errors.js';
 import { LineRange } from '../core/lineRange.js';
+import { Position } from '../core/position.js';
 import { Range } from '../core/range.js';
 import { SingleTextEdit } from '../core/textEdit.js';
 class LineRangeMapping {
@@ -74,6 +75,35 @@ class LineRangeMapping {
             ))));
         }
     }
+    toRangeMapping2(original, modified) {
+        if (isValidLineNumber(this.original.endLineNumberExclusive, original)
+            && isValidLineNumber(this.modified.endLineNumberExclusive, modified)) {
+            return ( new RangeMapping(( new Range(this.original.startLineNumber, 1, this.original.endLineNumberExclusive, 1)), ( new Range(this.modified.startLineNumber, 1, this.modified.endLineNumberExclusive, 1))));
+        }
+        if (!this.original.isEmpty && !this.modified.isEmpty) {
+            return ( new RangeMapping(Range.fromPositions(( new Position(this.original.startLineNumber, 1)), normalizePosition(( new Position(this.original.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER)), original)), Range.fromPositions(( new Position(this.modified.startLineNumber, 1)), normalizePosition(( new Position(this.modified.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER)), modified))));
+        }
+        if (this.original.startLineNumber > 1 && this.modified.startLineNumber > 1) {
+            return ( new RangeMapping(Range.fromPositions(normalizePosition(( new Position(this.original.startLineNumber - 1, Number.MAX_SAFE_INTEGER)), original), normalizePosition(( new Position(this.original.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER)), original)), Range.fromPositions(normalizePosition(( new Position(this.modified.startLineNumber - 1, Number.MAX_SAFE_INTEGER)), modified), normalizePosition(( new Position(this.modified.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER)), modified))));
+        }
+        throw ( new BugIndicatingError());
+    }
+}
+function normalizePosition(position, content) {
+    if (position.lineNumber < 1) {
+        return ( new Position(1, 1));
+    }
+    if (position.lineNumber > content.length) {
+        return ( new Position(content.length, content[content.length - 1].length + 1));
+    }
+    const line = content[position.lineNumber - 1];
+    if (position.column > line.length + 1) {
+        return ( new Position(position.lineNumber, line.length + 1));
+    }
+    return position;
+}
+function isValidLineNumber(lineNumber, lines) {
+    return lineNumber >= 1 && lineNumber <= lines.length;
 }
 class DetailedLineRangeMapping extends LineRangeMapping {
     static fromRangeMappings(rangeMappings) {
@@ -93,6 +123,16 @@ class DetailedLineRangeMapping extends LineRangeMapping {
     }
 }
 class RangeMapping {
+    static assertSorted(rangeMappings) {
+        for (let i = 1; i < rangeMappings.length; i++) {
+            const previous = rangeMappings[i - 1];
+            const current = rangeMappings[i];
+            if (!(previous.originalRange.getEndPosition().isBeforeOrEqual(current.originalRange.getStartPosition())
+                && previous.modifiedRange.getEndPosition().isBeforeOrEqual(current.modifiedRange.getStartPosition()))) {
+                throw ( new BugIndicatingError('Range mappings must be sorted'));
+            }
+        }
+    }
     constructor(originalRange, modifiedRange) {
         this.originalRange = originalRange;
         this.modifiedRange = modifiedRange;