@codingame/monaco-vscode-api 5.3.0 → 6.0.1

package/vscode/src/vs/editor/common/config/fontInfo.js

@@ -1,17 +1,17 @@
 import { isMacintosh } from '../../../base/common/platform.js';
-import { EditorOptions, EditorFontVariations, EDITOR_FONT_DEFAULTS } from './editorOptions.js';
+import { EditorOption, EditorOptions, EditorFontVariations, EDITOR_FONT_DEFAULTS } from './editorOptions.js';
 import { EditorZoom } from './editorZoom.js';
 const GOLDEN_LINE_HEIGHT_RATIO = isMacintosh ? 1.5 : 1.35;
 const MINIMUM_LINE_HEIGHT = 8;
 class BareFontInfo {
     static createFromValidatedSettings(options, pixelRatio, ignoreEditorZoom) {
-        const fontFamily = options.get(49 );
-        const fontWeight = options.get(53 );
-        const fontSize = options.get(52 );
-        const fontFeatureSettings = options.get(51 );
-        const fontVariationSettings = options.get(54 );
-        const lineHeight = options.get(67 );
-        const letterSpacing = options.get(64 );
+        const fontFamily = options.get(EditorOption.fontFamily);
+        const fontWeight = options.get(EditorOption.fontWeight);
+        const fontSize = options.get(EditorOption.fontSize);
+        const fontFeatureSettings = options.get(EditorOption.fontLigatures);
+        const fontVariationSettings = options.get(EditorOption.fontVariations);
+        const lineHeight = options.get(EditorOption.lineHeight);
+        const letterSpacing = options.get(EditorOption.letterSpacing);
         return BareFontInfo._create(fontFamily, fontWeight, fontSize, fontFeatureSettings, fontVariationSettings, lineHeight, letterSpacing, pixelRatio, ignoreEditorZoom);
     }
     static createFromRawSettings(opts, pixelRatio, ignoreEditorZoom = false) {

package/vscode/src/vs/editor/common/core/characterClassifier.js

@@ -33,15 +33,20 @@ class CharacterClassifier {
         this._map.clear();
     }
 }
+var Boolean;
+( (function(Boolean) {
+    Boolean[Boolean["False"] = 0] = "False";
+    Boolean[Boolean["True"] = 1] = "True";
+})(Boolean || (Boolean = {})));
 class CharacterSet {
     constructor() {
-        this._actual = ( new CharacterClassifier(0 ));
+        this._actual = ( new CharacterClassifier(Boolean.False));
     }
     add(charCode) {
-        this._actual.set(charCode, 1 );
+        this._actual.set(charCode, Boolean.True);
     }
     has(charCode) {
-        return (this._actual.get(charCode) === 1) ;
+        return (this._actual.get(charCode) === Boolean.True);
     }
     clear() {
         return this._actual.clear();

package/vscode/src/vs/editor/common/core/cursorColumns.js

@@ -1,7 +1,8 @@
+import { CharCode } from '../../../base/common/charCode.js';
 import { isFullWidthCharacter, isEmojiImprecise, getNextCodePoint, GraphemeIterator, CodePointIterator } from '../../../base/common/strings.js';
 class CursorColumns {
     static _nextVisibleColumn(codePoint, visibleColumn, tabSize) {
-        if (codePoint === 9 ) {
+        if (codePoint === CharCode.Tab) {
             return CursorColumns.nextRenderTabStop(visibleColumn, tabSize);
         }
         if (isFullWidthCharacter(codePoint) || isEmojiImprecise(codePoint)) {
@@ -27,7 +28,7 @@ class CursorColumns {
         let result = 0;
         while (!iterator.eol()) {
             const codePoint = iterator.nextCodePoint();
-            if (codePoint === 9 ) {
+            if (codePoint === CharCode.Tab) {
                 result = CursorColumns.nextRenderTabStop(result, tabSize);
             }
             else {

package/vscode/src/vs/editor/common/core/eolCounter.js

@@ -1,26 +1,34 @@
+import { CharCode } from '../../../base/common/charCode.js';
+var StringEOL;
+( (function(StringEOL) {
+    StringEOL[StringEOL["Unknown"] = 0] = "Unknown";
+    StringEOL[StringEOL["Invalid"] = 3] = "Invalid";
+    StringEOL[StringEOL["LF"] = 1] = "LF";
+    StringEOL[StringEOL["CRLF"] = 2] = "CRLF";
+})(StringEOL || (StringEOL = {})));
 function countEOL(text) {
     let eolCount = 0;
     let firstLineLength = 0;
     let lastLineStart = 0;
-    let eol = 0 ;
+    let eol = StringEOL.Unknown;
     for (let i = 0, len = text.length; i < len; i++) {
         const chr = text.charCodeAt(i);
-        if (chr === 13 ) {
+        if (chr === CharCode.CarriageReturn) {
             if (eolCount === 0) {
                 firstLineLength = i;
             }
             eolCount++;
-            if (i + 1 < len && text.charCodeAt(i + 1) === 10 ) {
-                eol |= 2 ;
+            if (i + 1 < len && text.charCodeAt(i + 1) === CharCode.LineFeed) {
+                eol |= StringEOL.CRLF;
                 i++;
             }
             else {
-                eol |= 3 ;
+                eol |= StringEOL.Invalid;
             }
             lastLineStart = i + 1;
         }
-        else if (chr === 10 ) {
-            eol |= 1 ;
+        else if (chr === CharCode.LineFeed) {
+            eol |= StringEOL.LF;
             if (eolCount === 0) {
                 firstLineLength = i;
             }
@@ -33,4 +41,4 @@ function countEOL(text) {
     }
     return [eolCount, firstLineLength, text.length - lastLineStart, eol];
 }
-export { countEOL };
+export { StringEOL, countEOL };

package/vscode/src/vs/editor/common/core/lineRange.d.ts

@@ -1,6 +1,5 @@
 import { OffsetRange } from './offsetRange.js';
 import { Range } from './range.js';
-import { ITextModel } from '../model.js';
 
 /**
  * A range of lines (1-based).
@@ -19,14 +18,6 @@ declare class LineRange {
      * @internal
      */
     static deserialize(lineRange: ISerializedLineRange): LineRange;
-    /**
-     * @internal
-     */
-    static invert(range: LineRange, model: ITextModel): LineRange[];
-    /**
-     * @internal
-     */
-    static asRange(lineRange: LineRange, model: ITextModel): Range;
     /**
      * The start line number.
      */

package/vscode/src/vs/editor/common/core/lineRange.js

@@ -60,34 +60,6 @@ class LineRange {
     static deserialize(lineRange) {
         return ( new LineRange(lineRange[0], lineRange[1]));
     }
-    static invert(range, model) {
-        if (range.isEmpty) {
-            return [];
-        }
-        const result = [];
-        if (range.startLineNumber > 1) {
-            result.push(( new LineRange(1, range.startLineNumber)));
-        }
-        if (range.endLineNumberExclusive < model.getLineCount() + 1) {
-            result.push(( new LineRange(range.endLineNumberExclusive, model.getLineCount() + 1)));
-        }
-        return result.filter(r => !r.isEmpty);
-    }
-    static asRange(lineRange, model) {
-        return lineRange.isEmpty
-            ? ( new Range(
-            lineRange.startLineNumber,
-            1,
-            lineRange.startLineNumber,
-            model.getLineLength(lineRange.startLineNumber)
-        ))
-            : ( new Range(
-            lineRange.startLineNumber,
-            1,
-            lineRange.endLineNumberExclusive - 1,
-            model.getLineLength(lineRange.endLineNumberExclusive - 1)
-        ));
-    }
     constructor(startLineNumber, endLineNumberExclusive) {
         if (startLineNumber > endLineNumberExclusive) {
             throw ( new BugIndicatingError(

package/vscode/src/vs/editor/common/core/selection.js

@@ -1,5 +1,10 @@
 import { Position } from './position.js';
 import { Range } from './range.js';
+var SelectionDirection;
+( (function(SelectionDirection) {
+    SelectionDirection[SelectionDirection["LTR"] = 0] = "LTR";
+    SelectionDirection[SelectionDirection["RTL"] = 1] = "RTL";
+})(SelectionDirection || (SelectionDirection = {})));
 class Selection extends Range {
     constructor(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn) {
         super(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn);
@@ -22,12 +27,12 @@ class Selection extends Range {
     }
     getDirection() {
         if (this.selectionStartLineNumber === this.startLineNumber && this.selectionStartColumn === this.startColumn) {
-            return 0 ;
+            return SelectionDirection.LTR;
         }
-        return 1 ;
+        return SelectionDirection.RTL;
     }
     setEndPosition(endLineNumber, endColumn) {
-        if (this.getDirection() === 0 ) {
+        if (this.getDirection() === SelectionDirection.LTR) {
             return ( new Selection(this.startLineNumber, this.startColumn, endLineNumber, endColumn));
         }
         return ( new Selection(endLineNumber, endColumn, this.startLineNumber, this.startColumn));
@@ -39,7 +44,7 @@ class Selection extends Range {
         return ( new Position(this.selectionStartLineNumber, this.selectionStartColumn));
     }
     setStartPosition(startLineNumber, startColumn) {
-        if (this.getDirection() === 0 ) {
+        if (this.getDirection() === SelectionDirection.LTR) {
             return ( new Selection(startLineNumber, startColumn, this.endLineNumber, this.endColumn));
         }
         return ( new Selection(this.endLineNumber, this.endColumn, startLineNumber, startColumn));
@@ -48,7 +53,7 @@ class Selection extends Range {
         return ( new Selection(start.lineNumber, start.column, end.lineNumber, end.column));
     }
     static fromRange(range, direction) {
-        if (direction === 0 ) {
+        if (direction === SelectionDirection.LTR) {
             return ( new Selection(
                 range.startLineNumber,
                 range.startColumn,
@@ -98,10 +103,10 @@ class Selection extends Range {
             && (typeof obj.positionColumn === 'number'));
     }
     static createWithDirection(startLineNumber, startColumn, endLineNumber, endColumn, direction) {
-        if (direction === 0 ) {
+        if (direction === SelectionDirection.LTR) {
             return ( new Selection(startLineNumber, startColumn, endLineNumber, endColumn));
         }
         return ( new Selection(endLineNumber, endColumn, startLineNumber, startColumn));
     }
 }
-export { Selection };
+export { Selection, SelectionDirection };

package/vscode/src/vs/editor/common/core/wordCharacterClassifier.js

@@ -1,8 +1,15 @@
+import { CharCode } from '../../../base/common/charCode.js';
 import { LRUCache } from '../../../base/common/map.js';
 import { CharacterClassifier } from './characterClassifier.js';
+var WordCharacterClass;
+( (function(WordCharacterClass) {
+    WordCharacterClass[WordCharacterClass["Regular"] = 0] = "Regular";
+    WordCharacterClass[WordCharacterClass["Whitespace"] = 1] = "Whitespace";
+    WordCharacterClass[WordCharacterClass["WordSeparator"] = 2] = "WordSeparator";
+})(WordCharacterClass || (WordCharacterClass = {})));
 class WordCharacterClassifier extends CharacterClassifier {
     constructor(wordSeparators, intlSegmenterLocales) {
-        super(0 );
+        super(WordCharacterClass.Regular);
         this._segmenter = null;
         this._cachedLine = null;
         this._cachedSegments = [];
@@ -14,10 +21,10 @@ class WordCharacterClassifier extends CharacterClassifier {
             this._segmenter = null;
         }
         for (let i = 0, len = wordSeparators.length; i < len; i++) {
-            this.set(wordSeparators.charCodeAt(i), 2 );
+            this.set(wordSeparators.charCodeAt(i), WordCharacterClass.WordSeparator);
         }
-        this.set(32 , 1 );
-        this.set(9 , 1 );
+        this.set(CharCode.Space, WordCharacterClass.Whitespace);
+        this.set(CharCode.Tab, WordCharacterClass.Whitespace);
     }
     findPrevIntlWordBeforeOrAtOffset(line, offset) {
         let candidate = null;
@@ -75,4 +82,4 @@ function getMapForWordSeparators(wordSeparators, intlSegmenterLocales) {
     }
     return result;
 }
-export { WordCharacterClassifier, getMapForWordSeparators };
+export { WordCharacterClass, WordCharacterClassifier, getMapForWordSeparators };

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

@@ -1,14 +1,17 @@
 import { onUnexpectedError } from '../../../base/common/errors.js';
 import { nextCharLength, commonPrefixLength, commonSuffixLength } from '../../../base/common/strings.js';
 import { CursorCollection } from './cursorCollection.js';
-import { CursorState, EditOperationResult } from '../cursorCommon.js';
+import { EditOperationType, CursorState, EditOperationResult } from '../cursorCommon.js';
 import { CursorContext } from './cursorContext.js';
 import { DeleteOperations } from './cursorDeleteOperations.js';
+import { CursorChangeReason } from '../cursorEvents.js';
 import { TypeOperations, CompositionOutcome, TypeWithAutoClosingCommand } from './cursorTypeOperations.js';
 import { Range } from '../core/range.js';
-import { Selection } from '../core/selection.js';
-import { ModelInjectedTextChangedEvent } from '../textModelEvents.js';
-import { ViewRevealRangeRequestEvent, ViewCursorStateChangedEvent } from '../viewEvents.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 { Disposable, dispose } from '../../../base/common/lifecycle.js';
 import { CursorStateChangedEvent } from '../viewModelEventDispatcher.js';
 class CursorsController extends Disposable {
@@ -25,7 +28,7 @@ class CursorsController extends Disposable {
         this._compositionState = null;
         this._columnSelectData = null;
         this._autoClosedActions = [];
-        this._prevEditOperationType = 0 ;
+        this._prevEditOperationType = EditOperationType.Other;
     }
     dispose() {
         this._cursors.dispose();
@@ -40,7 +43,7 @@ class CursorsController extends Disposable {
         if (this._knownModelVersionId !== this._model.getVersionId()) {
             return;
         }
-        this.setStates(eventsCollector, 'viewModel', 0 , this.getCursorStates());
+        this.setStates(eventsCollector, 'viewModel', CursorChangeReason.NotSet, this.getCursorStates());
     }
     setHasFocus(hasFocus) {
         this._hasFocus = hasFocus;
@@ -163,8 +166,8 @@ class CursorsController extends Disposable {
                 positionColumn: positionColumn
             });
         }
-        this.setStates(eventsCollector, 'restoreState', 0 , CursorState.fromModelSelections(desiredSelections));
-        this.revealAll(eventsCollector, 'restoreState', false, 0 , true, 1 );
+        this.setStates(eventsCollector, 'restoreState', CursorChangeReason.NotSet, CursorState.fromModelSelections(desiredSelections));
+        this.revealAll(eventsCollector, 'restoreState', false, VerticalRevealType.Simple, true, ScrollType.Immediate);
     }
     onModelContentChanged(eventsCollector, event) {
         if (event instanceof ModelInjectedTextChangedEvent) {
@@ -173,7 +176,7 @@ class CursorsController extends Disposable {
             }
             this._isHandling = true;
             try {
-                this.setStates(eventsCollector, 'modelChange', 0 , this.getCursorStates());
+                this.setStates(eventsCollector, 'modelChange', CursorChangeReason.NotSet, this.getCursorStates());
             }
             finally {
                 this._isHandling = false;
@@ -185,24 +188,24 @@ class CursorsController extends Disposable {
             if (this._isHandling) {
                 return;
             }
-            const hadFlushEvent = e.containsEvent(1 );
-            this._prevEditOperationType = 0 ;
+            const hadFlushEvent = e.containsEvent(RawContentChangedType.Flush);
+            this._prevEditOperationType = EditOperationType.Other;
             if (hadFlushEvent) {
                 this._cursors.dispose();
                 this._cursors = ( new CursorCollection(this.context));
                 this._validateAutoClosedActions();
-                this._emitStateChangedIfNecessary(eventsCollector, 'model', 1 , null, false);
+                this._emitStateChangedIfNecessary(eventsCollector, 'model', CursorChangeReason.ContentFlush, 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 ? 5  : e.isRedoing ? 6  : 2 , cursorState)) {
-                        this.revealAll(eventsCollector, 'modelChange', false, 0 , true, 0 );
+                    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);
                     }
                 }
                 else {
                     const selectionsFromMarkers = this._cursors.readSelectionFromMarkers();
-                    this.setStates(eventsCollector, 'modelChange', 2 , CursorState.fromModelSelections(selectionsFromMarkers));
+                    this.setStates(eventsCollector, 'modelChange', CursorChangeReason.RecoverFromMarkers, CursorState.fromModelSelections(selectionsFromMarkers));
                 }
             }
         }
@@ -255,14 +258,14 @@ class CursorsController extends Disposable {
                 options: {
                     description: 'auto-closed-character',
                     inlineClassName: 'auto-closed-character',
-                    stickiness: 1
+                    stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges
                 }
             });
             autoClosedEnclosingDeltaDecorations.push({
                 range: autoClosedEnclosingRanges[i],
                 options: {
                     description: 'auto-closed-enclosing',
-                    stickiness: 1
+                    stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges
                 }
             });
         }
@@ -396,13 +399,13 @@ class CursorsController extends Disposable {
         });
         if (selections) {
             this._isHandling = false;
-            this.setSelections(eventsCollector, source, selections, 0 );
+            this.setSelections(eventsCollector, source, selections, CursorChangeReason.NotSet);
         }
         if (autoClosedCharactersRanges.length > 0) {
             this._pushAutoClosedAction(autoClosedCharactersRanges, autoClosedEnclosingRanges);
         }
     }
-    _executeEdit(callback, eventsCollector, source, cursorChangeReason = 0 ) {
+    _executeEdit(callback, eventsCollector, source, cursorChangeReason = CursorChangeReason.NotSet) {
         if (this.context.cursorConfig.readOnly) {
             return;
         }
@@ -420,7 +423,7 @@ class CursorsController extends Disposable {
         this._cursors.startTrackingSelections();
         this._validateAutoClosedActions();
         if (this._emitStateChangedIfNecessary(eventsCollector, source, cursorChangeReason, oldState, false)) {
-            this.revealAll(eventsCollector, source, false, 0 , true, 0 );
+            this.revealAll(eventsCollector, source, false, VerticalRevealType.Simple, true, ScrollType.Smooth);
         }
     }
     getAutoClosedCharacters() {
@@ -467,7 +470,7 @@ class CursorsController extends Disposable {
                         position.column + positionDelta
                     ));
                 }));
-                this.setSelections(eventsCollector, source, newSelections, 0 );
+                this.setSelections(eventsCollector, source, newSelections, CursorChangeReason.NotSet);
             }
             return;
         }
@@ -478,7 +481,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, 4 );
+        }, eventsCollector, source, CursorChangeReason.Paste);
     }
     cut(eventsCollector, source) {
         this._executeEdit(() => {
@@ -488,7 +491,7 @@ class CursorsController extends Disposable {
     executeCommand(eventsCollector, command, source) {
         this._executeEdit(() => {
             this._cursors.killSecondaryCursors();
-            this._executeEditOperation(( new EditOperationResult(0 , [command], {
+            this._executeEditOperation(( new EditOperationResult(EditOperationType.Other, [command], {
                 shouldPushStackElementBefore: false,
                 shouldPushStackElementAfter: false
             })));
@@ -496,7 +499,7 @@ class CursorsController extends Disposable {
     }
     executeCommands(eventsCollector, commands, source) {
         this._executeEdit(() => {
-            this._executeEditOperation(( new EditOperationResult(0 , commands, {
+            this._executeEditOperation(( new EditOperationResult(EditOperationType.Other, commands, {
                 shouldPushStackElementBefore: false,
                 shouldPushStackElementAfter: false
             })));
@@ -590,7 +593,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, 0 );
+            ctx.model._setTrackedRange(ctx.trackedRanges[i], null, TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges);
         }
         return result;
     }
@@ -642,7 +645,7 @@ class CommandExecutor {
                         getTrackedSelection: (id) => {
                             const idx = parseInt(id, 10);
                             const range = ctx.model._getTrackedRange(ctx.trackedRanges[idx]);
-                            if (ctx.trackedRangesDirection[idx] === 0 ) {
+                            if (ctx.trackedRangesDirection[idx] === SelectionDirection.LTR) {
                                 return ( new Selection(
                                     range.startLineNumber,
                                     range.startColumn,
@@ -735,24 +738,24 @@ class CommandExecutor {
             if (selection.isEmpty()) {
                 if (typeof trackPreviousOnEmpty === 'boolean') {
                     if (trackPreviousOnEmpty) {
-                        stickiness = 2 ;
+                        stickiness = TrackedRangeStickiness.GrowsOnlyWhenTypingBefore;
                     }
                     else {
-                        stickiness = 3 ;
+                        stickiness = TrackedRangeStickiness.GrowsOnlyWhenTypingAfter;
                     }
                 }
                 else {
                     const maxLineColumn = ctx.model.getLineMaxColumn(selection.startLineNumber);
                     if (selection.startColumn === maxLineColumn) {
-                        stickiness = 2 ;
+                        stickiness = TrackedRangeStickiness.GrowsOnlyWhenTypingBefore;
                     }
                     else {
-                        stickiness = 3 ;
+                        stickiness = TrackedRangeStickiness.GrowsOnlyWhenTypingAfter;
                     }
                 }
             }
             else {
-                stickiness = 1 ;
+                stickiness = TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges;
             }
             const l = ctx.trackedRanges.length;
             const id = ctx.model._setTrackedRange(null, selection, stickiness);

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

@@ -1,4 +1,11 @@
+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;
@@ -15,10 +22,10 @@ class AtomicTabMoveOperations {
             }
             const chCode = lineContent.charCodeAt(i);
             switch (chCode) {
-                case 32 :
+                case CharCode.Space:
                     visibleColumn += 1;
                     break;
-                case 9 :
+                case CharCode.Tab:
                     visibleColumn = CursorColumns.nextRenderTabStop(visibleColumn, tabSize);
                     break;
                 default:
@@ -38,13 +45,13 @@ class AtomicTabMoveOperations {
         }
         let left;
         switch (direction) {
-            case 0 :
+            case Direction.Left:
                 left = true;
                 break;
-            case 1 :
+            case Direction.Right:
                 left = false;
                 break;
-            case 2 :
+            case Direction.Nearest:
                 if (visibleColumn % tabSize === 0) {
                     return position;
                 }
@@ -62,10 +69,10 @@ class AtomicTabMoveOperations {
                 }
                 const chCode = lineContent.charCodeAt(i);
                 switch (chCode) {
-                    case 32 :
+                    case CharCode.Space:
                         currentVisibleColumn += 1;
                         break;
-                    case 9 :
+                    case CharCode.Tab:
                         currentVisibleColumn = CursorColumns.nextRenderTabStop(currentVisibleColumn, tabSize);
                         break;
                     default:
@@ -85,10 +92,10 @@ class AtomicTabMoveOperations {
             }
             const chCode = lineContent.charCodeAt(i);
             switch (chCode) {
-                case 32 :
+                case CharCode.Space:
                     currentVisibleColumn += 1;
                     break;
-                case 9 :
+                case CharCode.Tab:
                     currentVisibleColumn = CursorColumns.nextRenderTabStop(currentVisibleColumn, tabSize);
                     break;
                 default:
@@ -101,4 +108,4 @@ class AtomicTabMoveOperations {
         return -1;
     }
 }
-export { AtomicTabMoveOperations };
+export { AtomicTabMoveOperations, Direction };

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

@@ -1,4 +1,4 @@
-import { SingleCursorState } from '../cursorCommon.js';
+import { SingleCursorState, SelectionStartKind } 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)), 0 , 0, ( new Position(lineNumber, endColumn)), 0)));
+            result.push(( new SingleCursorState(( new Range(lineNumber, startColumn, lineNumber, startColumn)), SelectionStartKind.Simple, 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)), 0 , 0, ( new Position(lineNumber, maxColumn)), 0)));
+                result.push(( new SingleCursorState(( new Range(lineNumber, maxColumn, lineNumber, maxColumn)), SelectionStartKind.Simple, 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 } from '../cursorCommon.js';
+import { isQuote, EditOperationResult, EditOperationType } 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 !== 3) );
+        let shouldPushStackElementBefore = (prevEditOperationType !== EditOperationType.DeletingRight);
         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 !== 2) );
+        let shouldPushStackElementBefore = (prevEditOperationType !== EditOperationType.DeletingLeft);
         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(0 , commands, {
+        return ( new EditOperationResult(EditOperationType.Other, commands, {
             shouldPushStackElementBefore: true,
             shouldPushStackElementAfter: true
         }));