@codingame/monaco-vscode-api 19.1.4 → 20.0.0

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

@@ -0,0 +1,30 @@
+import { Position } from "./core/position.js";
+import { Range } from "./core/range.js";
+import { ITextModel, PositionAffinity } from "./model.js";
+export interface ICoordinatesConverter {
+    convertViewPositionToModelPosition(viewPosition: Position): Position;
+    convertViewRangeToModelRange(viewRange: Range): Range;
+    validateViewPosition(viewPosition: Position, expectedModelPosition: Position): Position;
+    validateViewRange(viewRange: Range, expectedModelRange: Range): Range;
+    convertModelPositionToViewPosition(modelPosition: Position, affinity?: PositionAffinity, allowZeroLineNumber?: boolean, belowHiddenRanges?: boolean): Position;
+    convertModelRangeToViewRange(modelRange: Range, affinity?: PositionAffinity): Range;
+    modelPositionIsVisible(modelPosition: Position): boolean;
+    getModelLineViewLineCount(modelLineNumber: number): number;
+    getViewLineNumberOfModelPosition(modelLineNumber: number, modelColumn: number): number;
+}
+export declare class IdentityCoordinatesConverter implements ICoordinatesConverter {
+    private readonly _model;
+    constructor(model: ITextModel);
+    private _validPosition;
+    private _validRange;
+    convertViewPositionToModelPosition(viewPosition: Position): Position;
+    convertViewRangeToModelRange(viewRange: Range): Range;
+    validateViewPosition(_viewPosition: Position, expectedModelPosition: Position): Position;
+    validateViewRange(_viewRange: Range, expectedModelRange: Range): Range;
+    convertModelPositionToViewPosition(modelPosition: Position): Position;
+    convertModelRangeToViewRange(modelRange: Range): Range;
+    modelPositionIsVisible(modelPosition: Position): boolean;
+    modelRangeIsVisible(modelRange: Range): boolean;
+    getModelLineViewLineCount(modelLineNumber: number): number;
+    getViewLineNumberOfModelPosition(modelLineNumber: number, modelColumn: number): number;
+}

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

@@ -0,0 +1,56 @@
+
+
+class IdentityCoordinatesConverter {
+    constructor(model) {
+        this._model = model;
+    }
+    _validPosition(pos) {
+        return this._model.validatePosition(pos);
+    }
+    _validRange(range) {
+        return this._model.validateRange(range);
+    }
+    convertViewPositionToModelPosition(viewPosition) {
+        return this._validPosition(viewPosition);
+    }
+    convertViewRangeToModelRange(viewRange) {
+        return this._validRange(viewRange);
+    }
+    validateViewPosition(_viewPosition, expectedModelPosition) {
+        return this._validPosition(expectedModelPosition);
+    }
+    validateViewRange(_viewRange, expectedModelRange) {
+        return this._validRange(expectedModelRange);
+    }
+    convertModelPositionToViewPosition(modelPosition) {
+        return this._validPosition(modelPosition);
+    }
+    convertModelRangeToViewRange(modelRange) {
+        return this._validRange(modelRange);
+    }
+    modelPositionIsVisible(modelPosition) {
+        const lineCount = this._model.getLineCount();
+        if (modelPosition.lineNumber < 1 || modelPosition.lineNumber > lineCount) {
+            return false;
+        }
+        return true;
+    }
+    modelRangeIsVisible(modelRange) {
+        const lineCount = this._model.getLineCount();
+        if (modelRange.startLineNumber < 1 || modelRange.startLineNumber > lineCount) {
+            return false;
+        }
+        if (modelRange.endLineNumber < 1 || modelRange.endLineNumber > lineCount) {
+            return false;
+        }
+        return true;
+    }
+    getModelLineViewLineCount(modelLineNumber) {
+        return 1;
+    }
+    getViewLineNumberOfModelPosition(modelLineNumber, modelColumn) {
+        return modelLineNumber;
+    }
+}
+
+export { IdentityCoordinatesConverter };

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

@@ -1,5 +1,5 @@
 import { OffsetRange } from "../ranges/offsetRange.js";
-export declare abstract class BaseEdit<T extends BaseReplacement<T>, TEdit extends BaseEdit<T, TEdit>> {
+export declare abstract class BaseEdit<T extends BaseReplacement<T> = BaseReplacement<any>, TEdit extends BaseEdit<T, TEdit> = BaseEdit<T, any>> {
     readonly replacements: readonly T[];
     constructor(replacements: readonly T[]);
     protected abstract _createNew(replacements: readonly T[]): TEdit;
@@ -27,7 +27,7 @@ export declare abstract class BaseReplacement<TSelf extends BaseReplacement<TSel
     constructor(replaceRange: OffsetRange);
     abstract getNewLength(): number;
     abstract tryJoinTouching(other: TSelf): TSelf | undefined;
-    abstract slice(newReplaceRange: OffsetRange, rangeInReplacement: OffsetRange): TSelf;
+    abstract slice(newReplaceRange: OffsetRange, rangeInReplacement?: OffsetRange): TSelf;
     delta(offset: number): TSelf;
     getLengthDelta(): number;
     abstract equals(other: TSelf): boolean;
@@ -50,5 +50,5 @@ export declare class AnnotationReplacement<TAnnotation> extends BaseReplacement<
     equals(other: AnnotationReplacement<TAnnotation>): boolean;
     getNewLength(): number;
     tryJoinTouching(other: AnnotationReplacement<TAnnotation>): AnnotationReplacement<TAnnotation> | undefined;
-    slice(range: OffsetRange, rangeInReplacement: OffsetRange): AnnotationReplacement<TAnnotation>;
+    slice(range: OffsetRange, rangeInReplacement?: OffsetRange): AnnotationReplacement<TAnnotation>;
 }

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

@@ -3,13 +3,13 @@ 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 LineReplacement[];
+    readonly replacements: 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 LineReplacement[]): LineEdit;
-    constructor(edits: readonly LineReplacement[]);
+    constructor(replacements: readonly LineReplacement[]);
     isEmpty(): boolean;
     toEdit(initialValue: AbstractText): StringEdit;
     toString(): string;

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

@@ -41,31 +41,31 @@ class LineEdit {
         return ( new LineEdit(result));
     }
     constructor(
-    edits) {
-        this.edits = edits;
-        assert(checkAdjacentItems(edits, (i1, i2) => i1.lineRange.endLineNumberExclusive <= i2.lineRange.startLineNumber));
+    replacements) {
+        this.replacements = replacements;
+        assert(checkAdjacentItems(replacements, (i1, i2) => i1.lineRange.endLineNumberExclusive <= i2.lineRange.startLineNumber));
     }
     isEmpty() {
-        return this.edits.length === 0;
+        return this.replacements.length === 0;
     }
     toEdit(initialValue) {
         const edits = [];
-        for (const edit of this.edits) {
+        for (const edit of this.replacements) {
             const singleEdit = edit.toSingleEdit(initialValue);
             edits.push(singleEdit);
         }
         return ( new StringEdit(edits));
     }
     toString() {
-        return ( this.edits.map(e => ( e.toString()))).join(',');
+        return ( this.replacements.map(e => ( e.toString()))).join(',');
     }
     serialize() {
-        return ( this.edits.map(e => e.serialize()));
+        return ( this.replacements.map(e => e.serialize()));
     }
     getNewLineRanges() {
         const ranges = [];
         let offset = 0;
-        for (const e of this.edits) {
+        for (const e of this.replacements) {
             ranges.push(LineRange.ofLength(e.lineRange.startLineNumber + offset, e.newLines.length));
             offset += e.newLines.length - e.lineRange.length;
         }
@@ -73,7 +73,7 @@ class LineEdit {
     }
     mapLineNumber(lineNumber) {
         let lineDelta = 0;
-        for (const e of this.edits) {
+        for (const e of this.replacements) {
             if (e.lineRange.endLineNumberExclusive > lineNumber) {
                 break;
             }
@@ -92,10 +92,10 @@ class LineEdit {
         return i.mapLineRange(lineRange);
     }
     touches(other) {
-        return ( this.edits.some(e1 => ( other.edits.some(e2 => e1.lineRange.intersect(e2.lineRange)))));
+        return ( this.replacements.some(e1 => ( other.replacements.some(e2 => e1.lineRange.intersect(e2.lineRange)))));
     }
     rebase(base) {
-        return ( new LineEdit(( this.edits.map(e => ( new LineReplacement(base.mapLineRange(e.lineRange), e.newLines))))));
+        return ( new LineEdit(( this.replacements.map(e => ( new LineReplacement(base.mapLineRange(e.lineRange), e.newLines))))));
     }
     humanReadablePatch(originalLines) {
         const result = [];
@@ -113,7 +113,7 @@ class LineEdit {
         }
         let lineDelta = 0;
         let first = true;
-        for (const edits of groupAdjacentBy(this.edits, (e1, e2) => e1.lineRange.distanceToRange(e2.lineRange) <= 5)) {
+        for (const edits of groupAdjacentBy(this.replacements, (e1, e2) => e1.lineRange.distanceToRange(e2.lineRange) <= 5)) {
             if (!first) {
                 pushSeperator();
             }
@@ -147,7 +147,7 @@ class LineEdit {
     apply(lines) {
         const result = [];
         let currentLineIndex = 0;
-        for (const edit of this.edits) {
+        for (const edit of this.replacements) {
             while (currentLineIndex < edit.lineRange.startLineNumber - 1) {
                 result.push(lines[currentLineIndex]);
                 currentLineIndex++;
@@ -165,7 +165,7 @@ class LineEdit {
     }
     inverse(originalLines) {
         const newRanges = this.getNewLineRanges();
-        return ( new LineEdit(( this.edits.map((e, idx) => ( new LineReplacement(
+        return ( new LineEdit(( this.replacements.map((e, idx) => ( new LineReplacement(
             newRanges[idx],
             originalLines.slice(e.lineRange.startLineNumber - 1, e.lineRange.endLineNumberExclusive - 1)
         ))))));

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

@@ -4,10 +4,16 @@ import { BaseEdit, BaseReplacement } from "./edit.js";
 export declare abstract class BaseStringEdit<T extends BaseStringReplacement<T> = BaseStringReplacement<any>, TEdit extends BaseStringEdit<T, TEdit> = BaseStringEdit<any, any>> extends BaseEdit<T, TEdit> {
     get TReplacement(): T;
     static composeOrUndefined<T extends BaseStringEdit>(edits: readonly T[]): T | undefined;
+    static trySwap(e1: BaseStringEdit, e2: BaseStringEdit): {
+        e1: StringEdit;
+        e2: StringEdit;
+    } | undefined;
     apply(base: string): string;
-    inverse(baseStr: string): StringEdit;
-    tryRebase(base: StringEdit): StringEdit;
-    tryRebase(base: StringEdit, noOverlap: true): StringEdit | undefined;
+    inverseOnSlice(getOriginalSlice: (start: number, endEx: number) => string): StringEdit;
+    inverse(original: string): StringEdit;
+    rebaseSkipConflicting(base: StringEdit): StringEdit;
+    tryRebase(base: StringEdit): StringEdit | undefined;
+    private _tryRebase;
     toJson(): ISerializedStringEdit;
     isNeutralOn(text: string): boolean;
     removeCommonSuffixPrefix(originalText: string): StringEdit;
@@ -30,6 +36,7 @@ export declare abstract class BaseStringReplacement<T extends BaseStringReplacem
     removeCommonPrefix(source: string): T;
     removeCommonSuffix(source: string): T;
     toEdit(): StringEdit;
+    toJson(): ISerializedStringReplacement;
 }
 export declare class StringEdit extends BaseStringEdit<StringReplacement, StringEdit> {
     static readonly empty: StringEdit;
@@ -57,7 +64,7 @@ export declare class StringReplacement extends BaseStringReplacement<StringRepla
     static fromJson(data: ISerializedStringReplacement): StringReplacement;
     equals(other: StringReplacement): boolean;
     tryJoinTouching(other: StringReplacement): StringReplacement | undefined;
-    slice(range: OffsetRange, rangeInReplacement: OffsetRange): StringReplacement;
+    slice(range: OffsetRange, rangeInReplacement?: OffsetRange): StringReplacement;
 }
 export declare function applyEditsToRanges(sortedRanges: OffsetRange[], edit: StringEdit): OffsetRange[];
 export interface IEditData<T> {

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

@@ -18,6 +18,18 @@ class BaseStringEdit extends BaseEdit {
         }
         return result;
     }
+    static trySwap(e1, e2) {
+        const e1Inv = e1.inverseOnSlice((start, endEx) => ' '.repeat(endEx - start));
+        const e1_ = e2.tryRebase(e1Inv);
+        if (!e1_) {
+            return undefined;
+        }
+        const e2_ = e1.tryRebase(e1_);
+        if (!e2_) {
+            return undefined;
+        }
+        return { e1: e1_, e2: e2_ };
+    }
     apply(base) {
         const resultText = [];
         let pos = 0;
@@ -29,19 +41,25 @@ class BaseStringEdit extends BaseEdit {
         resultText.push(base.substring(pos));
         return resultText.join('');
     }
-    inverse(baseStr) {
+    inverseOnSlice(getOriginalSlice) {
         const edits = [];
         let offset = 0;
         for (const e of this.replacements) {
-            edits.push(( new StringReplacement(
-                OffsetRange.ofStartAndLength(e.replaceRange.start + offset, e.newText.length),
-                baseStr.substring(e.replaceRange.start, e.replaceRange.endExclusive)
-            )));
+            edits.push(StringReplacement.replace(OffsetRange.ofStartAndLength(e.replaceRange.start + offset, e.newText.length), getOriginalSlice(e.replaceRange.start, e.replaceRange.endExclusive)));
             offset += e.newText.length - e.replaceRange.length;
         }
         return ( new StringEdit(edits));
     }
-    tryRebase(base, noOverlap) {
+    inverse(original) {
+        return this.inverseOnSlice((start, endEx) => original.substring(start, endEx));
+    }
+    rebaseSkipConflicting(base) {
+        return this._tryRebase(base, false);
+    }
+    tryRebase(base) {
+        return this._tryRebase(base, true);
+    }
+    _tryRebase(base, noOverlap) {
         const newEdits = [];
         let baseIdx = 0;
         let ourIdx = 0;
@@ -74,11 +92,7 @@ class BaseStringEdit extends BaseEdit {
         return ( new StringEdit(newEdits));
     }
     toJson() {
-        return ( this.replacements.map(e => ({
-            txt: e.newText,
-            pos: e.replaceRange.start,
-            len: e.replaceRange.length,
-        })));
+        return ( this.replacements.map(e => e.toJson()));
     }
     isNeutralOn(text) {
         return this.replacements.every(e => e.isNeutralOn(text));
@@ -167,6 +181,13 @@ class BaseStringReplacement extends BaseReplacement {
     toEdit() {
         return ( new StringEdit([this]));
     }
+    toJson() {
+        return ({
+            txt: this.newText,
+            pos: this.replaceRange.start,
+            len: this.replaceRange.length,
+        });
+    }
 }
 class StringEdit extends BaseStringEdit {
     static { this.empty = ( new StringEdit([])); }
@@ -244,7 +265,10 @@ class StringReplacement extends BaseStringReplacement {
         ));
     }
     slice(range, rangeInReplacement) {
-        return ( new StringReplacement(range, rangeInReplacement.substring(this.newText)));
+        return ( new StringReplacement(
+            range,
+            rangeInReplacement ? rangeInReplacement.substring(this.newText) : this.newText
+        ));
     }
 }
 function applyEditsToRanges(sortedRanges, edit) {

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

@@ -38,6 +38,9 @@ export declare class TextReplacement {
     equals(other: TextReplacement): boolean;
     extendToCoverRange(range: Range, initialValue: AbstractText): TextReplacement;
     extendToFullLine(initialValue: AbstractText): TextReplacement;
+    removeCommonPrefixAndSuffix(text: AbstractText): TextReplacement;
     removeCommonPrefix(text: AbstractText): TextReplacement;
+    removeCommonSuffix(text: AbstractText): TextReplacement;
     isEffectiveDeletion(text: AbstractText): boolean;
+    toString(): string;
 }