@codingame/monaco-vscode-api 25.1.1 → 26.0.0

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

@@ -35,8 +35,8 @@ class CoreEditorCommand extends EditorCommand {
     }
 }
 var EditorScroll_;
-(function (EditorScroll_) {
-    const isEditorScrollArgs = function (arg) {
+(function(EditorScroll_) {
+    const isEditorScrollArgs = function(arg) {
         if (!isObject(arg)) {
             return false;
         }
@@ -56,101 +56,99 @@ var EditorScroll_;
         return true;
     };
     EditorScroll_.metadata = {
-        description: 'Scroll editor in the given direction',
-        args: [
-            {
-                name: 'Editor scroll argument object',
-                description: `Property-value pairs that can be passed through this argument:
-					* 'to': A mandatory direction value.
-						\`\`\`
-						'up', 'down'
-						\`\`\`
-					* 'by': Unit to move. Default is computed based on 'to' value.
-						\`\`\`
-						'line', 'wrappedLine', 'page', 'halfPage', 'editor'
-						\`\`\`
-					* 'value': Number of units to move. Default is '1'.
-					* 'revealCursor': If 'true' reveals the cursor if it is outside view port.
-				`,
-                constraint: isEditorScrollArgs,
-                schema: {
-                    'type': 'object',
-                    'required': ['to'],
-                    'properties': {
-                        'to': {
-                            'type': 'string',
-                            'enum': ['up', 'down']
-                        },
-                        'by': {
-                            'type': 'string',
-                            'enum': ['line', 'wrappedLine', 'page', 'halfPage', 'editor']
-                        },
-                        'value': {
-                            'type': 'number',
-                            'default': 1
-                        },
-                        'revealCursor': {
-                            'type': 'boolean',
-                        }
+        description: "Scroll editor in the given direction",
+        args: [{
+            name: "Editor scroll argument object",
+            description: `Property-value pairs that can be passed through this argument:
+                    * 'to': A mandatory direction value.
+                        \`\`\`
+                        'up', 'down'
+                        \`\`\`
+                    * 'by': Unit to move. Default is computed based on 'to' value.
+                        \`\`\`
+                        'line', 'wrappedLine', 'page', 'halfPage', 'editor'
+                        \`\`\`
+                    * 'value': Number of units to move. Default is '1'.
+                    * 'revealCursor': If 'true' reveals the cursor if it is outside view port.
+                `,
+            constraint: isEditorScrollArgs,
+            schema: {
+                "type": "object",
+                "required": ["to"],
+                "properties": {
+                    "to": {
+                        "type": "string",
+                        "enum": ["up", "down"]
+                    },
+                    "by": {
+                        "type": "string",
+                        "enum": ["line", "wrappedLine", "page", "halfPage", "editor"]
+                    },
+                    "value": {
+                        "type": "number",
+                        "default": 1
+                    },
+                    "revealCursor": {
+                        "type": "boolean"
                     }
                 }
             }
-        ]
+        }]
     };
     EditorScroll_.RawDirection = {
-        Up: 'up',
-        Right: 'right',
-        Down: 'down',
-        Left: 'left'
+        Up: "up",
+        Right: "right",
+        Down: "down",
+        Left: "left"
     };
     EditorScroll_.RawUnit = {
-        Line: 'line',
-        WrappedLine: 'wrappedLine',
-        Page: 'page',
-        HalfPage: 'halfPage',
-        Editor: 'editor',
-        Column: 'column'
+        Line: "line",
+        WrappedLine: "wrappedLine",
+        Page: "page",
+        HalfPage: "halfPage",
+        Editor: "editor",
+        Column: "column"
     };
     function parse(args) {
         let direction;
         switch (args.to) {
-            case EditorScroll_.RawDirection.Up:
-                direction = Direction.Up;
-                break;
-            case EditorScroll_.RawDirection.Right:
-                direction = Direction.Right;
-                break;
-            case EditorScroll_.RawDirection.Down:
-                direction = Direction.Down;
-                break;
-            case EditorScroll_.RawDirection.Left:
-                direction = Direction.Left;
-                break;
-            default:
-                return null;
+        case EditorScroll_.RawDirection.Up:
+            direction = Direction.Up;
+            break;
+        case EditorScroll_.RawDirection.Right:
+            direction = Direction.Right;
+            break;
+        case EditorScroll_.RawDirection.Down:
+            direction = Direction.Down;
+            break;
+        case EditorScroll_.RawDirection.Left:
+            direction = Direction.Left;
+            break;
+        default:
+            return null;
         }
         let unit;
         switch (args.by) {
-            case EditorScroll_.RawUnit.Line:
-                unit = Unit.Line;
-                break;
-            case EditorScroll_.RawUnit.WrappedLine:
-                unit = Unit.WrappedLine;
-                break;
-            case EditorScroll_.RawUnit.Page:
-                unit = Unit.Page;
-                break;
-            case EditorScroll_.RawUnit.HalfPage:
-                unit = Unit.HalfPage;
-                break;
-            case EditorScroll_.RawUnit.Editor:
-                unit = Unit.Editor;
-                break;
-            case EditorScroll_.RawUnit.Column:
-                unit = Unit.Column;
-                break;
-            default:
-                unit = Unit.WrappedLine;
+        case EditorScroll_.RawUnit.Line:
+            unit = Unit.Line;
+            break;
+        case EditorScroll_.RawUnit.WrappedLine:
+            unit = Unit.WrappedLine;
+            break;
+        case EditorScroll_.RawUnit.Page:
+            unit = Unit.Page;
+            break;
+        case EditorScroll_.RawUnit.HalfPage:
+            unit = Unit.HalfPage;
+            break;
+        case EditorScroll_.RawUnit.Editor:
+            unit = Unit.Editor;
+            break;
+        case EditorScroll_.RawUnit.Column:
+            unit = Unit.Column;
+            break;
+        default:
+            unit = Unit.WrappedLine;
         }
         const value = Math.floor(args.value || 1);
         const revealCursor = !!args.revealCursor;
@@ -164,14 +162,14 @@ var EditorScroll_;
     }
     EditorScroll_.parse = parse;
     let Direction;
-    (function (Direction) {
+    (function(Direction) {
         Direction[Direction["Up"] = 1] = "Up";
         Direction[Direction["Right"] = 2] = "Right";
         Direction[Direction["Down"] = 3] = "Down";
         Direction[Direction["Left"] = 4] = "Left";
     })(Direction = EditorScroll_.Direction || (EditorScroll_.Direction = {}));
     let Unit;
-    (function (Unit) {
+    (function(Unit) {
         Unit[Unit["Line"] = 1] = "Line";
         Unit[Unit["WrappedLine"] = 2] = "WrappedLine";
         Unit[Unit["Page"] = 3] = "Page";
@@ -181,8 +179,8 @@ var EditorScroll_;
     })(Unit = EditorScroll_.Unit || (EditorScroll_.Unit = {}));
 })(EditorScroll_ || (EditorScroll_ = {}));
 var RevealLine_;
-(function (RevealLine_) {
-    const isRevealLineArgs = function (arg) {
+(function(RevealLine_) {
+    const isRevealLineArgs = function(arg) {
         if (!isObject(arg)) {
             return false;
         }
@@ -196,50 +194,48 @@ var RevealLine_;
         return true;
     };
     RevealLine_.metadata = {
-        description: 'Reveal the given line at the given logical position',
-        args: [
-            {
-                name: 'Reveal line argument object',
-                description: `Property-value pairs that can be passed through this argument:
-					* 'lineNumber': A mandatory line number value.
-					* 'at': Logical position at which line has to be revealed.
-						\`\`\`
-						'top', 'center', 'bottom'
-						\`\`\`
-				`,
-                constraint: isRevealLineArgs,
-                schema: {
-                    'type': 'object',
-                    'required': ['lineNumber'],
-                    'properties': {
-                        'lineNumber': {
-                            'type': ['number', 'string'],
-                        },
-                        'at': {
-                            'type': 'string',
-                            'enum': ['top', 'center', 'bottom']
-                        }
+        description: "Reveal the given line at the given logical position",
+        args: [{
+            name: "Reveal line argument object",
+            description: `Property-value pairs that can be passed through this argument:
+                    * 'lineNumber': A mandatory line number value.
+                    * 'at': Logical position at which line has to be revealed.
+                        \`\`\`
+                        'top', 'center', 'bottom'
+                        \`\`\`
+                `,
+            constraint: isRevealLineArgs,
+            schema: {
+                "type": "object",
+                "required": ["lineNumber"],
+                "properties": {
+                    "lineNumber": {
+                        "type": ["number", "string"]
+                    },
+                    "at": {
+                        "type": "string",
+                        "enum": ["top", "center", "bottom"]
                     }
                 }
             }
-        ]
+        }]
     };
     RevealLine_.RawAtArgument = {
-        Top: 'top',
-        Center: 'center',
-        Bottom: 'bottom'
+        Top: "top",
+        Center: "center",
+        Bottom: "bottom"
     };
 })(RevealLine_ || (RevealLine_ = {}));
 class EditorOrNativeTextInputCommand {
     constructor(target) {
-        target.addImplementation(10000, 'code-editor', (accessor, args) => {
+        target.addImplementation(10000, "code-editor", (accessor, args) => {
             const focusedEditor = accessor.get(ICodeEditorService).getFocusedCodeEditor();
             if (focusedEditor && focusedEditor.hasTextFocus()) {
                 return this._runEditorCommand(accessor, focusedEditor, args);
             }
             return false;
         });
-        target.addImplementation(1000, 'generic-dom-input-textarea', (accessor, args) => {
+        target.addImplementation(1000, "generic-dom-input-textarea", (accessor, args) => {
             const activeElement = getActiveElement();
             if (activeElement && isEditableElement(activeElement)) {
                 this.runDOMCommand(activeElement);
@@ -247,7 +243,7 @@ class EditorOrNativeTextInputCommand {
             }
             return false;
         });
-        target.addImplementation(0, 'generic-dom', (accessor, args) => {
+        target.addImplementation(0, "generic-dom", (accessor, args) => {
             const activeEditor = accessor.get(ICodeEditorService).getActiveCodeEditor();
             if (activeEditor) {
                 activeEditor.focus();
@@ -265,13 +261,13 @@ class EditorOrNativeTextInputCommand {
     }
 }
 var NavigationCommandRevealType;
-(function (NavigationCommandRevealType) {
+(function(NavigationCommandRevealType) {
     NavigationCommandRevealType[NavigationCommandRevealType["Regular"] = 0] = "Regular";
     NavigationCommandRevealType[NavigationCommandRevealType["Minimal"] = 1] = "Minimal";
     NavigationCommandRevealType[NavigationCommandRevealType["None"] = 2] = "None";
 })(NavigationCommandRevealType || (NavigationCommandRevealType = {}));
 var CoreNavigationCommands;
-(function (CoreNavigationCommands) {
+(function(CoreNavigationCommands) {
     class BaseMoveToCommand extends CoreEditorCommand {
         constructor(opts) {
             super(opts);
@@ -282,32 +278,41 @@ var CoreNavigationCommands;
                 return;
             }
             viewModel.model.pushStackElement();
-            const cursorStateChanged = viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, [
-                CursorMoveCommands.moveTo(viewModel, viewModel.getPrimaryCursorState(), this._inSelectionMode, args.position, args.viewPosition)
-            ]);
+            const cursorStateChanged = viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, [CursorMoveCommands.moveTo(
+                viewModel,
+                viewModel.getPrimaryCursorState(),
+                this._inSelectionMode,
+                args.position,
+                args.viewPosition
+            )]);
             if (cursorStateChanged && args.revealType !== NavigationCommandRevealType.None) {
                 viewModel.revealAllCursors(args.source, true, true);
             }
         }
     }
     CoreNavigationCommands.MoveTo = registerEditorCommand(( new BaseMoveToCommand({
-        id: '_moveTo',
+        id: "_moveTo",
         inSelectionMode: false,
         precondition: undefined
     })));
     CoreNavigationCommands.MoveToSelect = registerEditorCommand(( new BaseMoveToCommand({
-        id: '_moveToSelect',
+        id: "_moveToSelect",
         inSelectionMode: true,
         precondition: undefined
     })));
     class ColumnSelectCommand extends CoreEditorCommand {
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            const result = this._getColumnSelectResult(viewModel, viewModel.getPrimaryCursorState(), viewModel.getCursorColumnSelectData(), args);
+            const result = this._getColumnSelectResult(
+                viewModel,
+                viewModel.getPrimaryCursorState(),
+                viewModel.getCursorColumnSelectData(),
+                args
+            );
             if (result === null) {
                 return;
             }
-            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, ( result.viewStates.map((viewState) => CursorState.fromViewState(viewState))));
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, ( result.viewStates.map(viewState => CursorState.fromViewState(viewState))));
             viewModel.setCursorColumnSelectData({
                 isReal: true,
                 fromViewLineNumber: result.fromLineNumber,
@@ -317,8 +322,7 @@ var CoreNavigationCommands;
             });
             if (result.reversed) {
                 viewModel.revealTopMostCursor(args.source);
-            }
-            else {
+            } else {
                 viewModel.revealBottomMostCursor(args.source);
             }
         }
@@ -326,55 +330,66 @@ var CoreNavigationCommands;
     CoreNavigationCommands.ColumnSelect = registerEditorCommand(new (class extends ColumnSelectCommand {
         constructor() {
             super({
-                id: 'columnSelect',
+                id: "columnSelect",
                 precondition: undefined
             });
         }
         _getColumnSelectResult(viewModel, primary, prevColumnSelectData, args) {
-            if (typeof args.position === 'undefined' || typeof args.viewPosition === 'undefined' || typeof args.mouseColumn === 'undefined') {
+            if (typeof args.position === "undefined" || typeof args.viewPosition === "undefined" || typeof args.mouseColumn === "undefined") {
                 return null;
             }
             const validatedPosition = viewModel.model.validatePosition(args.position);
             const validatedViewPosition = viewModel.coordinatesConverter.validateViewPosition(( new Position(args.viewPosition.lineNumber, args.viewPosition.column)), validatedPosition);
             const fromViewLineNumber = args.doColumnSelect ? prevColumnSelectData.fromViewLineNumber : validatedViewPosition.lineNumber;
             const fromViewVisualColumn = args.doColumnSelect ? prevColumnSelectData.fromViewVisualColumn : args.mouseColumn - 1;
-            return ColumnSelection.columnSelect(viewModel.cursorConfig, viewModel, fromViewLineNumber, fromViewVisualColumn, validatedViewPosition.lineNumber, args.mouseColumn - 1);
-        }
-    }));
+            return ColumnSelection.columnSelect(
+                viewModel.cursorConfig,
+                viewModel,
+                fromViewLineNumber,
+                fromViewVisualColumn,
+                validatedViewPosition.lineNumber,
+                args.mouseColumn - 1
+            );
+        }
+    })());
     CoreNavigationCommands.CursorColumnSelectLeft = registerEditorCommand(new (class extends ColumnSelectCommand {
         constructor() {
             super({
-                id: 'cursorColumnSelectLeft',
+                id: "cursorColumnSelectLeft",
                 precondition: undefined,
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
                     primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyMod$1.Alt | KeyCode.LeftArrow,
-                    linux: { primary: 0 }
+                    linux: {
+                        primary: 0
+                    }
                 }
             });
         }
         _getColumnSelectResult(viewModel, primary, prevColumnSelectData, args) {
             return ColumnSelection.columnSelectLeft(viewModel.cursorConfig, viewModel, prevColumnSelectData);
         }
-    }));
+    })());
     CoreNavigationCommands.CursorColumnSelectRight = registerEditorCommand(new (class extends ColumnSelectCommand {
         constructor() {
             super({
-                id: 'cursorColumnSelectRight',
+                id: "cursorColumnSelectRight",
                 precondition: undefined,
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
                     primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyMod$1.Alt | KeyCode.RightArrow,
-                    linux: { primary: 0 }
+                    linux: {
+                        primary: 0
+                    }
                 }
             });
         }
         _getColumnSelectResult(viewModel, primary, prevColumnSelectData, args) {
             return ColumnSelection.columnSelectRight(viewModel.cursorConfig, viewModel, prevColumnSelectData);
         }
-    }));
+    })());
     class ColumnSelectUpCommand extends ColumnSelectCommand {
         constructor(opts) {
             super(opts);
@@ -386,24 +401,28 @@ var CoreNavigationCommands;
     }
     CoreNavigationCommands.CursorColumnSelectUp = registerEditorCommand(( new ColumnSelectUpCommand({
         isPaged: false,
-        id: 'cursorColumnSelectUp',
+        id: "cursorColumnSelectUp",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyMod$1.Alt | KeyCode.UpArrow,
-            linux: { primary: 0 }
+            linux: {
+                primary: 0
+            }
         }
     })));
     CoreNavigationCommands.CursorColumnSelectPageUp = registerEditorCommand(( new ColumnSelectUpCommand({
         isPaged: true,
-        id: 'cursorColumnSelectPageUp',
+        id: "cursorColumnSelectPageUp",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyMod$1.Alt | KeyCode.PageUp,
-            linux: { primary: 0 }
+            linux: {
+                primary: 0
+            }
         }
     })));
     class ColumnSelectDownCommand extends ColumnSelectCommand {
@@ -417,30 +436,34 @@ var CoreNavigationCommands;
     }
     CoreNavigationCommands.CursorColumnSelectDown = registerEditorCommand(( new ColumnSelectDownCommand({
         isPaged: false,
-        id: 'cursorColumnSelectDown',
+        id: "cursorColumnSelectDown",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyMod$1.Alt | KeyCode.DownArrow,
-            linux: { primary: 0 }
+            linux: {
+                primary: 0
+            }
         }
     })));
     CoreNavigationCommands.CursorColumnSelectPageDown = registerEditorCommand(( new ColumnSelectDownCommand({
         isPaged: true,
-        id: 'cursorColumnSelectPageDown',
+        id: "cursorColumnSelectPageDown",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyMod$1.Alt | KeyCode.PageDown,
-            linux: { primary: 0 }
+            linux: {
+                primary: 0
+            }
         }
     })));
     class CursorMoveImpl extends CoreEditorCommand {
         constructor() {
             super({
-                id: 'cursorMove',
+                id: "cursorMove",
                 precondition: undefined,
                 metadata: CursorMove.metadata
             });
@@ -455,39 +478,43 @@ var CoreNavigationCommands;
         _runCursorMove(viewModel, source, args) {
             const effectiveSource = args.noHistory ? TextEditorSelectionSource.PROGRAMMATIC : source;
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(effectiveSource, CursorChangeReason.Explicit, CursorMoveImpl._move(viewModel, viewModel.getCursorStates(), args));
+            viewModel.setCursorStates(
+                effectiveSource,
+                CursorChangeReason.Explicit,
+                CursorMoveImpl._move(viewModel, viewModel.getCursorStates(), args)
+            );
             viewModel.revealAllCursors(effectiveSource, true);
         }
         static _move(viewModel, cursors, args) {
             const inSelectionMode = args.select;
             const value = args.value;
             switch (args.direction) {
-                case CursorMove.Direction.Left:
-                case CursorMove.Direction.Right:
-                case CursorMove.Direction.Up:
-                case CursorMove.Direction.Down:
-                case CursorMove.Direction.PrevBlankLine:
-                case CursorMove.Direction.NextBlankLine:
-                case CursorMove.Direction.WrappedLineStart:
-                case CursorMove.Direction.WrappedLineFirstNonWhitespaceCharacter:
-                case CursorMove.Direction.WrappedLineColumnCenter:
-                case CursorMove.Direction.WrappedLineEnd:
-                case CursorMove.Direction.WrappedLineLastNonWhitespaceCharacter:
-                    return CursorMoveCommands.simpleMove(viewModel, cursors, args.direction, inSelectionMode, value, args.unit);
-                case CursorMove.Direction.ViewPortTop:
-                case CursorMove.Direction.ViewPortBottom:
-                case CursorMove.Direction.ViewPortCenter:
-                case CursorMove.Direction.ViewPortIfOutside:
-                    return CursorMoveCommands.viewportMove(viewModel, cursors, args.direction, inSelectionMode, value);
-                default:
-                    return null;
+            case CursorMove.Direction.Left:
+            case CursorMove.Direction.Right:
+            case CursorMove.Direction.Up:
+            case CursorMove.Direction.Down:
+            case CursorMove.Direction.PrevBlankLine:
+            case CursorMove.Direction.NextBlankLine:
+            case CursorMove.Direction.WrappedLineStart:
+            case CursorMove.Direction.WrappedLineFirstNonWhitespaceCharacter:
+            case CursorMove.Direction.WrappedLineColumnCenter:
+            case CursorMove.Direction.WrappedLineEnd:
+            case CursorMove.Direction.WrappedLineLastNonWhitespaceCharacter:
+                return CursorMoveCommands.simpleMove(viewModel, cursors, args.direction, inSelectionMode, value, args.unit);
+            case CursorMove.Direction.ViewPortTop:
+            case CursorMove.Direction.ViewPortBottom:
+            case CursorMove.Direction.ViewPortCenter:
+            case CursorMove.Direction.ViewPortIfOutside:
+                return CursorMoveCommands.viewportMove(viewModel, cursors, args.direction, inSelectionMode, value);
+            default:
+                return null;
             }
         }
     }
     CoreNavigationCommands.CursorMoveImpl = CursorMoveImpl;
     CoreNavigationCommands.CursorMove = registerEditorCommand(( new CursorMoveImpl()));
     let Constants;
-    (function (Constants) {
+    (function(Constants) {
         Constants[Constants["PAGE_SIZE_MARKER"] = -1] = "PAGE_SIZE_MARKER";
     })(Constants || (Constants = {}));
     class CursorMoveBasedCommand extends CoreEditorCommand {
@@ -506,7 +533,18 @@ var CoreNavigationCommands;
                 };
             }
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(dynamicArgs.source, CursorChangeReason.Explicit, CursorMoveCommands.simpleMove(viewModel, viewModel.getCursorStates(), args.direction, args.select, args.value, args.unit));
+            viewModel.setCursorStates(
+                dynamicArgs.source,
+                CursorChangeReason.Explicit,
+                CursorMoveCommands.simpleMove(
+                    viewModel,
+                    viewModel.getCursorStates(),
+                    args.direction,
+                    args.select,
+                    args.value,
+                    args.unit
+                )
+            );
             viewModel.revealAllCursors(dynamicArgs.source, true);
         }
     }
@@ -517,13 +555,16 @@ var CoreNavigationCommands;
             select: false,
             value: 1
         },
-        id: 'cursorLeft',
+        id: "cursorLeft",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyCode.LeftArrow,
-            mac: { primary: KeyCode.LeftArrow, secondary: [KeyMod$1.WinCtrl | KeyCode.KeyB] }
+            mac: {
+                primary: KeyCode.LeftArrow,
+                secondary: [KeyMod$1.WinCtrl | KeyCode.KeyB]
+            }
         }
     })));
     CoreNavigationCommands.CursorLeftSelect = registerEditorCommand(( new CursorMoveBasedCommand({
@@ -533,7 +574,7 @@ var CoreNavigationCommands;
             select: true,
             value: 1
         },
-        id: 'cursorLeftSelect',
+        id: "cursorLeftSelect",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
@@ -548,13 +589,16 @@ var CoreNavigationCommands;
             select: false,
             value: 1
         },
-        id: 'cursorRight',
+        id: "cursorRight",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyCode.RightArrow,
-            mac: { primary: KeyCode.RightArrow, secondary: [KeyMod$1.WinCtrl | KeyCode.KeyF] }
+            mac: {
+                primary: KeyCode.RightArrow,
+                secondary: [KeyMod$1.WinCtrl | KeyCode.KeyF]
+            }
         }
     })));
     CoreNavigationCommands.CursorRightSelect = registerEditorCommand(( new CursorMoveBasedCommand({
@@ -564,7 +608,7 @@ var CoreNavigationCommands;
             select: true,
             value: 1
         },
-        id: 'cursorRightSelect',
+        id: "cursorRightSelect",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
@@ -579,13 +623,16 @@ var CoreNavigationCommands;
             select: false,
             value: 1
         },
-        id: 'cursorUp',
+        id: "cursorUp",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyCode.UpArrow,
-            mac: { primary: KeyCode.UpArrow, secondary: [KeyMod$1.WinCtrl | KeyCode.KeyP] }
+            mac: {
+                primary: KeyCode.UpArrow,
+                secondary: [KeyMod$1.WinCtrl | KeyCode.KeyP]
+            }
         }
     })));
     CoreNavigationCommands.CursorUpSelect = registerEditorCommand(( new CursorMoveBasedCommand({
@@ -595,15 +642,19 @@ var CoreNavigationCommands;
             select: true,
             value: 1
         },
-        id: 'cursorUpSelect',
+        id: "cursorUpSelect",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyMod$1.Shift | KeyCode.UpArrow,
             secondary: [KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.UpArrow],
-            mac: { primary: KeyMod$1.Shift | KeyCode.UpArrow },
-            linux: { primary: KeyMod$1.Shift | KeyCode.UpArrow }
+            mac: {
+                primary: KeyMod$1.Shift | KeyCode.UpArrow
+            },
+            linux: {
+                primary: KeyMod$1.Shift | KeyCode.UpArrow
+            }
         }
     })));
     CoreNavigationCommands.CursorPageUp = registerEditorCommand(( new CursorMoveBasedCommand({
@@ -613,7 +664,7 @@ var CoreNavigationCommands;
             select: false,
             value: Constants.PAGE_SIZE_MARKER
         },
-        id: 'cursorPageUp',
+        id: "cursorPageUp",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
@@ -628,7 +679,7 @@ var CoreNavigationCommands;
             select: true,
             value: Constants.PAGE_SIZE_MARKER
         },
-        id: 'cursorPageUpSelect',
+        id: "cursorPageUpSelect",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
@@ -643,13 +694,16 @@ var CoreNavigationCommands;
             select: false,
             value: 1
         },
-        id: 'cursorDown',
+        id: "cursorDown",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyCode.DownArrow,
-            mac: { primary: KeyCode.DownArrow, secondary: [KeyMod$1.WinCtrl | KeyCode.KeyN] }
+            mac: {
+                primary: KeyCode.DownArrow,
+                secondary: [KeyMod$1.WinCtrl | KeyCode.KeyN]
+            }
         }
     })));
     CoreNavigationCommands.CursorDownSelect = registerEditorCommand(( new CursorMoveBasedCommand({
@@ -659,15 +713,19 @@ var CoreNavigationCommands;
             select: true,
             value: 1
         },
-        id: 'cursorDownSelect',
+        id: "cursorDownSelect",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyMod$1.Shift | KeyCode.DownArrow,
             secondary: [KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.DownArrow],
-            mac: { primary: KeyMod$1.Shift | KeyCode.DownArrow },
-            linux: { primary: KeyMod$1.Shift | KeyCode.DownArrow }
+            mac: {
+                primary: KeyMod$1.Shift | KeyCode.DownArrow
+            },
+            linux: {
+                primary: KeyMod$1.Shift | KeyCode.DownArrow
+            }
         }
     })));
     CoreNavigationCommands.CursorPageDown = registerEditorCommand(( new CursorMoveBasedCommand({
@@ -677,7 +735,7 @@ var CoreNavigationCommands;
             select: false,
             value: Constants.PAGE_SIZE_MARKER
         },
-        id: 'cursorPageDown',
+        id: "cursorPageDown",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
@@ -692,7 +750,7 @@ var CoreNavigationCommands;
             select: true,
             value: Constants.PAGE_SIZE_MARKER
         },
-        id: 'cursorPageDownSelect',
+        id: "cursorPageDownSelect",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
@@ -703,7 +761,7 @@ var CoreNavigationCommands;
     CoreNavigationCommands.CreateCursor = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
-                id: 'createCursor',
+                id: "createCursor",
                 precondition: undefined
             });
         }
@@ -713,10 +771,21 @@ var CoreNavigationCommands;
             }
             let newState;
             if (args.wholeLine) {
-                newState = CursorMoveCommands.line(viewModel, viewModel.getPrimaryCursorState(), false, args.position, args.viewPosition);
-            }
-            else {
-                newState = CursorMoveCommands.moveTo(viewModel, viewModel.getPrimaryCursorState(), false, args.position, args.viewPosition);
+                newState = CursorMoveCommands.line(
+                    viewModel,
+                    viewModel.getPrimaryCursorState(),
+                    false,
+                    args.position,
+                    args.viewPosition
+                );
+            } else {
+                newState = CursorMoveCommands.moveTo(
+                    viewModel,
+                    viewModel.getPrimaryCursorState(),
+                    false,
+                    args.position,
+                    args.viewPosition
+                );
             }
             const states = viewModel.getCursorStates();
             if (states.length > 1) {
@@ -740,11 +809,11 @@ var CoreNavigationCommands;
             viewModel.model.pushStackElement();
             viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, states);
         }
-    }));
+    })());
     CoreNavigationCommands.LastCursorMoveToSelect = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
-                id: '_lastCursorMoveToSelect',
+                id: "_lastCursorMoveToSelect",
                 precondition: undefined
             });
         }
@@ -755,11 +824,17 @@ var CoreNavigationCommands;
             const lastAddedCursorIndex = viewModel.getLastAddedCursorIndex();
             const states = viewModel.getCursorStates();
             const newStates = states.slice(0);
-            newStates[lastAddedCursorIndex] = CursorMoveCommands.moveTo(viewModel, states[lastAddedCursorIndex], true, args.position, args.viewPosition);
+            newStates[lastAddedCursorIndex] = CursorMoveCommands.moveTo(
+                viewModel,
+                states[lastAddedCursorIndex],
+                true,
+                args.position,
+                args.viewPosition
+            );
             viewModel.model.pushStackElement();
             viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, newStates);
         }
-    }));
+    })());
     class HomeCommand extends CoreEditorCommand {
         constructor(opts) {
             super(opts);
@@ -767,30 +842,40 @@ var CoreNavigationCommands;
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, CursorMoveCommands.moveToBeginningOfLine(viewModel, viewModel.getCursorStates(), this._inSelectionMode));
+            viewModel.setCursorStates(
+                args.source,
+                CursorChangeReason.Explicit,
+                CursorMoveCommands.moveToBeginningOfLine(viewModel, viewModel.getCursorStates(), this._inSelectionMode)
+            );
             viewModel.revealAllCursors(args.source, true);
         }
     }
     CoreNavigationCommands.CursorHome = registerEditorCommand(( new HomeCommand({
         inSelectionMode: false,
-        id: 'cursorHome',
+        id: "cursorHome",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyCode.Home,
-            mac: { primary: KeyCode.Home, secondary: [KeyMod$1.CtrlCmd | KeyCode.LeftArrow] }
+            mac: {
+                primary: KeyCode.Home,
+                secondary: [KeyMod$1.CtrlCmd | KeyCode.LeftArrow]
+            }
         }
     })));
     CoreNavigationCommands.CursorHomeSelect = registerEditorCommand(( new HomeCommand({
         inSelectionMode: true,
-        id: 'cursorHomeSelect',
+        id: "cursorHomeSelect",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyMod$1.Shift | KeyCode.Home,
-            mac: { primary: KeyMod$1.Shift | KeyCode.Home, secondary: [KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.LeftArrow] }
+            mac: {
+                primary: KeyMod$1.Shift | KeyCode.Home,
+                secondary: [KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.LeftArrow]
+            }
         }
     })));
     class LineStartCommand extends CoreEditorCommand {
@@ -800,7 +885,11 @@ var CoreNavigationCommands;
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, this._exec(viewModel.getCursorStates()));
+            viewModel.setCursorStates(
+                args.source,
+                CursorChangeReason.Explicit,
+                this._exec(viewModel.getCursorStates())
+            );
             viewModel.revealAllCursors(args.source, true);
         }
         _exec(cursors) {
@@ -815,24 +904,28 @@ var CoreNavigationCommands;
     }
     CoreNavigationCommands.CursorLineStart = registerEditorCommand(( new LineStartCommand({
         inSelectionMode: false,
-        id: 'cursorLineStart',
+        id: "cursorLineStart",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: 0,
-            mac: { primary: KeyMod$1.WinCtrl | KeyCode.KeyA }
+            mac: {
+                primary: KeyMod$1.WinCtrl | KeyCode.KeyA
+            }
         }
     })));
     CoreNavigationCommands.CursorLineStartSelect = registerEditorCommand(( new LineStartCommand({
         inSelectionMode: true,
-        id: 'cursorLineStartSelect',
+        id: "cursorLineStartSelect",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: 0,
-            mac: { primary: KeyMod$1.WinCtrl | KeyMod$1.Shift | KeyCode.KeyA }
+            mac: {
+                primary: KeyMod$1.WinCtrl | KeyMod$1.Shift | KeyCode.KeyA
+            }
         }
     })));
     class EndCommand extends CoreEditorCommand {
@@ -842,64 +935,83 @@ var CoreNavigationCommands;
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, CursorMoveCommands.moveToEndOfLine(viewModel, viewModel.getCursorStates(), this._inSelectionMode, args.sticky || false));
+            viewModel.setCursorStates(
+                args.source,
+                CursorChangeReason.Explicit,
+                CursorMoveCommands.moveToEndOfLine(
+                    viewModel,
+                    viewModel.getCursorStates(),
+                    this._inSelectionMode,
+                    args.sticky || false
+                )
+            );
             viewModel.revealAllCursors(args.source, true);
         }
     }
     CoreNavigationCommands.CursorEnd = registerEditorCommand(( new EndCommand({
         inSelectionMode: false,
-        id: 'cursorEnd',
+        id: "cursorEnd",
         precondition: undefined,
         kbOpts: {
-            args: { sticky: false },
+            args: {
+                sticky: false
+            },
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyCode.End,
-            mac: { primary: KeyCode.End, secondary: [KeyMod$1.CtrlCmd | KeyCode.RightArrow] }
+            mac: {
+                primary: KeyCode.End,
+                secondary: [KeyMod$1.CtrlCmd | KeyCode.RightArrow]
+            }
         },
         metadata: {
             description: `Go to End`,
             args: [{
-                    name: 'args',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            'sticky': {
-                                description: ( localize(138, "Stick to the end even when going to longer lines")),
-                                type: 'boolean',
-                                default: false
-                            }
+                name: "args",
+                schema: {
+                    type: "object",
+                    properties: {
+                        "sticky": {
+                            description: ( localize(141, "Stick to the end even when going to longer lines")),
+                            type: "boolean",
+                            default: false
                         }
                     }
-                }]
+                }
+            }]
         }
     })));
     CoreNavigationCommands.CursorEndSelect = registerEditorCommand(( new EndCommand({
         inSelectionMode: true,
-        id: 'cursorEndSelect',
+        id: "cursorEndSelect",
         precondition: undefined,
         kbOpts: {
-            args: { sticky: false },
+            args: {
+                sticky: false
+            },
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyMod$1.Shift | KeyCode.End,
-            mac: { primary: KeyMod$1.Shift | KeyCode.End, secondary: [KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.RightArrow] }
+            mac: {
+                primary: KeyMod$1.Shift | KeyCode.End,
+                secondary: [KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.RightArrow]
+            }
         },
         metadata: {
             description: `Select to End`,
             args: [{
-                    name: 'args',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            'sticky': {
-                                description: ( localize(138, "Stick to the end even when going to longer lines")),
-                                type: 'boolean',
-                                default: false
-                            }
+                name: "args",
+                schema: {
+                    type: "object",
+                    properties: {
+                        "sticky": {
+                            description: ( localize(141, "Stick to the end even when going to longer lines")),
+                            type: "boolean",
+                            default: false
                         }
                     }
-                }]
+                }
+            }]
         }
     })));
     class LineEndCommand extends CoreEditorCommand {
@@ -909,7 +1021,11 @@ var CoreNavigationCommands;
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, this._exec(viewModel, viewModel.getCursorStates()));
+            viewModel.setCursorStates(
+                args.source,
+                CursorChangeReason.Explicit,
+                this._exec(viewModel, viewModel.getCursorStates())
+            );
             viewModel.revealAllCursors(args.source, true);
         }
         _exec(viewModel, cursors) {
@@ -925,24 +1041,28 @@ var CoreNavigationCommands;
     }
     CoreNavigationCommands.CursorLineEnd = registerEditorCommand(( new LineEndCommand({
         inSelectionMode: false,
-        id: 'cursorLineEnd',
+        id: "cursorLineEnd",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: 0,
-            mac: { primary: KeyMod$1.WinCtrl | KeyCode.KeyE }
+            mac: {
+                primary: KeyMod$1.WinCtrl | KeyCode.KeyE
+            }
         }
     })));
     CoreNavigationCommands.CursorLineEndSelect = registerEditorCommand(( new LineEndCommand({
         inSelectionMode: true,
-        id: 'cursorLineEndSelect',
+        id: "cursorLineEndSelect",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: 0,
-            mac: { primary: KeyMod$1.WinCtrl | KeyMod$1.Shift | KeyCode.KeyE }
+            mac: {
+                primary: KeyMod$1.WinCtrl | KeyMod$1.Shift | KeyCode.KeyE
+            }
         }
     })));
     class TopCommand extends CoreEditorCommand {
@@ -952,30 +1072,38 @@ var CoreNavigationCommands;
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, CursorMoveCommands.moveToBeginningOfBuffer(viewModel, viewModel.getCursorStates(), this._inSelectionMode));
+            viewModel.setCursorStates(
+                args.source,
+                CursorChangeReason.Explicit,
+                CursorMoveCommands.moveToBeginningOfBuffer(viewModel, viewModel.getCursorStates(), this._inSelectionMode)
+            );
             viewModel.revealAllCursors(args.source, true);
         }
     }
     CoreNavigationCommands.CursorTop = registerEditorCommand(( new TopCommand({
         inSelectionMode: false,
-        id: 'cursorTop',
+        id: "cursorTop",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyMod$1.CtrlCmd | KeyCode.Home,
-            mac: { primary: KeyMod$1.CtrlCmd | KeyCode.UpArrow }
+            mac: {
+                primary: KeyMod$1.CtrlCmd | KeyCode.UpArrow
+            }
         }
     })));
     CoreNavigationCommands.CursorTopSelect = registerEditorCommand(( new TopCommand({
         inSelectionMode: true,
-        id: 'cursorTopSelect',
+        id: "cursorTopSelect",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Home,
-            mac: { primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.UpArrow }
+            mac: {
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.UpArrow
+            }
         }
     })));
     class BottomCommand extends CoreEditorCommand {
@@ -985,36 +1113,44 @@ var CoreNavigationCommands;
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, CursorMoveCommands.moveToEndOfBuffer(viewModel, viewModel.getCursorStates(), this._inSelectionMode));
+            viewModel.setCursorStates(
+                args.source,
+                CursorChangeReason.Explicit,
+                CursorMoveCommands.moveToEndOfBuffer(viewModel, viewModel.getCursorStates(), this._inSelectionMode)
+            );
             viewModel.revealAllCursors(args.source, true);
         }
     }
     CoreNavigationCommands.CursorBottom = registerEditorCommand(( new BottomCommand({
         inSelectionMode: false,
-        id: 'cursorBottom',
+        id: "cursorBottom",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyMod$1.CtrlCmd | KeyCode.End,
-            mac: { primary: KeyMod$1.CtrlCmd | KeyCode.DownArrow }
+            mac: {
+                primary: KeyMod$1.CtrlCmd | KeyCode.DownArrow
+            }
         }
     })));
     CoreNavigationCommands.CursorBottomSelect = registerEditorCommand(( new BottomCommand({
         inSelectionMode: true,
-        id: 'cursorBottomSelect',
+        id: "cursorBottomSelect",
         precondition: undefined,
         kbOpts: {
             weight: CORE_WEIGHT,
             kbExpr: EditorContextKeys.textInputFocus,
             primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.End,
-            mac: { primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.DownArrow }
+            mac: {
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.DownArrow
+            }
         }
     })));
     class EditorScrollImpl extends CoreEditorCommand {
         constructor() {
             super({
-                id: 'editorScroll',
+                id: "editorScroll",
                 precondition: undefined,
                 metadata: EditorScroll_.metadata
             });
@@ -1058,7 +1194,9 @@ var CoreNavigationCommands;
                     CursorMoveCommands.findPositionInViewportIfOutside(viewModel, viewModel.getPrimaryCursorState(), paddedRange, args.select)
                 ]);
             }
-            viewModel.viewLayout.setScrollPosition({ scrollTop: desiredScrollTop }, ScrollType.Smooth);
+            viewModel.viewLayout.setScrollPosition({
+                scrollTop: desiredScrollTop
+            }, ScrollType.Smooth);
         }
         _computeDesiredScrollTop(viewModel, args) {
             if (args.unit === EditorScroll_.Unit.Line) {
@@ -1068,9 +1206,11 @@ var CoreNavigationCommands;
                 let desiredTopModelLineNumber;
                 if (args.direction === EditorScroll_.Direction.Up) {
                     desiredTopModelLineNumber = Math.max(1, visibleModelRange.startLineNumber - args.value);
-                }
-                else {
-                    desiredTopModelLineNumber = Math.min(viewModel.model.getLineCount(), visibleModelRange.startLineNumber + args.value);
+                } else {
+                    desiredTopModelLineNumber = Math.min(
+                        viewModel.model.getLineCount(),
+                        visibleModelRange.startLineNumber + args.value
+                    );
                 }
                 const viewPosition = viewModel.coordinatesConverter.convertModelPositionToViewPosition(( new Position(desiredTopModelLineNumber, 1)));
                 return viewModel.viewLayout.getVerticalOffsetForLineNumber(viewPosition.lineNumber);
@@ -1085,11 +1225,9 @@ var CoreNavigationCommands;
             let noOfLines;
             if (args.unit === EditorScroll_.Unit.Page) {
                 noOfLines = viewModel.cursorConfig.pageSize * args.value;
-            }
-            else if (args.unit === EditorScroll_.Unit.HalfPage) {
+            } else if (args.unit === EditorScroll_.Unit.HalfPage) {
                 noOfLines = Math.round(viewModel.cursorConfig.pageSize / 2) * args.value;
-            }
-            else {
+            } else {
                 noOfLines = args.value;
             }
             const deltaLines = (args.direction === EditorScroll_.Direction.Up ? -1 : 1) * noOfLines;
@@ -1097,7 +1235,9 @@ var CoreNavigationCommands;
         }
         _runHorizontalEditorScroll(viewModel, source, args) {
             const desiredScrollLeft = this._computeDesiredScrollLeft(viewModel, args);
-            viewModel.viewLayout.setScrollPosition({ scrollLeft: desiredScrollLeft }, ScrollType.Smooth);
+            viewModel.viewLayout.setScrollPosition({
+                scrollLeft: desiredScrollLeft
+            }, ScrollType.Smooth);
         }
         _computeDesiredScrollLeft(viewModel, args) {
             const deltaColumns = (args.direction === EditorScroll_.Direction.Left ? -1 : 1) * args.value;
@@ -1109,13 +1249,15 @@ var CoreNavigationCommands;
     CoreNavigationCommands.ScrollLineUp = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
-                id: 'scrollLineUp',
+                id: "scrollLineUp",
                 precondition: undefined,
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
                     primary: KeyMod$1.CtrlCmd | KeyCode.UpArrow,
-                    mac: { primary: KeyMod$1.WinCtrl | KeyCode.PageUp }
+                    mac: {
+                        primary: KeyMod$1.WinCtrl | KeyCode.PageUp
+                    }
                 }
             });
         }
@@ -1129,18 +1271,22 @@ var CoreNavigationCommands;
                 source: args.source
             });
         }
-    }));
+    })());
     CoreNavigationCommands.ScrollPageUp = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
-                id: 'scrollPageUp',
+                id: "scrollPageUp",
                 precondition: undefined,
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
                     primary: KeyMod$1.CtrlCmd | KeyCode.PageUp,
-                    win: { primary: KeyMod$1.Alt | KeyCode.PageUp },
-                    linux: { primary: KeyMod$1.Alt | KeyCode.PageUp }
+                    win: {
+                        primary: KeyMod$1.Alt | KeyCode.PageUp
+                    },
+                    linux: {
+                        primary: KeyMod$1.Alt | KeyCode.PageUp
+                    }
                 }
             });
         }
@@ -1154,15 +1300,15 @@ var CoreNavigationCommands;
                 source: args.source
             });
         }
-    }));
+    })());
     CoreNavigationCommands.ScrollEditorTop = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
-                id: 'scrollEditorTop',
+                id: "scrollEditorTop",
                 precondition: undefined,
                 kbOpts: {
                     weight: CORE_WEIGHT,
-                    kbExpr: EditorContextKeys.textInputFocus,
+                    kbExpr: EditorContextKeys.textInputFocus
                 }
             });
         }
@@ -1176,17 +1322,19 @@ var CoreNavigationCommands;
                 source: args.source
             });
         }
-    }));
+    })());
     CoreNavigationCommands.ScrollLineDown = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
-                id: 'scrollLineDown',
+                id: "scrollLineDown",
                 precondition: undefined,
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
                     primary: KeyMod$1.CtrlCmd | KeyCode.DownArrow,
-                    mac: { primary: KeyMod$1.WinCtrl | KeyCode.PageDown }
+                    mac: {
+                        primary: KeyMod$1.WinCtrl | KeyCode.PageDown
+                    }
                 }
             });
         }
@@ -1200,18 +1348,22 @@ var CoreNavigationCommands;
                 source: args.source
             });
         }
-    }));
+    })());
     CoreNavigationCommands.ScrollPageDown = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
-                id: 'scrollPageDown',
+                id: "scrollPageDown",
                 precondition: undefined,
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
                     primary: KeyMod$1.CtrlCmd | KeyCode.PageDown,
-                    win: { primary: KeyMod$1.Alt | KeyCode.PageDown },
-                    linux: { primary: KeyMod$1.Alt | KeyCode.PageDown }
+                    win: {
+                        primary: KeyMod$1.Alt | KeyCode.PageDown
+                    },
+                    linux: {
+                        primary: KeyMod$1.Alt | KeyCode.PageDown
+                    }
                 }
             });
         }
@@ -1225,15 +1377,15 @@ var CoreNavigationCommands;
                 source: args.source
             });
         }
-    }));
+    })());
     CoreNavigationCommands.ScrollEditorBottom = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
-                id: 'scrollEditorBottom',
+                id: "scrollEditorBottom",
                 precondition: undefined,
                 kbOpts: {
                     weight: CORE_WEIGHT,
-                    kbExpr: EditorContextKeys.textInputFocus,
+                    kbExpr: EditorContextKeys.textInputFocus
                 }
             });
         }
@@ -1247,15 +1399,15 @@ var CoreNavigationCommands;
                 source: args.source
             });
         }
-    }));
+    })());
     CoreNavigationCommands.ScrollLeft = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
-                id: 'scrollLeft',
+                id: "scrollLeft",
                 precondition: undefined,
                 kbOpts: {
                     weight: CORE_WEIGHT,
-                    kbExpr: EditorContextKeys.textInputFocus,
+                    kbExpr: EditorContextKeys.textInputFocus
                 }
             });
         }
@@ -1269,15 +1421,15 @@ var CoreNavigationCommands;
                 source: args.source
             });
         }
-    }));
+    })());
     CoreNavigationCommands.ScrollRight = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
-                id: 'scrollRight',
+                id: "scrollRight",
                 precondition: undefined,
                 kbOpts: {
                     weight: CORE_WEIGHT,
-                    kbExpr: EditorContextKeys.textInputFocus,
+                    kbExpr: EditorContextKeys.textInputFocus
                 }
             });
         }
@@ -1291,7 +1443,7 @@ var CoreNavigationCommands;
                 source: args.source
             });
         }
-    }));
+    })());
     class WordCommand extends CoreEditorCommand {
         constructor(opts) {
             super(opts);
@@ -1302,9 +1454,12 @@ var CoreNavigationCommands;
                 return;
             }
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, [
-                CursorMoveCommands.word(viewModel, viewModel.getPrimaryCursorState(), this._inSelectionMode, args.position)
-            ]);
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, [CursorMoveCommands.word(
+                viewModel,
+                viewModel.getPrimaryCursorState(),
+                this._inSelectionMode,
+                args.position
+            )]);
             if (args.revealType !== NavigationCommandRevealType.None) {
                 viewModel.revealAllCursors(args.source, true, true);
             }
@@ -1312,18 +1467,18 @@ var CoreNavigationCommands;
     }
     CoreNavigationCommands.WordSelect = registerEditorCommand(( new WordCommand({
         inSelectionMode: false,
-        id: '_wordSelect',
+        id: "_wordSelect",
         precondition: undefined
     })));
     CoreNavigationCommands.WordSelectDrag = registerEditorCommand(( new WordCommand({
         inSelectionMode: true,
-        id: '_wordSelectDrag',
+        id: "_wordSelectDrag",
         precondition: undefined
     })));
     CoreNavigationCommands.LastCursorWordSelect = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
-                id: 'lastCursorWordSelect',
+                id: "lastCursorWordSelect",
                 precondition: undefined
             });
         }
@@ -1335,11 +1490,16 @@ var CoreNavigationCommands;
             const states = viewModel.getCursorStates();
             const newStates = states.slice(0);
             const lastAddedState = states[lastAddedCursorIndex];
-            newStates[lastAddedCursorIndex] = CursorMoveCommands.word(viewModel, lastAddedState, lastAddedState.modelState.hasSelection(), args.position);
+            newStates[lastAddedCursorIndex] = CursorMoveCommands.word(
+                viewModel,
+                lastAddedState,
+                lastAddedState.modelState.hasSelection(),
+                args.position
+            );
             viewModel.model.pushStackElement();
             viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, newStates);
         }
-    }));
+    })());
     class LineCommand extends CoreEditorCommand {
         constructor(opts) {
             super(opts);
@@ -1350,9 +1510,13 @@ var CoreNavigationCommands;
                 return;
             }
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, [
-                CursorMoveCommands.line(viewModel, viewModel.getPrimaryCursorState(), this._inSelectionMode, args.position, args.viewPosition)
-            ]);
+            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, [CursorMoveCommands.line(
+                viewModel,
+                viewModel.getPrimaryCursorState(),
+                this._inSelectionMode,
+                args.position,
+                args.viewPosition
+            )]);
             if (args.revealType !== NavigationCommandRevealType.None) {
                 viewModel.revealAllCursors(args.source, false, true);
             }
@@ -1360,12 +1524,12 @@ var CoreNavigationCommands;
     }
     CoreNavigationCommands.LineSelect = registerEditorCommand(( new LineCommand({
         inSelectionMode: false,
-        id: '_lineSelect',
+        id: "_lineSelect",
         precondition: undefined
     })));
     CoreNavigationCommands.LineSelectDrag = registerEditorCommand(( new LineCommand({
         inSelectionMode: true,
-        id: '_lineSelectDrag',
+        id: "_lineSelectDrag",
         precondition: undefined
     })));
     class LastCursorLineCommand extends CoreEditorCommand {
@@ -1380,25 +1544,31 @@ var CoreNavigationCommands;
             const lastAddedCursorIndex = viewModel.getLastAddedCursorIndex();
             const states = viewModel.getCursorStates();
             const newStates = states.slice(0);
-            newStates[lastAddedCursorIndex] = CursorMoveCommands.line(viewModel, states[lastAddedCursorIndex], this._inSelectionMode, args.position, args.viewPosition);
+            newStates[lastAddedCursorIndex] = CursorMoveCommands.line(
+                viewModel,
+                states[lastAddedCursorIndex],
+                this._inSelectionMode,
+                args.position,
+                args.viewPosition
+            );
             viewModel.model.pushStackElement();
             viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, newStates);
         }
     }
     CoreNavigationCommands.LastCursorLineSelect = registerEditorCommand(( new LastCursorLineCommand({
         inSelectionMode: false,
-        id: 'lastCursorLineSelect',
+        id: "lastCursorLineSelect",
         precondition: undefined
     })));
     CoreNavigationCommands.LastCursorLineSelectDrag = registerEditorCommand(( new LastCursorLineCommand({
         inSelectionMode: true,
-        id: 'lastCursorLineSelectDrag',
+        id: "lastCursorLineSelectDrag",
         precondition: undefined
     })));
     CoreNavigationCommands.CancelSelection = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
-                id: 'cancelSelection',
+                id: "cancelSelection",
                 precondition: EditorContextKeys.hasNonEmptySelection,
                 kbOpts: {
                     weight: CORE_WEIGHT,
@@ -1415,11 +1585,11 @@ var CoreNavigationCommands;
             ]);
             viewModel.revealAllCursors(args.source, true);
         }
-    }));
+    })());
     CoreNavigationCommands.RemoveSecondaryCursors = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
-                id: 'removeSecondaryCursors',
+                id: "removeSecondaryCursors",
                 precondition: EditorContextKeys.hasMultipleSelections,
                 kbOpts: {
                     weight: CORE_WEIGHT + 1,
@@ -1431,17 +1601,19 @@ var CoreNavigationCommands;
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, [
-                viewModel.getPrimaryCursorState()
-            ]);
+            viewModel.setCursorStates(
+                args.source,
+                CursorChangeReason.Explicit,
+                [viewModel.getPrimaryCursorState()]
+            );
             viewModel.revealAllCursors(args.source, true);
-            status(( localize(139, "Removed secondary cursors")));
+            status(( localize(142, "Removed secondary cursors")));
         }
-    }));
+    })());
     CoreNavigationCommands.RevealLine = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
-                id: 'revealLine',
+                id: "revealLine",
                 precondition: undefined,
                 metadata: RevealLine_.metadata
             });
@@ -1449,7 +1621,7 @@ var CoreNavigationCommands;
         runCoreEditorCommand(viewModel, args) {
             const revealLineArg = args;
             const lineNumberArg = revealLineArg.lineNumber || 0;
-            let lineNumber = typeof lineNumberArg === 'number' ? (lineNumberArg + 1) : (parseInt(lineNumberArg) + 1);
+            let lineNumber = typeof lineNumberArg === "number" ? (lineNumberArg + 1) : (parseInt(lineNumberArg) + 1);
             if (lineNumber < 1) {
                 lineNumber = 1;
             }
@@ -1461,21 +1633,21 @@ var CoreNavigationCommands;
             let revealAt = VerticalRevealType.Simple;
             if (revealLineArg.at) {
                 switch (revealLineArg.at) {
-                    case RevealLine_.RawAtArgument.Top:
-                        revealAt = VerticalRevealType.Top;
-                        break;
-                    case RevealLine_.RawAtArgument.Center:
-                        revealAt = VerticalRevealType.Center;
-                        break;
-                    case RevealLine_.RawAtArgument.Bottom:
-                        revealAt = VerticalRevealType.Bottom;
-                        break;
+                case RevealLine_.RawAtArgument.Top:
+                    revealAt = VerticalRevealType.Top;
+                    break;
+                case RevealLine_.RawAtArgument.Center:
+                    revealAt = VerticalRevealType.Center;
+                    break;
+                case RevealLine_.RawAtArgument.Bottom:
+                    revealAt = VerticalRevealType.Bottom;
+                    break;
                 }
             }
             const viewRange = viewModel.coordinatesConverter.convertModelRangeToViewRange(range);
             viewModel.revealRange(args.source, false, viewRange, revealAt, ScrollType.Smooth);
         }
-    }));
+    })());
     CoreNavigationCommands.SelectAll = new (class extends EditorOrNativeTextInputCommand {
         constructor() {
             super(SelectAllCommand);
@@ -1485,7 +1657,7 @@ var CoreNavigationCommands;
                 activeElement.focus();
                 activeElement.select();
             }
-            activeElement.ownerDocument.execCommand('selectAll');
+            activeElement.ownerDocument.execCommand("selectAll");
         }
         runEditorCommand(accessor, editor, args) {
             const viewModel = editor._getViewModel();
@@ -1496,15 +1668,17 @@ var CoreNavigationCommands;
         }
         runCoreEditorCommand(viewModel, args) {
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates('keyboard', CursorChangeReason.Explicit, [
-                CursorMoveCommands.selectAll(viewModel, viewModel.getPrimaryCursorState())
-            ]);
+            viewModel.setCursorStates(
+                "keyboard",
+                CursorChangeReason.Explicit,
+                [CursorMoveCommands.selectAll(viewModel, viewModel.getPrimaryCursorState())]
+            );
         }
     })();
     CoreNavigationCommands.SetSelection = registerEditorCommand(new (class extends CoreEditorCommand {
         constructor() {
             super({
-                id: 'setSelection',
+                id: "setSelection",
                 precondition: undefined
             });
         }
@@ -1513,11 +1687,13 @@ var CoreNavigationCommands;
                 return;
             }
             viewModel.model.pushStackElement();
-            viewModel.setCursorStates(args.source, CursorChangeReason.Explicit, [
-                CursorState.fromModelSelection(args.selection)
-            ]);
+            viewModel.setCursorStates(
+                args.source,
+                CursorChangeReason.Explicit,
+                [CursorState.fromModelSelection(args.selection)]
+            );
         }
-    }));
+    })());
 })(CoreNavigationCommands || (CoreNavigationCommands = {}));
 const columnSelectionCondition = ( ContextKeyExpr.and(EditorContextKeys.textInputFocus, EditorContextKeys.columnSelection));
 function registerColumnSelection(id, keybinding) {
@@ -1528,18 +1704,36 @@ function registerColumnSelection(id, keybinding) {
         weight: CORE_WEIGHT + 1
     });
 }
-registerColumnSelection(CoreNavigationCommands.CursorColumnSelectLeft.id, KeyMod$1.Shift | KeyCode.LeftArrow);
-registerColumnSelection(CoreNavigationCommands.CursorColumnSelectRight.id, KeyMod$1.Shift | KeyCode.RightArrow);
-registerColumnSelection(CoreNavigationCommands.CursorColumnSelectUp.id, KeyMod$1.Shift | KeyCode.UpArrow);
-registerColumnSelection(CoreNavigationCommands.CursorColumnSelectPageUp.id, KeyMod$1.Shift | KeyCode.PageUp);
-registerColumnSelection(CoreNavigationCommands.CursorColumnSelectDown.id, KeyMod$1.Shift | KeyCode.DownArrow);
-registerColumnSelection(CoreNavigationCommands.CursorColumnSelectPageDown.id, KeyMod$1.Shift | KeyCode.PageDown);
+registerColumnSelection(
+    CoreNavigationCommands.CursorColumnSelectLeft.id,
+    KeyMod$1.Shift | KeyCode.LeftArrow
+);
+registerColumnSelection(
+    CoreNavigationCommands.CursorColumnSelectRight.id,
+    KeyMod$1.Shift | KeyCode.RightArrow
+);
+registerColumnSelection(
+    CoreNavigationCommands.CursorColumnSelectUp.id,
+    KeyMod$1.Shift | KeyCode.UpArrow
+);
+registerColumnSelection(
+    CoreNavigationCommands.CursorColumnSelectPageUp.id,
+    KeyMod$1.Shift | KeyCode.PageUp
+);
+registerColumnSelection(
+    CoreNavigationCommands.CursorColumnSelectDown.id,
+    KeyMod$1.Shift | KeyCode.DownArrow
+);
+registerColumnSelection(
+    CoreNavigationCommands.CursorColumnSelectPageDown.id,
+    KeyMod$1.Shift | KeyCode.PageDown
+);
 function registerCommand(command) {
     command.register();
     return command;
 }
 var CoreEditingCommands;
-(function (CoreEditingCommands) {
+(function(CoreEditingCommands) {
     class CoreEditingCommand extends EditorCommand {
         runEditorCommand(accessor, editor, args) {
             const viewModel = editor._getViewModel();
@@ -1553,25 +1747,30 @@ var CoreEditingCommands;
     CoreEditingCommands.LineBreakInsert = registerEditorCommand(new (class extends CoreEditingCommand {
         constructor() {
             super({
-                id: 'lineBreakInsert',
+                id: "lineBreakInsert",
                 precondition: EditorContextKeys.writable,
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
                     primary: 0,
-                    mac: { primary: KeyMod$1.WinCtrl | KeyCode.KeyO }
+                    mac: {
+                        primary: KeyMod$1.WinCtrl | KeyCode.KeyO
+                    }
                 }
             });
         }
         runCoreEditingCommand(editor, viewModel, args) {
             editor.pushUndoStop();
-            editor.executeCommands(this.id, EnterOperation.lineBreakInsert(viewModel.cursorConfig, viewModel.model, ( viewModel.getCursorStates().map(s => s.modelState.selection))));
+            editor.executeCommands(
+                this.id,
+                EnterOperation.lineBreakInsert(viewModel.cursorConfig, viewModel.model, ( viewModel.getCursorStates().map(s => s.modelState.selection)))
+            );
         }
-    }));
+    })());
     CoreEditingCommands.Outdent = registerEditorCommand(new (class extends CoreEditingCommand {
         constructor() {
             super({
-                id: 'outdent',
+                id: "outdent",
                 precondition: EditorContextKeys.writable,
                 kbOpts: {
                     weight: CORE_WEIGHT,
@@ -1582,14 +1781,17 @@ var CoreEditingCommands;
         }
         runCoreEditingCommand(editor, viewModel, args) {
             editor.pushUndoStop();
-            editor.executeCommands(this.id, TypeOperations.outdent(viewModel.cursorConfig, viewModel.model, ( viewModel.getCursorStates().map(s => s.modelState.selection))));
+            editor.executeCommands(
+                this.id,
+                TypeOperations.outdent(viewModel.cursorConfig, viewModel.model, ( viewModel.getCursorStates().map(s => s.modelState.selection)))
+            );
             editor.pushUndoStop();
         }
-    }));
+    })());
     CoreEditingCommands.Tab = registerEditorCommand(new (class extends CoreEditingCommand {
         constructor() {
             super({
-                id: 'tab',
+                id: "tab",
                 precondition: EditorContextKeys.writable,
                 kbOpts: {
                     weight: CORE_WEIGHT,
@@ -1600,61 +1802,85 @@ var CoreEditingCommands;
         }
         runCoreEditingCommand(editor, viewModel, args) {
             editor.pushUndoStop();
-            editor.executeCommands(this.id, TypeOperations.tab(viewModel.cursorConfig, viewModel.model, ( viewModel.getCursorStates().map(s => s.modelState.selection))));
+            editor.executeCommands(
+                this.id,
+                TypeOperations.tab(viewModel.cursorConfig, viewModel.model, ( viewModel.getCursorStates().map(s => s.modelState.selection)))
+            );
             editor.pushUndoStop();
         }
-    }));
+    })());
     CoreEditingCommands.DeleteLeft = registerEditorCommand(new (class extends CoreEditingCommand {
         constructor() {
             super({
-                id: 'deleteLeft',
+                id: "deleteLeft",
                 precondition: undefined,
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
                     primary: KeyCode.Backspace,
                     secondary: [KeyMod$1.Shift | KeyCode.Backspace],
-                    mac: { primary: KeyCode.Backspace, secondary: [KeyMod$1.Shift | KeyCode.Backspace, KeyMod$1.WinCtrl | KeyCode.KeyH, KeyMod$1.WinCtrl | KeyCode.Backspace] }
+                    mac: {
+                        primary: KeyCode.Backspace,
+                        secondary: [
+                            KeyMod$1.Shift | KeyCode.Backspace,
+                            KeyMod$1.WinCtrl | KeyCode.KeyH,
+                            KeyMod$1.WinCtrl | KeyCode.Backspace
+                        ]
+                    }
                 }
             });
         }
         runCoreEditingCommand(editor, viewModel, args) {
-            const [shouldPushStackElementBefore, commands] = DeleteOperations.deleteLeft(viewModel.getPrevEditOperationType(), viewModel.cursorConfig, viewModel.model, ( viewModel.getCursorStates().map(s => s.modelState.selection)), viewModel.getCursorAutoClosedCharacters());
+            const [shouldPushStackElementBefore, commands] = DeleteOperations.deleteLeft(
+                viewModel.getPrevEditOperationType(),
+                viewModel.cursorConfig,
+                viewModel.model,
+                ( viewModel.getCursorStates().map(s => s.modelState.selection)),
+                viewModel.getCursorAutoClosedCharacters()
+            );
             if (shouldPushStackElementBefore) {
                 editor.pushUndoStop();
             }
             editor.executeCommands(this.id, commands);
             viewModel.setPrevEditOperationType(EditOperationType.DeletingLeft);
         }
-    }));
+    })());
     CoreEditingCommands.DeleteRight = registerEditorCommand(new (class extends CoreEditingCommand {
         constructor() {
             super({
-                id: 'deleteRight',
+                id: "deleteRight",
                 precondition: undefined,
                 kbOpts: {
                     weight: CORE_WEIGHT,
                     kbExpr: EditorContextKeys.textInputFocus,
                     primary: KeyCode.Delete,
-                    mac: { primary: KeyCode.Delete, secondary: [KeyMod$1.WinCtrl | KeyCode.KeyD, KeyMod$1.WinCtrl | KeyCode.Delete] }
+                    mac: {
+                        primary: KeyCode.Delete,
+                        secondary: [KeyMod$1.WinCtrl | KeyCode.KeyD, KeyMod$1.WinCtrl | KeyCode.Delete]
+                    }
                 }
             });
         }
         runCoreEditingCommand(editor, viewModel, args) {
-            const [shouldPushStackElementBefore, commands] = DeleteOperations.deleteRight(viewModel.getPrevEditOperationType(), viewModel.cursorConfig, viewModel.model, ( viewModel.getCursorStates().map(s => s.modelState.selection)));
+            const [shouldPushStackElementBefore, commands] = DeleteOperations.deleteRight(
+                viewModel.getPrevEditOperationType(),
+                viewModel.cursorConfig,
+                viewModel.model,
+                ( viewModel.getCursorStates().map(s => s.modelState.selection))
+            );
             if (shouldPushStackElementBefore) {
                 editor.pushUndoStop();
             }
             editor.executeCommands(this.id, commands);
             viewModel.setPrevEditOperationType(EditOperationType.DeletingRight);
         }
-    }));
+    })());
     CoreEditingCommands.Undo = new (class extends EditorOrNativeTextInputCommand {
         constructor() {
             super(UndoCommand);
         }
         runDOMCommand(activeElement) {
-            activeElement.ownerDocument.execCommand('undo');
+            activeElement.ownerDocument.execCommand("undo");
         }
         runEditorCommand(accessor, editor, args) {
             if (!editor.hasModel() || editor.getOption(EditorOption.readOnly) === true) {
@@ -1668,7 +1894,7 @@ var CoreEditingCommands;
             super(RedoCommand);
         }
         runDOMCommand(activeElement) {
-            activeElement.ownerDocument.execCommand('redo');
+            activeElement.ownerDocument.execCommand("redo");
         }
         runEditorCommand(accessor, editor, args) {
             if (!editor.hasModel() || editor.getOption(EditorOption.readOnly) === true) {
@@ -1692,27 +1918,27 @@ class EditorHandlerCommand extends Command {
         if (!editor) {
             return;
         }
-        editor.trigger('keyboard', this._handlerId, args);
+        editor.trigger("keyboard", this._handlerId, args);
     }
 }
 function registerOverwritableCommand(handlerId, metadata) {
-    registerCommand(( new EditorHandlerCommand('default:' + handlerId, handlerId)));
+    registerCommand(( new EditorHandlerCommand("default:" + handlerId, handlerId)));
     registerCommand(( new EditorHandlerCommand(handlerId, handlerId, metadata)));
 }
 registerOverwritableCommand(Handler.Type, {
     description: `Type`,
     args: [{
-            name: 'args',
-            schema: {
-                'type': 'object',
-                'required': ['text'],
-                'properties': {
-                    'text': {
-                        'type': 'string'
-                    }
-                },
+        name: "args",
+        schema: {
+            "type": "object",
+            "required": ["text"],
+            "properties": {
+                "text": {
+                    "type": "string"
+                }
             }
-        }]
+        }
+    }]
 });
 registerOverwritableCommand(Handler.ReplacePreviousChar);
 registerOverwritableCommand(Handler.CompositionType);