monaco-editor11 1.0.9 → 1.1.1

package/dist/workers/editor/common/cursorMoveCommands.js

@@ -1,676 +0,0 @@
-import { isObject, isString, isUndefined, isBoolean, isNumber } 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';
-import { TextDirection } from '../model.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-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 => {
-            const direction = viewModel.getTextDirection(cursor.viewState.position.lineNumber);
-            const isRtl = direction === TextDirection.RTL;
-            return CursorState.fromViewState(isRtl
-                ? MoveOperations.moveRight(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode, noOfColumns)
-                : 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 => {
-            const direction = viewModel.getTextDirection(cursor.viewState.position.lineNumber);
-            const isRtl = direction === TextDirection.RTL;
-            return CursorState.fromViewState(isRtl
-                ? MoveOperations.moveLeft(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode, noOfColumns)
-                : 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;
-    }
-}
-var CursorMove;
-(function (CursorMove) {
-    const isCursorMoveArgs = function (arg) {
-        if (!isObject(arg)) {
-            return false;
-        }
-        const cursorMoveArg = arg;
-        if (!isString(cursorMoveArg.to)) {
-            return false;
-        }
-        if (!isUndefined(cursorMoveArg.select) && !isBoolean(cursorMoveArg.select)) {
-            return false;
-        }
-        if (!isUndefined(cursorMoveArg.by) && !isString(cursorMoveArg.by)) {
-            return false;
-        }
-        if (!isUndefined(cursorMoveArg.value) && !isNumber(cursorMoveArg.value)) {
-            return false;
-        }
-        if (!isUndefined(cursorMoveArg.noHistory) && !isBoolean(cursorMoveArg.noHistory)) {
-            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'.
-					* 'noHistory': If 'true' does not add the movement to navigation history. 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
-                        },
-                        'noHistory': {
-                            '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),
-            noHistory: (!!args.noHistory)
-        };
-    }
-    CursorMove.parse = parse;
-})(CursorMove || (CursorMove = {}));
-
-export { CursorMove, CursorMoveCommands };