@codingame/monaco-vscode-api 36.2.7 → 37.1.0

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

@@ -14,12 +14,12 @@ 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(716, "Background color for the highlight of line at the cursor position.")));
+const editorLineHighlight = registerColor("editor.lineHighlightBackground", null, ( localize(720, "Background color for the highlight of line at the cursor position.")));
 const editorInactiveLineHighlight = registerColor(
     "editor.inactiveLineHighlightBackground",
     editorLineHighlight,
     ( localize(
-    717,
+    721,
     "Background color for the highlight of line at the cursor position when the editor is not focused."
 ))
 );
@@ -29,7 +29,7 @@ const editorLineHighlightBorder = registerColor("editor.lineHighlightBorder", {
     hcDark: "#f38518",
     hcLight: contrastBorder
 }, ( localize(
-    718,
+    722,
     "Background color for the border around the line at the cursor position."
 )));
 const editorRangeHighlight = registerColor("editor.rangeHighlightBackground", {
@@ -38,7 +38,7 @@ const editorRangeHighlight = registerColor("editor.rangeHighlightBackground", {
     hcDark: null,
     hcLight: null
 }, ( localize(
-    719,
+    723,
     "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", {
@@ -46,14 +46,14 @@ registerColor("editor.rangeHighlightBorder", {
     light: null,
     hcDark: activeContrastBorder,
     hcLight: activeContrastBorder
-}, ( localize(720, "Background color of the border around highlighted ranges.")));
+}, ( localize(724, "Background color of the border around highlighted ranges.")));
 registerColor("editor.symbolHighlightBackground", {
     dark: editorFindMatchHighlight,
     light: editorFindMatchHighlight,
     hcDark: null,
     hcLight: null
 }, ( localize(
-    721,
+    725,
     "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", {
@@ -61,22 +61,22 @@ registerColor("editor.symbolHighlightBorder", {
     light: null,
     hcDark: activeContrastBorder,
     hcLight: activeContrastBorder
-}, ( localize(722, "Background color of the border around highlighted symbols.")));
+}, ( localize(726, "Background color of the border around highlighted symbols.")));
 const editorCursorForeground = registerColor("editorCursor.foreground", {
     dark: "#AEAFAD",
     light: Color.black,
     hcDark: Color.white,
     hcLight: "#0F4A85"
-}, ( localize(723, "Color of the editor cursor.")));
+}, ( localize(727, "Color of the editor cursor.")));
 const editorCursorBackground = registerColor("editorCursor.background", null, ( localize(
-    724,
+    728,
     "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(
-    725,
+    729,
     "Color of the primary editor cursor when multiple cursors are present."
 ))
 );
@@ -84,7 +84,7 @@ const editorMultiCursorPrimaryBackground = registerColor(
     "editorMultiCursor.primary.background",
     editorCursorBackground,
     ( localize(
-    726,
+    730,
     "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."
 ))
 );
@@ -92,7 +92,7 @@ const editorMultiCursorSecondaryForeground = registerColor(
     "editorMultiCursor.secondary.foreground",
     editorCursorForeground,
     ( localize(
-    727,
+    731,
     "Color of secondary editor cursors when multiple cursors are present."
 ))
 );
@@ -100,7 +100,7 @@ const editorMultiCursorSecondaryBackground = registerColor(
     "editorMultiCursor.secondary.background",
     editorCursorBackground,
     ( localize(
-    728,
+    732,
     "The background color of secondary editor cursors when multiple cursors are present. Allows customizing the color of a character overlapped by a block cursor."
 ))
 );
@@ -109,54 +109,54 @@ const editorWhitespaces = registerColor("editorWhitespace.foreground", {
     light: "#33333333",
     hcDark: "#e3e4e229",
     hcLight: "#CCCCCC"
-}, ( localize(729, "Color of whitespace characters in the editor.")));
+}, ( localize(733, "Color of whitespace characters in the editor.")));
 const editorLineNumbers = registerColor("editorLineNumber.foreground", {
     dark: "#858585",
     light: "#237893",
     hcDark: Color.white,
     hcLight: "#292929"
-}, ( localize(730, "Color of editor line numbers.")));
-const deprecatedEditorIndentGuides = registerColor("editorIndentGuide.background", editorWhitespaces, ( localize(731, "Color of the editor indentation guides.")), false, ( localize(
-    732,
+}, ( localize(734, "Color of editor line numbers.")));
+const deprecatedEditorIndentGuides = registerColor("editorIndentGuide.background", editorWhitespaces, ( localize(735, "Color of the editor indentation guides.")), false, ( localize(
+    736,
     "'editorIndentGuide.background' is deprecated. Use 'editorIndentGuide.background1' instead."
 )));
-const deprecatedEditorActiveIndentGuides = registerColor("editorIndentGuide.activeBackground", editorWhitespaces, ( localize(733, "Color of the active editor indentation guides.")), false, ( localize(
-    734,
+const deprecatedEditorActiveIndentGuides = registerColor("editorIndentGuide.activeBackground", editorWhitespaces, ( localize(737, "Color of the active editor indentation guides.")), false, ( localize(
+    738,
     "'editorIndentGuide.activeBackground' is deprecated. Use 'editorIndentGuide.activeBackground1' instead."
 )));
 const editorIndentGuide1 = registerColor(
     "editorIndentGuide.background1",
     deprecatedEditorIndentGuides,
-    ( localize(735, "Color of the editor indentation guides (1)."))
+    ( localize(739, "Color of the editor indentation guides (1)."))
 );
-const editorIndentGuide2 = registerColor("editorIndentGuide.background2", "#00000000", ( localize(736, "Color of the editor indentation guides (2).")));
-const editorIndentGuide3 = registerColor("editorIndentGuide.background3", "#00000000", ( localize(737, "Color of the editor indentation guides (3).")));
-const editorIndentGuide4 = registerColor("editorIndentGuide.background4", "#00000000", ( localize(738, "Color of the editor indentation guides (4).")));
-const editorIndentGuide5 = registerColor("editorIndentGuide.background5", "#00000000", ( localize(739, "Color of the editor indentation guides (5).")));
-const editorIndentGuide6 = registerColor("editorIndentGuide.background6", "#00000000", ( localize(740, "Color of the editor indentation guides (6).")));
+const editorIndentGuide2 = registerColor("editorIndentGuide.background2", "#00000000", ( localize(740, "Color of the editor indentation guides (2).")));
+const editorIndentGuide3 = registerColor("editorIndentGuide.background3", "#00000000", ( localize(741, "Color of the editor indentation guides (3).")));
+const editorIndentGuide4 = registerColor("editorIndentGuide.background4", "#00000000", ( localize(742, "Color of the editor indentation guides (4).")));
+const editorIndentGuide5 = registerColor("editorIndentGuide.background5", "#00000000", ( localize(743, "Color of the editor indentation guides (5).")));
+const editorIndentGuide6 = registerColor("editorIndentGuide.background6", "#00000000", ( localize(744, "Color of the editor indentation guides (6).")));
 const editorActiveIndentGuide1 = registerColor(
     "editorIndentGuide.activeBackground1",
     deprecatedEditorActiveIndentGuides,
-    ( localize(741, "Color of the active editor indentation guides (1)."))
+    ( localize(745, "Color of the active editor indentation guides (1)."))
 );
-const editorActiveIndentGuide2 = registerColor("editorIndentGuide.activeBackground2", "#00000000", ( localize(742, "Color of the active editor indentation guides (2).")));
-const editorActiveIndentGuide3 = registerColor("editorIndentGuide.activeBackground3", "#00000000", ( localize(743, "Color of the active editor indentation guides (3).")));
-const editorActiveIndentGuide4 = registerColor("editorIndentGuide.activeBackground4", "#00000000", ( localize(744, "Color of the active editor indentation guides (4).")));
-const editorActiveIndentGuide5 = registerColor("editorIndentGuide.activeBackground5", "#00000000", ( localize(745, "Color of the active editor indentation guides (5).")));
-const editorActiveIndentGuide6 = registerColor("editorIndentGuide.activeBackground6", "#00000000", ( localize(746, "Color of the active editor indentation guides (6).")));
+const editorActiveIndentGuide2 = registerColor("editorIndentGuide.activeBackground2", "#00000000", ( localize(746, "Color of the active editor indentation guides (2).")));
+const editorActiveIndentGuide3 = registerColor("editorIndentGuide.activeBackground3", "#00000000", ( localize(747, "Color of the active editor indentation guides (3).")));
+const editorActiveIndentGuide4 = registerColor("editorIndentGuide.activeBackground4", "#00000000", ( localize(748, "Color of the active editor indentation guides (4).")));
+const editorActiveIndentGuide5 = registerColor("editorIndentGuide.activeBackground5", "#00000000", ( localize(749, "Color of the active editor indentation guides (5).")));
+const editorActiveIndentGuide6 = registerColor("editorIndentGuide.activeBackground6", "#00000000", ( localize(750, "Color of the active editor indentation guides (6).")));
 const deprecatedEditorActiveLineNumber = registerColor("editorActiveLineNumber.foreground", {
     dark: "#c6c6c6",
     light: "#0B216F",
     hcDark: activeContrastBorder,
     hcLight: activeContrastBorder
-}, ( localize(747, "Color of editor active line number")), false, ( localize(748, "Id is deprecated. Use 'editorLineNumber.activeForeground' instead.")));
+}, ( localize(751, "Color of editor active line number")), false, ( localize(752, "Id is deprecated. Use 'editorLineNumber.activeForeground' instead.")));
 registerColor(
     "editorLineNumber.activeForeground",
     deprecatedEditorActiveLineNumber,
-    ( localize(747, "Color of editor active line number"))
+    ( localize(751, "Color of editor active line number"))
 );
 const editorDimmedLineNumber = registerColor("editorLineNumber.dimmedForeground", null, ( localize(
-    749,
+    753,
     "Color of the final editor line when editor.renderFinalNewline is set to dimmed."
 )));
 const editorRuler = registerColor("editorRuler.foreground", {
@@ -164,35 +164,35 @@ const editorRuler = registerColor("editorRuler.foreground", {
     light: Color.lightgrey,
     hcDark: Color.white,
     hcLight: "#292929"
-}, ( localize(750, "Color of the editor rulers.")));
+}, ( localize(754, "Color of the editor rulers.")));
 registerColor("editorCodeLens.foreground", {
     dark: "#999999",
     light: "#919191",
     hcDark: "#999999",
     hcLight: "#292929"
-}, ( localize(751, "Foreground color of editor CodeLens")));
+}, ( localize(755, "Foreground color of editor CodeLens")));
 registerColor("editorBracketMatch.background", {
     dark: "#0064001a",
     light: "#0064001a",
     hcDark: "#0064001a",
     hcLight: "#0000"
-}, ( localize(752, "Background color behind matching brackets")));
+}, ( localize(756, "Background color behind matching brackets")));
 registerColor("editorBracketMatch.border", {
     dark: "#888",
     light: "#B9B9B9",
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(753, "Color for matching brackets boxes")));
-const editorBracketMatchForeground = registerColor("editorBracketMatch.foreground", null, ( localize(754, "Foreground color for matching brackets")));
+}, ( localize(757, "Color for matching brackets boxes")));
+const editorBracketMatchForeground = registerColor("editorBracketMatch.foreground", null, ( localize(758, "Foreground color for matching brackets")));
 const editorOverviewRulerBorder = registerColor("editorOverviewRuler.border", {
     dark: "#7f7f7f4d",
     light: "#7f7f7f4d",
     hcDark: "#7f7f7f4d",
     hcLight: "#666666"
-}, ( localize(755, "Color of the overview ruler border.")));
-const editorOverviewRulerBackground = registerColor("editorOverviewRuler.background", null, ( localize(756, "Background color of the editor overview ruler.")));
+}, ( localize(759, "Color of the overview ruler border.")));
+const editorOverviewRulerBackground = registerColor("editorOverviewRuler.background", null, ( localize(760, "Background color of the editor overview ruler.")));
 registerColor("editorGutter.background", editorBackground, ( localize(
-    757,
+    761,
     "Background color of the editor gutter. The gutter contains the glyph margins and the line numbers."
 )));
 registerColor("editorUnnecessaryCode.border", {
@@ -200,14 +200,14 @@ registerColor("editorUnnecessaryCode.border", {
     light: null,
     hcDark: ( ( Color.fromHex("#fff")).transparent(0.8)),
     hcLight: contrastBorder
-}, ( localize(758, "Border color of unnecessary (unused) source code in the editor.")));
+}, ( localize(762, "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(
-    759,
+    763,
     "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", {
@@ -215,20 +215,20 @@ registerColor("editorGhostText.border", {
     light: null,
     hcDark: ( ( Color.fromHex("#fff")).transparent(0.8)),
     hcLight: ( ( Color.fromHex("#292929")).transparent(0.8))
-}, ( localize(760, "Border color of ghost text in the editor.")));
+}, ( localize(764, "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(761, "Foreground color of the ghost text in the editor.")));
-registerColor("editorGhostText.background", null, ( localize(762, "Background color of the ghost text in the editor.")));
+}, ( localize(765, "Foreground color of the ghost text in the editor.")));
+registerColor("editorGhostText.background", null, ( localize(766, "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(
-    763,
+    767,
     "Overview ruler marker color for range highlights. The color must not be opaque so as not to hide underlying decorations."
 )),
     true
@@ -238,26 +238,26 @@ const overviewRulerError = registerColor("editorOverviewRuler.errorForeground",
     light: ( new Color(( new RGBA(255, 18, 18, 0.7)))),
     hcDark: ( new Color(( new RGBA(255, 50, 50, 1)))),
     hcLight: "#B5200D"
-}, ( localize(764, "Overview ruler marker color for errors.")));
+}, ( localize(768, "Overview ruler marker color for errors.")));
 const overviewRulerWarning = registerColor("editorOverviewRuler.warningForeground", {
     dark: editorWarningForeground,
     light: editorWarningForeground,
     hcDark: editorWarningBorder,
     hcLight: editorWarningBorder
-}, ( localize(765, "Overview ruler marker color for warnings.")));
+}, ( localize(769, "Overview ruler marker color for warnings.")));
 const overviewRulerInfo = registerColor("editorOverviewRuler.infoForeground", {
     dark: editorInfoForeground,
     light: editorInfoForeground,
     hcDark: editorInfoBorder,
     hcLight: editorInfoBorder
-}, ( localize(766, "Overview ruler marker color for infos.")));
+}, ( localize(770, "Overview ruler marker color for infos.")));
 const editorBracketHighlightingForeground1 = registerColor("editorBracketHighlight.foreground1", {
     dark: "#FFD700",
     light: "#0431FAFF",
     hcDark: "#FFD700",
     hcLight: "#0431FAFF"
 }, ( localize(
-    767,
+    771,
     "Foreground color of brackets (1). Requires enabling bracket pair colorization."
 )));
 const editorBracketHighlightingForeground2 = registerColor("editorBracketHighlight.foreground2", {
@@ -266,7 +266,7 @@ const editorBracketHighlightingForeground2 = registerColor("editorBracketHighlig
     hcDark: "#DA70D6",
     hcLight: "#319331FF"
 }, ( localize(
-    768,
+    772,
     "Foreground color of brackets (2). Requires enabling bracket pair colorization."
 )));
 const editorBracketHighlightingForeground3 = registerColor("editorBracketHighlight.foreground3", {
@@ -275,19 +275,19 @@ const editorBracketHighlightingForeground3 = registerColor("editorBracketHighlig
     hcDark: "#87CEFA",
     hcLight: "#7B3814FF"
 }, ( localize(
-    769,
+    773,
     "Foreground color of brackets (3). Requires enabling bracket pair colorization."
 )));
 const editorBracketHighlightingForeground4 = registerColor("editorBracketHighlight.foreground4", "#00000000", ( localize(
-    770,
+    774,
     "Foreground color of brackets (4). Requires enabling bracket pair colorization."
 )));
 const editorBracketHighlightingForeground5 = registerColor("editorBracketHighlight.foreground5", "#00000000", ( localize(
-    771,
+    775,
     "Foreground color of brackets (5). Requires enabling bracket pair colorization."
 )));
 const editorBracketHighlightingForeground6 = registerColor("editorBracketHighlight.foreground6", "#00000000", ( localize(
-    772,
+    776,
     "Foreground color of brackets (6). Requires enabling bracket pair colorization."
 )));
 const editorBracketHighlightingUnexpectedBracketForeground = registerColor("editorBracketHighlight.unexpectedBracket.foreground", {
@@ -295,60 +295,60 @@ const editorBracketHighlightingUnexpectedBracketForeground = registerColor("edit
     light: ( new Color(( new RGBA(255, 18, 18, 0.8)))),
     hcDark: ( new Color(( new RGBA(255, 50, 50, 1)))),
     hcLight: "#B5200D"
-}, ( localize(773, "Foreground color of unexpected brackets.")));
+}, ( localize(777, "Foreground color of unexpected brackets.")));
 const editorBracketPairGuideBackground1 = registerColor("editorBracketPairGuide.background1", "#00000000", ( localize(
-    774,
+    778,
     "Background color of inactive bracket pair guides (1). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideBackground2 = registerColor("editorBracketPairGuide.background2", "#00000000", ( localize(
-    775,
+    779,
     "Background color of inactive bracket pair guides (2). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideBackground3 = registerColor("editorBracketPairGuide.background3", "#00000000", ( localize(
-    776,
+    780,
     "Background color of inactive bracket pair guides (3). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideBackground4 = registerColor("editorBracketPairGuide.background4", "#00000000", ( localize(
-    777,
+    781,
     "Background color of inactive bracket pair guides (4). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideBackground5 = registerColor("editorBracketPairGuide.background5", "#00000000", ( localize(
-    778,
+    782,
     "Background color of inactive bracket pair guides (5). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideBackground6 = registerColor("editorBracketPairGuide.background6", "#00000000", ( localize(
-    779,
+    783,
     "Background color of inactive bracket pair guides (6). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideActiveBackground1 = registerColor("editorBracketPairGuide.activeBackground1", "#00000000", ( localize(
-    780,
+    784,
     "Background color of active bracket pair guides (1). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideActiveBackground2 = registerColor("editorBracketPairGuide.activeBackground2", "#00000000", ( localize(
-    781,
+    785,
     "Background color of active bracket pair guides (2). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideActiveBackground3 = registerColor("editorBracketPairGuide.activeBackground3", "#00000000", ( localize(
-    782,
+    786,
     "Background color of active bracket pair guides (3). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideActiveBackground4 = registerColor("editorBracketPairGuide.activeBackground4", "#00000000", ( localize(
-    783,
+    787,
     "Background color of active bracket pair guides (4). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideActiveBackground5 = registerColor("editorBracketPairGuide.activeBackground5", "#00000000", ( localize(
-    784,
+    788,
     "Background color of active bracket pair guides (5). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideActiveBackground6 = registerColor("editorBracketPairGuide.activeBackground6", "#00000000", ( localize(
-    785,
+    789,
     "Background color of active bracket pair guides (6). Requires enabling bracket pair guides."
 )));
-registerColor("editorUnicodeHighlight.border", editorWarningForeground, ( localize(786, "Border color used to highlight unicode characters.")));
+registerColor("editorUnicodeHighlight.border", editorWarningForeground, ( localize(790, "Border color used to highlight unicode characters.")));
 registerColor(
     "editorUnicodeHighlight.background",
     editorWarningBackground,
-    ( localize(787, "Background color used to highlight unicode characters."))
+    ( localize(791, "Background color used to highlight unicode characters."))
 );
 registerThemingParticipant((theme, collector) => {
     const background = theme.getColor(editorBackground);

package/vscode/src/vs/editor/common/cursor/cursorMoveOperations.js

@@ -82,7 +82,7 @@ class MoveOperations {
             lineNumber = lineNumber + 1;
             column = model.getLineMinColumn(lineNumber);
         }
-        return ( new Position(lineNumber, column));
+        return model.normalizePosition(( new Position(lineNumber, column)), PositionAffinity.Right);
     }
     static rightPositionAtomicSoftTabs(model, lineNumber, column, tabSize, indentSize) {
         if (column < model.getLineIndentColumn(lineNumber)) {

package/vscode/src/vs/editor/common/cursor/cursorTypeEditOperations.js

@@ -193,6 +193,7 @@ class AutoClosingOpenCharTypeOperation {
         }
         let autoCloseConfig;
         let shouldAutoCloseBefore;
+        let shouldCheckBracketBalance = false;
         const chIsQuote = isQuote(ch);
         if (chIsQuote) {
             autoCloseConfig = config.autoClosingQuotes;
@@ -205,6 +206,7 @@ class AutoClosingOpenCharTypeOperation {
             } else {
                 autoCloseConfig = config.autoClosingBrackets;
                 shouldAutoCloseBefore = config.shouldAutoCloseBefore.bracket;
+                shouldCheckBracketBalance = true;
             }
         }
         if (autoCloseConfig === "never") {
@@ -232,6 +234,10 @@ class AutoClosingOpenCharTypeOperation {
                     return null;
                 }
             }
+            if (
+            shouldCheckBracketBalance && autoCloseConfig !== "always" && !chIsAlreadyTyped && model.bracketPairs.hasUnmatchedClosingBracketAfter(( new Position(lineNumber, beforeColumn)), pair.open)) {
+                return null;
+            }
             if (pair.open.length === 1 && (ch === "'" || ch === "\"") && autoCloseConfig !== "always") {
                 const wordSeparators = getMapForWordSeparators(config.wordSeparators, []);
                 if (lineBefore.length > 0) {

package/vscode/src/vs/editor/common/cursor/cursorWordOperations.js

@@ -536,7 +536,7 @@ class WordOperations {
         const lineContent = model.getLineContent(position.lineNumber);
         const startIndex = position.column - 1;
         const firstNonWhitespace = this._findFirstNonWhitespaceChar(lineContent, startIndex);
-        if (startIndex + 1 < firstNonWhitespace) {
+        if (startIndex < firstNonWhitespace) {
             return ( new Range(
                 position.lineNumber,
                 position.column,

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

@@ -50,7 +50,7 @@ export interface ICursorPositionChangedEvent {
      */
     readonly reason: CursorChangeReason;
     /**
-     * Source of the call that caused the event.
+     * Source of the call that caused the event. Possible sources include `'mouse'`, `'keyboard'`, and `'api'`.
      */
     readonly source: string;
 }
@@ -79,7 +79,7 @@ export interface ICursorSelectionChangedEvent {
      */
     readonly oldModelVersionId: number;
     /**
-     * Source of the call that caused the event.
+     * Source of the call that caused the event. Possible sources include `'mouse'`, `'keyboard'`, and `'api'`.
      */
     readonly source: string;
     /**

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

@@ -19,11 +19,15 @@ export declare namespace EditorContextKeys {
     const isEmbeddedDiffEditor: RawContextKey<boolean>;
     const inMultiDiffEditor: RawContextKey<boolean>;
     const multiDiffEditorAllCollapsed: RawContextKey<boolean>;
+    const multiDiffEditorItemAllUnchangedRegionsShown: RawContextKey<boolean>;
+    const multiDiffEditorRenderSideBySide: RawContextKey<boolean>;
     const hasChanges: RawContextKey<boolean>;
     const comparingMovedCode: RawContextKey<boolean>;
     const accessibleDiffViewerVisible: RawContextKey<boolean>;
     const diffEditorRenderSideBySideInlineBreakpointReached: RawContextKey<boolean>;
     const diffEditorInlineMode: RawContextKey<boolean>;
+    const diffEditorTemporaryInlineMode: RawContextKey<boolean>;
+    const diffEditorAutomaticRenderSideBySide: RawContextKey<boolean>;
     const diffEditorOriginalWritable: RawContextKey<boolean>;
     const diffEditorModifiedWritable: RawContextKey<boolean>;
     const diffEditorOriginalUri: RawContextKey<string>;