@codingame/monaco-vscode-api 11.1.2 → 12.0.1

package/vscode/src/vs/editor/browser/coreCommands.js

@@ -1,23 +1,29 @@
+
 import { localize } from '../../nls.js';
 import { isFirefox } from '../../base/browser/browser.js';
+import { KeyMod as KeyMod$1, KeyCode } from '../../base/common/keyCodes.js';
 import { isObject, isString, isUndefined, isNumber, isBoolean } from '../../base/common/types.js';
 import { status } from '../../base/browser/ui/aria/aria.js';
 import { EditorCommand, registerEditorCommand, SelectAllCommand, UndoCommand, RedoCommand, Command } from './editorExtensions.js';
 import { ICodeEditorService } from './services/codeEditorService.js';
 import { ColumnSelection } from '../common/cursor/cursorColumnSelection.js';
-import { CursorState } from '../common/cursorCommon.js';
+import { CursorState, EditOperationType } from '../common/cursorCommon.js';
 import { DeleteOperations } from '../common/cursor/cursorDeleteOperations.js';
+import { CursorChangeReason } from '../common/cursorEvents.js';
 import { CursorMoveCommands, CursorMove } from '../common/cursor/cursorMoveCommands.js';
 import { TypeOperations } from '../common/cursor/cursorTypeOperations.js';
 import { Position } from '../common/core/position.js';
 import { Range } from '../common/core/range.js';
+import { ScrollType, Handler } from '../common/editorCommon.js';
 import { EditorContextKeys } from '../common/editorContextKeys.js';
+import { VerticalRevealType } from '../common/viewEvents.js';
 import { ContextKeyExpr } from '../../platform/contextkey/common/contextkey.js';
-import { KeybindingsRegistry } from '../../platform/keybinding/common/keybindingsRegistry.js';
+import { KeybindingWeight, KeybindingsRegistry } from '../../platform/keybinding/common/keybindingsRegistry.js';
+import { EditorOption } from '../common/config/editorOptions.js';
 import { getActiveElement, isEditableElement } from '../../base/browser/dom.js';
 import { EnterOperation } from '../common/cursor/cursorTypeEditOperations.js';
 
-const CORE_WEIGHT = 0 ;
+const CORE_WEIGHT = KeybindingWeight.EditorCore;
 class CoreEditorCommand extends EditorCommand {
     runEditorCommand(accessor, editor, args) {
         const viewModel = editor._getViewModel();
@@ -28,7 +34,7 @@ class CoreEditorCommand extends EditorCommand {
     }
 }
 var EditorScroll_;
-( ((function(EditorScroll_) {
+(function (EditorScroll_) {
     const isEditorScrollArgs = function (arg) {
         if (!isObject(arg)) {
             return false;
@@ -108,16 +114,16 @@ var EditorScroll_;
         let direction;
         switch (args.to) {
             case EditorScroll_.RawDirection.Up:
-                direction = 1 ;
+                direction = Direction.Up;
                 break;
             case EditorScroll_.RawDirection.Right:
-                direction = 2 ;
+                direction = Direction.Right;
                 break;
             case EditorScroll_.RawDirection.Down:
-                direction = 3 ;
+                direction = Direction.Down;
                 break;
             case EditorScroll_.RawDirection.Left:
-                direction = 4 ;
+                direction = Direction.Left;
                 break;
             default:
                 return null;
@@ -125,25 +131,25 @@ var EditorScroll_;
         let unit;
         switch (args.by) {
             case EditorScroll_.RawUnit.Line:
-                unit = 1 ;
+                unit = Unit.Line;
                 break;
             case EditorScroll_.RawUnit.WrappedLine:
-                unit = 2 ;
+                unit = Unit.WrappedLine;
                 break;
             case EditorScroll_.RawUnit.Page:
-                unit = 3 ;
+                unit = Unit.Page;
                 break;
             case EditorScroll_.RawUnit.HalfPage:
-                unit = 4 ;
+                unit = Unit.HalfPage;
                 break;
             case EditorScroll_.RawUnit.Editor:
-                unit = 5 ;
+                unit = Unit.Editor;
                 break;
             case EditorScroll_.RawUnit.Column:
-                unit = 6 ;
+                unit = Unit.Column;
                 break;
             default:
-                unit = 2 ;
+                unit = Unit.WrappedLine;
         }
         const value = Math.floor(args.value || 1);
         const revealCursor = !!args.revealCursor;
@@ -156,23 +162,25 @@ var EditorScroll_;
         };
     }
     EditorScroll_.parse = parse;
-    ( ((function(Direction) {
+    let Direction;
+    (function (Direction) {
         Direction[Direction["Up"] = 1] = "Up";
         Direction[Direction["Right"] = 2] = "Right";
         Direction[Direction["Down"] = 3] = "Down";
         Direction[Direction["Left"] = 4] = "Left";
-    })(EditorScroll_.Direction || (EditorScroll_.Direction = {}))));
-    ( ((function(Unit) {
+    })(Direction = EditorScroll_.Direction || (EditorScroll_.Direction = {}));
+    let Unit;
+    (function (Unit) {
         Unit[Unit["Line"] = 1] = "Line";
         Unit[Unit["WrappedLine"] = 2] = "WrappedLine";
         Unit[Unit["Page"] = 3] = "Page";
         Unit[Unit["HalfPage"] = 4] = "HalfPage";
         Unit[Unit["Editor"] = 5] = "Editor";
         Unit[Unit["Column"] = 6] = "Column";
-    })(EditorScroll_.Unit || (EditorScroll_.Unit = {}))));
-})(EditorScroll_ || (EditorScroll_ = {}))));
+    })(Unit = EditorScroll_.Unit || (EditorScroll_.Unit = {}));
+})(EditorScroll_ || (EditorScroll_ = {}));
 var RevealLine_;
-( ((function(RevealLine_) {
+(function (RevealLine_) {
     const isRevealLineArgs = function (arg) {
         if (!isObject(arg)) {
             return false;
@@ -220,7 +228,7 @@ var RevealLine_;
         Center: 'center',
         Bottom: 'bottom'
     };
-})(RevealLine_ || (RevealLine_ = {}))));
+})(RevealLine_ || (RevealLine_ = {}));
 class EditorOrNativeTextInputCommand {
     constructor(target) {
         target.addImplementation(10000, 'code-editor', (accessor, args) => {
@@ -255,8 +263,14 @@ class EditorOrNativeTextInputCommand {
         return true;
     }
 }
+var NavigationCommandRevealType;
+(function (NavigationCommandRevealType) {
+    NavigationCommandRevealType[NavigationCommandRevealType["Regular"] = 0] = "Regular";
+    NavigationCommandRevealType[NavigationCommandRevealType["Minimal"] = 1] = "Minimal";
+    NavigationCommandRevealType[NavigationCommandRevealType["None"] = 2] = "None";
+})(NavigationCommandRevealType || (NavigationCommandRevealType = {}));
 var CoreNavigationCommands;
-( ((function(CoreNavigationCommands) {
+(function (CoreNavigationCommands) {
     class BaseMoveToCommand extends CoreEditorCommand {
         constructor(opts) {
             super(opts);
@@ -267,24 +281,24 @@ var CoreNavigationCommands;
                 return;
             }
             viewModel.model.pushStackElement();
-            const cursorStateChanged = viewModel.setCursorStates(args.source, 3 , [
+            const cursorStateChanged = viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, [
                 CursorMoveCommands.moveTo(viewModel, viewModel.getPrimaryCursorState(), this._inSelectionMode, args.position, args.viewPosition)
             ]);
-            if (cursorStateChanged && args.revealType !== 2 ) {
+            if (cursorStateChanged && args.revealType !== NavigationCommandRevealType.None) {
                 viewModel.revealAllCursors(args.source, true, true);
             }
         }
     }
-    CoreNavigationCommands.MoveTo = registerEditorCommand(( (new BaseMoveToCommand({
+    CoreNavigationCommands.MoveTo = registerEditorCommand(( new BaseMoveToCommand({
         id: '_moveTo',
         inSelectionMode: false,
         precondition: undefined
-    }))));
-    CoreNavigationCommands.MoveToSelect = registerEditorCommand(( (new BaseMoveToCommand({
+    })));
+    CoreNavigationCommands.MoveToSelect = registerEditorCommand(( new BaseMoveToCommand({
         id: '_moveToSelect',
         inSelectionMode: true,
         precondition: undefined
-    }))));
+    })));
     class ColumnSelectCommand extends CoreEditorCommand {
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
@@ -292,7 +306,7 @@ var CoreNavigationCommands;
             if (result === null) {
                 return;
             }
-            viewModel.setCursorStates(args.source, 3 , ( (result.viewStates.map((viewState) => CursorState.fromViewState(viewState)))));
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, ( result.viewStates.map((viewState) => CursorState.fromViewState(viewState))));
             viewModel.setCursorColumnSelectData({
                 isReal: true,
                 fromViewLineNumber: result.fromLineNumber,
@@ -320,7 +334,7 @@ var CoreNavigationCommands;
                 return null;
             }
             const validatedPosition = viewModel.model.validatePosition(args.position);
-            const validatedViewPosition = viewModel.coordinatesConverter.validateViewPosition(( (new Position(args.viewPosition.lineNumber, args.viewPosition.column))), validatedPosition);
+            const validatedViewPosition = viewModel.coordinatesConverter.validateViewPosition(( new Position(args.viewPosition.lineNumber, args.viewPosition.column)), validatedPosition);
             const fromViewLineNumber = args.doColumnSelect ? prevColumnSelectData.fromViewLineNumber : validatedViewPosition.lineNumber;
             const fromViewVisualColumn = args.doColumnSelect ? prevColumnSelectData.fromViewVisualColumn : args.mouseColumn - 1;
             return ColumnSelection.columnSelect(viewModel.cursorConfig, viewModel, fromViewLineNumber, fromViewVisualColumn, validatedViewPosition.lineNumber, args.mouseColumn - 1);
@@ -334,7 +348,7 @@ var CoreNavigationCommands;
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
-                    primary: 2048  | 1024  | 512  | 15 ,
+                    primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyMod$1.Alt | KeyCode.LeftArrow,
                     linux: { primary: 0 }
                 }
             });
@@ -351,7 +365,7 @@ var CoreNavigationCommands;
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
-                    primary: 2048  | 1024  | 512  | 17 ,
+                    primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyMod$1.Alt | KeyCode.RightArrow,
                     linux: { primary: 0 }
                 }
             });
@@ -369,28 +383,28 @@ var CoreNavigationCommands;
             return ColumnSelection.columnSelectUp(viewModel.cursorConfig, viewModel, prevColumnSelectData, this._isPaged);
         }
     }
-    CoreNavigationCommands.CursorColumnSelectUp = registerEditorCommand(( (new ColumnSelectUpCommand({
+    CoreNavigationCommands.CursorColumnSelectUp = registerEditorCommand(( new ColumnSelectUpCommand({
         isPaged: false,
         id: 'cursorColumnSelectUp',
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 2048  | 1024  | 512  | 16 ,
+            primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyMod$1.Alt | KeyCode.UpArrow,
             linux: { primary: 0 }
         }
-    }))));
-    CoreNavigationCommands.CursorColumnSelectPageUp = registerEditorCommand(( (new ColumnSelectUpCommand({
+    })));
+    CoreNavigationCommands.CursorColumnSelectPageUp = registerEditorCommand(( new ColumnSelectUpCommand({
         isPaged: true,
         id: 'cursorColumnSelectPageUp',
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 2048  | 1024  | 512  | 11 ,
+            primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyMod$1.Alt | KeyCode.PageUp,
             linux: { primary: 0 }
         }
-    }))));
+    })));
     class ColumnSelectDownCommand extends ColumnSelectCommand {
         constructor(opts) {
             super(opts);
@@ -400,28 +414,28 @@ var CoreNavigationCommands;
             return ColumnSelection.columnSelectDown(viewModel.cursorConfig, viewModel, prevColumnSelectData, this._isPaged);
         }
     }
-    CoreNavigationCommands.CursorColumnSelectDown = registerEditorCommand(( (new ColumnSelectDownCommand({
+    CoreNavigationCommands.CursorColumnSelectDown = registerEditorCommand(( new ColumnSelectDownCommand({
         isPaged: false,
         id: 'cursorColumnSelectDown',
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 2048  | 1024  | 512  | 18 ,
+            primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyMod$1.Alt | KeyCode.DownArrow,
             linux: { primary: 0 }
         }
-    }))));
-    CoreNavigationCommands.CursorColumnSelectPageDown = registerEditorCommand(( (new ColumnSelectDownCommand({
+    })));
+    CoreNavigationCommands.CursorColumnSelectPageDown = registerEditorCommand(( new ColumnSelectDownCommand({
         isPaged: true,
         id: 'cursorColumnSelectPageDown',
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 2048  | 1024  | 512  | 12 ,
+            primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyMod$1.Alt | KeyCode.PageDown,
             linux: { primary: 0 }
         }
-    }))));
+    })));
     class CursorMoveImpl extends CoreEditorCommand {
         constructor() {
             super({
@@ -439,29 +453,29 @@ var CoreNavigationCommands;
         }
         _runCursorMove(viewModel, source, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(source, 3 , CursorMoveImpl._move(viewModel, viewModel.getCursorStates(), args));
+            viewModel.setCursorStates(source, CursorChangeReason.Explicit, CursorMoveImpl._move(viewModel, viewModel.getCursorStates(), args));
             viewModel.revealAllCursors(source, true);
         }
         static _move(viewModel, cursors, args) {
             const inSelectionMode = args.select;
             const value = args.value;
             switch (args.direction) {
-                case 0 :
-                case 1 :
-                case 2 :
-                case 3 :
-                case 4 :
-                case 5 :
-                case 6 :
-                case 7 :
-                case 8 :
-                case 9 :
-                case 10 :
+                case CursorMove.Direction.Left:
+                case CursorMove.Direction.Right:
+                case CursorMove.Direction.Up:
+                case CursorMove.Direction.Down:
+                case CursorMove.Direction.PrevBlankLine:
+                case CursorMove.Direction.NextBlankLine:
+                case CursorMove.Direction.WrappedLineStart:
+                case CursorMove.Direction.WrappedLineFirstNonWhitespaceCharacter:
+                case CursorMove.Direction.WrappedLineColumnCenter:
+                case CursorMove.Direction.WrappedLineEnd:
+                case CursorMove.Direction.WrappedLineLastNonWhitespaceCharacter:
                     return CursorMoveCommands.simpleMove(viewModel, cursors, args.direction, inSelectionMode, value, args.unit);
-                case 11 :
-                case 13 :
-                case 12 :
-                case 14 :
+                case CursorMove.Direction.ViewPortTop:
+                case CursorMove.Direction.ViewPortBottom:
+                case CursorMove.Direction.ViewPortCenter:
+                case CursorMove.Direction.ViewPortIfOutside:
                     return CursorMoveCommands.viewportMove(viewModel, cursors, args.direction, inSelectionMode, value);
                 default:
                     return null;
@@ -469,7 +483,11 @@ var CoreNavigationCommands;
         }
     }
     CoreNavigationCommands.CursorMoveImpl = CursorMoveImpl;
-    CoreNavigationCommands.CursorMove = registerEditorCommand(( (new CursorMoveImpl())));
+    CoreNavigationCommands.CursorMove = registerEditorCommand(( new CursorMoveImpl()));
+    let Constants;
+    (function (Constants) {
+        Constants[Constants["PAGE_SIZE_MARKER"] = -1] = "PAGE_SIZE_MARKER";
+    })(Constants || (Constants = {}));
     class CursorMoveBasedCommand extends CoreEditorCommand {
         constructor(opts) {
             super(opts);
@@ -477,7 +495,7 @@ var CoreNavigationCommands;
         }
         runCoreEditorCommand(viewModel, dynamicArgs) {
             let args = this._staticArgs;
-            if (this._staticArgs.value === -1 ) {
+            if (this._staticArgs.value === Constants.PAGE_SIZE_MARKER) {
                 args = {
                     direction: this._staticArgs.direction,
                     unit: this._staticArgs.unit,
@@ -486,14 +504,14 @@ var CoreNavigationCommands;
                 };
             }
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(dynamicArgs.source, 3 , CursorMoveCommands.simpleMove(viewModel, viewModel.getCursorStates(), args.direction, args.select, args.value, args.unit));
+            viewModel.setCursorStates(dynamicArgs.source, CursorChangeReason.Explicit, CursorMoveCommands.simpleMove(viewModel, viewModel.getCursorStates(), args.direction, args.select, args.value, args.unit));
             viewModel.revealAllCursors(dynamicArgs.source, true);
         }
     }
-    CoreNavigationCommands.CursorLeft = registerEditorCommand(( (new CursorMoveBasedCommand({
+    CoreNavigationCommands.CursorLeft = registerEditorCommand(( new CursorMoveBasedCommand({
         args: {
-            direction: 0 ,
-            unit: 0 ,
+            direction: CursorMove.Direction.Left,
+            unit: CursorMove.Unit.None,
             select: false,
             value: 1
         },
@@ -502,14 +520,14 @@ var CoreNavigationCommands;
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 15 ,
-            mac: { primary: 15 , secondary: [256  | 32 ] }
+            primary: KeyCode.LeftArrow,
+            mac: { primary: KeyCode.LeftArrow, secondary: [KeyMod$1.WinCtrl | KeyCode.KeyB] }
         }
-    }))));
-    CoreNavigationCommands.CursorLeftSelect = registerEditorCommand(( (new CursorMoveBasedCommand({
+    })));
+    CoreNavigationCommands.CursorLeftSelect = registerEditorCommand(( new CursorMoveBasedCommand({
         args: {
-            direction: 0 ,
-            unit: 0 ,
+            direction: CursorMove.Direction.Left,
+            unit: CursorMove.Unit.None,
             select: true,
             value: 1
         },
@@ -518,13 +536,13 @@ var CoreNavigationCommands;
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 1024  | 15
+            primary: KeyMod$1.Shift | KeyCode.LeftArrow
         }
-    }))));
-    CoreNavigationCommands.CursorRight = registerEditorCommand(( (new CursorMoveBasedCommand({
+    })));
+    CoreNavigationCommands.CursorRight = registerEditorCommand(( new CursorMoveBasedCommand({
         args: {
-            direction: 1 ,
-            unit: 0 ,
+            direction: CursorMove.Direction.Right,
+            unit: CursorMove.Unit.None,
             select: false,
             value: 1
         },
@@ -533,14 +551,14 @@ var CoreNavigationCommands;
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 17 ,
-            mac: { primary: 17 , secondary: [256  | 36 ] }
+            primary: KeyCode.RightArrow,
+            mac: { primary: KeyCode.RightArrow, secondary: [KeyMod$1.WinCtrl | KeyCode.KeyF] }
         }
-    }))));
-    CoreNavigationCommands.CursorRightSelect = registerEditorCommand(( (new CursorMoveBasedCommand({
+    })));
+    CoreNavigationCommands.CursorRightSelect = registerEditorCommand(( new CursorMoveBasedCommand({
         args: {
-            direction: 1 ,
-            unit: 0 ,
+            direction: CursorMove.Direction.Right,
+            unit: CursorMove.Unit.None,
             select: true,
             value: 1
         },
@@ -549,13 +567,13 @@ var CoreNavigationCommands;
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 1024  | 17
+            primary: KeyMod$1.Shift | KeyCode.RightArrow
         }
-    }))));
-    CoreNavigationCommands.CursorUp = registerEditorCommand(( (new CursorMoveBasedCommand({
+    })));
+    CoreNavigationCommands.CursorUp = registerEditorCommand(( new CursorMoveBasedCommand({
         args: {
-            direction: 2 ,
-            unit: 2 ,
+            direction: CursorMove.Direction.Up,
+            unit: CursorMove.Unit.WrappedLine,
             select: false,
             value: 1
         },
@@ -564,14 +582,14 @@ var CoreNavigationCommands;
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 16 ,
-            mac: { primary: 16 , secondary: [256  | 46 ] }
+            primary: KeyCode.UpArrow,
+            mac: { primary: KeyCode.UpArrow, secondary: [KeyMod$1.WinCtrl | KeyCode.KeyP] }
         }
-    }))));
-    CoreNavigationCommands.CursorUpSelect = registerEditorCommand(( (new CursorMoveBasedCommand({
+    })));
+    CoreNavigationCommands.CursorUpSelect = registerEditorCommand(( new CursorMoveBasedCommand({
         args: {
-            direction: 2 ,
-            unit: 2 ,
+            direction: CursorMove.Direction.Up,
+            unit: CursorMove.Unit.WrappedLine,
             select: true,
             value: 1
         },
@@ -580,46 +598,46 @@ var CoreNavigationCommands;
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 1024  | 16 ,
-            secondary: [2048  | 1024  | 16 ],
-            mac: { primary: 1024  | 16  },
-            linux: { primary: 1024  | 16  }
+            primary: KeyMod$1.Shift | KeyCode.UpArrow,
+            secondary: [KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.UpArrow],
+            mac: { primary: KeyMod$1.Shift | KeyCode.UpArrow },
+            linux: { primary: KeyMod$1.Shift | KeyCode.UpArrow }
         }
-    }))));
-    CoreNavigationCommands.CursorPageUp = registerEditorCommand(( (new CursorMoveBasedCommand({
+    })));
+    CoreNavigationCommands.CursorPageUp = registerEditorCommand(( new CursorMoveBasedCommand({
         args: {
-            direction: 2 ,
-            unit: 2 ,
+            direction: CursorMove.Direction.Up,
+            unit: CursorMove.Unit.WrappedLine,
             select: false,
-            value: -1
+            value: Constants.PAGE_SIZE_MARKER
         },
         id: 'cursorPageUp',
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 11
+            primary: KeyCode.PageUp
         }
-    }))));
-    CoreNavigationCommands.CursorPageUpSelect = registerEditorCommand(( (new CursorMoveBasedCommand({
+    })));
+    CoreNavigationCommands.CursorPageUpSelect = registerEditorCommand(( new CursorMoveBasedCommand({
         args: {
-            direction: 2 ,
-            unit: 2 ,
+            direction: CursorMove.Direction.Up,
+            unit: CursorMove.Unit.WrappedLine,
             select: true,
-            value: -1
+            value: Constants.PAGE_SIZE_MARKER
         },
         id: 'cursorPageUpSelect',
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 1024  | 11
+            primary: KeyMod$1.Shift | KeyCode.PageUp
         }
-    }))));
-    CoreNavigationCommands.CursorDown = registerEditorCommand(( (new CursorMoveBasedCommand({
+    })));
+    CoreNavigationCommands.CursorDown = registerEditorCommand(( new CursorMoveBasedCommand({
         args: {
-            direction: 3 ,
-            unit: 2 ,
+            direction: CursorMove.Direction.Down,
+            unit: CursorMove.Unit.WrappedLine,
             select: false,
             value: 1
         },
@@ -628,14 +646,14 @@ var CoreNavigationCommands;
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 18 ,
-            mac: { primary: 18 , secondary: [256  | 44 ] }
+            primary: KeyCode.DownArrow,
+            mac: { primary: KeyCode.DownArrow, secondary: [KeyMod$1.WinCtrl | KeyCode.KeyN] }
         }
-    }))));
-    CoreNavigationCommands.CursorDownSelect = registerEditorCommand(( (new CursorMoveBasedCommand({
+    })));
+    CoreNavigationCommands.CursorDownSelect = registerEditorCommand(( new CursorMoveBasedCommand({
         args: {
-            direction: 3 ,
-            unit: 2 ,
+            direction: CursorMove.Direction.Down,
+            unit: CursorMove.Unit.WrappedLine,
             select: true,
             value: 1
         },
@@ -644,42 +662,42 @@ var CoreNavigationCommands;
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 1024  | 18 ,
-            secondary: [2048  | 1024  | 18 ],
-            mac: { primary: 1024  | 18  },
-            linux: { primary: 1024  | 18  }
+            primary: KeyMod$1.Shift | KeyCode.DownArrow,
+            secondary: [KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.DownArrow],
+            mac: { primary: KeyMod$1.Shift | KeyCode.DownArrow },
+            linux: { primary: KeyMod$1.Shift | KeyCode.DownArrow }
         }
-    }))));
-    CoreNavigationCommands.CursorPageDown = registerEditorCommand(( (new CursorMoveBasedCommand({
+    })));
+    CoreNavigationCommands.CursorPageDown = registerEditorCommand(( new CursorMoveBasedCommand({
         args: {
-            direction: 3 ,
-            unit: 2 ,
+            direction: CursorMove.Direction.Down,
+            unit: CursorMove.Unit.WrappedLine,
             select: false,
-            value: -1
+            value: Constants.PAGE_SIZE_MARKER
         },
         id: 'cursorPageDown',
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 12
+            primary: KeyCode.PageDown
         }
-    }))));
-    CoreNavigationCommands.CursorPageDownSelect = registerEditorCommand(( (new CursorMoveBasedCommand({
+    })));
+    CoreNavigationCommands.CursorPageDownSelect = registerEditorCommand(( new CursorMoveBasedCommand({
         args: {
-            direction: 3 ,
-            unit: 2 ,
+            direction: CursorMove.Direction.Down,
+            unit: CursorMove.Unit.WrappedLine,
             select: true,
-            value: -1
+            value: Constants.PAGE_SIZE_MARKER
         },
         id: 'cursorPageDownSelect',
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 1024  | 12
+            primary: KeyMod$1.Shift | KeyCode.PageDown
         }
-    }))));
+    })));
     CoreNavigationCommands.CreateCursor = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
@@ -712,13 +730,13 @@ var CoreNavigationCommands;
                     }
                     states.splice(i, 1);
                     viewModel.model.pushStackElement();
-                    viewModel.setCursorStates(args.source, 3 , states);
+                    viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, states);
                     return;
                 }
             }
             states.push(newState);
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, 3 , states);
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, states);
         }
     }));
     CoreNavigationCommands.LastCursorMoveToSelect = registerEditorCommand(new (class extends CoreEditorCommand {
@@ -737,7 +755,7 @@ var CoreNavigationCommands;
             const newStates = states.slice(0);
             newStates[lastAddedCursorIndex] = CursorMoveCommands.moveTo(viewModel, states[lastAddedCursorIndex], true, args.position, args.viewPosition);
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, 3 , newStates);
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, newStates);
         }
     }));
     class HomeCommand extends CoreEditorCommand {
@@ -747,32 +765,32 @@ var CoreNavigationCommands;
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, 3 , CursorMoveCommands.moveToBeginningOfLine(viewModel, viewModel.getCursorStates(), this._inSelectionMode));
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, CursorMoveCommands.moveToBeginningOfLine(viewModel, viewModel.getCursorStates(), this._inSelectionMode));
             viewModel.revealAllCursors(args.source, true);
         }
     }
-    CoreNavigationCommands.CursorHome = registerEditorCommand(( (new HomeCommand({
+    CoreNavigationCommands.CursorHome = registerEditorCommand(( new HomeCommand({
         inSelectionMode: false,
         id: 'cursorHome',
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 14 ,
-            mac: { primary: 14 , secondary: [2048  | 15 ] }
+            primary: KeyCode.Home,
+            mac: { primary: KeyCode.Home, secondary: [KeyMod$1.CtrlCmd | KeyCode.LeftArrow] }
         }
-    }))));
-    CoreNavigationCommands.CursorHomeSelect = registerEditorCommand(( (new HomeCommand({
+    })));
+    CoreNavigationCommands.CursorHomeSelect = registerEditorCommand(( new HomeCommand({
         inSelectionMode: true,
         id: 'cursorHomeSelect',
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 1024  | 14 ,
-            mac: { primary: 1024  | 14 , secondary: [2048  | 1024  | 15 ] }
+            primary: KeyMod$1.Shift | KeyCode.Home,
+            mac: { primary: KeyMod$1.Shift | KeyCode.Home, secondary: [KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.LeftArrow] }
         }
-    }))));
+    })));
     class LineStartCommand extends CoreEditorCommand {
         constructor(opts) {
             super(opts);
@@ -780,7 +798,7 @@ var CoreNavigationCommands;
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, 3 , this._exec(viewModel.getCursorStates()));
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, this._exec(viewModel.getCursorStates()));
             viewModel.revealAllCursors(args.source, true);
         }
         _exec(cursors) {
@@ -793,7 +811,7 @@ var CoreNavigationCommands;
             return result;
         }
     }
-    CoreNavigationCommands.CursorLineStart = registerEditorCommand(( (new LineStartCommand({
+    CoreNavigationCommands.CursorLineStart = registerEditorCommand(( new LineStartCommand({
         inSelectionMode: false,
         id: 'cursorLineStart',
         precondition: undefined,
@@ -801,10 +819,10 @@ var CoreNavigationCommands;
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: 0,
-            mac: { primary: 256  | 31  }
+            mac: { primary: KeyMod$1.WinCtrl | KeyCode.KeyA }
         }
-    }))));
-    CoreNavigationCommands.CursorLineStartSelect = registerEditorCommand(( (new LineStartCommand({
+    })));
+    CoreNavigationCommands.CursorLineStartSelect = registerEditorCommand(( new LineStartCommand({
         inSelectionMode: true,
         id: 'cursorLineStartSelect',
         precondition: undefined,
@@ -812,9 +830,9 @@ var CoreNavigationCommands;
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: 0,
-            mac: { primary: 256  | 1024  | 31  }
+            mac: { primary: KeyMod$1.WinCtrl | KeyMod$1.Shift | KeyCode.KeyA }
         }
-    }))));
+    })));
     class EndCommand extends CoreEditorCommand {
         constructor(opts) {
             super(opts);
@@ -822,11 +840,11 @@ var CoreNavigationCommands;
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, 3 , CursorMoveCommands.moveToEndOfLine(viewModel, viewModel.getCursorStates(), this._inSelectionMode, args.sticky || false));
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, CursorMoveCommands.moveToEndOfLine(viewModel, viewModel.getCursorStates(), this._inSelectionMode, args.sticky || false));
             viewModel.revealAllCursors(args.source, true);
         }
     }
-    CoreNavigationCommands.CursorEnd = registerEditorCommand(( (new EndCommand({
+    CoreNavigationCommands.CursorEnd = registerEditorCommand(( new EndCommand({
         inSelectionMode: false,
         id: 'cursorEnd',
         precondition: undefined,
@@ -834,8 +852,8 @@ var CoreNavigationCommands;
             args: { sticky: false },
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 13 ,
-            mac: { primary: 13 , secondary: [2048  | 17 ] }
+            primary: KeyCode.End,
+            mac: { primary: KeyCode.End, secondary: [KeyMod$1.CtrlCmd | KeyCode.RightArrow] }
         },
         metadata: {
             description: `Go to End`,
@@ -845,7 +863,7 @@ var CoreNavigationCommands;
                         type: 'object',
                         properties: {
                             'sticky': {
-                                description: ( localize(1672, "Stick to the end even when going to longer lines")),
+                                description: ( localize(136, "Stick to the end even when going to longer lines")),
                                 type: 'boolean',
                                 default: false
                             }
@@ -853,8 +871,8 @@ var CoreNavigationCommands;
                     }
                 }]
         }
-    }))));
-    CoreNavigationCommands.CursorEndSelect = registerEditorCommand(( (new EndCommand({
+    })));
+    CoreNavigationCommands.CursorEndSelect = registerEditorCommand(( new EndCommand({
         inSelectionMode: true,
         id: 'cursorEndSelect',
         precondition: undefined,
@@ -862,8 +880,8 @@ var CoreNavigationCommands;
             args: { sticky: false },
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 1024  | 13 ,
-            mac: { primary: 1024  | 13 , secondary: [2048  | 1024  | 17 ] }
+            primary: KeyMod$1.Shift | KeyCode.End,
+            mac: { primary: KeyMod$1.Shift | KeyCode.End, secondary: [KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.RightArrow] }
         },
         metadata: {
             description: `Select to End`,
@@ -873,7 +891,7 @@ var CoreNavigationCommands;
                         type: 'object',
                         properties: {
                             'sticky': {
-                                description: ( localize(1672, "Stick to the end even when going to longer lines")),
+                                description: ( localize(136, "Stick to the end even when going to longer lines")),
                                 type: 'boolean',
                                 default: false
                             }
@@ -881,7 +899,7 @@ var CoreNavigationCommands;
                     }
                 }]
         }
-    }))));
+    })));
     class LineEndCommand extends CoreEditorCommand {
         constructor(opts) {
             super(opts);
@@ -889,7 +907,7 @@ var CoreNavigationCommands;
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, 3 , this._exec(viewModel, viewModel.getCursorStates()));
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, this._exec(viewModel, viewModel.getCursorStates()));
             viewModel.revealAllCursors(args.source, true);
         }
         _exec(viewModel, cursors) {
@@ -903,7 +921,7 @@ var CoreNavigationCommands;
             return result;
         }
     }
-    CoreNavigationCommands.CursorLineEnd = registerEditorCommand(( (new LineEndCommand({
+    CoreNavigationCommands.CursorLineEnd = registerEditorCommand(( new LineEndCommand({
         inSelectionMode: false,
         id: 'cursorLineEnd',
         precondition: undefined,
@@ -911,10 +929,10 @@ var CoreNavigationCommands;
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: 0,
-            mac: { primary: 256  | 35  }
+            mac: { primary: KeyMod$1.WinCtrl | KeyCode.KeyE }
         }
-    }))));
-    CoreNavigationCommands.CursorLineEndSelect = registerEditorCommand(( (new LineEndCommand({
+    })));
+    CoreNavigationCommands.CursorLineEndSelect = registerEditorCommand(( new LineEndCommand({
         inSelectionMode: true,
         id: 'cursorLineEndSelect',
         precondition: undefined,
@@ -922,9 +940,9 @@ var CoreNavigationCommands;
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: 0,
-            mac: { primary: 256  | 1024  | 35  }
+            mac: { primary: KeyMod$1.WinCtrl | KeyMod$1.Shift | KeyCode.KeyE }
         }
-    }))));
+    })));
     class TopCommand extends CoreEditorCommand {
         constructor(opts) {
             super(opts);
@@ -932,32 +950,32 @@ var CoreNavigationCommands;
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, 3 , CursorMoveCommands.moveToBeginningOfBuffer(viewModel, viewModel.getCursorStates(), this._inSelectionMode));
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, CursorMoveCommands.moveToBeginningOfBuffer(viewModel, viewModel.getCursorStates(), this._inSelectionMode));
             viewModel.revealAllCursors(args.source, true);
         }
     }
-    CoreNavigationCommands.CursorTop = registerEditorCommand(( (new TopCommand({
+    CoreNavigationCommands.CursorTop = registerEditorCommand(( new TopCommand({
         inSelectionMode: false,
         id: 'cursorTop',
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 2048  | 14 ,
-            mac: { primary: 2048  | 16  }
+            primary: KeyMod$1.CtrlCmd | KeyCode.Home,
+            mac: { primary: KeyMod$1.CtrlCmd | KeyCode.UpArrow }
         }
-    }))));
-    CoreNavigationCommands.CursorTopSelect = registerEditorCommand(( (new TopCommand({
+    })));
+    CoreNavigationCommands.CursorTopSelect = registerEditorCommand(( new TopCommand({
         inSelectionMode: true,
         id: 'cursorTopSelect',
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 2048  | 1024  | 14 ,
-            mac: { primary: 2048  | 1024  | 16  }
+            primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Home,
+            mac: { primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.UpArrow }
         }
-    }))));
+    })));
     class BottomCommand extends CoreEditorCommand {
         constructor(opts) {
             super(opts);
@@ -965,32 +983,32 @@ var CoreNavigationCommands;
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, 3 , CursorMoveCommands.moveToEndOfBuffer(viewModel, viewModel.getCursorStates(), this._inSelectionMode));
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, CursorMoveCommands.moveToEndOfBuffer(viewModel, viewModel.getCursorStates(), this._inSelectionMode));
             viewModel.revealAllCursors(args.source, true);
         }
     }
-    CoreNavigationCommands.CursorBottom = registerEditorCommand(( (new BottomCommand({
+    CoreNavigationCommands.CursorBottom = registerEditorCommand(( new BottomCommand({
         inSelectionMode: false,
         id: 'cursorBottom',
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 2048  | 13 ,
-            mac: { primary: 2048  | 18  }
+            primary: KeyMod$1.CtrlCmd | KeyCode.End,
+            mac: { primary: KeyMod$1.CtrlCmd | KeyCode.DownArrow }
         }
-    }))));
-    CoreNavigationCommands.CursorBottomSelect = registerEditorCommand(( (new BottomCommand({
+    })));
+    CoreNavigationCommands.CursorBottomSelect = registerEditorCommand(( new BottomCommand({
         inSelectionMode: true,
         id: 'cursorBottomSelect',
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
-            primary: 2048  | 1024  | 13 ,
-            mac: { primary: 2048  | 1024  | 18  }
+            primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.End,
+            mac: { primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.DownArrow }
         }
-    }))));
+    })));
     class EditorScrollImpl extends CoreEditorCommand {
         constructor() {
             super({
@@ -1000,17 +1018,17 @@ var CoreNavigationCommands;
             });
         }
         determineScrollMethod(args) {
-            const horizontalUnits = [6 ];
+            const horizontalUnits = [EditorScroll_.Unit.Column];
             const verticalUnits = [
-                1 ,
-                2 ,
-                3 ,
-                4 ,
-                5 ,
-                6
+                EditorScroll_.Unit.Line,
+                EditorScroll_.Unit.WrappedLine,
+                EditorScroll_.Unit.Page,
+                EditorScroll_.Unit.HalfPage,
+                EditorScroll_.Unit.Editor,
+                EditorScroll_.Unit.Column
             ];
-            const horizontalDirections = [4 , 2 ];
-            const verticalDirections = [1 , 3 ];
+            const horizontalDirections = [EditorScroll_.Direction.Left, EditorScroll_.Direction.Right];
+            const verticalDirections = [EditorScroll_.Direction.Up, EditorScroll_.Direction.Down];
             if (horizontalUnits.includes(args.unit) && horizontalDirections.includes(args.direction)) {
                 return this._runHorizontalEditorScroll.bind(this);
             }
@@ -1034,58 +1052,58 @@ var CoreNavigationCommands;
             const desiredScrollTop = this._computeDesiredScrollTop(viewModel, args);
             if (args.revealCursor) {
                 const desiredVisibleViewRange = viewModel.getCompletelyVisibleViewRangeAtScrollTop(desiredScrollTop);
-                viewModel.setCursorStates(source, 3 , [
+                viewModel.setCursorStates(source, CursorChangeReason.Explicit, [
                     CursorMoveCommands.findPositionInViewportIfOutside(viewModel, viewModel.getPrimaryCursorState(), desiredVisibleViewRange, args.select)
                 ]);
             }
-            viewModel.viewLayout.setScrollPosition({ scrollTop: desiredScrollTop }, 0 );
+            viewModel.viewLayout.setScrollPosition({ scrollTop: desiredScrollTop }, ScrollType.Smooth);
         }
         _computeDesiredScrollTop(viewModel, args) {
-            if (args.unit === 1 ) {
+            if (args.unit === EditorScroll_.Unit.Line) {
                 const futureViewport = viewModel.viewLayout.getFutureViewport();
                 const visibleViewRange = viewModel.getCompletelyVisibleViewRangeAtScrollTop(futureViewport.top);
                 const visibleModelRange = viewModel.coordinatesConverter.convertViewRangeToModelRange(visibleViewRange);
                 let desiredTopModelLineNumber;
-                if (args.direction === 1 ) {
+                if (args.direction === EditorScroll_.Direction.Up) {
                     desiredTopModelLineNumber = Math.max(1, visibleModelRange.startLineNumber - args.value);
                 }
                 else {
                     desiredTopModelLineNumber = Math.min(viewModel.model.getLineCount(), visibleModelRange.startLineNumber + args.value);
                 }
-                const viewPosition = viewModel.coordinatesConverter.convertModelPositionToViewPosition(( (new Position(desiredTopModelLineNumber, 1))));
+                const viewPosition = viewModel.coordinatesConverter.convertModelPositionToViewPosition(( new Position(desiredTopModelLineNumber, 1)));
                 return viewModel.viewLayout.getVerticalOffsetForLineNumber(viewPosition.lineNumber);
             }
-            if (args.unit === 5 ) {
+            if (args.unit === EditorScroll_.Unit.Editor) {
                 let desiredTopModelLineNumber = 0;
-                if (args.direction === 3 ) {
+                if (args.direction === EditorScroll_.Direction.Down) {
                     desiredTopModelLineNumber = viewModel.model.getLineCount() - viewModel.cursorConfig.pageSize;
                 }
                 return viewModel.viewLayout.getVerticalOffsetForLineNumber(desiredTopModelLineNumber);
             }
             let noOfLines;
-            if (args.unit === 3 ) {
+            if (args.unit === EditorScroll_.Unit.Page) {
                 noOfLines = viewModel.cursorConfig.pageSize * args.value;
             }
-            else if (args.unit === 4 ) {
+            else if (args.unit === EditorScroll_.Unit.HalfPage) {
                 noOfLines = Math.round(viewModel.cursorConfig.pageSize / 2) * args.value;
             }
             else {
                 noOfLines = args.value;
             }
-            const deltaLines = (args.direction === 1  ? -1 : 1) * noOfLines;
+            const deltaLines = (args.direction === EditorScroll_.Direction.Up ? -1 : 1) * noOfLines;
             return viewModel.viewLayout.getCurrentScrollTop() + deltaLines * viewModel.cursorConfig.lineHeight;
         }
         _runHorizontalEditorScroll(viewModel, source, args) {
             const desiredScrollLeft = this._computeDesiredScrollLeft(viewModel, args);
-            viewModel.viewLayout.setScrollPosition({ scrollLeft: desiredScrollLeft }, 0 );
+            viewModel.viewLayout.setScrollPosition({ scrollLeft: desiredScrollLeft }, ScrollType.Smooth);
         }
         _computeDesiredScrollLeft(viewModel, args) {
-            const deltaColumns = (args.direction === 4  ? -1 : 1) * args.value;
+            const deltaColumns = (args.direction === EditorScroll_.Direction.Left ? -1 : 1) * args.value;
             return viewModel.viewLayout.getCurrentScrollLeft() + deltaColumns * viewModel.cursorConfig.typicalHalfwidthCharacterWidth;
         }
     }
     CoreNavigationCommands.EditorScrollImpl = EditorScrollImpl;
-    CoreNavigationCommands.EditorScroll = registerEditorCommand(( (new EditorScrollImpl())));
+    CoreNavigationCommands.EditorScroll = registerEditorCommand(( new EditorScrollImpl()));
     CoreNavigationCommands.ScrollLineUp = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
@@ -1094,8 +1112,8 @@ var CoreNavigationCommands;
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
-                    primary: 2048  | 16 ,
-                    mac: { primary: 256  | 11  }
+                    primary: KeyMod$1.CtrlCmd | KeyCode.UpArrow,
+                    mac: { primary: KeyMod$1.WinCtrl | KeyCode.PageUp }
                 }
             });
         }
@@ -1118,9 +1136,9 @@ var CoreNavigationCommands;
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
-                    primary: 2048  | 11 ,
-                    win: { primary: 512  | 11  },
-                    linux: { primary: 512  | 11  }
+                    primary: KeyMod$1.CtrlCmd | KeyCode.PageUp,
+                    win: { primary: KeyMod$1.Alt | KeyCode.PageUp },
+                    linux: { primary: KeyMod$1.Alt | KeyCode.PageUp }
                 }
             });
         }
@@ -1165,8 +1183,8 @@ var CoreNavigationCommands;
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
-                    primary: 2048  | 18 ,
-                    mac: { primary: 256  | 12  }
+                    primary: KeyMod$1.CtrlCmd | KeyCode.DownArrow,
+                    mac: { primary: KeyMod$1.WinCtrl | KeyCode.PageDown }
                 }
             });
         }
@@ -1189,9 +1207,9 @@ var CoreNavigationCommands;
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
-                    primary: 2048  | 12 ,
-                    win: { primary: 512  | 12  },
-                    linux: { primary: 512  | 12  }
+                    primary: KeyMod$1.CtrlCmd | KeyCode.PageDown,
+                    win: { primary: KeyMod$1.Alt | KeyCode.PageDown },
+                    linux: { primary: KeyMod$1.Alt | KeyCode.PageDown }
                 }
             });
         }
@@ -1282,24 +1300,24 @@ var CoreNavigationCommands;
                 return;
             }
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, 3 , [
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, [
                 CursorMoveCommands.word(viewModel, viewModel.getPrimaryCursorState(), this._inSelectionMode, args.position)
             ]);
-            if (args.revealType !== 2 ) {
+            if (args.revealType !== NavigationCommandRevealType.None) {
                 viewModel.revealAllCursors(args.source, true, true);
             }
         }
     }
-    CoreNavigationCommands.WordSelect = registerEditorCommand(( (new WordCommand({
+    CoreNavigationCommands.WordSelect = registerEditorCommand(( new WordCommand({
         inSelectionMode: false,
         id: '_wordSelect',
         precondition: undefined
-    }))));
-    CoreNavigationCommands.WordSelectDrag = registerEditorCommand(( (new WordCommand({
+    })));
+    CoreNavigationCommands.WordSelectDrag = registerEditorCommand(( new WordCommand({
         inSelectionMode: true,
         id: '_wordSelectDrag',
         precondition: undefined
-    }))));
+    })));
     CoreNavigationCommands.LastCursorWordSelect = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
@@ -1317,7 +1335,7 @@ var CoreNavigationCommands;
             const lastAddedState = states[lastAddedCursorIndex];
             newStates[lastAddedCursorIndex] = CursorMoveCommands.word(viewModel, lastAddedState, lastAddedState.modelState.hasSelection(), args.position);
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, 3 , newStates);
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, newStates);
         }
     }));
     class LineCommand extends CoreEditorCommand {
@@ -1330,24 +1348,24 @@ var CoreNavigationCommands;
                 return;
             }
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, 3 , [
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, [
                 CursorMoveCommands.line(viewModel, viewModel.getPrimaryCursorState(), this._inSelectionMode, args.position, args.viewPosition)
             ]);
-            if (args.revealType !== 2 ) {
+            if (args.revealType !== NavigationCommandRevealType.None) {
                 viewModel.revealAllCursors(args.source, false, true);
             }
         }
     }
-    CoreNavigationCommands.LineSelect = registerEditorCommand(( (new LineCommand({
+    CoreNavigationCommands.LineSelect = registerEditorCommand(( new LineCommand({
         inSelectionMode: false,
         id: '_lineSelect',
         precondition: undefined
-    }))));
-    CoreNavigationCommands.LineSelectDrag = registerEditorCommand(( (new LineCommand({
+    })));
+    CoreNavigationCommands.LineSelectDrag = registerEditorCommand(( new LineCommand({
         inSelectionMode: true,
         id: '_lineSelectDrag',
         precondition: undefined
-    }))));
+    })));
     class LastCursorLineCommand extends CoreEditorCommand {
         constructor(opts) {
             super(opts);
@@ -1362,19 +1380,19 @@ var CoreNavigationCommands;
             const newStates = states.slice(0);
             newStates[lastAddedCursorIndex] = CursorMoveCommands.line(viewModel, states[lastAddedCursorIndex], this._inSelectionMode, args.position, args.viewPosition);
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, 3 , newStates);
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, newStates);
         }
     }
-    CoreNavigationCommands.LastCursorLineSelect = registerEditorCommand(( (new LastCursorLineCommand({
+    CoreNavigationCommands.LastCursorLineSelect = registerEditorCommand(( new LastCursorLineCommand({
         inSelectionMode: false,
         id: 'lastCursorLineSelect',
         precondition: undefined
-    }))));
-    CoreNavigationCommands.LastCursorLineSelectDrag = registerEditorCommand(( (new LastCursorLineCommand({
+    })));
+    CoreNavigationCommands.LastCursorLineSelectDrag = registerEditorCommand(( new LastCursorLineCommand({
         inSelectionMode: true,
         id: 'lastCursorLineSelectDrag',
         precondition: undefined
-    }))));
+    })));
     CoreNavigationCommands.CancelSelection = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
@@ -1383,14 +1401,14 @@ var CoreNavigationCommands;
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
-                    primary: 9 ,
-                    secondary: [1024  | 9 ]
+                    primary: KeyCode.Escape,
+                    secondary: [KeyMod$1.Shift | KeyCode.Escape]
                 }
             });
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, 3 , [
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, [
                 CursorMoveCommands.cancelSelection(viewModel, viewModel.getPrimaryCursorState())
             ]);
             viewModel.revealAllCursors(args.source, true);
@@ -1404,18 +1422,18 @@ var CoreNavigationCommands;
                 kbOpts: {
                     weight: CORE_WEIGHT + 1,
                     kbExpr: EditorContextKeys.textInputFocus,
-                    primary: 9 ,
-                    secondary: [1024  | 9 ]
+                    primary: KeyCode.Escape,
+                    secondary: [KeyMod$1.Shift | KeyCode.Escape]
                 }
             });
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, 3 , [
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, [
                 viewModel.getPrimaryCursorState()
             ]);
             viewModel.revealAllCursors(args.source, true);
-            status(( localize(1673, "Removed secondary cursors")));
+            status(( localize(137, "Removed secondary cursors")));
         }
     }));
     CoreNavigationCommands.RevealLine = registerEditorCommand(new (class extends CoreEditorCommand {
@@ -1437,23 +1455,23 @@ var CoreNavigationCommands;
             if (lineNumber > lineCount) {
                 lineNumber = lineCount;
             }
-            const range = ( (new Range(lineNumber, 1, lineNumber, viewModel.model.getLineMaxColumn(lineNumber))));
-            let revealAt = 0 ;
+            const range = ( new Range(lineNumber, 1, lineNumber, viewModel.model.getLineMaxColumn(lineNumber)));
+            let revealAt = VerticalRevealType.Simple;
             if (revealLineArg.at) {
                 switch (revealLineArg.at) {
                     case RevealLine_.RawAtArgument.Top:
-                        revealAt = 3 ;
+                        revealAt = VerticalRevealType.Top;
                         break;
                     case RevealLine_.RawAtArgument.Center:
-                        revealAt = 1 ;
+                        revealAt = VerticalRevealType.Center;
                         break;
                     case RevealLine_.RawAtArgument.Bottom:
-                        revealAt = 4 ;
+                        revealAt = VerticalRevealType.Bottom;
                         break;
                 }
             }
             const viewRange = viewModel.coordinatesConverter.convertModelRangeToViewRange(range);
-            viewModel.revealRange(args.source, false, viewRange, revealAt, 0 );
+            viewModel.revealRange(args.source, false, viewRange, revealAt, ScrollType.Smooth);
         }
     }));
     CoreNavigationCommands.SelectAll = new (class extends EditorOrNativeTextInputCommand {
@@ -1476,7 +1494,7 @@ var CoreNavigationCommands;
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates('keyboard', 3 , [
+            viewModel.setCursorStates('keyboard', CursorChangeReason.Explicit, [
                 CursorMoveCommands.selectAll(viewModel, viewModel.getPrimaryCursorState())
             ]);
         }
@@ -1493,13 +1511,13 @@ var CoreNavigationCommands;
                 return;
             }
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, 3 , [
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, [
                 CursorState.fromModelSelection(args.selection)
             ]);
         }
     }));
-})(CoreNavigationCommands || (CoreNavigationCommands = {}))));
-const columnSelectionCondition = ( (ContextKeyExpr.and(EditorContextKeys.textInputFocus, EditorContextKeys.columnSelection)));
+})(CoreNavigationCommands || (CoreNavigationCommands = {}));
+const columnSelectionCondition = ( ContextKeyExpr.and(EditorContextKeys.textInputFocus, EditorContextKeys.columnSelection));
 function registerColumnSelection(id, keybinding) {
     KeybindingsRegistry.registerKeybindingRule({
         id: id,
@@ -1508,18 +1526,18 @@ function registerColumnSelection(id, keybinding) {
         weight: CORE_WEIGHT + 1
     });
 }
-registerColumnSelection(CoreNavigationCommands.CursorColumnSelectLeft.id, 1024  | 15 );
-registerColumnSelection(CoreNavigationCommands.CursorColumnSelectRight.id, 1024  | 17 );
-registerColumnSelection(CoreNavigationCommands.CursorColumnSelectUp.id, 1024  | 16 );
-registerColumnSelection(CoreNavigationCommands.CursorColumnSelectPageUp.id, 1024  | 11 );
-registerColumnSelection(CoreNavigationCommands.CursorColumnSelectDown.id, 1024  | 18 );
-registerColumnSelection(CoreNavigationCommands.CursorColumnSelectPageDown.id, 1024  | 12 );
+registerColumnSelection(CoreNavigationCommands.CursorColumnSelectLeft.id, KeyMod$1.Shift | KeyCode.LeftArrow);
+registerColumnSelection(CoreNavigationCommands.CursorColumnSelectRight.id, KeyMod$1.Shift | KeyCode.RightArrow);
+registerColumnSelection(CoreNavigationCommands.CursorColumnSelectUp.id, KeyMod$1.Shift | KeyCode.UpArrow);
+registerColumnSelection(CoreNavigationCommands.CursorColumnSelectPageUp.id, KeyMod$1.Shift | KeyCode.PageUp);
+registerColumnSelection(CoreNavigationCommands.CursorColumnSelectDown.id, KeyMod$1.Shift | KeyCode.DownArrow);
+registerColumnSelection(CoreNavigationCommands.CursorColumnSelectPageDown.id, KeyMod$1.Shift | KeyCode.PageDown);
 function registerCommand(command) {
     command.register();
     return command;
 }
 var CoreEditingCommands;
-( ((function(CoreEditingCommands) {
+(function (CoreEditingCommands) {
     class CoreEditingCommand extends EditorCommand {
         runEditorCommand(accessor, editor, args) {
             const viewModel = editor._getViewModel();
@@ -1539,13 +1557,13 @@ var CoreEditingCommands;
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
                     primary: 0,
-                    mac: { primary: 256  | 45  }
+                    mac: { primary: KeyMod$1.WinCtrl | KeyCode.KeyO }
                 }
             });
         }
         runCoreEditingCommand(editor, viewModel, args) {
             editor.pushUndoStop();
-            editor.executeCommands(this.id, EnterOperation.lineBreakInsert(viewModel.cursorConfig, viewModel.model, ( (viewModel.getCursorStates().map(s => s.modelState.selection)))));
+            editor.executeCommands(this.id, EnterOperation.lineBreakInsert(viewModel.cursorConfig, viewModel.model, ( viewModel.getCursorStates().map(s => s.modelState.selection))));
         }
     }));
     CoreEditingCommands.Outdent = registerEditorCommand(new (class extends CoreEditingCommand {
@@ -1555,14 +1573,14 @@ var CoreEditingCommands;
                 precondition: EditorContextKeys.writable,
                 kbOpts: {
                     weight: CORE_WEIGHT,
-                    kbExpr: ( (ContextKeyExpr.and(EditorContextKeys.editorTextFocus, EditorContextKeys.tabDoesNotMoveFocus))),
-                    primary: 1024  | 2
+                    kbExpr: ( ContextKeyExpr.and(EditorContextKeys.editorTextFocus, EditorContextKeys.tabDoesNotMoveFocus)),
+                    primary: KeyMod$1.Shift | KeyCode.Tab
                 }
             });
         }
         runCoreEditingCommand(editor, viewModel, args) {
             editor.pushUndoStop();
-            editor.executeCommands(this.id, TypeOperations.outdent(viewModel.cursorConfig, viewModel.model, ( (viewModel.getCursorStates().map(s => s.modelState.selection)))));
+            editor.executeCommands(this.id, TypeOperations.outdent(viewModel.cursorConfig, viewModel.model, ( viewModel.getCursorStates().map(s => s.modelState.selection))));
             editor.pushUndoStop();
         }
     }));
@@ -1573,14 +1591,14 @@ var CoreEditingCommands;
                 precondition: EditorContextKeys.writable,
                 kbOpts: {
                     weight: CORE_WEIGHT,
-                    kbExpr: ( (ContextKeyExpr.and(EditorContextKeys.editorTextFocus, EditorContextKeys.tabDoesNotMoveFocus))),
-                    primary: 2
+                    kbExpr: ( ContextKeyExpr.and(EditorContextKeys.editorTextFocus, EditorContextKeys.tabDoesNotMoveFocus)),
+                    primary: KeyCode.Tab
                 }
             });
         }
         runCoreEditingCommand(editor, viewModel, args) {
             editor.pushUndoStop();
-            editor.executeCommands(this.id, TypeOperations.tab(viewModel.cursorConfig, viewModel.model, ( (viewModel.getCursorStates().map(s => s.modelState.selection)))));
+            editor.executeCommands(this.id, TypeOperations.tab(viewModel.cursorConfig, viewModel.model, ( viewModel.getCursorStates().map(s => s.modelState.selection))));
             editor.pushUndoStop();
         }
     }));
@@ -1592,19 +1610,19 @@ var CoreEditingCommands;
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
-                    primary: 1 ,
-                    secondary: [1024  | 1 ],
-                    mac: { primary: 1 , secondary: [1024  | 1 , 256  | 38 , 256  | 1 ] }
+                    primary: KeyCode.Backspace,
+                    secondary: [KeyMod$1.Shift | KeyCode.Backspace],
+                    mac: { primary: KeyCode.Backspace, secondary: [KeyMod$1.Shift | KeyCode.Backspace, KeyMod$1.WinCtrl | KeyCode.KeyH, KeyMod$1.WinCtrl | KeyCode.Backspace] }
                 }
             });
         }
         runCoreEditingCommand(editor, viewModel, args) {
-            const [shouldPushStackElementBefore, commands] = DeleteOperations.deleteLeft(viewModel.getPrevEditOperationType(), viewModel.cursorConfig, viewModel.model, ( (viewModel.getCursorStates().map(s => s.modelState.selection))), viewModel.getCursorAutoClosedCharacters());
+            const [shouldPushStackElementBefore, commands] = DeleteOperations.deleteLeft(viewModel.getPrevEditOperationType(), viewModel.cursorConfig, viewModel.model, ( viewModel.getCursorStates().map(s => s.modelState.selection)), viewModel.getCursorAutoClosedCharacters());
             if (shouldPushStackElementBefore) {
                 editor.pushUndoStop();
             }
             editor.executeCommands(this.id, commands);
-            viewModel.setPrevEditOperationType(2 );
+            viewModel.setPrevEditOperationType(EditOperationType.DeletingLeft);
         }
     }));
     CoreEditingCommands.DeleteRight = registerEditorCommand(new (class extends CoreEditingCommand {
@@ -1615,18 +1633,18 @@ var CoreEditingCommands;
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
-                    primary: 20 ,
-                    mac: { primary: 20 , secondary: [256  | 34 , 256  | 20 ] }
+                    primary: KeyCode.Delete,
+                    mac: { primary: KeyCode.Delete, secondary: [KeyMod$1.WinCtrl | KeyCode.KeyD, KeyMod$1.WinCtrl | KeyCode.Delete] }
                 }
             });
         }
         runCoreEditingCommand(editor, viewModel, args) {
-            const [shouldPushStackElementBefore, commands] = DeleteOperations.deleteRight(viewModel.getPrevEditOperationType(), viewModel.cursorConfig, viewModel.model, ( (viewModel.getCursorStates().map(s => s.modelState.selection))));
+            const [shouldPushStackElementBefore, commands] = DeleteOperations.deleteRight(viewModel.getPrevEditOperationType(), viewModel.cursorConfig, viewModel.model, ( viewModel.getCursorStates().map(s => s.modelState.selection)));
             if (shouldPushStackElementBefore) {
                 editor.pushUndoStop();
             }
             editor.executeCommands(this.id, commands);
-            viewModel.setPrevEditOperationType(3 );
+            viewModel.setPrevEditOperationType(EditOperationType.DeletingRight);
         }
     }));
     CoreEditingCommands.Undo = new (class extends EditorOrNativeTextInputCommand {
@@ -1637,7 +1655,7 @@ var CoreEditingCommands;
             activeElement.ownerDocument.execCommand('undo');
         }
         runEditorCommand(accessor, editor, args) {
-            if (!editor.hasModel() || editor.getOption(94 ) === true) {
+            if (!editor.hasModel() || editor.getOption(EditorOption.readOnly) === true) {
                 return;
             }
             return editor.getModel().undo();
@@ -1651,13 +1669,13 @@ var CoreEditingCommands;
             activeElement.ownerDocument.execCommand('redo');
         }
         runEditorCommand(accessor, editor, args) {
-            if (!editor.hasModel() || editor.getOption(94 ) === true) {
+            if (!editor.hasModel() || editor.getOption(EditorOption.readOnly) === true) {
                 return;
             }
             return editor.getModel().redo();
         }
     })();
-})(CoreEditingCommands || (CoreEditingCommands = {}))));
+})(CoreEditingCommands || (CoreEditingCommands = {}));
 class EditorHandlerCommand extends Command {
     constructor(id, handlerId, metadata) {
         super({
@@ -1676,10 +1694,10 @@ class EditorHandlerCommand extends Command {
     }
 }
 function registerOverwritableCommand(handlerId, metadata) {
-    registerCommand(( (new EditorHandlerCommand('default:' + handlerId, handlerId))));
-    registerCommand(( (new EditorHandlerCommand(handlerId, handlerId, metadata))));
+    registerCommand(( new EditorHandlerCommand('default:' + handlerId, handlerId)));
+    registerCommand(( new EditorHandlerCommand(handlerId, handlerId, metadata)));
 }
-registerOverwritableCommand("type" , {
+registerOverwritableCommand(Handler.Type, {
     description: `Type`,
     args: [{
             name: 'args',
@@ -1694,11 +1712,11 @@ registerOverwritableCommand("type" , {
             }
         }]
 });
-registerOverwritableCommand("replacePreviousChar" );
-registerOverwritableCommand("compositionType" );
-registerOverwritableCommand("compositionStart" );
-registerOverwritableCommand("compositionEnd" );
-registerOverwritableCommand("paste" );
-registerOverwritableCommand("cut" );
+registerOverwritableCommand(Handler.ReplacePreviousChar);
+registerOverwritableCommand(Handler.CompositionType);
+registerOverwritableCommand(Handler.CompositionStart);
+registerOverwritableCommand(Handler.CompositionEnd);
+registerOverwritableCommand(Handler.Paste);
+registerOverwritableCommand(Handler.Cut);
 
-export { CoreEditingCommands, CoreEditorCommand, CoreNavigationCommands, EditorScroll_, RevealLine_ };
+export { CoreEditingCommands, CoreEditorCommand, CoreNavigationCommands, EditorScroll_, NavigationCommandRevealType, RevealLine_ };