@codingame/monaco-vscode-api 17.2.1 → 18.0.1

package/vscode/src/vs/editor/{browser → common/core/2d}/rect.d.ts

@@ -1,4 +1,4 @@
-import { OffsetRange } from "../common/core/offsetRange.js";
+import { OffsetRange } from "../ranges/offsetRange.js";
 import { Point } from "./point.js";
 export declare class Rect {
     readonly left: number;

package/vscode/src/vs/editor/{browser → common/core/2d}/rect.js

@@ -1,5 +1,5 @@
 
-import { BugIndicatingError } from '../../base/common/errors.js';
+import { BugIndicatingError } from '../../../../base/common/errors.js';
 import { Point } from './point.js';
 
 class Rect {

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

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

@@ -0,0 +1,48 @@
+import { OffsetRange } from "../ranges/offsetRange.js";
+export declare abstract class BaseEdit<T extends BaseReplacement<T>, TEdit extends BaseEdit<T, TEdit>> {
+    readonly replacements: readonly T[];
+    constructor(replacements: readonly T[]);
+    protected abstract _createNew(replacements: readonly T[]): TEdit;
+    equals(other: TEdit): boolean;
+    toString(): string;
+    normalize(): TEdit;
+    compose(other: TEdit): TEdit;
+    getNewRanges(): OffsetRange[];
+    getJoinedReplaceRange(): OffsetRange | undefined;
+    isEmpty(): boolean;
+    getLengthDelta(): number;
+    getNewDataLength(dataLength: number): number;
+    applyToOffset(originalOffset: number): number;
+    applyToOffsetRange(originalRange: OffsetRange): OffsetRange;
+    applyInverseToOffset(postEditsOffset: number): number;
+}
+export declare abstract class BaseReplacement<TSelf extends BaseReplacement<TSelf>> {
+    readonly replaceRange: OffsetRange;
+    constructor(replaceRange: OffsetRange);
+    abstract getNewLength(): number;
+    abstract tryJoinTouching(other: TSelf): TSelf | undefined;
+    abstract slice(newReplaceRange: OffsetRange, rangeInReplacement: OffsetRange): TSelf;
+    delta(offset: number): TSelf;
+    getLengthDelta(): number;
+    abstract equals(other: TSelf): boolean;
+    toString(): string;
+    get isEmpty(): boolean;
+    getRangeAfterReplace(): OffsetRange;
+}
+export type AnyEdit = BaseEdit<AnyReplacement, AnyEdit>;
+export type AnyReplacement = BaseReplacement<AnyReplacement>;
+export declare class Edit<T extends BaseReplacement<T>> extends BaseEdit<T, Edit<T>> {
+    static readonly empty: Edit<never>;
+    static create<T extends BaseReplacement<T>>(replacements: readonly T[]): Edit<T>;
+    static single<T extends BaseReplacement<T>>(replacement: T): Edit<T>;
+    protected _createNew(replacements: readonly T[]): Edit<T>;
+}
+export declare class AnnotationReplacement<TAnnotation> extends BaseReplacement<AnnotationReplacement<TAnnotation>> {
+    readonly newLength: number;
+    readonly annotation: TAnnotation;
+    constructor(range: OffsetRange, newLength: number, annotation: TAnnotation);
+    equals(other: AnnotationReplacement<TAnnotation>): boolean;
+    getNewLength(): number;
+    tryJoinTouching(other: AnnotationReplacement<TAnnotation>): AnnotationReplacement<TAnnotation> | undefined;
+    slice(range: OffsetRange, rangeInReplacement: OffsetRange): AnnotationReplacement<TAnnotation>;
+}

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

@@ -0,0 +1,227 @@
+
+import { sumBy } from '../../../../base/common/arrays.js';
+import { BugIndicatingError } from '../../../../base/common/errors.js';
+import { OffsetRange } from '../ranges/offsetRange.js';
+
+class BaseEdit {
+    constructor(replacements) {
+        this.replacements = replacements;
+        let lastEndEx = -1;
+        for (const replacement of replacements) {
+            if (!(replacement.replaceRange.start >= lastEndEx)) {
+                throw ( new BugIndicatingError(
+                    `Edits must be disjoint and sorted. Found ${replacement} after ${lastEndEx}`
+                ));
+            }
+            lastEndEx = replacement.replaceRange.endExclusive;
+        }
+    }
+    equals(other) {
+        if (this.replacements.length !== other.replacements.length) {
+            return false;
+        }
+        for (let i = 0; i < this.replacements.length; i++) {
+            if (!this.replacements[i].equals(other.replacements[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    toString() {
+        const edits = ( this.replacements.map(e => ( e.toString()))).join(', ');
+        return `[${edits}]`;
+    }
+    normalize() {
+        const newReplacements = [];
+        let lastReplacement;
+        for (const r of this.replacements) {
+            if (r.getNewLength() === 0 && r.replaceRange.length === 0) {
+                continue;
+            }
+            if (lastReplacement && lastReplacement.replaceRange.endExclusive === r.replaceRange.start) {
+                const joined = lastReplacement.tryJoinTouching(r);
+                if (joined) {
+                    lastReplacement = joined;
+                    continue;
+                }
+            }
+            if (lastReplacement) {
+                newReplacements.push(lastReplacement);
+            }
+            lastReplacement = r;
+        }
+        if (lastReplacement) {
+            newReplacements.push(lastReplacement);
+        }
+        return this._createNew(newReplacements);
+    }
+    compose(other) {
+        const edits1 = this.normalize();
+        const edits2 = other.normalize();
+        if (edits1.isEmpty()) {
+            return edits2;
+        }
+        if (edits2.isEmpty()) {
+            return edits1;
+        }
+        const edit1Queue = [...edits1.replacements];
+        const result = [];
+        let edit1ToEdit2 = 0;
+        for (const r2 of edits2.replacements) {
+            while (true) {
+                const r1 = edit1Queue[0];
+                if (!r1 || r1.replaceRange.start + edit1ToEdit2 + r1.getNewLength() >= r2.replaceRange.start) {
+                    break;
+                }
+                edit1Queue.shift();
+                result.push(r1);
+                edit1ToEdit2 += r1.getNewLength() - r1.replaceRange.length;
+            }
+            const firstEdit1ToEdit2 = edit1ToEdit2;
+            let firstIntersecting;
+            let lastIntersecting;
+            while (true) {
+                const r1 = edit1Queue[0];
+                if (!r1 || r1.replaceRange.start + edit1ToEdit2 > r2.replaceRange.endExclusive) {
+                    break;
+                }
+                if (!firstIntersecting) {
+                    firstIntersecting = r1;
+                }
+                lastIntersecting = r1;
+                edit1Queue.shift();
+                edit1ToEdit2 += r1.getNewLength() - r1.replaceRange.length;
+            }
+            if (!firstIntersecting) {
+                result.push(r2.delta(-edit1ToEdit2));
+            }
+            else {
+                const newReplaceRangeStart = Math.min(firstIntersecting.replaceRange.start, r2.replaceRange.start - firstEdit1ToEdit2);
+                const prefixLength = r2.replaceRange.start - (firstIntersecting.replaceRange.start + firstEdit1ToEdit2);
+                if (prefixLength > 0) {
+                    const prefix = firstIntersecting.slice(OffsetRange.emptyAt(newReplaceRangeStart), ( new OffsetRange(0, prefixLength)));
+                    result.push(prefix);
+                }
+                if (!lastIntersecting) {
+                    throw ( new BugIndicatingError(`Invariant violation: lastIntersecting is undefined`));
+                }
+                const suffixLength = (lastIntersecting.replaceRange.endExclusive + edit1ToEdit2) - r2.replaceRange.endExclusive;
+                if (suffixLength > 0) {
+                    const e = lastIntersecting.slice(OffsetRange.ofStartAndLength(lastIntersecting.replaceRange.endExclusive, 0), ( new OffsetRange(
+                        lastIntersecting.getNewLength() - suffixLength,
+                        lastIntersecting.getNewLength()
+                    )));
+                    edit1Queue.unshift(e);
+                    edit1ToEdit2 -= e.getNewLength() - e.replaceRange.length;
+                }
+                const newReplaceRange = ( new OffsetRange(newReplaceRangeStart, r2.replaceRange.endExclusive - edit1ToEdit2));
+                const middle = r2.slice(newReplaceRange, ( new OffsetRange(0, r2.getNewLength())));
+                result.push(middle);
+            }
+        }
+        while (true) {
+            const item = edit1Queue.shift();
+            if (!item) {
+                break;
+            }
+            result.push(item);
+        }
+        return this._createNew(result).normalize();
+    }
+    getNewRanges() {
+        const ranges = [];
+        let offset = 0;
+        for (const e of this.replacements) {
+            ranges.push(OffsetRange.ofStartAndLength(e.replaceRange.start + offset, e.getNewLength()));
+            offset += e.getLengthDelta();
+        }
+        return ranges;
+    }
+    getJoinedReplaceRange() {
+        if (this.replacements.length === 0) {
+            return undefined;
+        }
+        return this.replacements[0].replaceRange.join(this.replacements.at(-1).replaceRange);
+    }
+    isEmpty() {
+        return this.replacements.length === 0;
+    }
+    getLengthDelta() {
+        return sumBy(this.replacements, (replacement) => replacement.getLengthDelta());
+    }
+    getNewDataLength(dataLength) {
+        return dataLength + this.getLengthDelta();
+    }
+    applyToOffset(originalOffset) {
+        let accumulatedDelta = 0;
+        for (const r of this.replacements) {
+            if (r.replaceRange.start <= originalOffset) {
+                if (originalOffset < r.replaceRange.endExclusive) {
+                    return r.replaceRange.start + accumulatedDelta;
+                }
+                accumulatedDelta += r.getNewLength() - r.replaceRange.length;
+            }
+            else {
+                break;
+            }
+        }
+        return originalOffset + accumulatedDelta;
+    }
+    applyToOffsetRange(originalRange) {
+        return ( new OffsetRange(
+            this.applyToOffset(originalRange.start),
+            this.applyToOffset(originalRange.endExclusive)
+        ));
+    }
+    applyInverseToOffset(postEditsOffset) {
+        let accumulatedDelta = 0;
+        for (const edit of this.replacements) {
+            const editLength = edit.getNewLength();
+            if (edit.replaceRange.start <= postEditsOffset - accumulatedDelta) {
+                if (postEditsOffset - accumulatedDelta < edit.replaceRange.start + editLength) {
+                    return edit.replaceRange.start;
+                }
+                accumulatedDelta += editLength - edit.replaceRange.length;
+            }
+            else {
+                break;
+            }
+        }
+        return postEditsOffset - accumulatedDelta;
+    }
+}
+class BaseReplacement {
+    constructor(
+    replaceRange) {
+        this.replaceRange = replaceRange;
+    }
+    delta(offset) {
+        return this.slice(this.replaceRange.delta(offset), ( new OffsetRange(0, this.getNewLength())));
+    }
+    getLengthDelta() {
+        return this.getNewLength() - this.replaceRange.length;
+    }
+    toString() {
+        return `{ ${( this.replaceRange.toString())} -> ${this.getNewLength()} }`;
+    }
+    get isEmpty() {
+        return this.getNewLength() === 0 && this.replaceRange.length === 0;
+    }
+    getRangeAfterReplace() {
+        return ( new OffsetRange(this.replaceRange.start, this.replaceRange.start + this.getNewLength()));
+    }
+}
+class Edit extends BaseEdit {
+    static { this.empty = ( new Edit([])); }
+    static create(replacements) {
+        return ( new Edit(replacements));
+    }
+    static single(replacement) {
+        return ( new Edit([replacement]));
+    }
+    _createNew(replacements) {
+        return ( new Edit(replacements));
+    }
+}
+
+export { BaseEdit, BaseReplacement, Edit };

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

@@ -0,0 +1,25 @@
+import { OffsetRange } from "../ranges/offsetRange.js";
+import { AnyEdit, BaseEdit, BaseReplacement } from "./edit.js";
+export declare class LengthEdit extends BaseEdit<LengthReplacement, LengthEdit> {
+    static readonly empty: LengthEdit;
+    static fromEdit(edit: AnyEdit): LengthEdit;
+    static create(replacements: readonly LengthReplacement[]): LengthEdit;
+    static single(replacement: LengthReplacement): LengthEdit;
+    static replace(range: OffsetRange, newLength: number): LengthEdit;
+    static insert(offset: number, newLength: number): LengthEdit;
+    static delete(range: OffsetRange): LengthEdit;
+    static compose(edits: readonly LengthEdit[]): LengthEdit;
+    inverse(): LengthEdit;
+    protected _createNew(replacements: readonly LengthReplacement[]): LengthEdit;
+    applyArray<T>(arr: readonly T[], fillItem: T): T[];
+}
+export declare class LengthReplacement extends BaseReplacement<LengthReplacement> {
+    readonly newLength: number;
+    static create(startOffset: number, endOffsetExclusive: number, newLength: number): LengthReplacement;
+    constructor(range: OffsetRange, newLength: number);
+    equals(other: LengthReplacement): boolean;
+    getNewLength(): number;
+    tryJoinTouching(other: LengthReplacement): LengthReplacement | undefined;
+    slice(range: OffsetRange, rangeInReplacement: OffsetRange): LengthReplacement;
+    toString(): string;
+}