@codingame/monaco-vscode-api 18.4.0 → 19.0.1

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

@@ -78,7 +78,7 @@ class BareFontInfo {
     getMassagedFontFamily() {
         const fallbackFontFamily = EDITOR_FONT_DEFAULTS.fontFamily;
         const fontFamily = BareFontInfo._wrapInQuotes(this.fontFamily);
-        if (fallbackFontFamily && this.fontFamily !== fallbackFontFamily) {
+        if (this.fontFamily !== fallbackFontFamily) {
             return `${fontFamily}, ${fallbackFontFamily}`;
         }
         return fontFamily;

package/vscode/src/vs/editor/common/core/2d/point.d.ts

@@ -7,4 +7,9 @@ export declare class Point {
     deltaX(delta: number): Point;
     deltaY(delta: number): Point;
     toString(): string;
+    subtract(other: Point): Point;
+    scale(factor: number): Point;
+    mapComponents(map: (value: number) => number): Point;
+    isZero(): boolean;
+    withThreshold(threshold: number): Point;
 }

package/vscode/src/vs/editor/common/core/2d/point.js

@@ -20,6 +20,29 @@ class Point {
     toString() {
         return `(${this.x},${this.y})`;
     }
+    subtract(other) {
+        return ( new Point(this.x - other.x, this.y - other.y));
+    }
+    scale(factor) {
+        return ( new Point(this.x * factor, this.y * factor));
+    }
+    mapComponents(map) {
+        return ( new Point(( map(this.x)), ( map(this.y))));
+    }
+    isZero() {
+        return this.x === 0 && this.y === 0;
+    }
+    withThreshold(threshold) {
+        return this.mapComponents(axisVal => {
+            if (axisVal > threshold) {
+                return axisVal - threshold;
+            }
+            else if (axisVal < -threshold) {
+                return axisVal + threshold;
+            }
+            return 0;
+        });
+    }
 }
 
 export { Point };

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

@@ -7,6 +7,10 @@ export declare abstract class BaseEdit<T extends BaseReplacement<T>, TEdit exten
     toString(): string;
     normalize(): TEdit;
     compose(other: TEdit): TEdit;
+    decomposeSplit(shouldBeInE1: (repl: T) => boolean): {
+        e1: TEdit;
+        e2: TEdit;
+    };
     getNewRanges(): OffsetRange[];
     getJoinedReplaceRange(): OffsetRange | undefined;
     isEmpty(): boolean;
@@ -15,6 +19,8 @@ export declare abstract class BaseEdit<T extends BaseReplacement<T>, TEdit exten
     applyToOffset(originalOffset: number): number;
     applyToOffsetRange(originalRange: OffsetRange): OffsetRange;
     applyInverseToOffset(postEditsOffset: number): number;
+    applyToOffsetOrUndefined(originalOffset: number): number | undefined;
+    applyToOffsetRangeOrUndefined(originalRange: OffsetRange): OffsetRange | undefined;
 }
 export declare abstract class BaseReplacement<TSelf extends BaseReplacement<TSelf>> {
     readonly replaceRange: OffsetRange;

package/vscode/src/vs/editor/common/core/edits/edit.js

@@ -128,6 +128,21 @@ class BaseEdit {
         }
         return this._createNew(result).normalize();
     }
+    decomposeSplit(shouldBeInE1) {
+        const e1 = [];
+        const e2 = [];
+        let e2delta = 0;
+        for (const edit of this.replacements) {
+            if (shouldBeInE1(edit)) {
+                e1.push(edit);
+                e2delta += edit.getNewLength() - edit.replaceRange.length;
+            }
+            else {
+                e2.push(edit.slice(edit.replaceRange.delta(e2delta), ( new OffsetRange(0, edit.getNewLength()))));
+            }
+        }
+        return { e1: this._createNew(e1), e2: this._createNew(e2) };
+    }
     getNewRanges() {
         const ranges = [];
         let offset = 0;
@@ -189,6 +204,32 @@ class BaseEdit {
         }
         return postEditsOffset - accumulatedDelta;
     }
+    applyToOffsetOrUndefined(originalOffset) {
+        let accumulatedDelta = 0;
+        for (const edit of this.replacements) {
+            if (edit.replaceRange.start <= originalOffset) {
+                if (originalOffset < edit.replaceRange.endExclusive) {
+                    return undefined;
+                }
+                accumulatedDelta += edit.getNewLength() - edit.replaceRange.length;
+            }
+            else {
+                break;
+            }
+        }
+        return originalOffset + accumulatedDelta;
+    }
+    applyToOffsetRangeOrUndefined(originalRange) {
+        const start = this.applyToOffsetOrUndefined(originalRange.start);
+        if (start === undefined) {
+            return undefined;
+        }
+        const end = this.applyToOffsetOrUndefined(originalRange.endExclusive);
+        if (end === undefined) {
+            return undefined;
+        }
+        return ( new OffsetRange(start, end));
+    }
 }
 class BaseReplacement {
     constructor(

package/vscode/src/vs/editor/common/core/edits/lineEdit.d.ts

@@ -3,40 +3,46 @@ import { StringEdit, StringReplacement } from "./stringEdit.js";
 import { TextReplacement, TextEdit } from "./textEdit.js";
 import { AbstractText } from "../text/abstractText.js";
 export declare class LineEdit {
-    readonly edits: readonly SingleLineEdit[];
+    readonly edits: readonly LineReplacement[];
     static readonly empty: LineEdit;
     static deserialize(data: SerializedLineEdit): LineEdit;
     static fromEdit(edit: StringEdit, initialValue: AbstractText): LineEdit;
     static fromTextEdit(edit: TextEdit, initialValue: AbstractText): LineEdit;
-    static createFromUnsorted(edits: readonly SingleLineEdit[]): LineEdit;
-    constructor(edits: readonly SingleLineEdit[]);
+    static createFromUnsorted(edits: readonly LineReplacement[]): LineEdit;
+    constructor(edits: readonly LineReplacement[]);
+    isEmpty(): boolean;
     toEdit(initialValue: AbstractText): StringEdit;
     toString(): string;
     serialize(): SerializedLineEdit;
     getNewLineRanges(): LineRange[];
     mapLineNumber(lineNumber: number): number;
     mapLineRange(lineRange: LineRange): LineRange;
+    mapBackLineRange(lineRange: LineRange, originalLines: string[]): LineRange;
+    touches(other: LineEdit): boolean;
     rebase(base: LineEdit): LineEdit;
     humanReadablePatch(originalLines: string[]): string;
     apply(lines: string[]): string[];
-    toSingleEdit(): void;
+    inverse(originalLines: string[]): LineEdit;
 }
-export declare class SingleLineEdit {
+export declare class LineReplacement {
     readonly lineRange: LineRange;
     readonly newLines: readonly string[];
-    static deserialize(e: SerializedSingleLineEdit): SingleLineEdit;
-    static fromSingleTextEdit(edit: TextReplacement, initialValue: AbstractText): SingleLineEdit;
+    static deserialize(e: SerializedLineReplacement): LineReplacement;
+    static fromSingleTextEdit(edit: TextReplacement, initialValue: AbstractText): LineReplacement;
     constructor(lineRange: LineRange, newLines: readonly string[]);
     toSingleTextEdit(initialValue: AbstractText): TextReplacement;
     toSingleEdit(initialValue: AbstractText): StringReplacement;
     toString(): string;
-    serialize(): SerializedSingleLineEdit;
-    removeCommonSuffixPrefixLines(initialValue: AbstractText): SingleLineEdit;
+    serialize(): SerializedLineReplacement;
+    removeCommonSuffixPrefixLines(initialValue: AbstractText): LineReplacement;
     toLineEdit(): LineEdit;
 }
-export type SerializedLineEdit = SerializedSingleLineEdit[];
-export type SerializedSingleLineEdit = [
+export type SerializedLineEdit = SerializedLineReplacement[];
+export type SerializedLineReplacement = [
     startLineNumber: number,
     endLineNumber: number,
     newLines: readonly string[]
 ];
+export declare namespace SerializedLineReplacement {
+    function is(thing: unknown): thing is SerializedLineReplacement;
+}

package/vscode/src/vs/editor/common/core/edits/lineEdit.js

@@ -11,7 +11,7 @@ import { TextEdit, TextReplacement } from './textEdit.js';
 class LineEdit {
     static { this.empty = ( new LineEdit([])); }
     static deserialize(data) {
-        return ( new LineEdit(( data.map(e => SingleLineEdit.deserialize(e)))));
+        return ( new LineEdit(( data.map(e => LineReplacement.deserialize(e)))));
     }
     static fromEdit(edit, initialValue) {
         const textEdit = TextEdit.fromStringEdit(edit, initialValue);
@@ -30,7 +30,7 @@ class LineEdit {
             }
             const singleEdit = TextReplacement.joinReplacements(currentEdits, initialValue);
             currentEdits.length = 0;
-            const singleLineEdit = SingleLineEdit.fromSingleTextEdit(singleEdit, initialValue);
+            const singleLineEdit = LineReplacement.fromSingleTextEdit(singleEdit, initialValue);
             result.push(singleLineEdit);
         }
         return ( new LineEdit(result));
@@ -45,6 +45,9 @@ class LineEdit {
         this.edits = edits;
         assert(checkAdjacentItems(edits, (i1, i2) => i1.lineRange.endLineNumberExclusive <= i2.lineRange.startLineNumber));
     }
+    isEmpty() {
+        return this.edits.length === 0;
+    }
     toEdit(initialValue) {
         const edits = [];
         for (const edit of this.edits) {
@@ -84,8 +87,15 @@ class LineEdit {
             this.mapLineNumber(lineRange.endLineNumberExclusive)
         ));
     }
+    mapBackLineRange(lineRange, originalLines) {
+        const i = this.inverse(originalLines);
+        return i.mapLineRange(lineRange);
+    }
+    touches(other) {
+        return ( this.edits.some(e1 => ( other.edits.some(e2 => e1.lineRange.intersect(e2.lineRange)))));
+    }
     rebase(base) {
-        return ( new LineEdit(( this.edits.map(e => ( new SingleLineEdit(base.mapLineRange(e.lineRange), e.newLines))))));
+        return ( new LineEdit(( this.edits.map(e => ( new LineReplacement(base.mapLineRange(e.lineRange), e.newLines))))));
     }
     humanReadablePatch(originalLines) {
         const result = [];
@@ -153,12 +163,17 @@ class LineEdit {
         }
         return result;
     }
-    toSingleEdit() {
+    inverse(originalLines) {
+        const newRanges = this.getNewLineRanges();
+        return ( new LineEdit(( this.edits.map((e, idx) => ( new LineReplacement(
+            newRanges[idx],
+            originalLines.slice(e.lineRange.startLineNumber - 1, e.lineRange.endLineNumberExclusive - 1)
+        ))))));
     }
 }
-class SingleLineEdit {
+class LineReplacement {
     static deserialize(e) {
-        return ( new SingleLineEdit(LineRange.ofLength(e[0], e[1] - e[0]), e[2]));
+        return ( new LineReplacement(LineRange.ofLength(e[0], e[1] - e[0]), e[2]));
     }
     static fromSingleTextEdit(edit, initialValue) {
         const newLines = splitLines(edit.text);
@@ -179,7 +194,7 @@ class SingleLineEdit {
             endLineNumberEx--;
             newLines.pop();
         }
-        return ( new SingleLineEdit(( new LineRange(startLineNumber, endLineNumberEx)), newLines));
+        return ( new LineReplacement(( new LineRange(startLineNumber, endLineNumberEx)), newLines));
     }
     constructor(lineRange, newLines) {
         this.lineRange = lineRange;
@@ -268,11 +283,23 @@ class SingleLineEdit {
         if (trimStartCount === 0 && trimEndCount === 0) {
             return this;
         }
-        return ( new SingleLineEdit(( new LineRange(startLineNumber, endLineNumberEx)), this.newLines.slice(trimStartCount, this.newLines.length - trimEndCount)));
+        return ( new LineReplacement(( new LineRange(startLineNumber, endLineNumberEx)), this.newLines.slice(trimStartCount, this.newLines.length - trimEndCount)));
     }
     toLineEdit() {
         return ( new LineEdit([this]));
     }
 }
+var SerializedLineReplacement;
+(function (SerializedLineReplacement) {
+    function is(thing) {
+        return (Array.isArray(thing)
+            && thing.length === 3
+            && typeof thing[0] === 'number'
+            && typeof thing[1] === 'number'
+            && Array.isArray(thing[2])
+            && thing[2].every((e) => typeof e === 'string'));
+    }
+    SerializedLineReplacement.is = is;
+})(SerializedLineReplacement || (SerializedLineReplacement = {}));
 
-export { LineEdit, SingleLineEdit };
+export { LineEdit, LineReplacement, SerializedLineReplacement };