@codingame/monaco-vscode-api 13.1.7 → 14.0.1

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

@@ -30,7 +30,10 @@ export declare class SingleOffsetEdit {
     readonly newText: string;
     static fromJson(data: ISingleOffsetEdit): SingleOffsetEdit;
     static insert(offset: number, text: string): SingleOffsetEdit;
+    static replace(range: OffsetRange, text: string): SingleOffsetEdit;
     constructor(replaceRange: OffsetRange, newText: string);
     toString(): string;
     get isEmpty(): boolean;
+    apply(str: string): string;
+    getRangeAfterApply(): OffsetRange;
 }

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

@@ -167,6 +167,9 @@ class SingleOffsetEdit {
     static insert(offset, text) {
         return ( new SingleOffsetEdit(OffsetRange.emptyAt(offset), text));
     }
+    static replace(range, text) {
+        return ( new SingleOffsetEdit(range, text));
+    }
     constructor(replaceRange, newText) {
         this.replaceRange = replaceRange;
         this.newText = newText;
@@ -177,6 +180,12 @@ class SingleOffsetEdit {
     get isEmpty() {
         return this.newText.length === 0 && this.replaceRange.length === 0;
     }
+    apply(str) {
+        return str.substring(0, this.replaceRange.start) + this.newText + str.substring(this.replaceRange.endExclusive);
+    }
+    getRangeAfterApply() {
+        return ( new OffsetRange(this.replaceRange.start, this.replaceRange.start + this.newText.length));
+    }
 }
 function joinEdits(edits1, edits2) {
     edits1 = edits1.normalize();

package/vscode/src/vs/editor/common/core/offsetRange.d.ts

@@ -5,6 +5,7 @@ export interface IOffsetRange {
 export declare class OffsetRange implements IOffsetRange {
     readonly start: number;
     readonly endExclusive: number;
+    static fromTo(start: number, endExclusive: number): OffsetRange;
     static addRange(range: OffsetRange, sortedRanges: OffsetRange[]): void;
     static tryCreate(start: number, endExclusive: number): OffsetRange | undefined;
     static ofLength(length: number): OffsetRange;

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

@@ -2,6 +2,9 @@
 import { BugIndicatingError } from '../../../base/common/errors.js';
 
 class OffsetRange {
+    static fromTo(start, endExclusive) {
+        return ( new OffsetRange(start, endExclusive));
+    }
     static addRange(range, sortedRanges) {
         let i = 0;
         while (i < sortedRanges.length && sortedRanges[i].endExclusive < range.start) {

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

@@ -14,7 +14,7 @@ class Position {
         }
     }
     delta(deltaLineNumber = 0, deltaColumn = 0) {
-        return this.with(this.lineNumber + deltaLineNumber, this.column + deltaColumn);
+        return this.with(Math.max(1, this.lineNumber + deltaLineNumber), Math.max(1, this.column + deltaColumn));
     }
     equals(other) {
         return Position.equals(this, other);

package/vscode/src/vs/editor/common/core/positionToOffset.d.ts

@@ -8,6 +8,7 @@ export declare class PositionOffsetTransformer {
     private readonly lineEndOffsetByLineIdx;
     constructor(text: string);
     getOffset(position: Position): number;
+    private _validatePosition;
     getOffsetRange(range: Range): OffsetRange;
     getPosition(offset: number): Position;
     getRange(offsetRange: OffsetRange): Range;

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

@@ -25,7 +25,26 @@ class PositionOffsetTransformer {
         this.lineEndOffsetByLineIdx.push(text.length);
     }
     getOffset(position) {
-        return this.lineStartOffsetByLineIdx[position.lineNumber - 1] + position.column - 1;
+        const valPos = this._validatePosition(position);
+        return this.lineStartOffsetByLineIdx[valPos.lineNumber - 1] + valPos.column - 1;
+    }
+    _validatePosition(position) {
+        if (position.lineNumber < 1) {
+            return ( new Position(1, 1));
+        }
+        const lineCount = this.textLength.lineCount + 1;
+        if (position.lineNumber > lineCount) {
+            const lineLength = this.getLineLength(lineCount);
+            return ( new Position(lineCount, lineLength + 1));
+        }
+        if (position.column < 1) {
+            return ( new Position(position.lineNumber, 1));
+        }
+        const lineLength = this.getLineLength(position.lineNumber);
+        if (position.column - 1 > lineLength) {
+            return ( new Position(position.lineNumber, lineLength + 1));
+        }
+        return position;
     }
     getOffsetRange(range) {
         return ( new OffsetRange(

package/vscode/src/vs/editor/common/core/range.d.ts

@@ -38,6 +38,7 @@ export declare class Range {
     collapseToEnd(): Range;
     static collapseToEnd(range: IRange): Range;
     delta(lineCount: number): Range;
+    isSingleLine(): boolean;
     static fromPositions(start: IPosition, end?: IPosition): Range;
     static lift(range: undefined | null): null;
     static lift(range: IRange): Range;

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

@@ -218,6 +218,9 @@ class Range {
             this.endColumn
         ));
     }
+    isSingleLine() {
+        return this.startLineNumber === this.endLineNumber;
+    }
     static fromPositions(start, end = start) {
         return ( new Range(start.lineNumber, start.column, end.lineNumber, end.column));
     }

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

@@ -68,9 +68,3 @@ export declare class StringText extends AbstractText {
     getValueOfRange(range: Range): string;
     get length(): TextLength;
 }
-export declare class BasedTextEdit {
-    readonly base: AbstractText;
-    readonly edit: TextEdit;
-    constructor(base: AbstractText, edit: TextEdit);
-    toString(): string;
-}

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

@@ -3,7 +3,6 @@ import { equals } from '../../../base/common/arrays.js';
 import { assertFn, checkAdjacentItems, assert } from '../../../base/common/assert.js';
 import { BugIndicatingError } from '../../../base/common/errors.js';
 import { commonPrefixLength, commonSuffixLength, splitLines } from '../../../base/common/strings.js';
-import './lineEdit.js';
 import { Position } from './position.js';
 import { PositionOffsetTransformer } from './positionToOffset.js';
 import { Range } from './range.js';

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

@@ -108,7 +108,7 @@ class TextLength {
         return ( new Range(1, 1, this.lineCount + 1, this.columnCount + 1));
     }
     toLineRange() {
-        return LineRange.ofLength(1, this.lineCount);
+        return LineRange.ofLength(1, this.lineCount + 1);
     }
     addToPosition(position) {
         if (this.lineCount === 0) {

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

@@ -79,7 +79,7 @@ class DefaultLinesDiffComputer {
                 const seq1Offset = seq1LastStart + i;
                 const seq2Offset = seq2LastStart + i;
                 if (originalLines[seq1Offset] !== modifiedLines[seq2Offset]) {
-                    const characterDiffs = this.refineDiff(originalLines, modifiedLines, ( new SequenceDiff(( new OffsetRange(seq1Offset, seq1Offset + 1)), ( new OffsetRange(seq2Offset, seq2Offset + 1)))), timeout, considerWhitespaceChanges);
+                    const characterDiffs = this.refineDiff(originalLines, modifiedLines, ( new SequenceDiff(( new OffsetRange(seq1Offset, seq1Offset + 1)), ( new OffsetRange(seq2Offset, seq2Offset + 1)))), timeout, considerWhitespaceChanges, options);
                     for (const a of characterDiffs.mappings) {
                         alignments.push(a);
                     }
@@ -97,7 +97,7 @@ class DefaultLinesDiffComputer {
             scanForWhitespaceChanges(equalLinesCount);
             seq1LastStart = diff.seq1Range.endExclusive;
             seq2LastStart = diff.seq2Range.endExclusive;
-            const characterDiffs = this.refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges);
+            const characterDiffs = this.refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges, options);
             if (characterDiffs.hitTimeout) {
                 hitTimeout = true;
             }
@@ -109,7 +109,7 @@ class DefaultLinesDiffComputer {
         const changes = lineRangeMappingFromRangeMappings(alignments, ( new ArrayText(originalLines)), ( new ArrayText(modifiedLines)));
         let moves = [];
         if (options.computeMoves) {
-            moves = this.computeMoves(changes, originalLines, modifiedLines, originalLinesHashes, modifiedLinesHashes, timeout, considerWhitespaceChanges);
+            moves = this.computeMoves(changes, originalLines, modifiedLines, originalLinesHashes, modifiedLinesHashes, timeout, considerWhitespaceChanges, options);
         }
         assertFn(() => {
             function validatePosition(pos, lines) {
@@ -150,16 +150,16 @@ class DefaultLinesDiffComputer {
         });
         return ( new LinesDiff(changes, moves, hitTimeout));
     }
-    computeMoves(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout, considerWhitespaceChanges) {
+    computeMoves(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout, considerWhitespaceChanges, options) {
         const moves = computeMovedLines(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout);
         const movesWithDiffs = ( moves.map(m => {
-            const moveChanges = this.refineDiff(originalLines, modifiedLines, ( new SequenceDiff(m.original.toOffsetRange(), m.modified.toOffsetRange())), timeout, considerWhitespaceChanges);
+            const moveChanges = this.refineDiff(originalLines, modifiedLines, ( new SequenceDiff(m.original.toOffsetRange(), m.modified.toOffsetRange())), timeout, considerWhitespaceChanges, options);
             const mappings = lineRangeMappingFromRangeMappings(moveChanges.mappings, ( new ArrayText(originalLines)), ( new ArrayText(modifiedLines)), true);
             return ( new MovedText(m, mappings));
         }));
         return movesWithDiffs;
     }
-    refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges) {
+    refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges, options) {
         const lineRangeMapping = toLineRangeMapping(diff);
         const rangeMapping = lineRangeMapping.toRangeMapping2(originalLines, modifiedLines);
         const slice1 = ( new LinesSliceCharSequence(originalLines, rangeMapping.originalRange, considerWhitespaceChanges));
@@ -169,7 +169,10 @@ class DefaultLinesDiffComputer {
             : this.myersDiffingAlgorithm.compute(slice1, slice2, timeout);
         let diffs = diffResult.diffs;
         diffs = optimizeSequenceDiffs(slice1, slice2, diffs);
-        diffs = extendDiffsToEntireWordIfAppropriate(slice1, slice2, diffs);
+        diffs = extendDiffsToEntireWordIfAppropriate(slice1, slice2, diffs, (seq, idx) => seq.findWordContaining(idx));
+        if (options.extendToSubwords) {
+            diffs = extendDiffsToEntireWordIfAppropriate(slice1, slice2, diffs, (seq, idx) => seq.findSubWordContaining(idx), true);
+        }
         diffs = removeShortMatches(slice1, slice2, diffs);
         diffs = removeVeryShortMatchingTextBetweenLongDiffs(slice1, slice2, diffs);
         const result = ( diffs.map((d) => ( new RangeMapping(slice1.translateRange(d.seq1Range), slice2.translateRange(d.seq2Range)))));

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/heuristicSequenceOptimizations.d.ts

@@ -1,8 +1,9 @@
+import { OffsetRange } from "../../core/offsetRange.js";
 import { ISequence, SequenceDiff } from "./algorithms/diffAlgorithm.js";
 import { LineSequence } from "./lineSequence.js";
 import { LinesSliceCharSequence } from "./linesSliceCharSequence.js";
 export declare function optimizeSequenceDiffs(sequence1: ISequence, sequence2: ISequence, sequenceDiffs: SequenceDiff[]): SequenceDiff[];
 export declare function removeShortMatches(sequence1: ISequence, sequence2: ISequence, sequenceDiffs: SequenceDiff[]): SequenceDiff[];
-export declare function extendDiffsToEntireWordIfAppropriate(sequence1: LinesSliceCharSequence, sequence2: LinesSliceCharSequence, sequenceDiffs: SequenceDiff[]): SequenceDiff[];
+export declare function extendDiffsToEntireWordIfAppropriate(sequence1: LinesSliceCharSequence, sequence2: LinesSliceCharSequence, sequenceDiffs: SequenceDiff[], findParent: (seq: LinesSliceCharSequence, idx: number) => OffsetRange | undefined, force?: boolean): SequenceDiff[];
 export declare function removeVeryShortMatchingLinesBetweenDiffs(sequence1: LineSequence, _sequence2: LineSequence, sequenceDiffs: SequenceDiff[]): SequenceDiff[];
 export declare function removeVeryShortMatchingTextBetweenLongDiffs(sequence1: LinesSliceCharSequence, sequence2: LinesSliceCharSequence, sequenceDiffs: SequenceDiff[]): SequenceDiff[];

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

@@ -139,7 +139,7 @@ function removeShortMatches(sequence1, sequence2, sequenceDiffs) {
     }
     return result;
 }
-function extendDiffsToEntireWordIfAppropriate(sequence1, sequence2, sequenceDiffs) {
+function extendDiffsToEntireWordIfAppropriate(sequence1, sequence2, sequenceDiffs, findParent, force = false) {
     const equalMappings = SequenceDiff.invert(sequenceDiffs, sequence1.length);
     const additional = [];
     let lastPoint = ( new OffsetPair(0, 0));
@@ -147,8 +147,8 @@ function extendDiffsToEntireWordIfAppropriate(sequence1, sequence2, sequenceDiff
         if (pair.offset1 < lastPoint.offset1 || pair.offset2 < lastPoint.offset2) {
             return;
         }
-        const w1 = sequence1.findWordContaining(pair.offset1);
-        const w2 = sequence2.findWordContaining(pair.offset2);
+        const w1 = findParent(sequence1, pair.offset1);
+        const w2 = findParent(sequence2, pair.offset2);
         if (!w1 || !w2) {
             return;
         }
@@ -162,8 +162,8 @@ function extendDiffsToEntireWordIfAppropriate(sequence1, sequence2, sequenceDiff
             if (!intersects) {
                 break;
             }
-            const v1 = sequence1.findWordContaining(next.seq1Range.start);
-            const v2 = sequence2.findWordContaining(next.seq2Range.start);
+            const v1 = findParent(sequence1, next.seq1Range.start);
+            const v2 = findParent(sequence2, next.seq2Range.start);
             const v = ( new SequenceDiff(v1, v2));
             const equalPart = v.intersect(next);
             equalChars1 += equalPart.seq1Range.length;
@@ -176,7 +176,7 @@ function extendDiffsToEntireWordIfAppropriate(sequence1, sequence2, sequenceDiff
                 break;
             }
         }
-        if (equalChars1 + equalChars2 < (w.seq1Range.length + w.seq2Range.length) * 2 / 3) {
+        if ((force && equalChars1 + equalChars2 < w.seq1Range.length + w.seq2Range.length) || equalChars1 + equalChars2 < (w.seq1Range.length + w.seq2Range.length) * 2 / 3) {
             additional.push(w);
         }
         lastPoint = w.getEndExclusives();

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/linesSliceCharSequence.d.ts

@@ -20,6 +20,7 @@ export declare class LinesSliceCharSequence implements ISequence {
     translateOffset(offset: number, preference?: "left" | "right"): Position;
     translateRange(range: OffsetRange): Range;
     findWordContaining(offset: number): OffsetRange | undefined;
+    findSubWordContaining(offset: number): OffsetRange | undefined;
     countLinesIn(range: OffsetRange): number;
     isStronglyEqual(offset1: number, offset2: number): boolean;
     extendToFullLines(range: OffsetRange): OffsetRange;

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

@@ -109,6 +109,23 @@ class LinesSliceCharSequence {
         }
         return ( new OffsetRange(start, end));
     }
+    findSubWordContaining(offset) {
+        if (offset < 0 || offset >= this.elements.length) {
+            return undefined;
+        }
+        if (!isWordChar(this.elements[offset])) {
+            return undefined;
+        }
+        let start = offset;
+        while (start > 0 && isWordChar(this.elements[start - 1]) && !isUpperCase(this.elements[start])) {
+            start--;
+        }
+        let end = offset;
+        while (end < this.elements.length && isWordChar(this.elements[end]) && !isUpperCase(this.elements[end])) {
+            end++;
+        }
+        return ( new OffsetRange(start, end));
+    }
     countLinesIn(range) {
         return this.translateOffset(range.endExclusive).lineNumber - this.translateOffset(range.start).lineNumber;
     }
@@ -126,6 +143,9 @@ function isWordChar(charCode) {
         || charCode >= CharCode.A && charCode <= CharCode.Z
         || charCode >= CharCode.Digit0 && charCode <= CharCode.Digit9;
 }
+function isUpperCase(charCode) {
+    return charCode >= CharCode.A && charCode <= CharCode.Z;
+}
 var CharBoundaryCategory;
 (function (CharBoundaryCategory) {
     CharBoundaryCategory[CharBoundaryCategory["WordLower"] = 0] = "WordLower";

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

@@ -6,6 +6,7 @@ export interface ILinesDiffComputerOptions {
     readonly ignoreTrimWhitespace: boolean;
     readonly maxComputationTimeMs: number;
     readonly computeMoves: boolean;
+    readonly extendToSubwords?: boolean;
 }
 export declare class LinesDiff {
     readonly changes: readonly DetailedLineRangeMapping[];

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

@@ -37,4 +37,4 @@ export declare class RangeMapping {
 }
 export declare function lineRangeMappingFromRangeMappings(alignments: readonly RangeMapping[], originalLines: AbstractText, modifiedLines: AbstractText, dontAssertStartLine?: boolean): DetailedLineRangeMapping[];
 export declare function getLineRangeMapping(rangeMapping: RangeMapping, originalLines: AbstractText, modifiedLines: AbstractText): DetailedLineRangeMapping;
-export declare function lineRangeMappingFromChanges(changes: IChange[]): LineRangeMapping[];
+export declare function lineRangeMappingFromChange(change: IChange): LineRangeMapping;

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

@@ -229,26 +229,5 @@ function getLineRangeMapping(rangeMapping, originalLines, modifiedLines) {
     ));
     return ( new DetailedLineRangeMapping(originalLineRange, modifiedLineRange, [rangeMapping]));
 }
-function lineRangeMappingFromChanges(changes) {
-    const lineRangeMapping = [];
-    for (const change of changes) {
-        let originalRange;
-        if (change.originalEndLineNumber === 0) {
-            originalRange = ( new LineRange(change.originalStartLineNumber + 1, change.originalStartLineNumber + 1));
-        }
-        else {
-            originalRange = ( new LineRange(change.originalStartLineNumber, change.originalEndLineNumber + 1));
-        }
-        let modifiedRange;
-        if (change.modifiedEndLineNumber === 0) {
-            modifiedRange = ( new LineRange(change.modifiedStartLineNumber + 1, change.modifiedStartLineNumber + 1));
-        }
-        else {
-            modifiedRange = ( new LineRange(change.modifiedStartLineNumber, change.modifiedEndLineNumber + 1));
-        }
-        lineRangeMapping.push(( new LineRangeMapping(originalRange, modifiedRange)));
-    }
-    return lineRangeMapping;
-}
 
-export { DetailedLineRangeMapping, LineRangeMapping, RangeMapping, getLineRangeMapping, lineRangeMappingFromChanges, lineRangeMappingFromRangeMappings };
+export { DetailedLineRangeMapping, LineRangeMapping, RangeMapping, getLineRangeMapping, lineRangeMappingFromRangeMappings };