@codingame/monaco-vscode-api 9.0.3 → 10.0.0

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

@@ -1,18 +1,15 @@
 import { onUnexpectedError } from '../../../base/common/errors.js';
 import { nextCharLength, commonPrefixLength, commonSuffixLength } from '../../../base/common/strings.js';
 import { CursorCollection } from './cursorCollection.js';
-import { EditOperationType, CursorState, EditOperationResult } from '../cursorCommon.js';
+import { CursorState, EditOperationResult } from '../cursorCommon.js';
 import { CursorContext } from './cursorContext.js';
 import { DeleteOperations } from './cursorDeleteOperations.js';
-import { CursorChangeReason } from '../cursorEvents.js';
 import { TypeOperations, CompositionOutcome } from './cursorTypeOperations.js';
 import { BaseTypeWithAutoClosingCommand } from './cursorTypeEditOperations.js';
 import { Range } from '../core/range.js';
-import { SelectionDirection, Selection } from '../core/selection.js';
-import { ScrollType } from '../editorCommon.js';
-import { TrackedRangeStickiness } from '../model.js';
-import { ModelInjectedTextChangedEvent, RawContentChangedType } from '../textModelEvents.js';
-import { ViewRevealRangeRequestEvent, VerticalRevealType, ViewCursorStateChangedEvent } from '../viewEvents.js';
+import { Selection } from '../core/selection.js';
+import { ModelInjectedTextChangedEvent } from '../textModelEvents.js';
+import { ViewRevealRangeRequestEvent, ViewCursorStateChangedEvent } from '../viewEvents.js';
 import { Disposable, dispose } from '../../../base/common/lifecycle.js';
 import { CursorStateChangedEvent } from '../viewModelEventDispatcher.js';
 class CursorsController extends Disposable {
@@ -29,7 +26,7 @@ class CursorsController extends Disposable {
         this._compositionState = null;
         this._columnSelectData = null;
         this._autoClosedActions = [];
-        this._prevEditOperationType = EditOperationType.Other;
+        this._prevEditOperationType = 0 ;
     }
     dispose() {
         this._cursors.dispose();
@@ -44,7 +41,7 @@ class CursorsController extends Disposable {
         if (this._knownModelVersionId !== this._model.getVersionId()) {
             return;
         }
-        this.setStates(eventsCollector, 'viewModel', CursorChangeReason.NotSet, this.getCursorStates());
+        this.setStates(eventsCollector, 'viewModel', 0 , this.getCursorStates());
     }
     setHasFocus(hasFocus) {
         this._hasFocus = hasFocus;
@@ -167,8 +164,8 @@ class CursorsController extends Disposable {
                 positionColumn: positionColumn
             });
         }
-        this.setStates(eventsCollector, 'restoreState', CursorChangeReason.NotSet, CursorState.fromModelSelections(desiredSelections));
-        this.revealAll(eventsCollector, 'restoreState', false, VerticalRevealType.Simple, true, ScrollType.Immediate);
+        this.setStates(eventsCollector, 'restoreState', 0 , CursorState.fromModelSelections(desiredSelections));
+        this.revealAll(eventsCollector, 'restoreState', false, 0 , true, 1 );
     }
     onModelContentChanged(eventsCollector, event) {
         if (event instanceof ModelInjectedTextChangedEvent) {
@@ -177,7 +174,7 @@ class CursorsController extends Disposable {
             }
             this._isHandling = true;
             try {
-                this.setStates(eventsCollector, 'modelChange', CursorChangeReason.NotSet, this.getCursorStates());
+                this.setStates(eventsCollector, 'modelChange', 0 , this.getCursorStates());
             }
             finally {
                 this._isHandling = false;
@@ -189,24 +186,24 @@ class CursorsController extends Disposable {
             if (this._isHandling) {
                 return;
             }
-            const hadFlushEvent = e.containsEvent(RawContentChangedType.Flush);
-            this._prevEditOperationType = EditOperationType.Other;
+            const hadFlushEvent = e.containsEvent(1 );
+            this._prevEditOperationType = 0 ;
             if (hadFlushEvent) {
                 this._cursors.dispose();
                 this._cursors = ( new CursorCollection(this.context));
                 this._validateAutoClosedActions();
-                this._emitStateChangedIfNecessary(eventsCollector, 'model', CursorChangeReason.ContentFlush, null, false);
+                this._emitStateChangedIfNecessary(eventsCollector, 'model', 1 , null, false);
             }
             else {
                 if (this._hasFocus && e.resultingSelection && e.resultingSelection.length > 0) {
                     const cursorState = CursorState.fromModelSelections(e.resultingSelection);
-                    if (this.setStates(eventsCollector, 'modelChange', e.isUndoing ? CursorChangeReason.Undo : e.isRedoing ? CursorChangeReason.Redo : CursorChangeReason.RecoverFromMarkers, cursorState)) {
-                        this.revealAll(eventsCollector, 'modelChange', false, VerticalRevealType.Simple, true, ScrollType.Smooth);
+                    if (this.setStates(eventsCollector, 'modelChange', e.isUndoing ? 5  : e.isRedoing ? 6  : 2 , cursorState)) {
+                        this.revealAll(eventsCollector, 'modelChange', false, 0 , true, 0 );
                     }
                 }
                 else {
                     const selectionsFromMarkers = this._cursors.readSelectionFromMarkers();
-                    this.setStates(eventsCollector, 'modelChange', CursorChangeReason.RecoverFromMarkers, CursorState.fromModelSelections(selectionsFromMarkers));
+                    this.setStates(eventsCollector, 'modelChange', 2 , CursorState.fromModelSelections(selectionsFromMarkers));
                 }
             }
         }
@@ -259,14 +256,14 @@ class CursorsController extends Disposable {
                 options: {
                     description: 'auto-closed-character',
                     inlineClassName: 'auto-closed-character',
-                    stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges
+                    stickiness: 1
                 }
             });
             autoClosedEnclosingDeltaDecorations.push({
                 range: autoClosedEnclosingRanges[i],
                 options: {
                     description: 'auto-closed-enclosing',
-                    stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges
+                    stickiness: 1
                 }
             });
         }
@@ -400,13 +397,13 @@ class CursorsController extends Disposable {
         });
         if (selections) {
             this._isHandling = false;
-            this.setSelections(eventsCollector, source, selections, CursorChangeReason.NotSet);
+            this.setSelections(eventsCollector, source, selections, 0 );
         }
         if (autoClosedCharactersRanges.length > 0) {
             this._pushAutoClosedAction(autoClosedCharactersRanges, autoClosedEnclosingRanges);
         }
     }
-    _executeEdit(callback, eventsCollector, source, cursorChangeReason = CursorChangeReason.NotSet) {
+    _executeEdit(callback, eventsCollector, source, cursorChangeReason = 0 ) {
         if (this.context.cursorConfig.readOnly) {
             return;
         }
@@ -424,7 +421,7 @@ class CursorsController extends Disposable {
         this._cursors.startTrackingSelections();
         this._validateAutoClosedActions();
         if (this._emitStateChangedIfNecessary(eventsCollector, source, cursorChangeReason, oldState, false)) {
-            this.revealAll(eventsCollector, source, false, VerticalRevealType.Simple, true, ScrollType.Smooth);
+            this.revealAll(eventsCollector, source, false, 0 , true, 0 );
         }
     }
     getAutoClosedCharacters() {
@@ -471,7 +468,7 @@ class CursorsController extends Disposable {
                         position.column + positionDelta
                     ));
                 }));
-                this.setSelections(eventsCollector, source, newSelections, CursorChangeReason.NotSet);
+                this.setSelections(eventsCollector, source, newSelections, 0 );
             }
             return;
         }
@@ -482,7 +479,7 @@ class CursorsController extends Disposable {
     paste(eventsCollector, text, pasteOnNewLine, multicursorText, source) {
         this._executeEdit(() => {
             this._executeEditOperation(TypeOperations.paste(this.context.cursorConfig, this._model, this.getSelections(), text, pasteOnNewLine, multicursorText || []));
-        }, eventsCollector, source, CursorChangeReason.Paste);
+        }, eventsCollector, source, 4 );
     }
     cut(eventsCollector, source) {
         this._executeEdit(() => {
@@ -492,7 +489,7 @@ class CursorsController extends Disposable {
     executeCommand(eventsCollector, command, source) {
         this._executeEdit(() => {
             this._cursors.killSecondaryCursors();
-            this._executeEditOperation(( new EditOperationResult(EditOperationType.Other, [command], {
+            this._executeEditOperation(( new EditOperationResult(0 , [command], {
                 shouldPushStackElementBefore: false,
                 shouldPushStackElementAfter: false
             })));
@@ -500,7 +497,7 @@ class CursorsController extends Disposable {
     }
     executeCommands(eventsCollector, commands, source) {
         this._executeEdit(() => {
-            this._executeEditOperation(( new EditOperationResult(EditOperationType.Other, commands, {
+            this._executeEditOperation(( new EditOperationResult(0 , commands, {
                 shouldPushStackElementBefore: false,
                 shouldPushStackElementAfter: false
             })));
@@ -594,7 +591,7 @@ class CommandExecutor {
         };
         const result = this._innerExecuteCommands(ctx, commands);
         for (let i = 0, len = ctx.trackedRanges.length; i < len; i++) {
-            ctx.model._setTrackedRange(ctx.trackedRanges[i], null, TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges);
+            ctx.model._setTrackedRange(ctx.trackedRanges[i], null, 0 );
         }
         return result;
     }
@@ -646,7 +643,7 @@ class CommandExecutor {
                         getTrackedSelection: (id) => {
                             const idx = parseInt(id, 10);
                             const range = ctx.model._getTrackedRange(ctx.trackedRanges[idx]);
-                            if (ctx.trackedRangesDirection[idx] === SelectionDirection.LTR) {
+                            if (ctx.trackedRangesDirection[idx] === 0 ) {
                                 return ( new Selection(
                                     range.startLineNumber,
                                     range.startColumn,
@@ -739,24 +736,24 @@ class CommandExecutor {
             if (selection.isEmpty()) {
                 if (typeof trackPreviousOnEmpty === 'boolean') {
                     if (trackPreviousOnEmpty) {
-                        stickiness = TrackedRangeStickiness.GrowsOnlyWhenTypingBefore;
+                        stickiness = 2 ;
                     }
                     else {
-                        stickiness = TrackedRangeStickiness.GrowsOnlyWhenTypingAfter;
+                        stickiness = 3 ;
                     }
                 }
                 else {
                     const maxLineColumn = ctx.model.getLineMaxColumn(selection.startLineNumber);
                     if (selection.startColumn === maxLineColumn) {
-                        stickiness = TrackedRangeStickiness.GrowsOnlyWhenTypingBefore;
+                        stickiness = 2 ;
                     }
                     else {
-                        stickiness = TrackedRangeStickiness.GrowsOnlyWhenTypingAfter;
+                        stickiness = 3 ;
                     }
                 }
             }
             else {
-                stickiness = TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges;
+                stickiness = 1 ;
             }
             const l = ctx.trackedRanges.length;
             const id = ctx.model._setTrackedRange(null, selection, stickiness);

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

@@ -1,11 +1,4 @@
-import { CharCode } from '../../../base/common/charCode.js';
 import { CursorColumns } from '../core/cursorColumns.js';
-var Direction;
-( (function(Direction) {
-    Direction[Direction["Left"] = 0] = "Left";
-    Direction[Direction["Right"] = 1] = "Right";
-    Direction[Direction["Nearest"] = 2] = "Nearest";
-})(Direction || (Direction = {})));
 class AtomicTabMoveOperations {
     static whitespaceVisibleColumn(lineContent, position, tabSize) {
         const lineLength = lineContent.length;
@@ -22,10 +15,10 @@ class AtomicTabMoveOperations {
             }
             const chCode = lineContent.charCodeAt(i);
             switch (chCode) {
-                case CharCode.Space:
+                case 32 :
                     visibleColumn += 1;
                     break;
-                case CharCode.Tab:
+                case 9 :
                     visibleColumn = CursorColumns.nextRenderTabStop(visibleColumn, tabSize);
                     break;
                 default:
@@ -45,13 +38,13 @@ class AtomicTabMoveOperations {
         }
         let left;
         switch (direction) {
-            case Direction.Left:
+            case 0 :
                 left = true;
                 break;
-            case Direction.Right:
+            case 1 :
                 left = false;
                 break;
-            case Direction.Nearest:
+            case 2 :
                 if (visibleColumn % tabSize === 0) {
                     return position;
                 }
@@ -69,10 +62,10 @@ class AtomicTabMoveOperations {
                 }
                 const chCode = lineContent.charCodeAt(i);
                 switch (chCode) {
-                    case CharCode.Space:
+                    case 32 :
                         currentVisibleColumn += 1;
                         break;
-                    case CharCode.Tab:
+                    case 9 :
                         currentVisibleColumn = CursorColumns.nextRenderTabStop(currentVisibleColumn, tabSize);
                         break;
                     default:
@@ -92,10 +85,10 @@ class AtomicTabMoveOperations {
             }
             const chCode = lineContent.charCodeAt(i);
             switch (chCode) {
-                case CharCode.Space:
+                case 32 :
                     currentVisibleColumn += 1;
                     break;
-                case CharCode.Tab:
+                case 9 :
                     currentVisibleColumn = CursorColumns.nextRenderTabStop(currentVisibleColumn, tabSize);
                     break;
                 default:
@@ -108,4 +101,4 @@ class AtomicTabMoveOperations {
         return -1;
     }
 }
-export { AtomicTabMoveOperations, Direction };
+export { AtomicTabMoveOperations };

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

@@ -1,4 +1,4 @@
-import { SingleCursorState, SelectionStartKind } from '../cursorCommon.js';
+import { SingleCursorState } from '../cursorCommon.js';
 import { Position } from '../core/position.js';
 import { Range } from '../core/range.js';
 class ColumnSelection {
@@ -30,13 +30,13 @@ class ColumnSelection {
                     continue;
                 }
             }
-            result.push(( new SingleCursorState(( new Range(lineNumber, startColumn, lineNumber, startColumn)), SelectionStartKind.Simple, 0, ( new Position(lineNumber, endColumn)), 0)));
+            result.push(( new SingleCursorState(( new Range(lineNumber, startColumn, lineNumber, startColumn)), 0 , 0, ( new Position(lineNumber, endColumn)), 0)));
         }
         if (result.length === 0) {
             for (let i = 0; i < lineCount; i++) {
                 const lineNumber = fromLineNumber + (reversed ? -i : i);
                 const maxColumn = model.getLineMaxColumn(lineNumber);
-                result.push(( new SingleCursorState(( new Range(lineNumber, maxColumn, lineNumber, maxColumn)), SelectionStartKind.Simple, 0, ( new Position(lineNumber, maxColumn)), 0)));
+                result.push(( new SingleCursorState(( new Range(lineNumber, maxColumn, lineNumber, maxColumn)), 0 , 0, ( new Position(lineNumber, maxColumn)), 0)));
             }
         }
         return {

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

@@ -1,6 +1,6 @@
 import { firstNonWhitespaceIndex, getLeftDeleteOffset } from '../../../base/common/strings.js';
 import { ReplaceCommand } from '../commands/replaceCommand.js';
-import { isQuote, EditOperationResult, EditOperationType } from '../cursorCommon.js';
+import { isQuote, EditOperationResult } from '../cursorCommon.js';
 import { CursorColumns } from '../core/cursorColumns.js';
 import { MoveOperations } from './cursorMoveOperations.js';
 import { Range } from '../core/range.js';
@@ -8,7 +8,7 @@ import { Position } from '../core/position.js';
 class DeleteOperations {
     static deleteRight(prevEditOperationType, config, model, selections) {
         const commands = [];
-        let shouldPushStackElementBefore = (prevEditOperationType !== EditOperationType.DeletingRight);
+        let shouldPushStackElementBefore = ((prevEditOperationType !== 3) );
         for (let i = 0, len = selections.length; i < len; i++) {
             const selection = selections[i];
             let deleteSelection = selection;
@@ -110,7 +110,7 @@ class DeleteOperations {
             return this._runAutoClosingPairDelete(config, model, selections);
         }
         const commands = [];
-        let shouldPushStackElementBefore = (prevEditOperationType !== EditOperationType.DeletingLeft);
+        let shouldPushStackElementBefore = ((prevEditOperationType !== 2) );
         for (let i = 0, len = selections.length; i < len; i++) {
             const deleteRange = DeleteOperations.getDeleteRange(selections[i], model, config);
             if (deleteRange.isEmpty()) {
@@ -202,7 +202,7 @@ class DeleteOperations {
                 commands[i] = ( new ReplaceCommand(selection, ''));
             }
         }
-        return ( new EditOperationResult(EditOperationType.Other, commands, {
+        return ( new EditOperationResult(0 , commands, {
             shouldPushStackElementBefore: true,
             shouldPushStackElementAfter: true
         }));

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

@@ -1,5 +1,5 @@
 import { isObject, isString, isUndefined, isBoolean, isNumber } from '../../../base/common/types.js';
-import { CursorState, SingleCursorState, SelectionStartKind } from '../cursorCommon.js';
+import { CursorState, SingleCursorState } from '../cursorCommon.js';
 import { MoveOperations } from './cursorMoveOperations.js';
 import { WordOperations } from './cursorWordOperations.js';
 import { Position } from '../core/position.js';
@@ -106,7 +106,7 @@ class CursorMoveCommands {
                 endLineNumber++;
                 endColumn = 1;
             }
-            result[i] = CursorState.fromModelState(( new SingleCursorState(( new Range(startLineNumber, 1, startLineNumber, 1)), SelectionStartKind.Simple, 0, ( new Position(endLineNumber, endColumn)), 0)));
+            result[i] = CursorState.fromModelState(( new SingleCursorState(( new Range(startLineNumber, 1, startLineNumber, 1)), 0 , 0, ( new Position(endLineNumber, endColumn)), 0)));
         }
         return result;
     }
@@ -129,7 +129,7 @@ class CursorMoveCommands {
     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)), SelectionStartKind.Simple, 0, ( new Position(lineCount, maxColumn)), 0)));
+        return CursorState.fromModelState(( new SingleCursorState(( new Range(1, 1, 1, 1)), 0 , 0, ( new Position(lineCount, maxColumn)), 0)));
     }
     static line(viewModel, cursor, inSelectionMode, _position, _viewPosition) {
         const position = viewModel.model.validatePosition(_position);
@@ -144,7 +144,7 @@ class CursorMoveCommands {
                 selectToLineNumber = lineCount;
                 selectToColumn = viewModel.model.getLineMaxColumn(selectToLineNumber);
             }
-            return CursorState.fromModelState(( new SingleCursorState(( new Range(position.lineNumber, 1, selectToLineNumber, selectToColumn)), SelectionStartKind.Line, 0, ( new Position(selectToLineNumber, selectToColumn)), 0)));
+            return CursorState.fromModelState(( new SingleCursorState(( new Range(position.lineNumber, 1, selectToLineNumber, selectToColumn)), 2 , 0, ( new Position(selectToLineNumber, selectToColumn)), 0)));
         }
         const enteringLineNumber = cursor.modelState.selectionStart.getStartPosition().lineNumber;
         if (position.lineNumber < enteringLineNumber) {
@@ -175,14 +175,14 @@ class CursorMoveCommands {
         }
         const lineNumber = cursor.viewState.position.lineNumber;
         const column = cursor.viewState.position.column;
-        return CursorState.fromViewState(( new SingleCursorState(( new Range(lineNumber, column, lineNumber, column)), SelectionStartKind.Simple, 0, ( new Position(lineNumber, column)), 0)));
+        return CursorState.fromViewState(( new SingleCursorState(( new Range(lineNumber, column, lineNumber, column)), 0 , 0, ( new Position(lineNumber, column)), 0)));
     }
     static moveTo(viewModel, cursor, inSelectionMode, _position, _viewPosition) {
         if (inSelectionMode) {
-            if (cursor.modelState.selectionStartKind === SelectionStartKind.Word) {
+            if (cursor.modelState.selectionStartKind === 1 ) {
                 return this.word(viewModel, cursor, inSelectionMode, _position);
             }
-            if (cursor.modelState.selectionStartKind === SelectionStartKind.Line) {
+            if (cursor.modelState.selectionStartKind === 2 ) {
                 return this.line(viewModel, cursor, inSelectionMode, _position, _viewPosition);
             }
         }
@@ -194,40 +194,40 @@ class CursorMoveCommands {
     }
     static simpleMove(viewModel, cursors, direction, inSelectionMode, value, unit) {
         switch (direction) {
-            case CursorMove.Direction.Left: {
-                if (unit === CursorMove.Unit.HalfLine) {
+            case 0 : {
+                if (unit === 4 ) {
                     return this._moveHalfLineLeft(viewModel, cursors, inSelectionMode);
                 }
                 else {
                     return this._moveLeft(viewModel, cursors, inSelectionMode, value);
                 }
             }
-            case CursorMove.Direction.Right: {
-                if (unit === CursorMove.Unit.HalfLine) {
+            case 1 : {
+                if (unit === 4 ) {
                     return this._moveHalfLineRight(viewModel, cursors, inSelectionMode);
                 }
                 else {
                     return this._moveRight(viewModel, cursors, inSelectionMode, value);
                 }
             }
-            case CursorMove.Direction.Up: {
-                if (unit === CursorMove.Unit.WrappedLine) {
+            case 2 : {
+                if (unit === 2 ) {
                     return this._moveUpByViewLines(viewModel, cursors, inSelectionMode, value);
                 }
                 else {
                     return this._moveUpByModelLines(viewModel, cursors, inSelectionMode, value);
                 }
             }
-            case CursorMove.Direction.Down: {
-                if (unit === CursorMove.Unit.WrappedLine) {
+            case 3 : {
+                if (unit === 2 ) {
                     return this._moveDownByViewLines(viewModel, cursors, inSelectionMode, value);
                 }
                 else {
                     return this._moveDownByModelLines(viewModel, cursors, inSelectionMode, value);
                 }
             }
-            case CursorMove.Direction.PrevBlankLine: {
-                if (unit === CursorMove.Unit.WrappedLine) {
+            case 4 : {
+                if (unit === 2 ) {
                     return ( cursors.map(
                         cursor => CursorState.fromViewState(MoveOperations.moveToPrevBlankLine(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode))
                     ));
@@ -238,8 +238,8 @@ class CursorMoveCommands {
                     ));
                 }
             }
-            case CursorMove.Direction.NextBlankLine: {
-                if (unit === CursorMove.Unit.WrappedLine) {
+            case 5 : {
+                if (unit === 2 ) {
                     return ( cursors.map(
                         cursor => CursorState.fromViewState(MoveOperations.moveToNextBlankLine(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode))
                     ));
@@ -250,19 +250,19 @@ class CursorMoveCommands {
                     ));
                 }
             }
-            case CursorMove.Direction.WrappedLineStart: {
+            case 6 : {
                 return this._moveToViewMinColumn(viewModel, cursors, inSelectionMode);
             }
-            case CursorMove.Direction.WrappedLineFirstNonWhitespaceCharacter: {
+            case 7 : {
                 return this._moveToViewFirstNonWhitespaceColumn(viewModel, cursors, inSelectionMode);
             }
-            case CursorMove.Direction.WrappedLineColumnCenter: {
+            case 8 : {
                 return this._moveToViewCenterColumn(viewModel, cursors, inSelectionMode);
             }
-            case CursorMove.Direction.WrappedLineEnd: {
+            case 9 : {
                 return this._moveToViewMaxColumn(viewModel, cursors, inSelectionMode);
             }
-            case CursorMove.Direction.WrappedLineLastNonWhitespaceCharacter: {
+            case 10 : {
                 return this._moveToViewLastNonWhitespaceColumn(viewModel, cursors, inSelectionMode);
             }
             default:
@@ -273,22 +273,22 @@ class CursorMoveCommands {
         const visibleViewRange = viewModel.getCompletelyVisibleViewRange();
         const visibleModelRange = viewModel.coordinatesConverter.convertViewRangeToModelRange(visibleViewRange);
         switch (direction) {
-            case CursorMove.Direction.ViewPortTop: {
+            case 11 : {
                 const modelLineNumber = this._firstLineNumberInRange(viewModel.model, visibleModelRange, value);
                 const modelColumn = viewModel.model.getLineFirstNonWhitespaceColumn(modelLineNumber);
                 return [this._moveToModelPosition(viewModel, cursors[0], inSelectionMode, modelLineNumber, modelColumn)];
             }
-            case CursorMove.Direction.ViewPortBottom: {
+            case 13 : {
                 const modelLineNumber = this._lastLineNumberInRange(viewModel.model, visibleModelRange, value);
                 const modelColumn = viewModel.model.getLineFirstNonWhitespaceColumn(modelLineNumber);
                 return [this._moveToModelPosition(viewModel, cursors[0], inSelectionMode, modelLineNumber, modelColumn)];
             }
-            case CursorMove.Direction.ViewPortCenter: {
+            case 12 : {
                 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 CursorMove.Direction.ViewPortIfOutside: {
+            case 14 : {
                 const result = [];
                 for (let i = 0, len = cursors.length; i < len; i++) {
                     const cursor = cursors[i];
@@ -550,66 +550,66 @@ var CursorMove;
         let direction;
         switch (args.to) {
             case CursorMove.RawDirection.Left:
-                direction = Direction.Left;
+                direction = 0 ;
                 break;
             case CursorMove.RawDirection.Right:
-                direction = Direction.Right;
+                direction = 1 ;
                 break;
             case CursorMove.RawDirection.Up:
-                direction = Direction.Up;
+                direction = 2 ;
                 break;
             case CursorMove.RawDirection.Down:
-                direction = Direction.Down;
+                direction = 3 ;
                 break;
             case CursorMove.RawDirection.PrevBlankLine:
-                direction = Direction.PrevBlankLine;
+                direction = 4 ;
                 break;
             case CursorMove.RawDirection.NextBlankLine:
-                direction = Direction.NextBlankLine;
+                direction = 5 ;
                 break;
             case CursorMove.RawDirection.WrappedLineStart:
-                direction = Direction.WrappedLineStart;
+                direction = 6 ;
                 break;
             case CursorMove.RawDirection.WrappedLineFirstNonWhitespaceCharacter:
-                direction = Direction.WrappedLineFirstNonWhitespaceCharacter;
+                direction = 7 ;
                 break;
             case CursorMove.RawDirection.WrappedLineColumnCenter:
-                direction = Direction.WrappedLineColumnCenter;
+                direction = 8 ;
                 break;
             case CursorMove.RawDirection.WrappedLineEnd:
-                direction = Direction.WrappedLineEnd;
+                direction = 9 ;
                 break;
             case CursorMove.RawDirection.WrappedLineLastNonWhitespaceCharacter:
-                direction = Direction.WrappedLineLastNonWhitespaceCharacter;
+                direction = 10 ;
                 break;
             case CursorMove.RawDirection.ViewPortTop:
-                direction = Direction.ViewPortTop;
+                direction = 11 ;
                 break;
             case CursorMove.RawDirection.ViewPortBottom:
-                direction = Direction.ViewPortBottom;
+                direction = 13 ;
                 break;
             case CursorMove.RawDirection.ViewPortCenter:
-                direction = Direction.ViewPortCenter;
+                direction = 12 ;
                 break;
             case CursorMove.RawDirection.ViewPortIfOutside:
-                direction = Direction.ViewPortIfOutside;
+                direction = 14 ;
                 break;
             default:
                 return null;
         }
-        let unit = Unit.None;
+        let unit = 0 ;
         switch (args.by) {
             case CursorMove.RawUnit.Line:
-                unit = Unit.Line;
+                unit = 1 ;
                 break;
             case CursorMove.RawUnit.WrappedLine:
-                unit = Unit.WrappedLine;
+                unit = 2 ;
                 break;
             case CursorMove.RawUnit.Character:
-                unit = Unit.Character;
+                unit = 3 ;
                 break;
             case CursorMove.RawUnit.HalfLine:
-                unit = Unit.HalfLine;
+                unit = 4 ;
                 break;
         }
         return {
@@ -620,7 +620,6 @@ var CursorMove;
         };
     }
     CursorMove.parse = parse;
-    let Direction;
     ( (function(Direction) {
         Direction[Direction["Left"] = 0] = "Left";
         Direction[Direction["Right"] = 1] = "Right";
@@ -637,14 +636,13 @@ var CursorMove;
         Direction[Direction["ViewPortCenter"] = 12] = "ViewPortCenter";
         Direction[Direction["ViewPortBottom"] = 13] = "ViewPortBottom";
         Direction[Direction["ViewPortIfOutside"] = 14] = "ViewPortIfOutside";
-    })(Direction = CursorMove.Direction || (CursorMove.Direction = {})));
-    let Unit;
+    })(CursorMove.Direction || (CursorMove.Direction = {})));
     ( (function(Unit) {
         Unit[Unit["None"] = 0] = "None";
         Unit[Unit["Line"] = 1] = "Line";
         Unit[Unit["WrappedLine"] = 2] = "WrappedLine";
         Unit[Unit["Character"] = 3] = "Character";
         Unit[Unit["HalfLine"] = 4] = "HalfLine";
-    })(Unit = CursorMove.Unit || (CursorMove.Unit = {})));
+    })(CursorMove.Unit || (CursorMove.Unit = {})));
 })(CursorMove || (CursorMove = {})));
 export { CursorMove, CursorMoveCommands };