@umbraco-cms/backoffice 15.3.0 → 15.4.0-rc

package/dist-cms/monaco-editor/vs/editor/common/cursor/cursorMoveCommands.js

@@ -0,0 +1,651 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as types from '../../../base/common/types.js';
+import { CursorState, SingleCursorState } from '../cursorCommon.js';
+import { MoveOperations } from './cursorMoveOperations.js';
+import { WordOperations } from './cursorWordOperations.js';
+import { Position } from '../core/position.js';
+import { Range } from '../core/range.js';
+export class CursorMoveCommands {
+    static addCursorDown(viewModel, cursors, useLogicalLine) {
+        const result = [];
+        let resultLen = 0;
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            result[resultLen++] = new CursorState(cursor.modelState, cursor.viewState);
+            if (useLogicalLine) {
+                result[resultLen++] = CursorState.fromModelState(MoveOperations.translateDown(viewModel.cursorConfig, viewModel.model, cursor.modelState));
+            }
+            else {
+                result[resultLen++] = CursorState.fromViewState(MoveOperations.translateDown(viewModel.cursorConfig, viewModel, cursor.viewState));
+            }
+        }
+        return result;
+    }
+    static addCursorUp(viewModel, cursors, useLogicalLine) {
+        const result = [];
+        let resultLen = 0;
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            result[resultLen++] = new CursorState(cursor.modelState, cursor.viewState);
+            if (useLogicalLine) {
+                result[resultLen++] = CursorState.fromModelState(MoveOperations.translateUp(viewModel.cursorConfig, viewModel.model, cursor.modelState));
+            }
+            else {
+                result[resultLen++] = CursorState.fromViewState(MoveOperations.translateUp(viewModel.cursorConfig, viewModel, cursor.viewState));
+            }
+        }
+        return result;
+    }
+    static moveToBeginningOfLine(viewModel, cursors, inSelectionMode) {
+        const result = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            result[i] = this._moveToLineStart(viewModel, cursor, inSelectionMode);
+        }
+        return result;
+    }
+    static _moveToLineStart(viewModel, cursor, inSelectionMode) {
+        const currentViewStateColumn = cursor.viewState.position.column;
+        const currentModelStateColumn = cursor.modelState.position.column;
+        const isFirstLineOfWrappedLine = currentViewStateColumn === currentModelStateColumn;
+        const currentViewStatelineNumber = cursor.viewState.position.lineNumber;
+        const firstNonBlankColumn = viewModel.getLineFirstNonWhitespaceColumn(currentViewStatelineNumber);
+        const isBeginningOfViewLine = currentViewStateColumn === firstNonBlankColumn;
+        if (!isFirstLineOfWrappedLine && !isBeginningOfViewLine) {
+            return this._moveToLineStartByView(viewModel, cursor, inSelectionMode);
+        }
+        else {
+            return this._moveToLineStartByModel(viewModel, cursor, inSelectionMode);
+        }
+    }
+    static _moveToLineStartByView(viewModel, cursor, inSelectionMode) {
+        return CursorState.fromViewState(MoveOperations.moveToBeginningOfLine(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode));
+    }
+    static _moveToLineStartByModel(viewModel, cursor, inSelectionMode) {
+        return CursorState.fromModelState(MoveOperations.moveToBeginningOfLine(viewModel.cursorConfig, viewModel.model, cursor.modelState, inSelectionMode));
+    }
+    static moveToEndOfLine(viewModel, cursors, inSelectionMode, sticky) {
+        const result = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            result[i] = this._moveToLineEnd(viewModel, cursor, inSelectionMode, sticky);
+        }
+        return result;
+    }
+    static _moveToLineEnd(viewModel, cursor, inSelectionMode, sticky) {
+        const viewStatePosition = cursor.viewState.position;
+        const viewModelMaxColumn = viewModel.getLineMaxColumn(viewStatePosition.lineNumber);
+        const isEndOfViewLine = viewStatePosition.column === viewModelMaxColumn;
+        const modelStatePosition = cursor.modelState.position;
+        const modelMaxColumn = viewModel.model.getLineMaxColumn(modelStatePosition.lineNumber);
+        const isEndLineOfWrappedLine = viewModelMaxColumn - viewStatePosition.column === modelMaxColumn - modelStatePosition.column;
+        if (isEndOfViewLine || isEndLineOfWrappedLine) {
+            return this._moveToLineEndByModel(viewModel, cursor, inSelectionMode, sticky);
+        }
+        else {
+            return this._moveToLineEndByView(viewModel, cursor, inSelectionMode, sticky);
+        }
+    }
+    static _moveToLineEndByView(viewModel, cursor, inSelectionMode, sticky) {
+        return CursorState.fromViewState(MoveOperations.moveToEndOfLine(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode, sticky));
+    }
+    static _moveToLineEndByModel(viewModel, cursor, inSelectionMode, sticky) {
+        return CursorState.fromModelState(MoveOperations.moveToEndOfLine(viewModel.cursorConfig, viewModel.model, cursor.modelState, inSelectionMode, sticky));
+    }
+    static expandLineSelection(viewModel, cursors) {
+        const result = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            const startLineNumber = cursor.modelState.selection.startLineNumber;
+            const lineCount = viewModel.model.getLineCount();
+            let endLineNumber = cursor.modelState.selection.endLineNumber;
+            let endColumn;
+            if (endLineNumber === lineCount) {
+                endColumn = viewModel.model.getLineMaxColumn(lineCount);
+            }
+            else {
+                endLineNumber++;
+                endColumn = 1;
+            }
+            result[i] = CursorState.fromModelState(new SingleCursorState(new Range(startLineNumber, 1, startLineNumber, 1), 0 /* SelectionStartKind.Simple */, 0, new Position(endLineNumber, endColumn), 0));
+        }
+        return result;
+    }
+    static moveToBeginningOfBuffer(viewModel, cursors, inSelectionMode) {
+        const result = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            result[i] = CursorState.fromModelState(MoveOperations.moveToBeginningOfBuffer(viewModel.cursorConfig, viewModel.model, cursor.modelState, inSelectionMode));
+        }
+        return result;
+    }
+    static moveToEndOfBuffer(viewModel, cursors, inSelectionMode) {
+        const result = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            result[i] = CursorState.fromModelState(MoveOperations.moveToEndOfBuffer(viewModel.cursorConfig, viewModel.model, cursor.modelState, inSelectionMode));
+        }
+        return result;
+    }
+    static selectAll(viewModel, cursor) {
+        const lineCount = viewModel.model.getLineCount();
+        const maxColumn = viewModel.model.getLineMaxColumn(lineCount);
+        return CursorState.fromModelState(new SingleCursorState(new Range(1, 1, 1, 1), 0 /* SelectionStartKind.Simple */, 0, new Position(lineCount, maxColumn), 0));
+    }
+    static line(viewModel, cursor, inSelectionMode, _position, _viewPosition) {
+        const position = viewModel.model.validatePosition(_position);
+        const viewPosition = (_viewPosition
+            ? viewModel.coordinatesConverter.validateViewPosition(new Position(_viewPosition.lineNumber, _viewPosition.column), position)
+            : viewModel.coordinatesConverter.convertModelPositionToViewPosition(position));
+        if (!inSelectionMode) {
+            // Entering line selection for the first time
+            const lineCount = viewModel.model.getLineCount();
+            let selectToLineNumber = position.lineNumber + 1;
+            let selectToColumn = 1;
+            if (selectToLineNumber > lineCount) {
+                selectToLineNumber = lineCount;
+                selectToColumn = viewModel.model.getLineMaxColumn(selectToLineNumber);
+            }
+            return CursorState.fromModelState(new SingleCursorState(new Range(position.lineNumber, 1, selectToLineNumber, selectToColumn), 2 /* SelectionStartKind.Line */, 0, new Position(selectToLineNumber, selectToColumn), 0));
+        }
+        // Continuing line selection
+        const enteringLineNumber = cursor.modelState.selectionStart.getStartPosition().lineNumber;
+        if (position.lineNumber < enteringLineNumber) {
+            return CursorState.fromViewState(cursor.viewState.move(true, viewPosition.lineNumber, 1, 0));
+        }
+        else if (position.lineNumber > enteringLineNumber) {
+            const lineCount = viewModel.getLineCount();
+            let selectToViewLineNumber = viewPosition.lineNumber + 1;
+            let selectToViewColumn = 1;
+            if (selectToViewLineNumber > lineCount) {
+                selectToViewLineNumber = lineCount;
+                selectToViewColumn = viewModel.getLineMaxColumn(selectToViewLineNumber);
+            }
+            return CursorState.fromViewState(cursor.viewState.move(true, selectToViewLineNumber, selectToViewColumn, 0));
+        }
+        else {
+            const endPositionOfSelectionStart = cursor.modelState.selectionStart.getEndPosition();
+            return CursorState.fromModelState(cursor.modelState.move(true, endPositionOfSelectionStart.lineNumber, endPositionOfSelectionStart.column, 0));
+        }
+    }
+    static word(viewModel, cursor, inSelectionMode, _position) {
+        const position = viewModel.model.validatePosition(_position);
+        return CursorState.fromModelState(WordOperations.word(viewModel.cursorConfig, viewModel.model, cursor.modelState, inSelectionMode, position));
+    }
+    static cancelSelection(viewModel, cursor) {
+        if (!cursor.modelState.hasSelection()) {
+            return new CursorState(cursor.modelState, cursor.viewState);
+        }
+        const lineNumber = cursor.viewState.position.lineNumber;
+        const column = cursor.viewState.position.column;
+        return CursorState.fromViewState(new SingleCursorState(new Range(lineNumber, column, lineNumber, column), 0 /* SelectionStartKind.Simple */, 0, new Position(lineNumber, column), 0));
+    }
+    static moveTo(viewModel, cursor, inSelectionMode, _position, _viewPosition) {
+        if (inSelectionMode) {
+            if (cursor.modelState.selectionStartKind === 1 /* SelectionStartKind.Word */) {
+                return this.word(viewModel, cursor, inSelectionMode, _position);
+            }
+            if (cursor.modelState.selectionStartKind === 2 /* SelectionStartKind.Line */) {
+                return this.line(viewModel, cursor, inSelectionMode, _position, _viewPosition);
+            }
+        }
+        const position = viewModel.model.validatePosition(_position);
+        const viewPosition = (_viewPosition
+            ? viewModel.coordinatesConverter.validateViewPosition(new Position(_viewPosition.lineNumber, _viewPosition.column), position)
+            : viewModel.coordinatesConverter.convertModelPositionToViewPosition(position));
+        return CursorState.fromViewState(cursor.viewState.move(inSelectionMode, viewPosition.lineNumber, viewPosition.column, 0));
+    }
+    static simpleMove(viewModel, cursors, direction, inSelectionMode, value, unit) {
+        switch (direction) {
+            case 0 /* CursorMove.Direction.Left */: {
+                if (unit === 4 /* CursorMove.Unit.HalfLine */) {
+                    // Move left by half the current line length
+                    return this._moveHalfLineLeft(viewModel, cursors, inSelectionMode);
+                }
+                else {
+                    // Move left by `moveParams.value` columns
+                    return this._moveLeft(viewModel, cursors, inSelectionMode, value);
+                }
+            }
+            case 1 /* CursorMove.Direction.Right */: {
+                if (unit === 4 /* CursorMove.Unit.HalfLine */) {
+                    // Move right by half the current line length
+                    return this._moveHalfLineRight(viewModel, cursors, inSelectionMode);
+                }
+                else {
+                    // Move right by `moveParams.value` columns
+                    return this._moveRight(viewModel, cursors, inSelectionMode, value);
+                }
+            }
+            case 2 /* CursorMove.Direction.Up */: {
+                if (unit === 2 /* CursorMove.Unit.WrappedLine */) {
+                    // Move up by view lines
+                    return this._moveUpByViewLines(viewModel, cursors, inSelectionMode, value);
+                }
+                else {
+                    // Move up by model lines
+                    return this._moveUpByModelLines(viewModel, cursors, inSelectionMode, value);
+                }
+            }
+            case 3 /* CursorMove.Direction.Down */: {
+                if (unit === 2 /* CursorMove.Unit.WrappedLine */) {
+                    // Move down by view lines
+                    return this._moveDownByViewLines(viewModel, cursors, inSelectionMode, value);
+                }
+                else {
+                    // Move down by model lines
+                    return this._moveDownByModelLines(viewModel, cursors, inSelectionMode, value);
+                }
+            }
+            case 4 /* CursorMove.Direction.PrevBlankLine */: {
+                if (unit === 2 /* CursorMove.Unit.WrappedLine */) {
+                    return cursors.map(cursor => CursorState.fromViewState(MoveOperations.moveToPrevBlankLine(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode)));
+                }
+                else {
+                    return cursors.map(cursor => CursorState.fromModelState(MoveOperations.moveToPrevBlankLine(viewModel.cursorConfig, viewModel.model, cursor.modelState, inSelectionMode)));
+                }
+            }
+            case 5 /* CursorMove.Direction.NextBlankLine */: {
+                if (unit === 2 /* CursorMove.Unit.WrappedLine */) {
+                    return cursors.map(cursor => CursorState.fromViewState(MoveOperations.moveToNextBlankLine(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode)));
+                }
+                else {
+                    return cursors.map(cursor => CursorState.fromModelState(MoveOperations.moveToNextBlankLine(viewModel.cursorConfig, viewModel.model, cursor.modelState, inSelectionMode)));
+                }
+            }
+            case 6 /* CursorMove.Direction.WrappedLineStart */: {
+                // Move to the beginning of the current view line
+                return this._moveToViewMinColumn(viewModel, cursors, inSelectionMode);
+            }
+            case 7 /* CursorMove.Direction.WrappedLineFirstNonWhitespaceCharacter */: {
+                // Move to the first non-whitespace column of the current view line
+                return this._moveToViewFirstNonWhitespaceColumn(viewModel, cursors, inSelectionMode);
+            }
+            case 8 /* CursorMove.Direction.WrappedLineColumnCenter */: {
+                // Move to the "center" of the current view line
+                return this._moveToViewCenterColumn(viewModel, cursors, inSelectionMode);
+            }
+            case 9 /* CursorMove.Direction.WrappedLineEnd */: {
+                // Move to the end of the current view line
+                return this._moveToViewMaxColumn(viewModel, cursors, inSelectionMode);
+            }
+            case 10 /* CursorMove.Direction.WrappedLineLastNonWhitespaceCharacter */: {
+                // Move to the last non-whitespace column of the current view line
+                return this._moveToViewLastNonWhitespaceColumn(viewModel, cursors, inSelectionMode);
+            }
+            default:
+                return null;
+        }
+    }
+    static viewportMove(viewModel, cursors, direction, inSelectionMode, value) {
+        const visibleViewRange = viewModel.getCompletelyVisibleViewRange();
+        const visibleModelRange = viewModel.coordinatesConverter.convertViewRangeToModelRange(visibleViewRange);
+        switch (direction) {
+            case 11 /* CursorMove.Direction.ViewPortTop */: {
+                // Move to the nth line start in the viewport (from the top)
+                const modelLineNumber = this._firstLineNumberInRange(viewModel.model, visibleModelRange, value);
+                const modelColumn = viewModel.model.getLineFirstNonWhitespaceColumn(modelLineNumber);
+                return [this._moveToModelPosition(viewModel, cursors[0], inSelectionMode, modelLineNumber, modelColumn)];
+            }
+            case 13 /* CursorMove.Direction.ViewPortBottom */: {
+                // Move to the nth line start in the viewport (from the bottom)
+                const modelLineNumber = this._lastLineNumberInRange(viewModel.model, visibleModelRange, value);
+                const modelColumn = viewModel.model.getLineFirstNonWhitespaceColumn(modelLineNumber);
+                return [this._moveToModelPosition(viewModel, cursors[0], inSelectionMode, modelLineNumber, modelColumn)];
+            }
+            case 12 /* CursorMove.Direction.ViewPortCenter */: {
+                // Move to the line start in the viewport center
+                const modelLineNumber = Math.round((visibleModelRange.startLineNumber + visibleModelRange.endLineNumber) / 2);
+                const modelColumn = viewModel.model.getLineFirstNonWhitespaceColumn(modelLineNumber);
+                return [this._moveToModelPosition(viewModel, cursors[0], inSelectionMode, modelLineNumber, modelColumn)];
+            }
+            case 14 /* CursorMove.Direction.ViewPortIfOutside */: {
+                // Move to a position inside the viewport
+                const result = [];
+                for (let i = 0, len = cursors.length; i < len; i++) {
+                    const cursor = cursors[i];
+                    result[i] = this.findPositionInViewportIfOutside(viewModel, cursor, visibleViewRange, inSelectionMode);
+                }
+                return result;
+            }
+            default:
+                return null;
+        }
+    }
+    static findPositionInViewportIfOutside(viewModel, cursor, visibleViewRange, inSelectionMode) {
+        const viewLineNumber = cursor.viewState.position.lineNumber;
+        if (visibleViewRange.startLineNumber <= viewLineNumber && viewLineNumber <= visibleViewRange.endLineNumber - 1) {
+            // Nothing to do, cursor is in viewport
+            return new CursorState(cursor.modelState, cursor.viewState);
+        }
+        else {
+            let newViewLineNumber;
+            if (viewLineNumber > visibleViewRange.endLineNumber - 1) {
+                newViewLineNumber = visibleViewRange.endLineNumber - 1;
+            }
+            else if (viewLineNumber < visibleViewRange.startLineNumber) {
+                newViewLineNumber = visibleViewRange.startLineNumber;
+            }
+            else {
+                newViewLineNumber = viewLineNumber;
+            }
+            const position = MoveOperations.vertical(viewModel.cursorConfig, viewModel, viewLineNumber, cursor.viewState.position.column, cursor.viewState.leftoverVisibleColumns, newViewLineNumber, false);
+            return CursorState.fromViewState(cursor.viewState.move(inSelectionMode, position.lineNumber, position.column, position.leftoverVisibleColumns));
+        }
+    }
+    /**
+     * Find the nth line start included in the range (from the start).
+     */
+    static _firstLineNumberInRange(model, range, count) {
+        let startLineNumber = range.startLineNumber;
+        if (range.startColumn !== model.getLineMinColumn(startLineNumber)) {
+            // Move on to the second line if the first line start is not included in the range
+            startLineNumber++;
+        }
+        return Math.min(range.endLineNumber, startLineNumber + count - 1);
+    }
+    /**
+     * Find the nth line start included in the range (from the end).
+     */
+    static _lastLineNumberInRange(model, range, count) {
+        let startLineNumber = range.startLineNumber;
+        if (range.startColumn !== model.getLineMinColumn(startLineNumber)) {
+            // Move on to the second line if the first line start is not included in the range
+            startLineNumber++;
+        }
+        return Math.max(startLineNumber, range.endLineNumber - count + 1);
+    }
+    static _moveLeft(viewModel, cursors, inSelectionMode, noOfColumns) {
+        return cursors.map(cursor => CursorState.fromViewState(MoveOperations.moveLeft(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode, noOfColumns)));
+    }
+    static _moveHalfLineLeft(viewModel, cursors, inSelectionMode) {
+        const result = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            const viewLineNumber = cursor.viewState.position.lineNumber;
+            const halfLine = Math.round(viewModel.getLineLength(viewLineNumber) / 2);
+            result[i] = CursorState.fromViewState(MoveOperations.moveLeft(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode, halfLine));
+        }
+        return result;
+    }
+    static _moveRight(viewModel, cursors, inSelectionMode, noOfColumns) {
+        return cursors.map(cursor => CursorState.fromViewState(MoveOperations.moveRight(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode, noOfColumns)));
+    }
+    static _moveHalfLineRight(viewModel, cursors, inSelectionMode) {
+        const result = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            const viewLineNumber = cursor.viewState.position.lineNumber;
+            const halfLine = Math.round(viewModel.getLineLength(viewLineNumber) / 2);
+            result[i] = CursorState.fromViewState(MoveOperations.moveRight(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode, halfLine));
+        }
+        return result;
+    }
+    static _moveDownByViewLines(viewModel, cursors, inSelectionMode, linesCount) {
+        const result = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            result[i] = CursorState.fromViewState(MoveOperations.moveDown(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode, linesCount));
+        }
+        return result;
+    }
+    static _moveDownByModelLines(viewModel, cursors, inSelectionMode, linesCount) {
+        const result = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            result[i] = CursorState.fromModelState(MoveOperations.moveDown(viewModel.cursorConfig, viewModel.model, cursor.modelState, inSelectionMode, linesCount));
+        }
+        return result;
+    }
+    static _moveUpByViewLines(viewModel, cursors, inSelectionMode, linesCount) {
+        const result = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            result[i] = CursorState.fromViewState(MoveOperations.moveUp(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode, linesCount));
+        }
+        return result;
+    }
+    static _moveUpByModelLines(viewModel, cursors, inSelectionMode, linesCount) {
+        const result = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            result[i] = CursorState.fromModelState(MoveOperations.moveUp(viewModel.cursorConfig, viewModel.model, cursor.modelState, inSelectionMode, linesCount));
+        }
+        return result;
+    }
+    static _moveToViewPosition(viewModel, cursor, inSelectionMode, toViewLineNumber, toViewColumn) {
+        return CursorState.fromViewState(cursor.viewState.move(inSelectionMode, toViewLineNumber, toViewColumn, 0));
+    }
+    static _moveToModelPosition(viewModel, cursor, inSelectionMode, toModelLineNumber, toModelColumn) {
+        return CursorState.fromModelState(cursor.modelState.move(inSelectionMode, toModelLineNumber, toModelColumn, 0));
+    }
+    static _moveToViewMinColumn(viewModel, cursors, inSelectionMode) {
+        const result = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            const viewLineNumber = cursor.viewState.position.lineNumber;
+            const viewColumn = viewModel.getLineMinColumn(viewLineNumber);
+            result[i] = this._moveToViewPosition(viewModel, cursor, inSelectionMode, viewLineNumber, viewColumn);
+        }
+        return result;
+    }
+    static _moveToViewFirstNonWhitespaceColumn(viewModel, cursors, inSelectionMode) {
+        const result = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            const viewLineNumber = cursor.viewState.position.lineNumber;
+            const viewColumn = viewModel.getLineFirstNonWhitespaceColumn(viewLineNumber);
+            result[i] = this._moveToViewPosition(viewModel, cursor, inSelectionMode, viewLineNumber, viewColumn);
+        }
+        return result;
+    }
+    static _moveToViewCenterColumn(viewModel, cursors, inSelectionMode) {
+        const result = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            const viewLineNumber = cursor.viewState.position.lineNumber;
+            const viewColumn = Math.round((viewModel.getLineMaxColumn(viewLineNumber) + viewModel.getLineMinColumn(viewLineNumber)) / 2);
+            result[i] = this._moveToViewPosition(viewModel, cursor, inSelectionMode, viewLineNumber, viewColumn);
+        }
+        return result;
+    }
+    static _moveToViewMaxColumn(viewModel, cursors, inSelectionMode) {
+        const result = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            const viewLineNumber = cursor.viewState.position.lineNumber;
+            const viewColumn = viewModel.getLineMaxColumn(viewLineNumber);
+            result[i] = this._moveToViewPosition(viewModel, cursor, inSelectionMode, viewLineNumber, viewColumn);
+        }
+        return result;
+    }
+    static _moveToViewLastNonWhitespaceColumn(viewModel, cursors, inSelectionMode) {
+        const result = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            const cursor = cursors[i];
+            const viewLineNumber = cursor.viewState.position.lineNumber;
+            const viewColumn = viewModel.getLineLastNonWhitespaceColumn(viewLineNumber);
+            result[i] = this._moveToViewPosition(viewModel, cursor, inSelectionMode, viewLineNumber, viewColumn);
+        }
+        return result;
+    }
+}
+export var CursorMove;
+(function (CursorMove) {
+    const isCursorMoveArgs = function (arg) {
+        if (!types.isObject(arg)) {
+            return false;
+        }
+        const cursorMoveArg = arg;
+        if (!types.isString(cursorMoveArg.to)) {
+            return false;
+        }
+        if (!types.isUndefined(cursorMoveArg.select) && !types.isBoolean(cursorMoveArg.select)) {
+            return false;
+        }
+        if (!types.isUndefined(cursorMoveArg.by) && !types.isString(cursorMoveArg.by)) {
+            return false;
+        }
+        if (!types.isUndefined(cursorMoveArg.value) && !types.isNumber(cursorMoveArg.value)) {
+            return false;
+        }
+        return true;
+    };
+    CursorMove.metadata = {
+        description: 'Move cursor to a logical position in the view',
+        args: [
+            {
+                name: 'Cursor move argument object',
+                description: `Property-value pairs that can be passed through this argument:
+					* 'to': A mandatory logical position value providing where to move the cursor.
+						\`\`\`
+						'left', 'right', 'up', 'down', 'prevBlankLine', 'nextBlankLine',
+						'wrappedLineStart', 'wrappedLineEnd', 'wrappedLineColumnCenter'
+						'wrappedLineFirstNonWhitespaceCharacter', 'wrappedLineLastNonWhitespaceCharacter'
+						'viewPortTop', 'viewPortCenter', 'viewPortBottom', 'viewPortIfOutside'
+						\`\`\`
+					* 'by': Unit to move. Default is computed based on 'to' value.
+						\`\`\`
+						'line', 'wrappedLine', 'character', 'halfLine'
+						\`\`\`
+					* 'value': Number of units to move. Default is '1'.
+					* 'select': If 'true' makes the selection. Default is 'false'.
+				`,
+                constraint: isCursorMoveArgs,
+                schema: {
+                    'type': 'object',
+                    'required': ['to'],
+                    'properties': {
+                        'to': {
+                            'type': 'string',
+                            'enum': ['left', 'right', 'up', 'down', 'prevBlankLine', 'nextBlankLine', 'wrappedLineStart', 'wrappedLineEnd', 'wrappedLineColumnCenter', 'wrappedLineFirstNonWhitespaceCharacter', 'wrappedLineLastNonWhitespaceCharacter', 'viewPortTop', 'viewPortCenter', 'viewPortBottom', 'viewPortIfOutside']
+                        },
+                        'by': {
+                            'type': 'string',
+                            'enum': ['line', 'wrappedLine', 'character', 'halfLine']
+                        },
+                        'value': {
+                            'type': 'number',
+                            'default': 1
+                        },
+                        'select': {
+                            'type': 'boolean',
+                            'default': false
+                        }
+                    }
+                }
+            }
+        ]
+    };
+    /**
+     * Positions in the view for cursor move command.
+     */
+    CursorMove.RawDirection = {
+        Left: 'left',
+        Right: 'right',
+        Up: 'up',
+        Down: 'down',
+        PrevBlankLine: 'prevBlankLine',
+        NextBlankLine: 'nextBlankLine',
+        WrappedLineStart: 'wrappedLineStart',
+        WrappedLineFirstNonWhitespaceCharacter: 'wrappedLineFirstNonWhitespaceCharacter',
+        WrappedLineColumnCenter: 'wrappedLineColumnCenter',
+        WrappedLineEnd: 'wrappedLineEnd',
+        WrappedLineLastNonWhitespaceCharacter: 'wrappedLineLastNonWhitespaceCharacter',
+        ViewPortTop: 'viewPortTop',
+        ViewPortCenter: 'viewPortCenter',
+        ViewPortBottom: 'viewPortBottom',
+        ViewPortIfOutside: 'viewPortIfOutside'
+    };
+    /**
+     * Units for Cursor move 'by' argument
+     */
+    CursorMove.RawUnit = {
+        Line: 'line',
+        WrappedLine: 'wrappedLine',
+        Character: 'character',
+        HalfLine: 'halfLine'
+    };
+    function parse(args) {
+        if (!args.to) {
+            // illegal arguments
+            return null;
+        }
+        let direction;
+        switch (args.to) {
+            case CursorMove.RawDirection.Left:
+                direction = 0 /* Direction.Left */;
+                break;
+            case CursorMove.RawDirection.Right:
+                direction = 1 /* Direction.Right */;
+                break;
+            case CursorMove.RawDirection.Up:
+                direction = 2 /* Direction.Up */;
+                break;
+            case CursorMove.RawDirection.Down:
+                direction = 3 /* Direction.Down */;
+                break;
+            case CursorMove.RawDirection.PrevBlankLine:
+                direction = 4 /* Direction.PrevBlankLine */;
+                break;
+            case CursorMove.RawDirection.NextBlankLine:
+                direction = 5 /* Direction.NextBlankLine */;
+                break;
+            case CursorMove.RawDirection.WrappedLineStart:
+                direction = 6 /* Direction.WrappedLineStart */;
+                break;
+            case CursorMove.RawDirection.WrappedLineFirstNonWhitespaceCharacter:
+                direction = 7 /* Direction.WrappedLineFirstNonWhitespaceCharacter */;
+                break;
+            case CursorMove.RawDirection.WrappedLineColumnCenter:
+                direction = 8 /* Direction.WrappedLineColumnCenter */;
+                break;
+            case CursorMove.RawDirection.WrappedLineEnd:
+                direction = 9 /* Direction.WrappedLineEnd */;
+                break;
+            case CursorMove.RawDirection.WrappedLineLastNonWhitespaceCharacter:
+                direction = 10 /* Direction.WrappedLineLastNonWhitespaceCharacter */;
+                break;
+            case CursorMove.RawDirection.ViewPortTop:
+                direction = 11 /* Direction.ViewPortTop */;
+                break;
+            case CursorMove.RawDirection.ViewPortBottom:
+                direction = 13 /* Direction.ViewPortBottom */;
+                break;
+            case CursorMove.RawDirection.ViewPortCenter:
+                direction = 12 /* Direction.ViewPortCenter */;
+                break;
+            case CursorMove.RawDirection.ViewPortIfOutside:
+                direction = 14 /* Direction.ViewPortIfOutside */;
+                break;
+            default:
+                // illegal arguments
+                return null;
+        }
+        let unit = 0 /* Unit.None */;
+        switch (args.by) {
+            case CursorMove.RawUnit.Line:
+                unit = 1 /* Unit.Line */;
+                break;
+            case CursorMove.RawUnit.WrappedLine:
+                unit = 2 /* Unit.WrappedLine */;
+                break;
+            case CursorMove.RawUnit.Character:
+                unit = 3 /* Unit.Character */;
+                break;
+            case CursorMove.RawUnit.HalfLine:
+                unit = 4 /* Unit.HalfLine */;
+                break;
+        }
+        return {
+            direction: direction,
+            unit: unit,
+            select: (!!args.select),
+            value: (args.value || 1)
+        };
+    }
+    CursorMove.parse = parse;
+})(CursorMove || (CursorMove = {}));