@codingame/monaco-vscode-api 27.0.0 → 28.0.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(699, "Background color for the highlight of line at the cursor position.")));
+const editorLineHighlight = registerColor("editor.lineHighlightBackground", null, ( localize(701, "Background color for the highlight of line at the cursor position.")));
 const editorInactiveLineHighlight = registerColor(
     "editor.inactiveLineHighlightBackground",
     editorLineHighlight,
     ( localize(
-    700,
+    702,
     "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(
-    701,
+    703,
     "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(
-    702,
+    704,
     "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(703, "Background color of the border around highlighted ranges.")));
+}, ( localize(705, "Background color of the border around highlighted ranges.")));
 registerColor("editor.symbolHighlightBackground", {
     dark: editorFindMatchHighlight,
     light: editorFindMatchHighlight,
     hcDark: null,
     hcLight: null
 }, ( localize(
-    704,
+    706,
     "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(705, "Background color of the border around highlighted symbols.")));
+}, ( localize(707, "Background color of the border around highlighted symbols.")));
 const editorCursorForeground = registerColor("editorCursor.foreground", {
     dark: "#AEAFAD",
     light: Color.black,
     hcDark: Color.white,
     hcLight: "#0F4A85"
-}, ( localize(706, "Color of the editor cursor.")));
+}, ( localize(708, "Color of the editor cursor.")));
 const editorCursorBackground = registerColor("editorCursor.background", null, ( localize(
-    707,
+    709,
     "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(
-    708,
+    710,
     "Color of the primary editor cursor when multiple cursors are present."
 ))
 );
@@ -84,7 +84,7 @@ const editorMultiCursorPrimaryBackground = registerColor(
     "editorMultiCursor.primary.background",
     editorCursorBackground,
     ( localize(
-    709,
+    711,
     "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(
-    710,
+    712,
     "Color of secondary editor cursors when multiple cursors are present."
 ))
 );
@@ -100,7 +100,7 @@ const editorMultiCursorSecondaryBackground = registerColor(
     "editorMultiCursor.secondary.background",
     editorCursorBackground,
     ( localize(
-    711,
+    713,
     "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(712, "Color of whitespace characters in the editor.")));
+}, ( localize(714, "Color of whitespace characters in the editor.")));
 const editorLineNumbers = registerColor("editorLineNumber.foreground", {
     dark: "#858585",
     light: "#237893",
     hcDark: Color.white,
     hcLight: "#292929"
-}, ( localize(713, "Color of editor line numbers.")));
-const deprecatedEditorIndentGuides = registerColor("editorIndentGuide.background", editorWhitespaces, ( localize(714, "Color of the editor indentation guides.")), false, ( localize(
-    715,
+}, ( localize(715, "Color of editor line numbers.")));
+const deprecatedEditorIndentGuides = registerColor("editorIndentGuide.background", editorWhitespaces, ( localize(716, "Color of the editor indentation guides.")), false, ( localize(
+    717,
     "'editorIndentGuide.background' is deprecated. Use 'editorIndentGuide.background1' instead."
 )));
-const deprecatedEditorActiveIndentGuides = registerColor("editorIndentGuide.activeBackground", editorWhitespaces, ( localize(716, "Color of the active editor indentation guides.")), false, ( localize(
-    717,
+const deprecatedEditorActiveIndentGuides = registerColor("editorIndentGuide.activeBackground", editorWhitespaces, ( localize(718, "Color of the active editor indentation guides.")), false, ( localize(
+    719,
     "'editorIndentGuide.activeBackground' is deprecated. Use 'editorIndentGuide.activeBackground1' instead."
 )));
 const editorIndentGuide1 = registerColor(
     "editorIndentGuide.background1",
     deprecatedEditorIndentGuides,
-    ( localize(718, "Color of the editor indentation guides (1)."))
+    ( localize(720, "Color of the editor indentation guides (1)."))
 );
-const editorIndentGuide2 = registerColor("editorIndentGuide.background2", "#00000000", ( localize(719, "Color of the editor indentation guides (2).")));
-const editorIndentGuide3 = registerColor("editorIndentGuide.background3", "#00000000", ( localize(720, "Color of the editor indentation guides (3).")));
-const editorIndentGuide4 = registerColor("editorIndentGuide.background4", "#00000000", ( localize(721, "Color of the editor indentation guides (4).")));
-const editorIndentGuide5 = registerColor("editorIndentGuide.background5", "#00000000", ( localize(722, "Color of the editor indentation guides (5).")));
-const editorIndentGuide6 = registerColor("editorIndentGuide.background6", "#00000000", ( localize(723, "Color of the editor indentation guides (6).")));
+const editorIndentGuide2 = registerColor("editorIndentGuide.background2", "#00000000", ( localize(721, "Color of the editor indentation guides (2).")));
+const editorIndentGuide3 = registerColor("editorIndentGuide.background3", "#00000000", ( localize(722, "Color of the editor indentation guides (3).")));
+const editorIndentGuide4 = registerColor("editorIndentGuide.background4", "#00000000", ( localize(723, "Color of the editor indentation guides (4).")));
+const editorIndentGuide5 = registerColor("editorIndentGuide.background5", "#00000000", ( localize(724, "Color of the editor indentation guides (5).")));
+const editorIndentGuide6 = registerColor("editorIndentGuide.background6", "#00000000", ( localize(725, "Color of the editor indentation guides (6).")));
 const editorActiveIndentGuide1 = registerColor(
     "editorIndentGuide.activeBackground1",
     deprecatedEditorActiveIndentGuides,
-    ( localize(724, "Color of the active editor indentation guides (1)."))
+    ( localize(726, "Color of the active editor indentation guides (1)."))
 );
-const editorActiveIndentGuide2 = registerColor("editorIndentGuide.activeBackground2", "#00000000", ( localize(725, "Color of the active editor indentation guides (2).")));
-const editorActiveIndentGuide3 = registerColor("editorIndentGuide.activeBackground3", "#00000000", ( localize(726, "Color of the active editor indentation guides (3).")));
-const editorActiveIndentGuide4 = registerColor("editorIndentGuide.activeBackground4", "#00000000", ( localize(727, "Color of the active editor indentation guides (4).")));
-const editorActiveIndentGuide5 = registerColor("editorIndentGuide.activeBackground5", "#00000000", ( localize(728, "Color of the active editor indentation guides (5).")));
-const editorActiveIndentGuide6 = registerColor("editorIndentGuide.activeBackground6", "#00000000", ( localize(729, "Color of the active editor indentation guides (6).")));
+const editorActiveIndentGuide2 = registerColor("editorIndentGuide.activeBackground2", "#00000000", ( localize(727, "Color of the active editor indentation guides (2).")));
+const editorActiveIndentGuide3 = registerColor("editorIndentGuide.activeBackground3", "#00000000", ( localize(728, "Color of the active editor indentation guides (3).")));
+const editorActiveIndentGuide4 = registerColor("editorIndentGuide.activeBackground4", "#00000000", ( localize(729, "Color of the active editor indentation guides (4).")));
+const editorActiveIndentGuide5 = registerColor("editorIndentGuide.activeBackground5", "#00000000", ( localize(730, "Color of the active editor indentation guides (5).")));
+const editorActiveIndentGuide6 = registerColor("editorIndentGuide.activeBackground6", "#00000000", ( localize(731, "Color of the active editor indentation guides (6).")));
 const deprecatedEditorActiveLineNumber = registerColor("editorActiveLineNumber.foreground", {
     dark: "#c6c6c6",
     light: "#0B216F",
     hcDark: activeContrastBorder,
     hcLight: activeContrastBorder
-}, ( localize(730, "Color of editor active line number")), false, ( localize(731, "Id is deprecated. Use 'editorLineNumber.activeForeground' instead.")));
+}, ( localize(732, "Color of editor active line number")), false, ( localize(733, "Id is deprecated. Use 'editorLineNumber.activeForeground' instead.")));
 registerColor(
     "editorLineNumber.activeForeground",
     deprecatedEditorActiveLineNumber,
-    ( localize(730, "Color of editor active line number"))
+    ( localize(732, "Color of editor active line number"))
 );
 const editorDimmedLineNumber = registerColor("editorLineNumber.dimmedForeground", null, ( localize(
-    732,
+    734,
     "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(733, "Color of the editor rulers.")));
+}, ( localize(735, "Color of the editor rulers.")));
 registerColor("editorCodeLens.foreground", {
     dark: "#999999",
     light: "#919191",
     hcDark: "#999999",
     hcLight: "#292929"
-}, ( localize(734, "Foreground color of editor CodeLens")));
+}, ( localize(736, "Foreground color of editor CodeLens")));
 registerColor("editorBracketMatch.background", {
     dark: "#0064001a",
     light: "#0064001a",
     hcDark: "#0064001a",
     hcLight: "#0000"
-}, ( localize(735, "Background color behind matching brackets")));
+}, ( localize(737, "Background color behind matching brackets")));
 registerColor("editorBracketMatch.border", {
     dark: "#888",
     light: "#B9B9B9",
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(736, "Color for matching brackets boxes")));
-const editorBracketMatchForeground = registerColor("editorBracketMatch.foreground", null, ( localize(737, "Foreground color for matching brackets")));
+}, ( localize(738, "Color for matching brackets boxes")));
+const editorBracketMatchForeground = registerColor("editorBracketMatch.foreground", null, ( localize(739, "Foreground color for matching brackets")));
 const editorOverviewRulerBorder = registerColor("editorOverviewRuler.border", {
     dark: "#7f7f7f4d",
     light: "#7f7f7f4d",
     hcDark: "#7f7f7f4d",
     hcLight: "#666666"
-}, ( localize(738, "Color of the overview ruler border.")));
-const editorOverviewRulerBackground = registerColor("editorOverviewRuler.background", null, ( localize(739, "Background color of the editor overview ruler.")));
+}, ( localize(740, "Color of the overview ruler border.")));
+const editorOverviewRulerBackground = registerColor("editorOverviewRuler.background", null, ( localize(741, "Background color of the editor overview ruler.")));
 registerColor("editorGutter.background", editorBackground, ( localize(
-    740,
+    742,
     "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(741, "Border color of unnecessary (unused) source code in the editor.")));
+}, ( localize(743, "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(
-    742,
+    744,
     "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(743, "Border color of ghost text in the editor.")));
+}, ( localize(745, "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(744, "Foreground color of the ghost text in the editor.")));
-registerColor("editorGhostText.background", null, ( localize(745, "Background color of the ghost text in the editor.")));
+}, ( localize(746, "Foreground color of the ghost text in the editor.")));
+registerColor("editorGhostText.background", null, ( localize(747, "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(
-    746,
+    748,
     "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(747, "Overview ruler marker color for errors.")));
+}, ( localize(749, "Overview ruler marker color for errors.")));
 const overviewRulerWarning = registerColor("editorOverviewRuler.warningForeground", {
     dark: editorWarningForeground,
     light: editorWarningForeground,
     hcDark: editorWarningBorder,
     hcLight: editorWarningBorder
-}, ( localize(748, "Overview ruler marker color for warnings.")));
+}, ( localize(750, "Overview ruler marker color for warnings.")));
 const overviewRulerInfo = registerColor("editorOverviewRuler.infoForeground", {
     dark: editorInfoForeground,
     light: editorInfoForeground,
     hcDark: editorInfoBorder,
     hcLight: editorInfoBorder
-}, ( localize(749, "Overview ruler marker color for infos.")));
+}, ( localize(751, "Overview ruler marker color for infos.")));
 const editorBracketHighlightingForeground1 = registerColor("editorBracketHighlight.foreground1", {
     dark: "#FFD700",
     light: "#0431FAFF",
     hcDark: "#FFD700",
     hcLight: "#0431FAFF"
 }, ( localize(
-    750,
+    752,
     "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(
-    751,
+    753,
     "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(
-    752,
+    754,
     "Foreground color of brackets (3). Requires enabling bracket pair colorization."
 )));
 const editorBracketHighlightingForeground4 = registerColor("editorBracketHighlight.foreground4", "#00000000", ( localize(
-    753,
+    755,
     "Foreground color of brackets (4). Requires enabling bracket pair colorization."
 )));
 const editorBracketHighlightingForeground5 = registerColor("editorBracketHighlight.foreground5", "#00000000", ( localize(
-    754,
+    756,
     "Foreground color of brackets (5). Requires enabling bracket pair colorization."
 )));
 const editorBracketHighlightingForeground6 = registerColor("editorBracketHighlight.foreground6", "#00000000", ( localize(
-    755,
+    757,
     "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(756, "Foreground color of unexpected brackets.")));
+}, ( localize(758, "Foreground color of unexpected brackets.")));
 const editorBracketPairGuideBackground1 = registerColor("editorBracketPairGuide.background1", "#00000000", ( localize(
-    757,
+    759,
     "Background color of inactive bracket pair guides (1). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideBackground2 = registerColor("editorBracketPairGuide.background2", "#00000000", ( localize(
-    758,
+    760,
     "Background color of inactive bracket pair guides (2). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideBackground3 = registerColor("editorBracketPairGuide.background3", "#00000000", ( localize(
-    759,
+    761,
     "Background color of inactive bracket pair guides (3). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideBackground4 = registerColor("editorBracketPairGuide.background4", "#00000000", ( localize(
-    760,
+    762,
     "Background color of inactive bracket pair guides (4). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideBackground5 = registerColor("editorBracketPairGuide.background5", "#00000000", ( localize(
-    761,
+    763,
     "Background color of inactive bracket pair guides (5). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideBackground6 = registerColor("editorBracketPairGuide.background6", "#00000000", ( localize(
-    762,
+    764,
     "Background color of inactive bracket pair guides (6). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideActiveBackground1 = registerColor("editorBracketPairGuide.activeBackground1", "#00000000", ( localize(
-    763,
+    765,
     "Background color of active bracket pair guides (1). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideActiveBackground2 = registerColor("editorBracketPairGuide.activeBackground2", "#00000000", ( localize(
-    764,
+    766,
     "Background color of active bracket pair guides (2). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideActiveBackground3 = registerColor("editorBracketPairGuide.activeBackground3", "#00000000", ( localize(
-    765,
+    767,
     "Background color of active bracket pair guides (3). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideActiveBackground4 = registerColor("editorBracketPairGuide.activeBackground4", "#00000000", ( localize(
-    766,
+    768,
     "Background color of active bracket pair guides (4). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideActiveBackground5 = registerColor("editorBracketPairGuide.activeBackground5", "#00000000", ( localize(
-    767,
+    769,
     "Background color of active bracket pair guides (5). Requires enabling bracket pair guides."
 )));
 const editorBracketPairGuideActiveBackground6 = registerColor("editorBracketPairGuide.activeBackground6", "#00000000", ( localize(
-    768,
+    770,
     "Background color of active bracket pair guides (6). Requires enabling bracket pair guides."
 )));
-registerColor("editorUnicodeHighlight.border", editorWarningForeground, ( localize(769, "Border color used to highlight unicode characters.")));
+registerColor("editorUnicodeHighlight.border", editorWarningForeground, ( localize(771, "Border color used to highlight unicode characters.")));
 registerColor(
     "editorUnicodeHighlight.background",
     editorWarningBackground,
-    ( localize(770, "Background color used to highlight unicode characters."))
+    ( localize(772, "Background color used to highlight unicode characters."))
 );
 registerThemingParticipant((theme, collector) => {
     const background = theme.getColor(editorBackground);

package/vscode/src/vs/editor/common/cursor/cursorMoveCommands.d.ts

@@ -41,6 +41,10 @@ export declare class CursorMoveCommands {
     private static _moveDownByModelLines;
     private static _moveUpByViewLines;
     private static _moveUpByModelLines;
+    private static _moveDownByFoldedLines;
+    private static _moveUpByFoldedLines;
+    private static _targetFoldedDown;
+    private static _targetFoldedUp;
     private static _moveToViewPosition;
     private static _moveToModelPosition;
     private static _moveToViewMinColumn;
@@ -79,6 +83,7 @@ export declare namespace CursorMove {
         WrappedLine: string;
         Character: string;
         HalfLine: string;
+        FoldedLine: string;
     };
     /**
      * Arguments for Cursor move command
@@ -128,6 +133,7 @@ export declare namespace CursorMove {
         Line = 1,
         WrappedLine = 2,
         Character = 3,
-        HalfLine = 4
+        HalfLine = 4,
+        FoldedLine = 5
     }
 }

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

@@ -256,6 +256,8 @@ class CursorMoveCommands {
             {
                 if (unit === CursorMove.Unit.WrappedLine) {
                     return this._moveUpByViewLines(viewModel, cursors, inSelectionMode, value);
+                } else if (unit === CursorMove.Unit.FoldedLine) {
+                    return this._moveUpByFoldedLines(viewModel, cursors, inSelectionMode, value);
                 } else {
                     return this._moveUpByModelLines(viewModel, cursors, inSelectionMode, value);
                 }
@@ -264,6 +266,8 @@ class CursorMoveCommands {
             {
                 if (unit === CursorMove.Unit.WrappedLine) {
                     return this._moveDownByViewLines(viewModel, cursors, inSelectionMode, value);
+                } else if (unit === CursorMove.Unit.FoldedLine) {
+                    return this._moveDownByFoldedLines(viewModel, cursors, inSelectionMode, value);
                 } else {
                     return this._moveDownByModelLines(viewModel, cursors, inSelectionMode, value);
                 }
@@ -533,6 +537,85 @@ class CursorMoveCommands {
         }
         return result;
     }
+    static _moveDownByFoldedLines(viewModel, cursors, inSelectionMode, count) {
+        const model = viewModel.model;
+        const lineCount = model.getLineCount();
+        const hiddenAreas = viewModel.getHiddenAreas();
+        return ( cursors.map(cursor => {
+            const startLine = cursor.modelState.hasSelection() && !inSelectionMode ? cursor.modelState.selection.endLineNumber : cursor.modelState.position.lineNumber;
+            const targetLine = CursorMoveCommands._targetFoldedDown(startLine, count, hiddenAreas, lineCount);
+            const delta = targetLine - startLine;
+            if (delta === 0) {
+                return CursorState.fromModelState(cursor.modelState);
+            }
+            return CursorState.fromModelState(
+                MoveOperations.moveDown(viewModel.cursorConfig, model, cursor.modelState, inSelectionMode, delta)
+            );
+        }));
+    }
+    static _moveUpByFoldedLines(viewModel, cursors, inSelectionMode, count) {
+        const model = viewModel.model;
+        const hiddenAreas = viewModel.getHiddenAreas();
+        return ( cursors.map(cursor => {
+            const startLine = cursor.modelState.hasSelection() && !inSelectionMode ? cursor.modelState.selection.startLineNumber : cursor.modelState.position.lineNumber;
+            const targetLine = CursorMoveCommands._targetFoldedUp(startLine, count, hiddenAreas);
+            const delta = startLine - targetLine;
+            if (delta === 0) {
+                return CursorState.fromModelState(cursor.modelState);
+            }
+            return CursorState.fromModelState(
+                MoveOperations.moveUp(viewModel.cursorConfig, model, cursor.modelState, inSelectionMode, delta)
+            );
+        }));
+    }
+    static _targetFoldedDown(startLine, count, hiddenAreas, lineCount) {
+        let line = startLine;
+        let i = 0;
+        while (i < hiddenAreas.length && hiddenAreas[i].endLineNumber < line + 1) {
+            i++;
+        }
+        for (let step = 0; step < count; step++) {
+            if (line >= lineCount) {
+                return lineCount;
+            }
+            let candidate = line + 1;
+            while (i < hiddenAreas.length && hiddenAreas[i].endLineNumber < candidate) {
+                i++;
+            }
+            if (i < hiddenAreas.length && hiddenAreas[i].startLineNumber <= candidate) {
+                candidate = hiddenAreas[i].endLineNumber + 1;
+            }
+            if (candidate > lineCount) {
+                return line;
+            }
+            line = candidate;
+        }
+        return line;
+    }
+    static _targetFoldedUp(startLine, count, hiddenAreas) {
+        let line = startLine;
+        let i = hiddenAreas.length - 1;
+        while (i >= 0 && hiddenAreas[i].startLineNumber > line - 1) {
+            i--;
+        }
+        for (let step = 0; step < count; step++) {
+            if (line <= 1) {
+                return 1;
+            }
+            let candidate = line - 1;
+            while (i >= 0 && hiddenAreas[i].startLineNumber > candidate) {
+                i--;
+            }
+            if (i >= 0 && hiddenAreas[i].endLineNumber >= candidate) {
+                candidate = hiddenAreas[i].startLineNumber - 1;
+            }
+            if (candidate < 1) {
+                return line;
+            }
+            line = candidate;
+        }
+        return line;
+    }
     static _moveToViewPosition(viewModel, cursor, inSelectionMode, toViewLineNumber, toViewColumn) {
         return CursorState.fromViewState(cursor.viewState.move(inSelectionMode, toViewLineNumber, toViewColumn, 0));
     }
@@ -632,8 +715,10 @@ var CursorMove;
                         \`\`\`
                     * 'by': Unit to move. Default is computed based on 'to' value.
                         \`\`\`
-                        'line', 'wrappedLine', 'character', 'halfLine'
+                        'line', 'wrappedLine', 'character', 'halfLine', 'foldedLine'
                         \`\`\`
+                        Use 'foldedLine' with 'up'/'down' to move by logical lines while treating each
+                        folded region as a single step.
                     * 'value': Number of units to move. Default is '1'.
                     * 'select': If 'true' makes the selection. Default is 'false'.
                     * 'noHistory': If 'true' does not add the movement to navigation history. Default is 'false'.
@@ -665,7 +750,7 @@ var CursorMove;
                     },
                     "by": {
                         "type": "string",
-                        "enum": ["line", "wrappedLine", "character", "halfLine"]
+                        "enum": ["line", "wrappedLine", "character", "halfLine", "foldedLine"]
                     },
                     "value": {
                         "type": "number",
@@ -704,7 +789,8 @@ var CursorMove;
         Line: "line",
         WrappedLine: "wrappedLine",
         Character: "character",
-        HalfLine: "halfLine"
+        HalfLine: "halfLine",
+        FoldedLine: "foldedLine"
     };
     function parse(args) {
         if (!args.to) {
@@ -774,6 +860,9 @@ var CursorMove;
         case CursorMove.RawUnit.HalfLine:
             unit = Unit.HalfLine;
             break;
+        case CursorMove.RawUnit.FoldedLine:
+            unit = Unit.FoldedLine;
+            break;
         }
         return {
             direction: direction,
@@ -809,6 +898,7 @@ var CursorMove;
         Unit[Unit["WrappedLine"] = 2] = "WrappedLine";
         Unit[Unit["Character"] = 3] = "Character";
         Unit[Unit["HalfLine"] = 4] = "HalfLine";
+        Unit[Unit["FoldedLine"] = 5] = "FoldedLine";
     })(Unit = CursorMove.Unit || (CursorMove.Unit = {}));
 })(CursorMove || (CursorMove = {}));