@codingame/monaco-vscode-api 1.85.6 → 2.0.0-v2.1

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

@@ -0,0 +1,1713 @@
+import { localizeWithPath } from '../../nls.js';
+import { isFirefox } from '../../base/browser/browser.js';
+import { isObject, isString, isUndefined, isNumber, isBoolean } from '../../base/common/types.js';
+import { status } from '../../base/browser/ui/aria/aria.js';
+import { registerEditorCommand, SelectAllCommand, UndoCommand, RedoCommand, EditorCommand, Command } from './editorExtensions.js';
+import { ICodeEditorService } from './services/codeEditorService.js';
+import { ColumnSelection } from '../common/cursor/cursorColumnSelection.js';
+import { CursorState } from '../common/cursorCommon.js';
+import { DeleteOperations } from '../common/cursor/cursorDeleteOperations.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 { EditorContextKeys } from '../common/editorContextKeys.js';
+import { ContextKeyExpr } from '../../platform/contextkey/common/contextkey.js';
+import { KeybindingsRegistry } from '../../platform/keybinding/common/keybindingsRegistry.js';
+import { getActiveElement } from '../../base/browser/dom.js';
+const CORE_WEIGHT = 0 ;
+class CoreEditorCommand extends EditorCommand {
+    runEditorCommand(accessor, editor, args) {
+        const viewModel = editor._getViewModel();
+        if (!viewModel) {
+            return;
+        }
+        this.runCoreEditorCommand(viewModel, args || {});
+    }
+}
+var EditorScroll_;
+( (function(EditorScroll_) {
+    const isEditorScrollArgs = function (arg) {
+        if (!isObject(arg)) {
+            return false;
+        }
+        const scrollArg = arg;
+        if (!isString(scrollArg.to)) {
+            return false;
+        }
+        if (!isUndefined(scrollArg.by) && !isString(scrollArg.by)) {
+            return false;
+        }
+        if (!isUndefined(scrollArg.value) && !isNumber(scrollArg.value)) {
+            return false;
+        }
+        if (!isUndefined(scrollArg.revealCursor) && !isBoolean(scrollArg.revealCursor)) {
+            return false;
+        }
+        return true;
+    };
+    EditorScroll_.metadata = {
+        description: 'Scroll editor in the given direction',
+        args: [
+            {
+                name: 'Editor scroll argument object',
+                description: `Property-value pairs that can be passed through this argument:
+					* 'to': A mandatory direction value.
+						\`\`\`
+						'up', 'down'
+						\`\`\`
+					* 'by': Unit to move. Default is computed based on 'to' value.
+						\`\`\`
+						'line', 'wrappedLine', 'page', 'halfPage', 'editor'
+						\`\`\`
+					* 'value': Number of units to move. Default is '1'.
+					* 'revealCursor': If 'true' reveals the cursor if it is outside view port.
+				`,
+                constraint: isEditorScrollArgs,
+                schema: {
+                    'type': 'object',
+                    'required': ['to'],
+                    'properties': {
+                        'to': {
+                            'type': 'string',
+                            'enum': ['up', 'down']
+                        },
+                        'by': {
+                            'type': 'string',
+                            'enum': ['line', 'wrappedLine', 'page', 'halfPage', 'editor']
+                        },
+                        'value': {
+                            'type': 'number',
+                            'default': 1
+                        },
+                        'revealCursor': {
+                            'type': 'boolean',
+                        }
+                    }
+                }
+            }
+        ]
+    };
+    EditorScroll_.RawDirection = {
+        Up: 'up',
+        Right: 'right',
+        Down: 'down',
+        Left: 'left'
+    };
+    EditorScroll_.RawUnit = {
+        Line: 'line',
+        WrappedLine: 'wrappedLine',
+        Page: 'page',
+        HalfPage: 'halfPage',
+        Editor: 'editor',
+        Column: 'column'
+    };
+    function parse(args) {
+        let direction;
+        switch (args.to) {
+            case EditorScroll_.RawDirection.Up:
+                direction = 1 ;
+                break;
+            case EditorScroll_.RawDirection.Right:
+                direction = 2 ;
+                break;
+            case EditorScroll_.RawDirection.Down:
+                direction = 3 ;
+                break;
+            case EditorScroll_.RawDirection.Left:
+                direction = 4 ;
+                break;
+            default:
+                return null;
+        }
+        let unit;
+        switch (args.by) {
+            case EditorScroll_.RawUnit.Line:
+                unit = 1 ;
+                break;
+            case EditorScroll_.RawUnit.WrappedLine:
+                unit = 2 ;
+                break;
+            case EditorScroll_.RawUnit.Page:
+                unit = 3 ;
+                break;
+            case EditorScroll_.RawUnit.HalfPage:
+                unit = 4 ;
+                break;
+            case EditorScroll_.RawUnit.Editor:
+                unit = 5 ;
+                break;
+            case EditorScroll_.RawUnit.Column:
+                unit = 6 ;
+                break;
+            default:
+                unit = 2 ;
+        }
+        const value = Math.floor(args.value || 1);
+        const revealCursor = !!args.revealCursor;
+        return {
+            direction: direction,
+            unit: unit,
+            value: value,
+            revealCursor: revealCursor,
+            select: (!!args.select)
+        };
+    }
+    EditorScroll_.parse = parse;
+    ( (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) {
+        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_ = {})));
+var RevealLine_;
+( (function(RevealLine_) {
+    const isRevealLineArgs = function (arg) {
+        if (!isObject(arg)) {
+            return false;
+        }
+        const reveaLineArg = arg;
+        if (!isNumber(reveaLineArg.lineNumber) && !isString(reveaLineArg.lineNumber)) {
+            return false;
+        }
+        if (!isUndefined(reveaLineArg.at) && !isString(reveaLineArg.at)) {
+            return false;
+        }
+        return true;
+    };
+    RevealLine_.metadata = {
+        description: 'Reveal the given line at the given logical position',
+        args: [
+            {
+                name: 'Reveal line argument object',
+                description: `Property-value pairs that can be passed through this argument:
+					* 'lineNumber': A mandatory line number value.
+					* 'at': Logical position at which line has to be revealed.
+						\`\`\`
+						'top', 'center', 'bottom'
+						\`\`\`
+				`,
+                constraint: isRevealLineArgs,
+                schema: {
+                    'type': 'object',
+                    'required': ['lineNumber'],
+                    'properties': {
+                        'lineNumber': {
+                            'type': ['number', 'string'],
+                        },
+                        'at': {
+                            'type': 'string',
+                            'enum': ['top', 'center', 'bottom']
+                        }
+                    }
+                }
+            }
+        ]
+    };
+    RevealLine_.RawAtArgument = {
+        Top: 'top',
+        Center: 'center',
+        Bottom: 'bottom'
+    };
+})(RevealLine_ || (RevealLine_ = {})));
+class EditorOrNativeTextInputCommand {
+    constructor(target) {
+        target.addImplementation(10000, 'code-editor', (accessor, args) => {
+            const focusedEditor = accessor.get(ICodeEditorService).getFocusedCodeEditor();
+            if (focusedEditor && focusedEditor.hasTextFocus()) {
+                return this._runEditorCommand(accessor, focusedEditor, args);
+            }
+            return false;
+        });
+        target.addImplementation(1000, 'generic-dom-input-textarea', (accessor, args) => {
+            const activeElement = getActiveElement();
+            if (activeElement && ['input', 'textarea'].indexOf(activeElement.tagName.toLowerCase()) >= 0) {
+                this.runDOMCommand(activeElement);
+                return true;
+            }
+            return false;
+        });
+        target.addImplementation(0, 'generic-dom', (accessor, args) => {
+            const activeEditor = accessor.get(ICodeEditorService).getActiveCodeEditor();
+            if (activeEditor) {
+                activeEditor.focus();
+                return this._runEditorCommand(accessor, activeEditor, args);
+            }
+            return false;
+        });
+    }
+    _runEditorCommand(accessor, editor, args) {
+        const result = this.runEditorCommand(accessor, editor, args);
+        if (result) {
+            return result;
+        }
+        return true;
+    }
+}
+var CoreNavigationCommands;
+( (function(CoreNavigationCommands) {
+    class BaseMoveToCommand extends CoreEditorCommand {
+        constructor(opts) {
+            super(opts);
+            this._inSelectionMode = opts.inSelectionMode;
+        }
+        runCoreEditorCommand(viewModel, args) {
+            if (!args.position) {
+                return;
+            }
+            viewModel.model.pushStackElement();
+            const cursorStateChanged = viewModel.setCursorStates(args.source, 3 , [
+                CursorMoveCommands.moveTo(viewModel, viewModel.getPrimaryCursorState(), this._inSelectionMode, args.position, args.viewPosition)
+            ]);
+            if (cursorStateChanged && args.revealType !== 2 ) {
+                viewModel.revealPrimaryCursor(args.source, true, true);
+            }
+        }
+    }
+    CoreNavigationCommands.MoveTo = registerEditorCommand(( new BaseMoveToCommand({
+        id: '_moveTo',
+        inSelectionMode: false,
+        precondition: undefined
+    })));
+    CoreNavigationCommands.MoveToSelect = registerEditorCommand(( new BaseMoveToCommand({
+        id: '_moveToSelect',
+        inSelectionMode: true,
+        precondition: undefined
+    })));
+    class ColumnSelectCommand extends CoreEditorCommand {
+        runCoreEditorCommand(viewModel, args) {
+            viewModel.model.pushStackElement();
+            const result = this._getColumnSelectResult(viewModel, viewModel.getPrimaryCursorState(), viewModel.getCursorColumnSelectData(), args);
+            if (result === null) {
+                return;
+            }
+            viewModel.setCursorStates(args.source, 3 , ( result.viewStates.map((viewState) => CursorState.fromViewState(viewState))));
+            viewModel.setCursorColumnSelectData({
+                isReal: true,
+                fromViewLineNumber: result.fromLineNumber,
+                fromViewVisualColumn: result.fromVisualColumn,
+                toViewLineNumber: result.toLineNumber,
+                toViewVisualColumn: result.toVisualColumn
+            });
+            if (result.reversed) {
+                viewModel.revealTopMostCursor(args.source);
+            }
+            else {
+                viewModel.revealBottomMostCursor(args.source);
+            }
+        }
+    }
+    CoreNavigationCommands.ColumnSelect = registerEditorCommand(new (class extends ColumnSelectCommand {
+        constructor() {
+            super({
+                id: 'columnSelect',
+                precondition: undefined
+            });
+        }
+        _getColumnSelectResult(viewModel, primary, prevColumnSelectData, args) {
+            if (typeof args.position === 'undefined' || typeof args.viewPosition === 'undefined' || typeof args.mouseColumn === 'undefined') {
+                return null;
+            }
+            const validatedPosition = viewModel.model.validatePosition(args.position);
+            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);
+        }
+    }));
+    CoreNavigationCommands.CursorColumnSelectLeft = registerEditorCommand(new (class extends ColumnSelectCommand {
+        constructor() {
+            super({
+                id: 'cursorColumnSelectLeft',
+                precondition: undefined,
+                kbOpts: {
+                    weight: CORE_WEIGHT,
+                    kbExpr: EditorContextKeys.textInputFocus,
+                    primary: 2048  | 1024  | 512  | 15 ,
+                    linux: { primary: 0 }
+                }
+            });
+        }
+        _getColumnSelectResult(viewModel, primary, prevColumnSelectData, args) {
+            return ColumnSelection.columnSelectLeft(viewModel.cursorConfig, viewModel, prevColumnSelectData);
+        }
+    }));
+    CoreNavigationCommands.CursorColumnSelectRight = registerEditorCommand(new (class extends ColumnSelectCommand {
+        constructor() {
+            super({
+                id: 'cursorColumnSelectRight',
+                precondition: undefined,
+                kbOpts: {
+                    weight: CORE_WEIGHT,
+                    kbExpr: EditorContextKeys.textInputFocus,
+                    primary: 2048  | 1024  | 512  | 17 ,
+                    linux: { primary: 0 }
+                }
+            });
+        }
+        _getColumnSelectResult(viewModel, primary, prevColumnSelectData, args) {
+            return ColumnSelection.columnSelectRight(viewModel.cursorConfig, viewModel, prevColumnSelectData);
+        }
+    }));
+    class ColumnSelectUpCommand extends ColumnSelectCommand {
+        constructor(opts) {
+            super(opts);
+            this._isPaged = opts.isPaged;
+        }
+        _getColumnSelectResult(viewModel, primary, prevColumnSelectData, args) {
+            return ColumnSelection.columnSelectUp(viewModel.cursorConfig, viewModel, prevColumnSelectData, this._isPaged);
+        }
+    }
+    CoreNavigationCommands.CursorColumnSelectUp = registerEditorCommand(( new ColumnSelectUpCommand({
+        isPaged: false,
+        id: 'cursorColumnSelectUp',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 2048  | 1024  | 512  | 16 ,
+            linux: { primary: 0 }
+        }
+    })));
+    CoreNavigationCommands.CursorColumnSelectPageUp = registerEditorCommand(( new ColumnSelectUpCommand({
+        isPaged: true,
+        id: 'cursorColumnSelectPageUp',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 2048  | 1024  | 512  | 11 ,
+            linux: { primary: 0 }
+        }
+    })));
+    class ColumnSelectDownCommand extends ColumnSelectCommand {
+        constructor(opts) {
+            super(opts);
+            this._isPaged = opts.isPaged;
+        }
+        _getColumnSelectResult(viewModel, primary, prevColumnSelectData, args) {
+            return ColumnSelection.columnSelectDown(viewModel.cursorConfig, viewModel, prevColumnSelectData, this._isPaged);
+        }
+    }
+    CoreNavigationCommands.CursorColumnSelectDown = registerEditorCommand(( new ColumnSelectDownCommand({
+        isPaged: false,
+        id: 'cursorColumnSelectDown',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 2048  | 1024  | 512  | 18 ,
+            linux: { primary: 0 }
+        }
+    })));
+    CoreNavigationCommands.CursorColumnSelectPageDown = registerEditorCommand(( new ColumnSelectDownCommand({
+        isPaged: true,
+        id: 'cursorColumnSelectPageDown',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 2048  | 1024  | 512  | 12 ,
+            linux: { primary: 0 }
+        }
+    })));
+    class CursorMoveImpl extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: 'cursorMove',
+                precondition: undefined,
+                metadata: CursorMove.metadata
+            });
+        }
+        runCoreEditorCommand(viewModel, args) {
+            const parsed = CursorMove.parse(args);
+            if (!parsed) {
+                return;
+            }
+            this._runCursorMove(viewModel, args.source, parsed);
+        }
+        _runCursorMove(viewModel, source, args) {
+            viewModel.model.pushStackElement();
+            viewModel.setCursorStates(source, 3 , CursorMoveImpl._move(viewModel, viewModel.getCursorStates(), args));
+            viewModel.revealPrimaryCursor(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 :
+                    return CursorMoveCommands.simpleMove(viewModel, cursors, args.direction, inSelectionMode, value, args.unit);
+                case 11 :
+                case 13 :
+                case 12 :
+                case 14 :
+                    return CursorMoveCommands.viewportMove(viewModel, cursors, args.direction, inSelectionMode, value);
+                default:
+                    return null;
+            }
+        }
+    }
+    CoreNavigationCommands.CursorMoveImpl = CursorMoveImpl;
+    CoreNavigationCommands.CursorMove = registerEditorCommand(( new CursorMoveImpl()));
+    class CursorMoveBasedCommand extends CoreEditorCommand {
+        constructor(opts) {
+            super(opts);
+            this._staticArgs = opts.args;
+        }
+        runCoreEditorCommand(viewModel, dynamicArgs) {
+            let args = this._staticArgs;
+            if (this._staticArgs.value === -1 ) {
+                args = {
+                    direction: this._staticArgs.direction,
+                    unit: this._staticArgs.unit,
+                    select: this._staticArgs.select,
+                    value: dynamicArgs.pageSize || viewModel.cursorConfig.pageSize
+                };
+            }
+            viewModel.model.pushStackElement();
+            viewModel.setCursorStates(dynamicArgs.source, 3 , CursorMoveCommands.simpleMove(viewModel, viewModel.getCursorStates(), args.direction, args.select, args.value, args.unit));
+            viewModel.revealPrimaryCursor(dynamicArgs.source, true);
+        }
+    }
+    CoreNavigationCommands.CursorLeft = registerEditorCommand(( new CursorMoveBasedCommand({
+        args: {
+            direction: 0 ,
+            unit: 0 ,
+            select: false,
+            value: 1
+        },
+        id: 'cursorLeft',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 15 ,
+            mac: { primary: 15 , secondary: [256  | 32 ] }
+        }
+    })));
+    CoreNavigationCommands.CursorLeftSelect = registerEditorCommand(( new CursorMoveBasedCommand({
+        args: {
+            direction: 0 ,
+            unit: 0 ,
+            select: true,
+            value: 1
+        },
+        id: 'cursorLeftSelect',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 1024  | 15
+        }
+    })));
+    CoreNavigationCommands.CursorRight = registerEditorCommand(( new CursorMoveBasedCommand({
+        args: {
+            direction: 1 ,
+            unit: 0 ,
+            select: false,
+            value: 1
+        },
+        id: 'cursorRight',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 17 ,
+            mac: { primary: 17 , secondary: [256  | 36 ] }
+        }
+    })));
+    CoreNavigationCommands.CursorRightSelect = registerEditorCommand(( new CursorMoveBasedCommand({
+        args: {
+            direction: 1 ,
+            unit: 0 ,
+            select: true,
+            value: 1
+        },
+        id: 'cursorRightSelect',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 1024  | 17
+        }
+    })));
+    CoreNavigationCommands.CursorUp = registerEditorCommand(( new CursorMoveBasedCommand({
+        args: {
+            direction: 2 ,
+            unit: 2 ,
+            select: false,
+            value: 1
+        },
+        id: 'cursorUp',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 16 ,
+            mac: { primary: 16 , secondary: [256  | 46 ] }
+        }
+    })));
+    CoreNavigationCommands.CursorUpSelect = registerEditorCommand(( new CursorMoveBasedCommand({
+        args: {
+            direction: 2 ,
+            unit: 2 ,
+            select: true,
+            value: 1
+        },
+        id: 'cursorUpSelect',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 1024  | 16 ,
+            secondary: [2048  | 1024  | 16 ],
+            mac: { primary: 1024  | 16  },
+            linux: { primary: 1024  | 16  }
+        }
+    })));
+    CoreNavigationCommands.CursorPageUp = registerEditorCommand(( new CursorMoveBasedCommand({
+        args: {
+            direction: 2 ,
+            unit: 2 ,
+            select: false,
+            value: -1
+        },
+        id: 'cursorPageUp',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 11
+        }
+    })));
+    CoreNavigationCommands.CursorPageUpSelect = registerEditorCommand(( new CursorMoveBasedCommand({
+        args: {
+            direction: 2 ,
+            unit: 2 ,
+            select: true,
+            value: -1
+        },
+        id: 'cursorPageUpSelect',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 1024  | 11
+        }
+    })));
+    CoreNavigationCommands.CursorDown = registerEditorCommand(( new CursorMoveBasedCommand({
+        args: {
+            direction: 3 ,
+            unit: 2 ,
+            select: false,
+            value: 1
+        },
+        id: 'cursorDown',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 18 ,
+            mac: { primary: 18 , secondary: [256  | 44 ] }
+        }
+    })));
+    CoreNavigationCommands.CursorDownSelect = registerEditorCommand(( new CursorMoveBasedCommand({
+        args: {
+            direction: 3 ,
+            unit: 2 ,
+            select: true,
+            value: 1
+        },
+        id: 'cursorDownSelect',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 1024  | 18 ,
+            secondary: [2048  | 1024  | 18 ],
+            mac: { primary: 1024  | 18  },
+            linux: { primary: 1024  | 18  }
+        }
+    })));
+    CoreNavigationCommands.CursorPageDown = registerEditorCommand(( new CursorMoveBasedCommand({
+        args: {
+            direction: 3 ,
+            unit: 2 ,
+            select: false,
+            value: -1
+        },
+        id: 'cursorPageDown',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 12
+        }
+    })));
+    CoreNavigationCommands.CursorPageDownSelect = registerEditorCommand(( new CursorMoveBasedCommand({
+        args: {
+            direction: 3 ,
+            unit: 2 ,
+            select: true,
+            value: -1
+        },
+        id: 'cursorPageDownSelect',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 1024  | 12
+        }
+    })));
+    CoreNavigationCommands.CreateCursor = registerEditorCommand(new (class extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: 'createCursor',
+                precondition: undefined
+            });
+        }
+        runCoreEditorCommand(viewModel, args) {
+            if (!args.position) {
+                return;
+            }
+            let newState;
+            if (args.wholeLine) {
+                newState = CursorMoveCommands.line(viewModel, viewModel.getPrimaryCursorState(), false, args.position, args.viewPosition);
+            }
+            else {
+                newState = CursorMoveCommands.moveTo(viewModel, viewModel.getPrimaryCursorState(), false, args.position, args.viewPosition);
+            }
+            const states = viewModel.getCursorStates();
+            if (states.length > 1) {
+                const newModelPosition = (newState.modelState ? newState.modelState.position : null);
+                const newViewPosition = (newState.viewState ? newState.viewState.position : null);
+                for (let i = 0, len = states.length; i < len; i++) {
+                    const state = states[i];
+                    if (newModelPosition && !state.modelState.selection.containsPosition(newModelPosition)) {
+                        continue;
+                    }
+                    if (newViewPosition && !state.viewState.selection.containsPosition(newViewPosition)) {
+                        continue;
+                    }
+                    states.splice(i, 1);
+                    viewModel.model.pushStackElement();
+                    viewModel.setCursorStates(args.source, 3 , states);
+                    return;
+                }
+            }
+            states.push(newState);
+            viewModel.model.pushStackElement();
+            viewModel.setCursorStates(args.source, 3 , states);
+        }
+    }));
+    CoreNavigationCommands.LastCursorMoveToSelect = registerEditorCommand(new (class extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: '_lastCursorMoveToSelect',
+                precondition: undefined
+            });
+        }
+        runCoreEditorCommand(viewModel, args) {
+            if (!args.position) {
+                return;
+            }
+            const lastAddedCursorIndex = viewModel.getLastAddedCursorIndex();
+            const states = viewModel.getCursorStates();
+            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);
+        }
+    }));
+    class HomeCommand extends CoreEditorCommand {
+        constructor(opts) {
+            super(opts);
+            this._inSelectionMode = opts.inSelectionMode;
+        }
+        runCoreEditorCommand(viewModel, args) {
+            viewModel.model.pushStackElement();
+            viewModel.setCursorStates(args.source, 3 , CursorMoveCommands.moveToBeginningOfLine(viewModel, viewModel.getCursorStates(), this._inSelectionMode));
+            viewModel.revealPrimaryCursor(args.source, true);
+        }
+    }
+    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 ] }
+        }
+    })));
+    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 ] }
+        }
+    })));
+    class LineStartCommand extends CoreEditorCommand {
+        constructor(opts) {
+            super(opts);
+            this._inSelectionMode = opts.inSelectionMode;
+        }
+        runCoreEditorCommand(viewModel, args) {
+            viewModel.model.pushStackElement();
+            viewModel.setCursorStates(args.source, 3 , this._exec(viewModel.getCursorStates()));
+            viewModel.revealPrimaryCursor(args.source, true);
+        }
+        _exec(cursors) {
+            const result = [];
+            for (let i = 0, len = cursors.length; i < len; i++) {
+                const cursor = cursors[i];
+                const lineNumber = cursor.modelState.position.lineNumber;
+                result[i] = CursorState.fromModelState(cursor.modelState.move(this._inSelectionMode, lineNumber, 1, 0));
+            }
+            return result;
+        }
+    }
+    CoreNavigationCommands.CursorLineStart = registerEditorCommand(( new LineStartCommand({
+        inSelectionMode: false,
+        id: 'cursorLineStart',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 0,
+            mac: { primary: 256  | 31  }
+        }
+    })));
+    CoreNavigationCommands.CursorLineStartSelect = registerEditorCommand(( new LineStartCommand({
+        inSelectionMode: true,
+        id: 'cursorLineStartSelect',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 0,
+            mac: { primary: 256  | 1024  | 31  }
+        }
+    })));
+    class EndCommand extends CoreEditorCommand {
+        constructor(opts) {
+            super(opts);
+            this._inSelectionMode = opts.inSelectionMode;
+        }
+        runCoreEditorCommand(viewModel, args) {
+            viewModel.model.pushStackElement();
+            viewModel.setCursorStates(args.source, 3 , CursorMoveCommands.moveToEndOfLine(viewModel, viewModel.getCursorStates(), this._inSelectionMode, args.sticky || false));
+            viewModel.revealPrimaryCursor(args.source, true);
+        }
+    }
+    CoreNavigationCommands.CursorEnd = registerEditorCommand(( new EndCommand({
+        inSelectionMode: false,
+        id: 'cursorEnd',
+        precondition: undefined,
+        kbOpts: {
+            args: { sticky: false },
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 13 ,
+            mac: { primary: 13 , secondary: [2048  | 17 ] }
+        },
+        metadata: {
+            description: `Go to End`,
+            args: [{
+                    name: 'args',
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            'sticky': {
+                                description: ( localizeWithPath(
+                                    'vs/editor/browser/coreCommands',
+                                    'stickydesc',
+                                    "Stick to the end even when going to longer lines"
+                                )),
+                                type: 'boolean',
+                                default: false
+                            }
+                        }
+                    }
+                }]
+        }
+    })));
+    CoreNavigationCommands.CursorEndSelect = registerEditorCommand(( new EndCommand({
+        inSelectionMode: true,
+        id: 'cursorEndSelect',
+        precondition: undefined,
+        kbOpts: {
+            args: { sticky: false },
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 1024  | 13 ,
+            mac: { primary: 1024  | 13 , secondary: [2048  | 1024  | 17 ] }
+        },
+        metadata: {
+            description: `Select to End`,
+            args: [{
+                    name: 'args',
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            'sticky': {
+                                description: ( localizeWithPath(
+                                    'vs/editor/browser/coreCommands',
+                                    'stickydesc',
+                                    "Stick to the end even when going to longer lines"
+                                )),
+                                type: 'boolean',
+                                default: false
+                            }
+                        }
+                    }
+                }]
+        }
+    })));
+    class LineEndCommand extends CoreEditorCommand {
+        constructor(opts) {
+            super(opts);
+            this._inSelectionMode = opts.inSelectionMode;
+        }
+        runCoreEditorCommand(viewModel, args) {
+            viewModel.model.pushStackElement();
+            viewModel.setCursorStates(args.source, 3 , this._exec(viewModel, viewModel.getCursorStates()));
+            viewModel.revealPrimaryCursor(args.source, true);
+        }
+        _exec(viewModel, cursors) {
+            const result = [];
+            for (let i = 0, len = cursors.length; i < len; i++) {
+                const cursor = cursors[i];
+                const lineNumber = cursor.modelState.position.lineNumber;
+                const maxColumn = viewModel.model.getLineMaxColumn(lineNumber);
+                result[i] = CursorState.fromModelState(cursor.modelState.move(this._inSelectionMode, lineNumber, maxColumn, 0));
+            }
+            return result;
+        }
+    }
+    CoreNavigationCommands.CursorLineEnd = registerEditorCommand(( new LineEndCommand({
+        inSelectionMode: false,
+        id: 'cursorLineEnd',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 0,
+            mac: { primary: 256  | 35  }
+        }
+    })));
+    CoreNavigationCommands.CursorLineEndSelect = registerEditorCommand(( new LineEndCommand({
+        inSelectionMode: true,
+        id: 'cursorLineEndSelect',
+        precondition: undefined,
+        kbOpts: {
+            weight: CORE_WEIGHT,
+            kbExpr: EditorContextKeys.textInputFocus,
+            primary: 0,
+            mac: { primary: 256  | 1024  | 35  }
+        }
+    })));
+    class TopCommand extends CoreEditorCommand {
+        constructor(opts) {
+            super(opts);
+            this._inSelectionMode = opts.inSelectionMode;
+        }
+        runCoreEditorCommand(viewModel, args) {
+            viewModel.model.pushStackElement();
+            viewModel.setCursorStates(args.source, 3 , CursorMoveCommands.moveToBeginningOfBuffer(viewModel, viewModel.getCursorStates(), this._inSelectionMode));
+            viewModel.revealPrimaryCursor(args.source, true);
+        }
+    }
+    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  }
+        }
+    })));
+    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  }
+        }
+    })));
+    class BottomCommand extends CoreEditorCommand {
+        constructor(opts) {
+            super(opts);
+            this._inSelectionMode = opts.inSelectionMode;
+        }
+        runCoreEditorCommand(viewModel, args) {
+            viewModel.model.pushStackElement();
+            viewModel.setCursorStates(args.source, 3 , CursorMoveCommands.moveToEndOfBuffer(viewModel, viewModel.getCursorStates(), this._inSelectionMode));
+            viewModel.revealPrimaryCursor(args.source, true);
+        }
+    }
+    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  }
+        }
+    })));
+    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  }
+        }
+    })));
+    class EditorScrollImpl extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: 'editorScroll',
+                precondition: undefined,
+                metadata: EditorScroll_.metadata
+            });
+        }
+        determineScrollMethod(args) {
+            const horizontalUnits = [6 ];
+            const verticalUnits = [
+                1 ,
+                2 ,
+                3 ,
+                4 ,
+                5 ,
+                6
+            ];
+            const horizontalDirections = [4 , 2 ];
+            const verticalDirections = [1 , 3 ];
+            if (horizontalUnits.includes(args.unit) && horizontalDirections.includes(args.direction)) {
+                return this._runHorizontalEditorScroll.bind(this);
+            }
+            if (verticalUnits.includes(args.unit) && verticalDirections.includes(args.direction)) {
+                return this._runVerticalEditorScroll.bind(this);
+            }
+            return null;
+        }
+        runCoreEditorCommand(viewModel, args) {
+            const parsed = EditorScroll_.parse(args);
+            if (!parsed) {
+                return;
+            }
+            const runEditorScroll = this.determineScrollMethod(parsed);
+            if (!runEditorScroll) {
+                return;
+            }
+            runEditorScroll(viewModel, args.source, parsed);
+        }
+        _runVerticalEditorScroll(viewModel, source, args) {
+            const desiredScrollTop = this._computeDesiredScrollTop(viewModel, args);
+            if (args.revealCursor) {
+                const desiredVisibleViewRange = viewModel.getCompletelyVisibleViewRangeAtScrollTop(desiredScrollTop);
+                viewModel.setCursorStates(source, 3 , [
+                    CursorMoveCommands.findPositionInViewportIfOutside(viewModel, viewModel.getPrimaryCursorState(), desiredVisibleViewRange, args.select)
+                ]);
+            }
+            viewModel.viewLayout.setScrollPosition({ scrollTop: desiredScrollTop }, 0 );
+        }
+        _computeDesiredScrollTop(viewModel, args) {
+            if (args.unit === 1 ) {
+                const futureViewport = viewModel.viewLayout.getFutureViewport();
+                const visibleViewRange = viewModel.getCompletelyVisibleViewRangeAtScrollTop(futureViewport.top);
+                const visibleModelRange = viewModel.coordinatesConverter.convertViewRangeToModelRange(visibleViewRange);
+                let desiredTopModelLineNumber;
+                if (args.direction === 1 ) {
+                    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)));
+                return viewModel.viewLayout.getVerticalOffsetForLineNumber(viewPosition.lineNumber);
+            }
+            if (args.unit === 5 ) {
+                let desiredTopModelLineNumber = 0;
+                if (args.direction === 3 ) {
+                    desiredTopModelLineNumber = viewModel.model.getLineCount() - viewModel.cursorConfig.pageSize;
+                }
+                return viewModel.viewLayout.getVerticalOffsetForLineNumber(desiredTopModelLineNumber);
+            }
+            let noOfLines;
+            if (args.unit === 3 ) {
+                noOfLines = viewModel.cursorConfig.pageSize * args.value;
+            }
+            else if (args.unit === 4 ) {
+                noOfLines = Math.round(viewModel.cursorConfig.pageSize / 2) * args.value;
+            }
+            else {
+                noOfLines = args.value;
+            }
+            const deltaLines = (args.direction === 1  ? -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 );
+        }
+        _computeDesiredScrollLeft(viewModel, args) {
+            const deltaColumns = (args.direction === 4  ? -1 : 1) * args.value;
+            return viewModel.viewLayout.getCurrentScrollLeft() + deltaColumns * viewModel.cursorConfig.typicalHalfwidthCharacterWidth;
+        }
+    }
+    CoreNavigationCommands.EditorScrollImpl = EditorScrollImpl;
+    CoreNavigationCommands.EditorScroll = registerEditorCommand(( new EditorScrollImpl()));
+    CoreNavigationCommands.ScrollLineUp = registerEditorCommand(new (class extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: 'scrollLineUp',
+                precondition: undefined,
+                kbOpts: {
+                    weight: CORE_WEIGHT,
+                    kbExpr: EditorContextKeys.textInputFocus,
+                    primary: 2048  | 16 ,
+                    mac: { primary: 256  | 11  }
+                }
+            });
+        }
+        runCoreEditorCommand(viewModel, args) {
+            CoreNavigationCommands.EditorScroll.runCoreEditorCommand(viewModel, {
+                to: EditorScroll_.RawDirection.Up,
+                by: EditorScroll_.RawUnit.WrappedLine,
+                value: 1,
+                revealCursor: false,
+                select: false,
+                source: args.source
+            });
+        }
+    }));
+    CoreNavigationCommands.ScrollPageUp = registerEditorCommand(new (class extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: 'scrollPageUp',
+                precondition: undefined,
+                kbOpts: {
+                    weight: CORE_WEIGHT,
+                    kbExpr: EditorContextKeys.textInputFocus,
+                    primary: 2048  | 11 ,
+                    win: { primary: 512  | 11  },
+                    linux: { primary: 512  | 11  }
+                }
+            });
+        }
+        runCoreEditorCommand(viewModel, args) {
+            CoreNavigationCommands.EditorScroll.runCoreEditorCommand(viewModel, {
+                to: EditorScroll_.RawDirection.Up,
+                by: EditorScroll_.RawUnit.Page,
+                value: 1,
+                revealCursor: false,
+                select: false,
+                source: args.source
+            });
+        }
+    }));
+    CoreNavigationCommands.ScrollEditorTop = registerEditorCommand(new (class extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: 'scrollEditorTop',
+                precondition: undefined,
+                kbOpts: {
+                    weight: CORE_WEIGHT,
+                    kbExpr: EditorContextKeys.textInputFocus,
+                }
+            });
+        }
+        runCoreEditorCommand(viewModel, args) {
+            CoreNavigationCommands.EditorScroll.runCoreEditorCommand(viewModel, {
+                to: EditorScroll_.RawDirection.Up,
+                by: EditorScroll_.RawUnit.Editor,
+                value: 1,
+                revealCursor: false,
+                select: false,
+                source: args.source
+            });
+        }
+    }));
+    CoreNavigationCommands.ScrollLineDown = registerEditorCommand(new (class extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: 'scrollLineDown',
+                precondition: undefined,
+                kbOpts: {
+                    weight: CORE_WEIGHT,
+                    kbExpr: EditorContextKeys.textInputFocus,
+                    primary: 2048  | 18 ,
+                    mac: { primary: 256  | 12  }
+                }
+            });
+        }
+        runCoreEditorCommand(viewModel, args) {
+            CoreNavigationCommands.EditorScroll.runCoreEditorCommand(viewModel, {
+                to: EditorScroll_.RawDirection.Down,
+                by: EditorScroll_.RawUnit.WrappedLine,
+                value: 1,
+                revealCursor: false,
+                select: false,
+                source: args.source
+            });
+        }
+    }));
+    CoreNavigationCommands.ScrollPageDown = registerEditorCommand(new (class extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: 'scrollPageDown',
+                precondition: undefined,
+                kbOpts: {
+                    weight: CORE_WEIGHT,
+                    kbExpr: EditorContextKeys.textInputFocus,
+                    primary: 2048  | 12 ,
+                    win: { primary: 512  | 12  },
+                    linux: { primary: 512  | 12  }
+                }
+            });
+        }
+        runCoreEditorCommand(viewModel, args) {
+            CoreNavigationCommands.EditorScroll.runCoreEditorCommand(viewModel, {
+                to: EditorScroll_.RawDirection.Down,
+                by: EditorScroll_.RawUnit.Page,
+                value: 1,
+                revealCursor: false,
+                select: false,
+                source: args.source
+            });
+        }
+    }));
+    CoreNavigationCommands.ScrollEditorBottom = registerEditorCommand(new (class extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: 'scrollEditorBottom',
+                precondition: undefined,
+                kbOpts: {
+                    weight: CORE_WEIGHT,
+                    kbExpr: EditorContextKeys.textInputFocus,
+                }
+            });
+        }
+        runCoreEditorCommand(viewModel, args) {
+            CoreNavigationCommands.EditorScroll.runCoreEditorCommand(viewModel, {
+                to: EditorScroll_.RawDirection.Down,
+                by: EditorScroll_.RawUnit.Editor,
+                value: 1,
+                revealCursor: false,
+                select: false,
+                source: args.source
+            });
+        }
+    }));
+    CoreNavigationCommands.ScrollLeft = registerEditorCommand(new (class extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: 'scrollLeft',
+                precondition: undefined,
+                kbOpts: {
+                    weight: CORE_WEIGHT,
+                    kbExpr: EditorContextKeys.textInputFocus,
+                }
+            });
+        }
+        runCoreEditorCommand(viewModel, args) {
+            CoreNavigationCommands.EditorScroll.runCoreEditorCommand(viewModel, {
+                to: EditorScroll_.RawDirection.Left,
+                by: EditorScroll_.RawUnit.Column,
+                value: 2,
+                revealCursor: false,
+                select: false,
+                source: args.source
+            });
+        }
+    }));
+    CoreNavigationCommands.ScrollRight = registerEditorCommand(new (class extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: 'scrollRight',
+                precondition: undefined,
+                kbOpts: {
+                    weight: CORE_WEIGHT,
+                    kbExpr: EditorContextKeys.textInputFocus,
+                }
+            });
+        }
+        runCoreEditorCommand(viewModel, args) {
+            CoreNavigationCommands.EditorScroll.runCoreEditorCommand(viewModel, {
+                to: EditorScroll_.RawDirection.Right,
+                by: EditorScroll_.RawUnit.Column,
+                value: 2,
+                revealCursor: false,
+                select: false,
+                source: args.source
+            });
+        }
+    }));
+    class WordCommand extends CoreEditorCommand {
+        constructor(opts) {
+            super(opts);
+            this._inSelectionMode = opts.inSelectionMode;
+        }
+        runCoreEditorCommand(viewModel, args) {
+            if (!args.position) {
+                return;
+            }
+            viewModel.model.pushStackElement();
+            viewModel.setCursorStates(args.source, 3 , [
+                CursorMoveCommands.word(viewModel, viewModel.getPrimaryCursorState(), this._inSelectionMode, args.position)
+            ]);
+            if (args.revealType !== 2 ) {
+                viewModel.revealPrimaryCursor(args.source, true, true);
+            }
+        }
+    }
+    CoreNavigationCommands.WordSelect = registerEditorCommand(( new WordCommand({
+        inSelectionMode: false,
+        id: '_wordSelect',
+        precondition: undefined
+    })));
+    CoreNavigationCommands.WordSelectDrag = registerEditorCommand(( new WordCommand({
+        inSelectionMode: true,
+        id: '_wordSelectDrag',
+        precondition: undefined
+    })));
+    CoreNavigationCommands.LastCursorWordSelect = registerEditorCommand(new (class extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: 'lastCursorWordSelect',
+                precondition: undefined
+            });
+        }
+        runCoreEditorCommand(viewModel, args) {
+            if (!args.position) {
+                return;
+            }
+            const lastAddedCursorIndex = viewModel.getLastAddedCursorIndex();
+            const states = viewModel.getCursorStates();
+            const newStates = states.slice(0);
+            const lastAddedState = states[lastAddedCursorIndex];
+            newStates[lastAddedCursorIndex] = CursorMoveCommands.word(viewModel, lastAddedState, lastAddedState.modelState.hasSelection(), args.position);
+            viewModel.model.pushStackElement();
+            viewModel.setCursorStates(args.source, 3 , newStates);
+        }
+    }));
+    class LineCommand extends CoreEditorCommand {
+        constructor(opts) {
+            super(opts);
+            this._inSelectionMode = opts.inSelectionMode;
+        }
+        runCoreEditorCommand(viewModel, args) {
+            if (!args.position) {
+                return;
+            }
+            viewModel.model.pushStackElement();
+            viewModel.setCursorStates(args.source, 3 , [
+                CursorMoveCommands.line(viewModel, viewModel.getPrimaryCursorState(), this._inSelectionMode, args.position, args.viewPosition)
+            ]);
+            if (args.revealType !== 2 ) {
+                viewModel.revealPrimaryCursor(args.source, false, true);
+            }
+        }
+    }
+    CoreNavigationCommands.LineSelect = registerEditorCommand(( new LineCommand({
+        inSelectionMode: false,
+        id: '_lineSelect',
+        precondition: undefined
+    })));
+    CoreNavigationCommands.LineSelectDrag = registerEditorCommand(( new LineCommand({
+        inSelectionMode: true,
+        id: '_lineSelectDrag',
+        precondition: undefined
+    })));
+    class LastCursorLineCommand extends CoreEditorCommand {
+        constructor(opts) {
+            super(opts);
+            this._inSelectionMode = opts.inSelectionMode;
+        }
+        runCoreEditorCommand(viewModel, args) {
+            if (!args.position) {
+                return;
+            }
+            const lastAddedCursorIndex = viewModel.getLastAddedCursorIndex();
+            const states = viewModel.getCursorStates();
+            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);
+        }
+    }
+    CoreNavigationCommands.LastCursorLineSelect = registerEditorCommand(( new LastCursorLineCommand({
+        inSelectionMode: false,
+        id: 'lastCursorLineSelect',
+        precondition: undefined
+    })));
+    CoreNavigationCommands.LastCursorLineSelectDrag = registerEditorCommand(( new LastCursorLineCommand({
+        inSelectionMode: true,
+        id: 'lastCursorLineSelectDrag',
+        precondition: undefined
+    })));
+    CoreNavigationCommands.CancelSelection = registerEditorCommand(new (class extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: 'cancelSelection',
+                precondition: EditorContextKeys.hasNonEmptySelection,
+                kbOpts: {
+                    weight: CORE_WEIGHT,
+                    kbExpr: EditorContextKeys.textInputFocus,
+                    primary: 9 ,
+                    secondary: [1024  | 9 ]
+                }
+            });
+        }
+        runCoreEditorCommand(viewModel, args) {
+            viewModel.model.pushStackElement();
+            viewModel.setCursorStates(args.source, 3 , [
+                CursorMoveCommands.cancelSelection(viewModel, viewModel.getPrimaryCursorState())
+            ]);
+            viewModel.revealPrimaryCursor(args.source, true);
+        }
+    }));
+    CoreNavigationCommands.RemoveSecondaryCursors = registerEditorCommand(new (class extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: 'removeSecondaryCursors',
+                precondition: EditorContextKeys.hasMultipleSelections,
+                kbOpts: {
+                    weight: CORE_WEIGHT + 1,
+                    kbExpr: EditorContextKeys.textInputFocus,
+                    primary: 9 ,
+                    secondary: [1024  | 9 ]
+                }
+            });
+        }
+        runCoreEditorCommand(viewModel, args) {
+            viewModel.model.pushStackElement();
+            viewModel.setCursorStates(args.source, 3 , [
+                viewModel.getPrimaryCursorState()
+            ]);
+            viewModel.revealPrimaryCursor(args.source, true);
+            status(( localizeWithPath(
+                'vs/editor/browser/coreCommands',
+                'removedCursor',
+                "Removed secondary cursors"
+            )));
+        }
+    }));
+    CoreNavigationCommands.RevealLine = registerEditorCommand(new (class extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: 'revealLine',
+                precondition: undefined,
+                metadata: RevealLine_.metadata
+            });
+        }
+        runCoreEditorCommand(viewModel, args) {
+            const revealLineArg = args;
+            const lineNumberArg = revealLineArg.lineNumber || 0;
+            let lineNumber = typeof lineNumberArg === 'number' ? (lineNumberArg + 1) : (parseInt(lineNumberArg) + 1);
+            if (lineNumber < 1) {
+                lineNumber = 1;
+            }
+            const lineCount = viewModel.model.getLineCount();
+            if (lineNumber > lineCount) {
+                lineNumber = lineCount;
+            }
+            const range = ( new Range(lineNumber, 1, lineNumber, viewModel.model.getLineMaxColumn(lineNumber)));
+            let revealAt = 0 ;
+            if (revealLineArg.at) {
+                switch (revealLineArg.at) {
+                    case RevealLine_.RawAtArgument.Top:
+                        revealAt = 3 ;
+                        break;
+                    case RevealLine_.RawAtArgument.Center:
+                        revealAt = 1 ;
+                        break;
+                    case RevealLine_.RawAtArgument.Bottom:
+                        revealAt = 4 ;
+                        break;
+                }
+            }
+            const viewRange = viewModel.coordinatesConverter.convertModelRangeToViewRange(range);
+            viewModel.revealRange(args.source, false, viewRange, revealAt, 0 );
+        }
+    }));
+    CoreNavigationCommands.SelectAll = new (class extends EditorOrNativeTextInputCommand {
+        constructor() {
+            super(SelectAllCommand);
+        }
+        runDOMCommand(activeElement) {
+            if (isFirefox) {
+                activeElement.focus();
+                activeElement.select();
+            }
+            activeElement.ownerDocument.execCommand('selectAll');
+        }
+        runEditorCommand(accessor, editor, args) {
+            const viewModel = editor._getViewModel();
+            if (!viewModel) {
+                return;
+            }
+            this.runCoreEditorCommand(viewModel, args);
+        }
+        runCoreEditorCommand(viewModel, args) {
+            viewModel.model.pushStackElement();
+            viewModel.setCursorStates('keyboard', 3 , [
+                CursorMoveCommands.selectAll(viewModel, viewModel.getPrimaryCursorState())
+            ]);
+        }
+    })();
+    CoreNavigationCommands.SetSelection = registerEditorCommand(new (class extends CoreEditorCommand {
+        constructor() {
+            super({
+                id: 'setSelection',
+                precondition: undefined
+            });
+        }
+        runCoreEditorCommand(viewModel, args) {
+            if (!args.selection) {
+                return;
+            }
+            viewModel.model.pushStackElement();
+            viewModel.setCursorStates(args.source, 3 , [
+                CursorState.fromModelSelection(args.selection)
+            ]);
+        }
+    }));
+})(CoreNavigationCommands || (CoreNavigationCommands = {})));
+const columnSelectionCondition = ( ContextKeyExpr.and(EditorContextKeys.textInputFocus, EditorContextKeys.columnSelection));
+function registerColumnSelection(id, keybinding) {
+    KeybindingsRegistry.registerKeybindingRule({
+        id: id,
+        primary: keybinding,
+        when: columnSelectionCondition,
+        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 );
+function registerCommand(command) {
+    command.register();
+    return command;
+}
+var CoreEditingCommands;
+( (function(CoreEditingCommands) {
+    class CoreEditingCommand extends EditorCommand {
+        runEditorCommand(accessor, editor, args) {
+            const viewModel = editor._getViewModel();
+            if (!viewModel) {
+                return;
+            }
+            this.runCoreEditingCommand(editor, viewModel, args || {});
+        }
+    }
+    CoreEditingCommands.CoreEditingCommand = CoreEditingCommand;
+    CoreEditingCommands.LineBreakInsert = registerEditorCommand(new (class extends CoreEditingCommand {
+        constructor() {
+            super({
+                id: 'lineBreakInsert',
+                precondition: EditorContextKeys.writable,
+                kbOpts: {
+                    weight: CORE_WEIGHT,
+                    kbExpr: EditorContextKeys.textInputFocus,
+                    primary: 0,
+                    mac: { primary: 256  | 45  }
+                }
+            });
+        }
+        runCoreEditingCommand(editor, viewModel, args) {
+            editor.pushUndoStop();
+            editor.executeCommands(this.id, TypeOperations.lineBreakInsert(viewModel.cursorConfig, viewModel.model, ( viewModel.getCursorStates().map(s => s.modelState.selection))));
+        }
+    }));
+    CoreEditingCommands.Outdent = registerEditorCommand(new (class extends CoreEditingCommand {
+        constructor() {
+            super({
+                id: 'outdent',
+                precondition: EditorContextKeys.writable,
+                kbOpts: {
+                    weight: CORE_WEIGHT,
+                    kbExpr: ( ContextKeyExpr.and(EditorContextKeys.editorTextFocus, EditorContextKeys.tabDoesNotMoveFocus)),
+                    primary: 1024  | 2
+                }
+            });
+        }
+        runCoreEditingCommand(editor, viewModel, args) {
+            editor.pushUndoStop();
+            editor.executeCommands(this.id, TypeOperations.outdent(viewModel.cursorConfig, viewModel.model, ( viewModel.getCursorStates().map(s => s.modelState.selection))));
+            editor.pushUndoStop();
+        }
+    }));
+    CoreEditingCommands.Tab = registerEditorCommand(new (class extends CoreEditingCommand {
+        constructor() {
+            super({
+                id: 'tab',
+                precondition: EditorContextKeys.writable,
+                kbOpts: {
+                    weight: CORE_WEIGHT,
+                    kbExpr: ( ContextKeyExpr.and(EditorContextKeys.editorTextFocus, EditorContextKeys.tabDoesNotMoveFocus)),
+                    primary: 2
+                }
+            });
+        }
+        runCoreEditingCommand(editor, viewModel, args) {
+            editor.pushUndoStop();
+            editor.executeCommands(this.id, TypeOperations.tab(viewModel.cursorConfig, viewModel.model, ( viewModel.getCursorStates().map(s => s.modelState.selection))));
+            editor.pushUndoStop();
+        }
+    }));
+    CoreEditingCommands.DeleteLeft = registerEditorCommand(new (class extends CoreEditingCommand {
+        constructor() {
+            super({
+                id: 'deleteLeft',
+                precondition: undefined,
+                kbOpts: {
+                    weight: CORE_WEIGHT,
+                    kbExpr: EditorContextKeys.textInputFocus,
+                    primary: 1 ,
+                    secondary: [1024  | 1 ],
+                    mac: { primary: 1 , secondary: [1024  | 1 , 256  | 38 , 256  | 1 ] }
+                }
+            });
+        }
+        runCoreEditingCommand(editor, viewModel, args) {
+            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 );
+        }
+    }));
+    CoreEditingCommands.DeleteRight = registerEditorCommand(new (class extends CoreEditingCommand {
+        constructor() {
+            super({
+                id: 'deleteRight',
+                precondition: undefined,
+                kbOpts: {
+                    weight: CORE_WEIGHT,
+                    kbExpr: EditorContextKeys.textInputFocus,
+                    primary: 20 ,
+                    mac: { primary: 20 , secondary: [256  | 34 , 256  | 20 ] }
+                }
+            });
+        }
+        runCoreEditingCommand(editor, viewModel, args) {
+            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 );
+        }
+    }));
+    CoreEditingCommands.Undo = new (class extends EditorOrNativeTextInputCommand {
+        constructor() {
+            super(UndoCommand);
+        }
+        runDOMCommand(activeElement) {
+            activeElement.ownerDocument.execCommand('undo');
+        }
+        runEditorCommand(accessor, editor, args) {
+            if (!editor.hasModel() || editor.getOption(90 ) === true) {
+                return;
+            }
+            return editor.getModel().undo();
+        }
+    })();
+    CoreEditingCommands.Redo = new (class extends EditorOrNativeTextInputCommand {
+        constructor() {
+            super(RedoCommand);
+        }
+        runDOMCommand(activeElement) {
+            activeElement.ownerDocument.execCommand('redo');
+        }
+        runEditorCommand(accessor, editor, args) {
+            if (!editor.hasModel() || editor.getOption(90 ) === true) {
+                return;
+            }
+            return editor.getModel().redo();
+        }
+    })();
+})(CoreEditingCommands || (CoreEditingCommands = {})));
+class EditorHandlerCommand extends Command {
+    constructor(id, handlerId, metadata) {
+        super({
+            id: id,
+            precondition: undefined,
+            metadata
+        });
+        this._handlerId = handlerId;
+    }
+    runCommand(accessor, args) {
+        const editor = accessor.get(ICodeEditorService).getFocusedCodeEditor();
+        if (!editor) {
+            return;
+        }
+        editor.trigger('keyboard', this._handlerId, args);
+    }
+}
+function registerOverwritableCommand(handlerId, metadata) {
+    registerCommand(( new EditorHandlerCommand('default:' + handlerId, handlerId)));
+    registerCommand(( new EditorHandlerCommand(handlerId, handlerId, metadata)));
+}
+registerOverwritableCommand("type" , {
+    description: `Type`,
+    args: [{
+            name: 'args',
+            schema: {
+                'type': 'object',
+                'required': ['text'],
+                'properties': {
+                    'text': {
+                        'type': 'string'
+                    }
+                },
+            }
+        }]
+});
+registerOverwritableCommand("replacePreviousChar" );
+registerOverwritableCommand("compositionType" );
+registerOverwritableCommand("compositionStart" );
+registerOverwritableCommand("compositionEnd" );
+registerOverwritableCommand("paste" );
+registerOverwritableCommand("cut" );
+export { CoreEditingCommands, CoreEditorCommand, CoreNavigationCommands, EditorScroll_, RevealLine_ };