@codingame/monaco-vscode-api 15.0.3 → 16.0.0

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

@@ -14,174 +14,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(645, 'Background color for the highlight of line at the cursor position.')));
+const editorLineHighlight = registerColor('editor.lineHighlightBackground', null, ( localize(647, '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(
- 646,
+ 648,
  '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(
- 647,
+ 649,
  '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(648, 'Background color of the border around highlighted ranges.')));
+registerColor('editor.rangeHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(650, 'Background color of the border around highlighted ranges.')));
 registerColor('editor.symbolHighlightBackground', { dark: editorFindMatchHighlight, light: editorFindMatchHighlight, hcDark: null, hcLight: null }, ( localize(
- 649,
+ 651,
  '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(650, 'Background color of the border around highlighted symbols.')));
-const editorCursorForeground = registerColor('editorCursor.foreground', { dark: '#AEAFAD', light: Color.black, hcDark: Color.white, hcLight: '#0F4A85' }, ( localize(651, 'Color of the editor cursor.')));
+registerColor('editor.symbolHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(652, 'Background color of the border around highlighted symbols.')));
+const editorCursorForeground = registerColor('editorCursor.foreground', { dark: '#AEAFAD', light: Color.black, hcDark: Color.white, hcLight: '#0F4A85' }, ( localize(653, 'Color of the editor cursor.')));
 const editorCursorBackground = registerColor('editorCursor.background', null, ( localize(
- 652,
+ 654,
  '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(
- 653,
+ 655,
  'Color of the primary editor cursor when multiple cursors are present.'
 )));
 const editorMultiCursorPrimaryBackground = registerColor('editorMultiCursor.primary.background', editorCursorBackground, ( localize(
- 654,
+ 656,
  '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(
- 655,
+ 657,
  'Color of secondary editor cursors when multiple cursors are present.'
 )));
 const editorMultiCursorSecondaryBackground = registerColor('editorMultiCursor.secondary.background', editorCursorBackground, ( localize(
- 656,
+ 658,
  '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(657, 'Color of whitespace characters in the editor.')));
-const editorLineNumbers = registerColor('editorLineNumber.foreground', { dark: '#858585', light: '#237893', hcDark: Color.white, hcLight: '#292929' }, ( localize(658, 'Color of editor line numbers.')));
-const deprecatedEditorIndentGuides = registerColor('editorIndentGuide.background', editorWhitespaces, ( localize(659, 'Color of the editor indentation guides.')), false, ( localize(
- 660,
+const editorWhitespaces = registerColor('editorWhitespace.foreground', { dark: '#e3e4e229', light: '#33333333', hcDark: '#e3e4e229', hcLight: '#CCCCCC' }, ( localize(659, 'Color of whitespace characters in the editor.')));
+const editorLineNumbers = registerColor('editorLineNumber.foreground', { dark: '#858585', light: '#237893', hcDark: Color.white, hcLight: '#292929' }, ( localize(660, 'Color of editor line numbers.')));
+const deprecatedEditorIndentGuides = registerColor('editorIndentGuide.background', editorWhitespaces, ( localize(661, 'Color of the editor indentation guides.')), false, ( localize(
+ 662,
  '\'editorIndentGuide.background\' is deprecated. Use \'editorIndentGuide.background1\' instead.'
 )));
-const deprecatedEditorActiveIndentGuides = registerColor('editorIndentGuide.activeBackground', editorWhitespaces, ( localize(661, 'Color of the active editor indentation guides.')), false, ( localize(
- 662,
+const deprecatedEditorActiveIndentGuides = registerColor('editorIndentGuide.activeBackground', editorWhitespaces, ( localize(663, 'Color of the active editor indentation guides.')), false, ( localize(
+ 664,
  '\'editorIndentGuide.activeBackground\' is deprecated. Use \'editorIndentGuide.activeBackground1\' instead.'
 )));
-const editorIndentGuide1 = registerColor('editorIndentGuide.background1', deprecatedEditorIndentGuides, ( localize(663, 'Color of the editor indentation guides (1).')));
-const editorIndentGuide2 = registerColor('editorIndentGuide.background2', '#00000000', ( localize(664, 'Color of the editor indentation guides (2).')));
-const editorIndentGuide3 = registerColor('editorIndentGuide.background3', '#00000000', ( localize(665, 'Color of the editor indentation guides (3).')));
-const editorIndentGuide4 = registerColor('editorIndentGuide.background4', '#00000000', ( localize(666, 'Color of the editor indentation guides (4).')));
-const editorIndentGuide5 = registerColor('editorIndentGuide.background5', '#00000000', ( localize(667, 'Color of the editor indentation guides (5).')));
-const editorIndentGuide6 = registerColor('editorIndentGuide.background6', '#00000000', ( localize(668, 'Color of the editor indentation guides (6).')));
-const editorActiveIndentGuide1 = registerColor('editorIndentGuide.activeBackground1', deprecatedEditorActiveIndentGuides, ( localize(669, 'Color of the active editor indentation guides (1).')));
-const editorActiveIndentGuide2 = registerColor('editorIndentGuide.activeBackground2', '#00000000', ( localize(670, 'Color of the active editor indentation guides (2).')));
-const editorActiveIndentGuide3 = registerColor('editorIndentGuide.activeBackground3', '#00000000', ( localize(671, 'Color of the active editor indentation guides (3).')));
-const editorActiveIndentGuide4 = registerColor('editorIndentGuide.activeBackground4', '#00000000', ( localize(672, 'Color of the active editor indentation guides (4).')));
-const editorActiveIndentGuide5 = registerColor('editorIndentGuide.activeBackground5', '#00000000', ( localize(673, 'Color of the active editor indentation guides (5).')));
-const editorActiveIndentGuide6 = registerColor('editorIndentGuide.activeBackground6', '#00000000', ( localize(674, 'Color of the active editor indentation guides (6).')));
-const deprecatedEditorActiveLineNumber = registerColor('editorActiveLineNumber.foreground', { dark: '#c6c6c6', light: '#0B216F', hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(675, 'Color of editor active line number')), false, ( localize(
- 676,
+const editorIndentGuide1 = registerColor('editorIndentGuide.background1', deprecatedEditorIndentGuides, ( localize(665, 'Color of the editor indentation guides (1).')));
+const editorIndentGuide2 = registerColor('editorIndentGuide.background2', '#00000000', ( localize(666, 'Color of the editor indentation guides (2).')));
+const editorIndentGuide3 = registerColor('editorIndentGuide.background3', '#00000000', ( localize(667, 'Color of the editor indentation guides (3).')));
+const editorIndentGuide4 = registerColor('editorIndentGuide.background4', '#00000000', ( localize(668, 'Color of the editor indentation guides (4).')));
+const editorIndentGuide5 = registerColor('editorIndentGuide.background5', '#00000000', ( localize(669, 'Color of the editor indentation guides (5).')));
+const editorIndentGuide6 = registerColor('editorIndentGuide.background6', '#00000000', ( localize(670, 'Color of the editor indentation guides (6).')));
+const editorActiveIndentGuide1 = registerColor('editorIndentGuide.activeBackground1', deprecatedEditorActiveIndentGuides, ( localize(671, 'Color of the active editor indentation guides (1).')));
+const editorActiveIndentGuide2 = registerColor('editorIndentGuide.activeBackground2', '#00000000', ( localize(672, 'Color of the active editor indentation guides (2).')));
+const editorActiveIndentGuide3 = registerColor('editorIndentGuide.activeBackground3', '#00000000', ( localize(673, 'Color of the active editor indentation guides (3).')));
+const editorActiveIndentGuide4 = registerColor('editorIndentGuide.activeBackground4', '#00000000', ( localize(674, 'Color of the active editor indentation guides (4).')));
+const editorActiveIndentGuide5 = registerColor('editorIndentGuide.activeBackground5', '#00000000', ( localize(675, 'Color of the active editor indentation guides (5).')));
+const editorActiveIndentGuide6 = registerColor('editorIndentGuide.activeBackground6', '#00000000', ( localize(676, 'Color of the active editor indentation guides (6).')));
+const deprecatedEditorActiveLineNumber = registerColor('editorActiveLineNumber.foreground', { dark: '#c6c6c6', light: '#0B216F', hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(677, 'Color of editor active line number')), false, ( localize(
+ 678,
  'Id is deprecated. Use \'editorLineNumber.activeForeground\' instead.'
 )));
-registerColor('editorLineNumber.activeForeground', deprecatedEditorActiveLineNumber, ( localize(675, 'Color of editor active line number')));
+registerColor('editorLineNumber.activeForeground', deprecatedEditorActiveLineNumber, ( localize(677, 'Color of editor active line number')));
 const editorDimmedLineNumber = registerColor('editorLineNumber.dimmedForeground', null, ( localize(
- 677,
+ 679,
  '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(678, 'Color of the editor rulers.')));
-registerColor('editorCodeLens.foreground', { dark: '#999999', light: '#919191', hcDark: '#999999', hcLight: '#292929' }, ( localize(679, 'Foreground color of editor CodeLens')));
-registerColor('editorBracketMatch.background', { dark: '#0064001a', light: '#0064001a', hcDark: '#0064001a', hcLight: '#0000' }, ( localize(680, 'Background color behind matching brackets')));
-registerColor('editorBracketMatch.border', { dark: '#888', light: '#B9B9B9', hcDark: contrastBorder, hcLight: contrastBorder }, ( localize(681, 'Color for matching brackets boxes')));
-const editorOverviewRulerBorder = registerColor('editorOverviewRuler.border', { dark: '#7f7f7f4d', light: '#7f7f7f4d', hcDark: '#7f7f7f4d', hcLight: '#666666' }, ( localize(682, 'Color of the overview ruler border.')));
-const editorOverviewRulerBackground = registerColor('editorOverviewRuler.background', null, ( localize(683, 'Background color of the editor overview ruler.')));
+const editorRuler = registerColor('editorRuler.foreground', { dark: '#5A5A5A', light: Color.lightgrey, hcDark: Color.white, hcLight: '#292929' }, ( localize(680, 'Color of the editor rulers.')));
+registerColor('editorCodeLens.foreground', { dark: '#999999', light: '#919191', hcDark: '#999999', hcLight: '#292929' }, ( localize(681, 'Foreground color of editor CodeLens')));
+registerColor('editorBracketMatch.background', { dark: '#0064001a', light: '#0064001a', hcDark: '#0064001a', hcLight: '#0000' }, ( localize(682, 'Background color behind matching brackets')));
+registerColor('editorBracketMatch.border', { dark: '#888', light: '#B9B9B9', hcDark: contrastBorder, hcLight: contrastBorder }, ( localize(683, 'Color for matching brackets boxes')));
+const editorOverviewRulerBorder = registerColor('editorOverviewRuler.border', { dark: '#7f7f7f4d', light: '#7f7f7f4d', hcDark: '#7f7f7f4d', hcLight: '#666666' }, ( localize(684, 'Color of the overview ruler border.')));
+const editorOverviewRulerBackground = registerColor('editorOverviewRuler.background', null, ( localize(685, 'Background color of the editor overview ruler.')));
 registerColor('editorGutter.background', editorBackground, ( localize(
- 684,
+ 686,
  '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(685, '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(687, '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(
- 686,
+ 688,
  '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(687, '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(688, 'Foreground color of the ghost text in the editor.')));
-registerColor('editorGhostText.background', null, ( localize(689, '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(689, '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(690, 'Foreground color of the ghost text in the editor.')));
+registerColor('editorGhostText.background', null, ( localize(691, '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(
- 690,
+ 692,
  '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(691, 'Overview ruler marker color for errors.')));
-const overviewRulerWarning = registerColor('editorOverviewRuler.warningForeground', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningBorder, hcLight: editorWarningBorder }, ( localize(692, 'Overview ruler marker color for warnings.')));
-const overviewRulerInfo = registerColor('editorOverviewRuler.infoForeground', { dark: editorInfoForeground, light: editorInfoForeground, hcDark: editorInfoBorder, hcLight: editorInfoBorder }, ( localize(693, '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(693, 'Overview ruler marker color for errors.')));
+const overviewRulerWarning = registerColor('editorOverviewRuler.warningForeground', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningBorder, hcLight: editorWarningBorder }, ( localize(694, 'Overview ruler marker color for warnings.')));
+const overviewRulerInfo = registerColor('editorOverviewRuler.infoForeground', { dark: editorInfoForeground, light: editorInfoForeground, hcDark: editorInfoBorder, hcLight: editorInfoBorder }, ( localize(695, 'Overview ruler marker color for infos.')));
 const editorBracketHighlightingForeground1 = registerColor('editorBracketHighlight.foreground1', { dark: '#FFD700', light: '#0431FAFF', hcDark: '#FFD700', hcLight: '#0431FAFF' }, ( localize(
- 694,
+ 696,
  'Foreground color of brackets (1). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground2 = registerColor('editorBracketHighlight.foreground2', { dark: '#DA70D6', light: '#319331FF', hcDark: '#DA70D6', hcLight: '#319331FF' }, ( localize(
- 695,
+ 697,
  'Foreground color of brackets (2). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground3 = registerColor('editorBracketHighlight.foreground3', { dark: '#179FFF', light: '#7B3814FF', hcDark: '#87CEFA', hcLight: '#7B3814FF' }, ( localize(
- 696,
+ 698,
  'Foreground color of brackets (3). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground4 = registerColor('editorBracketHighlight.foreground4', '#00000000', ( localize(
- 697,
+ 699,
  'Foreground color of brackets (4). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground5 = registerColor('editorBracketHighlight.foreground5', '#00000000', ( localize(
- 698,
+ 700,
  'Foreground color of brackets (5). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground6 = registerColor('editorBracketHighlight.foreground6', '#00000000', ( localize(
- 699,
+ 701,
  '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(700, '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(702, 'Foreground color of unexpected brackets.')));
 const editorBracketPairGuideBackground1 = registerColor('editorBracketPairGuide.background1', '#00000000', ( localize(
- 701,
+ 703,
  'Background color of inactive bracket pair guides (1). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground2 = registerColor('editorBracketPairGuide.background2', '#00000000', ( localize(
- 702,
+ 704,
  'Background color of inactive bracket pair guides (2). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground3 = registerColor('editorBracketPairGuide.background3', '#00000000', ( localize(
- 703,
+ 705,
  'Background color of inactive bracket pair guides (3). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground4 = registerColor('editorBracketPairGuide.background4', '#00000000', ( localize(
- 704,
+ 706,
  'Background color of inactive bracket pair guides (4). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground5 = registerColor('editorBracketPairGuide.background5', '#00000000', ( localize(
- 705,
+ 707,
  'Background color of inactive bracket pair guides (5). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground6 = registerColor('editorBracketPairGuide.background6', '#00000000', ( localize(
- 706,
+ 708,
  'Background color of inactive bracket pair guides (6). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground1 = registerColor('editorBracketPairGuide.activeBackground1', '#00000000', ( localize(
- 707,
+ 709,
  'Background color of active bracket pair guides (1). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground2 = registerColor('editorBracketPairGuide.activeBackground2', '#00000000', ( localize(
- 708,
+ 710,
  'Background color of active bracket pair guides (2). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground3 = registerColor('editorBracketPairGuide.activeBackground3', '#00000000', ( localize(
- 709,
+ 711,
  'Background color of active bracket pair guides (3). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground4 = registerColor('editorBracketPairGuide.activeBackground4', '#00000000', ( localize(
- 710,
+ 712,
  'Background color of active bracket pair guides (4). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground5 = registerColor('editorBracketPairGuide.activeBackground5', '#00000000', ( localize(
- 711,
+ 713,
  'Background color of active bracket pair guides (5). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground6 = registerColor('editorBracketPairGuide.activeBackground6', '#00000000', ( localize(
- 712,
+ 714,
  'Background color of active bracket pair guides (6). Requires enabling bracket pair guides.'
 )));
-registerColor('editorUnicodeHighlight.border', editorWarningForeground, ( localize(713, 'Border color used to highlight unicode characters.')));
-registerColor('editorUnicodeHighlight.background', editorWarningBackground, ( localize(714, 'Background color used to highlight unicode characters.')));
+registerColor('editorUnicodeHighlight.border', editorWarningForeground, ( localize(715, 'Border color used to highlight unicode characters.')));
+registerColor('editorUnicodeHighlight.background', editorWarningBackground, ( localize(716, '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/editorContextKeys.js

@@ -5,73 +5,73 @@ import { RawContextKey } from '../../platform/contextkey/common/contextkey.js';
 var EditorContextKeys;
 (function (EditorContextKeys) {
     EditorContextKeys.editorSimpleInput = ( new RawContextKey('editorSimpleInput', false, true));
-    EditorContextKeys.editorTextFocus = ( new RawContextKey('editorTextFocus', false, ( localize(715, "Whether the editor text has focus (cursor is blinking)"))));
+    EditorContextKeys.editorTextFocus = ( new RawContextKey('editorTextFocus', false, ( localize(717, "Whether the editor text has focus (cursor is blinking)"))));
     EditorContextKeys.focus = ( new RawContextKey('editorFocus', false, ( localize(
-     716,
+     718,
      "Whether the editor or an editor widget has focus (e.g. focus is in the find widget)"
     ))));
     EditorContextKeys.textInputFocus = ( new RawContextKey('textInputFocus', false, ( localize(
-     717,
+     719,
      "Whether an editor or a rich text input has focus (cursor is blinking)"
     ))));
-    EditorContextKeys.readOnly = ( new RawContextKey('editorReadonly', false, ( localize(718, "Whether the editor is read-only"))));
-    EditorContextKeys.inDiffEditor = ( new RawContextKey('inDiffEditor', false, ( localize(719, "Whether the context is a diff editor"))));
-    EditorContextKeys.isEmbeddedDiffEditor = ( new RawContextKey('isEmbeddedDiffEditor', false, ( localize(720, "Whether the context is an embedded diff editor"))));
-    EditorContextKeys.multiDiffEditorAllCollapsed = ( new RawContextKey('multiDiffEditorAllCollapsed', undefined, ( localize(721, "Whether all files in multi diff editor are collapsed"))));
-    EditorContextKeys.hasChanges = ( new RawContextKey('diffEditorHasChanges', false, ( localize(722, "Whether the diff editor has changes"))));
-    EditorContextKeys.comparingMovedCode = ( new RawContextKey('comparingMovedCode', false, ( localize(723, "Whether a moved code block is selected for comparison"))));
-    EditorContextKeys.accessibleDiffViewerVisible = ( new RawContextKey('accessibleDiffViewerVisible', false, ( localize(724, "Whether the accessible diff viewer is visible"))));
+    EditorContextKeys.readOnly = ( new RawContextKey('editorReadonly', false, ( localize(720, "Whether the editor is read-only"))));
+    EditorContextKeys.inDiffEditor = ( new RawContextKey('inDiffEditor', false, ( localize(721, "Whether the context is a diff editor"))));
+    EditorContextKeys.isEmbeddedDiffEditor = ( new RawContextKey('isEmbeddedDiffEditor', false, ( localize(722, "Whether the context is an embedded diff editor"))));
+    EditorContextKeys.multiDiffEditorAllCollapsed = ( new RawContextKey('multiDiffEditorAllCollapsed', undefined, ( localize(723, "Whether all files in multi diff editor are collapsed"))));
+    EditorContextKeys.hasChanges = ( new RawContextKey('diffEditorHasChanges', false, ( localize(724, "Whether the diff editor has changes"))));
+    EditorContextKeys.comparingMovedCode = ( new RawContextKey('comparingMovedCode', false, ( localize(725, "Whether a moved code block is selected for comparison"))));
+    EditorContextKeys.accessibleDiffViewerVisible = ( new RawContextKey('accessibleDiffViewerVisible', false, ( localize(726, "Whether the accessible diff viewer is visible"))));
     EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached = ( new RawContextKey('diffEditorRenderSideBySideInlineBreakpointReached', false, ( localize(
-     725,
+     727,
      "Whether the diff editor render side by side inline breakpoint is reached"
     ))));
-    EditorContextKeys.diffEditorInlineMode = ( new RawContextKey('diffEditorInlineMode', false, ( localize(726, "Whether inline mode is active"))));
-    EditorContextKeys.diffEditorOriginalWritable = ( new RawContextKey('diffEditorOriginalWritable', false, ( localize(727, "Whether modified is writable in the diff editor"))));
-    EditorContextKeys.diffEditorModifiedWritable = ( new RawContextKey('diffEditorModifiedWritable', false, ( localize(728, "Whether modified is writable in the diff editor"))));
-    EditorContextKeys.diffEditorOriginalUri = ( new RawContextKey('diffEditorOriginalUri', '', ( localize(729, "The uri of the original document"))));
-    EditorContextKeys.diffEditorModifiedUri = ( new RawContextKey('diffEditorModifiedUri', '', ( localize(730, "The uri of the modified document"))));
-    EditorContextKeys.columnSelection = ( new RawContextKey('editorColumnSelection', false, ( localize(731, "Whether `editor.columnSelection` is enabled"))));
+    EditorContextKeys.diffEditorInlineMode = ( new RawContextKey('diffEditorInlineMode', false, ( localize(728, "Whether inline mode is active"))));
+    EditorContextKeys.diffEditorOriginalWritable = ( new RawContextKey('diffEditorOriginalWritable', false, ( localize(729, "Whether modified is writable in the diff editor"))));
+    EditorContextKeys.diffEditorModifiedWritable = ( new RawContextKey('diffEditorModifiedWritable', false, ( localize(730, "Whether modified is writable in the diff editor"))));
+    EditorContextKeys.diffEditorOriginalUri = ( new RawContextKey('diffEditorOriginalUri', '', ( localize(731, "The uri of the original document"))));
+    EditorContextKeys.diffEditorModifiedUri = ( new RawContextKey('diffEditorModifiedUri', '', ( localize(732, "The uri of the modified document"))));
+    EditorContextKeys.columnSelection = ( new RawContextKey('editorColumnSelection', false, ( localize(733, "Whether `editor.columnSelection` is enabled"))));
     EditorContextKeys.writable = ( EditorContextKeys.readOnly.toNegated());
-    EditorContextKeys.hasNonEmptySelection = ( new RawContextKey('editorHasSelection', false, ( localize(732, "Whether the editor has text selected"))));
+    EditorContextKeys.hasNonEmptySelection = ( new RawContextKey('editorHasSelection', false, ( localize(734, "Whether the editor has text selected"))));
     EditorContextKeys.hasOnlyEmptySelection = ( EditorContextKeys.hasNonEmptySelection.toNegated());
-    EditorContextKeys.hasMultipleSelections = ( new RawContextKey('editorHasMultipleSelections', false, ( localize(733, "Whether the editor has multiple selections"))));
+    EditorContextKeys.hasMultipleSelections = ( new RawContextKey('editorHasMultipleSelections', false, ( localize(735, "Whether the editor has multiple selections"))));
     EditorContextKeys.hasSingleSelection = ( EditorContextKeys.hasMultipleSelections.toNegated());
-    EditorContextKeys.tabMovesFocus = ( new RawContextKey('editorTabMovesFocus', false, ( localize(734, "Whether `Tab` will move focus out of the editor"))));
+    EditorContextKeys.tabMovesFocus = ( new RawContextKey('editorTabMovesFocus', false, ( localize(736, "Whether `Tab` will move focus out of the editor"))));
     EditorContextKeys.tabDoesNotMoveFocus = ( EditorContextKeys.tabMovesFocus.toNegated());
     EditorContextKeys.isInEmbeddedEditor = ( new RawContextKey('isInEmbeddedEditor', false, true));
     EditorContextKeys.canUndo = ( new RawContextKey('canUndo', false, true));
     EditorContextKeys.canRedo = ( new RawContextKey('canRedo', false, true));
-    EditorContextKeys.hoverVisible = ( new RawContextKey('editorHoverVisible', false, ( localize(735, "Whether the editor hover is visible"))));
-    EditorContextKeys.hoverFocused = ( new RawContextKey('editorHoverFocused', false, ( localize(736, "Whether the editor hover is focused"))));
-    EditorContextKeys.stickyScrollFocused = ( new RawContextKey('stickyScrollFocused', false, ( localize(737, "Whether the sticky scroll is focused"))));
-    EditorContextKeys.stickyScrollVisible = ( new RawContextKey('stickyScrollVisible', false, ( localize(738, "Whether the sticky scroll is visible"))));
-    EditorContextKeys.standaloneColorPickerVisible = ( new RawContextKey('standaloneColorPickerVisible', false, ( localize(739, "Whether the standalone color picker is visible"))));
-    EditorContextKeys.standaloneColorPickerFocused = ( new RawContextKey('standaloneColorPickerFocused', false, ( localize(740, "Whether the standalone color picker is focused"))));
-    EditorContextKeys.inCompositeEditor = ( new RawContextKey('inCompositeEditor', undefined, ( localize(741, "Whether the editor is part of a larger editor (e.g. notebooks)"))));
+    EditorContextKeys.hoverVisible = ( new RawContextKey('editorHoverVisible', false, ( localize(737, "Whether the editor hover is visible"))));
+    EditorContextKeys.hoverFocused = ( new RawContextKey('editorHoverFocused', false, ( localize(738, "Whether the editor hover is focused"))));
+    EditorContextKeys.stickyScrollFocused = ( new RawContextKey('stickyScrollFocused', false, ( localize(739, "Whether the sticky scroll is focused"))));
+    EditorContextKeys.stickyScrollVisible = ( new RawContextKey('stickyScrollVisible', false, ( localize(740, "Whether the sticky scroll is visible"))));
+    EditorContextKeys.standaloneColorPickerVisible = ( new RawContextKey('standaloneColorPickerVisible', false, ( localize(741, "Whether the standalone color picker is visible"))));
+    EditorContextKeys.standaloneColorPickerFocused = ( new RawContextKey('standaloneColorPickerFocused', false, ( localize(742, "Whether the standalone color picker is focused"))));
+    EditorContextKeys.inCompositeEditor = ( new RawContextKey('inCompositeEditor', undefined, ( localize(743, "Whether the editor is part of a larger editor (e.g. notebooks)"))));
     EditorContextKeys.notInCompositeEditor = ( EditorContextKeys.inCompositeEditor.toNegated());
-    EditorContextKeys.languageId = ( new RawContextKey('editorLangId', '', ( localize(742, "The language identifier of the editor"))));
-    EditorContextKeys.hasCompletionItemProvider = ( new RawContextKey('editorHasCompletionItemProvider', false, ( localize(743, "Whether the editor has a completion item provider"))));
-    EditorContextKeys.hasCodeActionsProvider = ( new RawContextKey('editorHasCodeActionsProvider', false, ( localize(744, "Whether the editor has a code actions provider"))));
-    EditorContextKeys.hasCodeLensProvider = ( new RawContextKey('editorHasCodeLensProvider', false, ( localize(745, "Whether the editor has a code lens provider"))));
-    EditorContextKeys.hasDefinitionProvider = ( new RawContextKey('editorHasDefinitionProvider', false, ( localize(746, "Whether the editor has a definition provider"))));
-    EditorContextKeys.hasDeclarationProvider = ( new RawContextKey('editorHasDeclarationProvider', false, ( localize(747, "Whether the editor has a declaration provider"))));
-    EditorContextKeys.hasImplementationProvider = ( new RawContextKey('editorHasImplementationProvider', false, ( localize(748, "Whether the editor has an implementation provider"))));
-    EditorContextKeys.hasTypeDefinitionProvider = ( new RawContextKey('editorHasTypeDefinitionProvider', false, ( localize(749, "Whether the editor has a type definition provider"))));
-    EditorContextKeys.hasHoverProvider = ( new RawContextKey('editorHasHoverProvider', false, ( localize(750, "Whether the editor has a hover provider"))));
-    EditorContextKeys.hasDocumentHighlightProvider = ( new RawContextKey('editorHasDocumentHighlightProvider', false, ( localize(751, "Whether the editor has a document highlight provider"))));
-    EditorContextKeys.hasDocumentSymbolProvider = ( new RawContextKey('editorHasDocumentSymbolProvider', false, ( localize(752, "Whether the editor has a document symbol provider"))));
-    EditorContextKeys.hasReferenceProvider = ( new RawContextKey('editorHasReferenceProvider', false, ( localize(753, "Whether the editor has a reference provider"))));
-    EditorContextKeys.hasRenameProvider = ( new RawContextKey('editorHasRenameProvider', false, ( localize(754, "Whether the editor has a rename provider"))));
-    EditorContextKeys.hasSignatureHelpProvider = ( new RawContextKey('editorHasSignatureHelpProvider', false, ( localize(755, "Whether the editor has a signature help provider"))));
-    EditorContextKeys.hasInlayHintsProvider = ( new RawContextKey('editorHasInlayHintsProvider', false, ( localize(756, "Whether the editor has an inline hints provider"))));
-    EditorContextKeys.hasDocumentFormattingProvider = ( new RawContextKey('editorHasDocumentFormattingProvider', false, ( localize(757, "Whether the editor has a document formatting provider"))));
-    EditorContextKeys.hasDocumentSelectionFormattingProvider = ( new RawContextKey('editorHasDocumentSelectionFormattingProvider', false, ( localize(758, "Whether the editor has a document selection formatting provider"))));
-    EditorContextKeys.hasMultipleDocumentFormattingProvider = ( new RawContextKey('editorHasMultipleDocumentFormattingProvider', false, ( localize(759, "Whether the editor has multiple document formatting providers"))));
+    EditorContextKeys.languageId = ( new RawContextKey('editorLangId', '', ( localize(744, "The language identifier of the editor"))));
+    EditorContextKeys.hasCompletionItemProvider = ( new RawContextKey('editorHasCompletionItemProvider', false, ( localize(745, "Whether the editor has a completion item provider"))));
+    EditorContextKeys.hasCodeActionsProvider = ( new RawContextKey('editorHasCodeActionsProvider', false, ( localize(746, "Whether the editor has a code actions provider"))));
+    EditorContextKeys.hasCodeLensProvider = ( new RawContextKey('editorHasCodeLensProvider', false, ( localize(747, "Whether the editor has a code lens provider"))));
+    EditorContextKeys.hasDefinitionProvider = ( new RawContextKey('editorHasDefinitionProvider', false, ( localize(748, "Whether the editor has a definition provider"))));
+    EditorContextKeys.hasDeclarationProvider = ( new RawContextKey('editorHasDeclarationProvider', false, ( localize(749, "Whether the editor has a declaration provider"))));
+    EditorContextKeys.hasImplementationProvider = ( new RawContextKey('editorHasImplementationProvider', false, ( localize(750, "Whether the editor has an implementation provider"))));
+    EditorContextKeys.hasTypeDefinitionProvider = ( new RawContextKey('editorHasTypeDefinitionProvider', false, ( localize(751, "Whether the editor has a type definition provider"))));
+    EditorContextKeys.hasHoverProvider = ( new RawContextKey('editorHasHoverProvider', false, ( localize(752, "Whether the editor has a hover provider"))));
+    EditorContextKeys.hasDocumentHighlightProvider = ( new RawContextKey('editorHasDocumentHighlightProvider', false, ( localize(753, "Whether the editor has a document highlight provider"))));
+    EditorContextKeys.hasDocumentSymbolProvider = ( new RawContextKey('editorHasDocumentSymbolProvider', false, ( localize(754, "Whether the editor has a document symbol provider"))));
+    EditorContextKeys.hasReferenceProvider = ( new RawContextKey('editorHasReferenceProvider', false, ( localize(755, "Whether the editor has a reference provider"))));
+    EditorContextKeys.hasRenameProvider = ( new RawContextKey('editorHasRenameProvider', false, ( localize(756, "Whether the editor has a rename provider"))));
+    EditorContextKeys.hasSignatureHelpProvider = ( new RawContextKey('editorHasSignatureHelpProvider', false, ( localize(757, "Whether the editor has a signature help provider"))));
+    EditorContextKeys.hasInlayHintsProvider = ( new RawContextKey('editorHasInlayHintsProvider', false, ( localize(758, "Whether the editor has an inline hints provider"))));
+    EditorContextKeys.hasDocumentFormattingProvider = ( new RawContextKey('editorHasDocumentFormattingProvider', false, ( localize(759, "Whether the editor has a document formatting provider"))));
+    EditorContextKeys.hasDocumentSelectionFormattingProvider = ( new RawContextKey('editorHasDocumentSelectionFormattingProvider', false, ( localize(760, "Whether the editor has a document selection formatting provider"))));
+    EditorContextKeys.hasMultipleDocumentFormattingProvider = ( new RawContextKey('editorHasMultipleDocumentFormattingProvider', false, ( localize(761, "Whether the editor has multiple document formatting providers"))));
     EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider = ( new RawContextKey(
      'editorHasMultipleDocumentSelectionFormattingProvider',
      false,
      ( localize(
-     760,
+     762,
      "Whether the editor has multiple document selection formatting providers"
     ))
     ));

package/vscode/src/vs/editor/common/languages/modesRegistry.js

@@ -39,7 +39,7 @@ const PLAINTEXT_EXTENSION = '.txt';
 ModesRegistry.registerLanguage({
     id: PLAINTEXT_LANGUAGE_ID,
     extensions: [PLAINTEXT_EXTENSION],
-    aliases: [( localize(788, "Plain Text")), 'text'],
+    aliases: [( localize(818, "Plain Text")), 'text'],
     mimetypes: [Mimes.text]
 });
 ( Registry.as(Extensions$1.Configuration))

package/vscode/src/vs/editor/common/languages.d.ts

@@ -19,9 +19,10 @@ import { ContiguousMultilineTokens } from "./tokens/contiguousMultilineTokens.js
 import { ExtensionIdentifier } from "../../platform/extensions/common/extensions.js";
 import { IMarkerData } from "../../platform/markers/common/markers.js";
 import { IModelTokensChangedEvent } from "./textModelEvents.js";
-import type * as Parser from "@vscode/tree-sitter-wasm";
 import { ITextModel } from "./model.js";
 import { TokenUpdate } from "@codingame/monaco-vscode-treesitter-service-override/vscode/vs/editor/common/model/tokenStore";
+import { ITextModelTreeSitter } from "@codingame/monaco-vscode-treesitter-service-override/vscode/vs/editor/common/services/treeSitterParserService";
+import type * as Parser from "@vscode/tree-sitter-wasm";
 export interface ILanguageIdCodec {
     encodeLanguageId(languageId: string): LanguageId;
     decodeLanguageId(languageId: LanguageId): string;
@@ -49,22 +50,25 @@ export declare class EncodedTokenizationResult {
 export interface SyntaxNode {
     startIndex: number;
     endIndex: number;
+    startPosition: IPosition;
+    endPosition: IPosition;
 }
 export interface QueryCapture {
     name: string;
     text?: string;
     node: SyntaxNode;
+    encodedLanguageId: number;
 }
 export interface ITreeSitterTokenizationSupport {
     getTokensInRange(textModel: ITextModel, range: Range, rangeStartOffset: number, rangeEndOffset: number): TokenUpdate[] | undefined;
     tokenizeEncoded(lineNumber: number, textModel: model.ITextModel): void;
     captureAtPosition(lineNumber: number, column: number, textModel: model.ITextModel): QueryCapture[];
-    captureAtPositionTree(lineNumber: number, column: number, tree: Parser.Tree): QueryCapture[];
+    captureAtRangeTree(range: Range, tree: Parser.Tree, textModelTreeSitter: ITextModelTreeSitter): QueryCapture[];
     onDidChangeTokens: Event<{
         textModel: model.ITextModel;
         changes: IModelTokensChangedEvent;
     }>;
-    onDidCompleteFirstTokenization: Event<{
+    onDidChangeBackgroundTokenization: Event<{
         textModel: model.ITextModel;
     }>;
     tokenizeEncodedInstrumented(lineNumber: number, textModel: model.ITextModel): {
@@ -72,6 +76,7 @@ export interface ITreeSitterTokenizationSupport {
         captureTime: number;
         metadataTime: number;
     } | undefined;
+    guessTokensForLinesContent(lineNumber: number, textModel: model.ITextModel, lines: string[]): Uint32Array[] | undefined;
 }
 export interface ITokenizationSupport {
     readonly backgroundTokenizerShouldOnlyVerifyTokens?: boolean;
@@ -178,6 +183,7 @@ export declare enum CompletionItemKind {
 }
 export declare namespace CompletionItemKinds {
     function toIcon(kind: CompletionItemKind): ThemeIcon;
+    function toLabel(kind: CompletionItemKind): string;
     function fromString(value: string): CompletionItemKind;
     function fromString(value: string, strict: true): CompletionItemKind | undefined;
 }

package/vscode/src/vs/editor/common/languages.js

@@ -109,6 +109,40 @@ var CompletionItemKinds;
         return codicon;
     }
     CompletionItemKinds.toIcon = toIcon;
+    function toLabel(kind) {
+        switch (kind) {
+            case CompletionItemKind.Method: return localize(763, 'Method');
+            case CompletionItemKind.Function: return localize(764, 'Function');
+            case CompletionItemKind.Constructor: return localize(765, 'Constructor');
+            case CompletionItemKind.Field: return localize(766, 'Field');
+            case CompletionItemKind.Variable: return localize(767, 'Variable');
+            case CompletionItemKind.Class: return localize(768, 'Class');
+            case CompletionItemKind.Struct: return localize(769, 'Struct');
+            case CompletionItemKind.Interface: return localize(770, 'Interface');
+            case CompletionItemKind.Module: return localize(771, 'Module');
+            case CompletionItemKind.Property: return localize(772, 'Property');
+            case CompletionItemKind.Event: return localize(773, 'Event');
+            case CompletionItemKind.Operator: return localize(774, 'Operator');
+            case CompletionItemKind.Unit: return localize(775, 'Unit');
+            case CompletionItemKind.Value: return localize(776, 'Value');
+            case CompletionItemKind.Constant: return localize(777, 'Constant');
+            case CompletionItemKind.Enum: return localize(778, 'Enum');
+            case CompletionItemKind.EnumMember: return localize(779, 'Enum Member');
+            case CompletionItemKind.Keyword: return localize(780, 'Keyword');
+            case CompletionItemKind.Text: return localize(781, 'Text');
+            case CompletionItemKind.Color: return localize(782, 'Color');
+            case CompletionItemKind.File: return localize(783, 'File');
+            case CompletionItemKind.Reference: return localize(784, 'Reference');
+            case CompletionItemKind.Customcolor: return localize(785, 'Custom Color');
+            case CompletionItemKind.Folder: return localize(786, 'Folder');
+            case CompletionItemKind.TypeParameter: return localize(787, 'Type Parameter');
+            case CompletionItemKind.User: return localize(788, 'User');
+            case CompletionItemKind.Issue: return localize(789, 'Issue');
+            case CompletionItemKind.Snippet: return localize(790, 'Snippet');
+            default: return '';
+        }
+    }
+    CompletionItemKinds.toLabel = toLabel;
     const data = ( new Map());
     data.set('method', CompletionItemKind.Method);
     data.set('function', CompletionItemKind.Function);
@@ -253,35 +287,35 @@ var SymbolKind;
     SymbolKind[SymbolKind["TypeParameter"] = 25] = "TypeParameter";
 })(SymbolKind || (SymbolKind = {}));
 const symbolKindNames = {
-    [SymbolKind.Array]: ( localize(761, "array")),
-    [SymbolKind.Boolean]: ( localize(762, "boolean")),
-    [SymbolKind.Class]: ( localize(763, "class")),
-    [SymbolKind.Constant]: ( localize(764, "constant")),
-    [SymbolKind.Constructor]: ( localize(765, "constructor")),
-    [SymbolKind.Enum]: ( localize(766, "enumeration")),
-    [SymbolKind.EnumMember]: ( localize(767, "enumeration member")),
-    [SymbolKind.Event]: ( localize(768, "event")),
-    [SymbolKind.Field]: ( localize(769, "field")),
-    [SymbolKind.File]: ( localize(770, "file")),
-    [SymbolKind.Function]: ( localize(771, "function")),
-    [SymbolKind.Interface]: ( localize(772, "interface")),
-    [SymbolKind.Key]: ( localize(773, "key")),
-    [SymbolKind.Method]: ( localize(774, "method")),
-    [SymbolKind.Module]: ( localize(775, "module")),
-    [SymbolKind.Namespace]: ( localize(776, "namespace")),
-    [SymbolKind.Null]: ( localize(777, "null")),
-    [SymbolKind.Number]: ( localize(778, "number")),
-    [SymbolKind.Object]: ( localize(779, "object")),
-    [SymbolKind.Operator]: ( localize(780, "operator")),
-    [SymbolKind.Package]: ( localize(781, "package")),
-    [SymbolKind.Property]: ( localize(782, "property")),
-    [SymbolKind.String]: ( localize(783, "string")),
-    [SymbolKind.Struct]: ( localize(784, "struct")),
-    [SymbolKind.TypeParameter]: ( localize(785, "type parameter")),
-    [SymbolKind.Variable]: ( localize(786, "variable")),
+    [SymbolKind.Array]: ( localize(791, "array")),
+    [SymbolKind.Boolean]: ( localize(792, "boolean")),
+    [SymbolKind.Class]: ( localize(793, "class")),
+    [SymbolKind.Constant]: ( localize(794, "constant")),
+    [SymbolKind.Constructor]: ( localize(795, "constructor")),
+    [SymbolKind.Enum]: ( localize(796, "enumeration")),
+    [SymbolKind.EnumMember]: ( localize(797, "enumeration member")),
+    [SymbolKind.Event]: ( localize(798, "event")),
+    [SymbolKind.Field]: ( localize(799, "field")),
+    [SymbolKind.File]: ( localize(800, "file")),
+    [SymbolKind.Function]: ( localize(801, "function")),
+    [SymbolKind.Interface]: ( localize(802, "interface")),
+    [SymbolKind.Key]: ( localize(803, "key")),
+    [SymbolKind.Method]: ( localize(804, "method")),
+    [SymbolKind.Module]: ( localize(805, "module")),
+    [SymbolKind.Namespace]: ( localize(806, "namespace")),
+    [SymbolKind.Null]: ( localize(807, "null")),
+    [SymbolKind.Number]: ( localize(808, "number")),
+    [SymbolKind.Object]: ( localize(809, "object")),
+    [SymbolKind.Operator]: ( localize(810, "operator")),
+    [SymbolKind.Package]: ( localize(811, "package")),
+    [SymbolKind.Property]: ( localize(812, "property")),
+    [SymbolKind.String]: ( localize(813, "string")),
+    [SymbolKind.Struct]: ( localize(814, "struct")),
+    [SymbolKind.TypeParameter]: ( localize(815, "type parameter")),
+    [SymbolKind.Variable]: ( localize(816, "variable")),
 };
 function getAriaLabelForSymbol(symbolName, kind) {
-    return localize(787, '{0} ({1})', symbolName, symbolKindNames[kind]);
+    return localize(817, '{0} ({1})', symbolName, symbolKindNames[kind]);
 }
 var SymbolTag;
 (function (SymbolTag) {

package/vscode/src/vs/editor/common/model/editStack.js

@@ -353,7 +353,7 @@ class EditStack {
         if (isEditStackElement(lastElement) && lastElement.canAppend(this._model)) {
             return lastElement;
         }
-        const newElement = ( new SingleModelEditStackElement(( localize(789, "Typing")), 'undoredo.textBufferEdit', this._model, beforeCursorState));
+        const newElement = ( new SingleModelEditStackElement(( localize(819, "Typing")), 'undoredo.textBufferEdit', this._model, beforeCursorState));
         this._undoRedoService.pushElement(newElement, group);
         return newElement;
     }

package/vscode/src/vs/editor/common/model/treeSitterTokenStoreService.service.d.ts

@@ -1,9 +1,11 @@
 import { Range } from "../core/range.js";
 import { ITextModel } from "../model.js";
+import { IModelContentChangedEvent } from "../textModelEvents.js";
 import { TokenUpdate, TokenQuality } from "@codingame/monaco-vscode-treesitter-service-override/vscode/vs/editor/common/model/tokenStore";
 export interface ITreeSitterTokenizationStoreService {
     readonly _serviceBrand: undefined;
     setTokens(model: ITextModel, tokens: TokenUpdate[], tokenQuality: TokenQuality): void;
+    handleContentChanged(model: ITextModel, e: IModelContentChangedEvent): void;
     getTokens(model: ITextModel, line: number): Uint32Array | undefined;
     updateTokens(model: ITextModel, version: number, updates: {
         oldRangeLength?: number;
@@ -17,5 +19,6 @@ export interface ITreeSitterTokenizationStoreService {
     }[];
     hasTokens(model: ITextModel, accurateForRange?: Range): boolean;
     rangeHasTokens(model: ITextModel, range: Range, minimumTokenQuality: TokenQuality): boolean;
+    delete(model: ITextModel): void;
 }
 export declare const ITreeSitterTokenizationStoreService: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITreeSitterTokenizationStoreService>;