@codingame/monaco-vscode-api 5.2.0 → 6.0.0

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

@@ -1,22 +1,36 @@
+import { CharCode } from '../../../base/common/charCode.js';
 import { isLowerAsciiLetter, isAsciiDigit, isUpperAsciiLetter, lastNonWhitespaceIndex } from '../../../base/common/strings.js';
-import { SingleCursorState } from '../cursorCommon.js';
+import { SingleCursorState, SelectionStartKind } from '../cursorCommon.js';
 import { DeleteOperations } from './cursorDeleteOperations.js';
-import { getMapForWordSeparators } from '../core/wordCharacterClassifier.js';
+import { WordCharacterClass, getMapForWordSeparators } from '../core/wordCharacterClassifier.js';
 import { Position } from '../core/position.js';
 import { Range } from '../core/range.js';
+var WordType;
+( (function(WordType) {
+    WordType[WordType["None"] = 0] = "None";
+    WordType[WordType["Regular"] = 1] = "Regular";
+    WordType[WordType["Separator"] = 2] = "Separator";
+})(WordType || (WordType = {})));
+var WordNavigationType;
+( (function(WordNavigationType) {
+    WordNavigationType[WordNavigationType["WordStart"] = 0] = "WordStart";
+    WordNavigationType[WordNavigationType["WordStartFast"] = 1] = "WordStartFast";
+    WordNavigationType[WordNavigationType["WordEnd"] = 2] = "WordEnd";
+    WordNavigationType[WordNavigationType["WordAccessibility"] = 3] = "WordAccessibility";
+})(WordNavigationType || (WordNavigationType = {})));
 class WordOperations {
     static _createWord(lineContent, wordType, nextCharClass, start, end) {
         return { start: start, end: end, wordType: wordType, nextCharClass: nextCharClass };
     }
     static _createIntlWord(intlWord, nextCharClass) {
-        return { start: intlWord.index, end: intlWord.index + intlWord.segment.length, wordType: 1 , nextCharClass: nextCharClass };
+        return { start: intlWord.index, end: intlWord.index + intlWord.segment.length, wordType: WordType.Regular, nextCharClass: nextCharClass };
     }
     static _findPreviousWordOnLine(wordSeparators, model, position) {
         const lineContent = model.getLineContent(position.lineNumber);
         return this._doFindPreviousWordOnLine(lineContent, wordSeparators, position);
     }
     static _doFindPreviousWordOnLine(lineContent, wordSeparators, position) {
-        let wordType = 0 ;
+        let wordType = WordType.None;
         const previousIntlWord = wordSeparators.findPrevIntlWordBeforeOrAtOffset(lineContent, position.column - 2);
         for (let chIndex = position.column - 2; chIndex >= 0; chIndex--) {
             const chCode = lineContent.charCodeAt(chIndex);
@@ -24,26 +38,26 @@ class WordOperations {
             if (previousIntlWord && chIndex === previousIntlWord.index) {
                 return this._createIntlWord(previousIntlWord, chClass);
             }
-            if (chClass === 0 ) {
-                if (wordType === 2 ) {
+            if (chClass === WordCharacterClass.Regular) {
+                if (wordType === WordType.Separator) {
                     return this._createWord(lineContent, wordType, chClass, chIndex + 1, this._findEndOfWord(lineContent, wordSeparators, wordType, chIndex + 1));
                 }
-                wordType = 1 ;
+                wordType = WordType.Regular;
             }
-            else if (chClass === 2 ) {
-                if (wordType === 1 ) {
+            else if (chClass === WordCharacterClass.WordSeparator) {
+                if (wordType === WordType.Regular) {
                     return this._createWord(lineContent, wordType, chClass, chIndex + 1, this._findEndOfWord(lineContent, wordSeparators, wordType, chIndex + 1));
                 }
-                wordType = 2 ;
+                wordType = WordType.Separator;
             }
-            else if (chClass === 1 ) {
-                if (wordType !== 0 ) {
+            else if (chClass === WordCharacterClass.Whitespace) {
+                if (wordType !== WordType.None) {
                     return this._createWord(lineContent, wordType, chClass, chIndex + 1, this._findEndOfWord(lineContent, wordSeparators, wordType, chIndex + 1));
                 }
             }
         }
-        if (wordType !== 0 ) {
-            return this._createWord(lineContent, wordType, 1 , 0, this._findEndOfWord(lineContent, wordSeparators, wordType, 0));
+        if (wordType !== WordType.None) {
+            return this._createWord(lineContent, wordType, WordCharacterClass.Whitespace, 0, this._findEndOfWord(lineContent, wordSeparators, wordType, 0));
         }
         return null;
     }
@@ -56,13 +70,13 @@ class WordOperations {
             if (nextIntlWord && chIndex === nextIntlWord.index + nextIntlWord.segment.length) {
                 return chIndex;
             }
-            if (chClass === 1 ) {
+            if (chClass === WordCharacterClass.Whitespace) {
                 return chIndex;
             }
-            if (wordType === 1  && chClass === 2 ) {
+            if (wordType === WordType.Regular && chClass === WordCharacterClass.WordSeparator) {
                 return chIndex;
             }
-            if (wordType === 2  && chClass === 0 ) {
+            if (wordType === WordType.Separator && chClass === WordCharacterClass.Regular) {
                 return chIndex;
             }
         }
@@ -73,7 +87,7 @@ class WordOperations {
         return this._doFindNextWordOnLine(lineContent, wordSeparators, position);
     }
     static _doFindNextWordOnLine(lineContent, wordSeparators, position) {
-        let wordType = 0 ;
+        let wordType = WordType.None;
         const len = lineContent.length;
         const nextIntlWord = wordSeparators.findNextIntlWordAtOrAfterOffset(lineContent, position.column - 1);
         for (let chIndex = position.column - 1; chIndex < len; chIndex++) {
@@ -82,26 +96,26 @@ class WordOperations {
             if (nextIntlWord && chIndex === nextIntlWord.index) {
                 return this._createIntlWord(nextIntlWord, chClass);
             }
-            if (chClass === 0 ) {
-                if (wordType === 2 ) {
+            if (chClass === WordCharacterClass.Regular) {
+                if (wordType === WordType.Separator) {
                     return this._createWord(lineContent, wordType, chClass, this._findStartOfWord(lineContent, wordSeparators, wordType, chIndex - 1), chIndex);
                 }
-                wordType = 1 ;
+                wordType = WordType.Regular;
             }
-            else if (chClass === 2 ) {
-                if (wordType === 1 ) {
+            else if (chClass === WordCharacterClass.WordSeparator) {
+                if (wordType === WordType.Regular) {
                     return this._createWord(lineContent, wordType, chClass, this._findStartOfWord(lineContent, wordSeparators, wordType, chIndex - 1), chIndex);
                 }
-                wordType = 2 ;
+                wordType = WordType.Separator;
             }
-            else if (chClass === 1 ) {
-                if (wordType !== 0 ) {
+            else if (chClass === WordCharacterClass.Whitespace) {
+                if (wordType !== WordType.None) {
                     return this._createWord(lineContent, wordType, chClass, this._findStartOfWord(lineContent, wordSeparators, wordType, chIndex - 1), chIndex);
                 }
             }
         }
-        if (wordType !== 0 ) {
-            return this._createWord(lineContent, wordType, 1 , this._findStartOfWord(lineContent, wordSeparators, wordType, len - 1), len);
+        if (wordType !== WordType.None) {
+            return this._createWord(lineContent, wordType, WordCharacterClass.Whitespace, this._findStartOfWord(lineContent, wordSeparators, wordType, len - 1), len);
         }
         return null;
     }
@@ -113,13 +127,13 @@ class WordOperations {
             if (previousIntlWord && chIndex === previousIntlWord.index) {
                 return chIndex;
             }
-            if (chClass === 1 ) {
+            if (chClass === WordCharacterClass.Whitespace) {
                 return chIndex + 1;
             }
-            if (wordType === 1  && chClass === 2 ) {
+            if (wordType === WordType.Regular && chClass === WordCharacterClass.WordSeparator) {
                 return chIndex + 1;
             }
-            if (wordType === 2  && chClass === 0 ) {
+            if (wordType === WordType.Separator && chClass === WordCharacterClass.Regular) {
                 return chIndex + 1;
             }
         }
@@ -135,21 +149,21 @@ class WordOperations {
             }
         }
         let prevWordOnLine = WordOperations._findPreviousWordOnLine(wordSeparators, model, ( new Position(lineNumber, column)));
-        if (wordNavigationType === 0 ) {
+        if (wordNavigationType === WordNavigationType.WordStart) {
             return ( new Position(lineNumber, prevWordOnLine ? prevWordOnLine.start + 1 : 1));
         }
-        if (wordNavigationType === 1 ) {
+        if (wordNavigationType === WordNavigationType.WordStartFast) {
             if (prevWordOnLine
-                && prevWordOnLine.wordType === 2
+                && prevWordOnLine.wordType === WordType.Separator
                 && prevWordOnLine.end - prevWordOnLine.start === 1
-                && prevWordOnLine.nextCharClass === 0 ) {
+                && prevWordOnLine.nextCharClass === WordCharacterClass.Regular) {
                 prevWordOnLine = WordOperations._findPreviousWordOnLine(wordSeparators, model, ( new Position(lineNumber, prevWordOnLine.start + 1)));
             }
             return ( new Position(lineNumber, prevWordOnLine ? prevWordOnLine.start + 1 : 1));
         }
-        if (wordNavigationType === 3 ) {
+        if (wordNavigationType === WordNavigationType.WordAccessibility) {
             while (prevWordOnLine
-                && prevWordOnLine.wordType === 2 ) {
+                && prevWordOnLine.wordType === WordType.Separator) {
                 prevWordOnLine = WordOperations._findPreviousWordOnLine(wordSeparators, model, ( new Position(lineNumber, prevWordOnLine.start + 1)));
             }
             return ( new Position(lineNumber, prevWordOnLine ? prevWordOnLine.start + 1 : 1));
@@ -169,10 +183,10 @@ class WordOperations {
         for (let column = position.column - 1; column > 1; column--) {
             const left = lineContent.charCodeAt(column - 2);
             const right = lineContent.charCodeAt(column - 1);
-            if (left === 95  && right !== 95 ) {
+            if (left === CharCode.Underline && right !== CharCode.Underline) {
                 return ( new Position(lineNumber, column));
             }
-            if (left === 45  && right !== 45 ) {
+            if (left === CharCode.Dash && right !== CharCode.Dash) {
                 return ( new Position(lineNumber, column));
             }
             if ((isLowerAsciiLetter(left) || isAsciiDigit(left)) && isUpperAsciiLetter(right)) {
@@ -201,9 +215,9 @@ class WordOperations {
             }
         }
         let nextWordOnLine = WordOperations._findNextWordOnLine(wordSeparators, model, ( new Position(lineNumber, column)));
-        if (wordNavigationType === 2 ) {
-            if (nextWordOnLine && nextWordOnLine.wordType === 2 ) {
-                if (nextWordOnLine.end - nextWordOnLine.start === 1 && nextWordOnLine.nextCharClass === 0 ) {
+        if (wordNavigationType === WordNavigationType.WordEnd) {
+            if (nextWordOnLine && nextWordOnLine.wordType === WordType.Separator) {
+                if (nextWordOnLine.end - nextWordOnLine.start === 1 && nextWordOnLine.nextCharClass === WordCharacterClass.Regular) {
                     nextWordOnLine = WordOperations._findNextWordOnLine(wordSeparators, model, ( new Position(lineNumber, nextWordOnLine.end + 1)));
                 }
             }
@@ -214,12 +228,12 @@ class WordOperations {
                 column = model.getLineMaxColumn(lineNumber);
             }
         }
-        else if (wordNavigationType === 3 ) {
+        else if (wordNavigationType === WordNavigationType.WordAccessibility) {
             if (movedDown) {
                 column = 0;
             }
             while (nextWordOnLine
-                && (nextWordOnLine.wordType === 2
+                && (nextWordOnLine.wordType === WordType.Separator
                     || nextWordOnLine.start + 1 <= column)) {
                 nextWordOnLine = WordOperations._findNextWordOnLine(wordSeparators, model, ( new Position(lineNumber, nextWordOnLine.end + 1)));
             }
@@ -253,10 +267,10 @@ class WordOperations {
         for (let column = position.column + 1; column < maxColumn; column++) {
             const left = lineContent.charCodeAt(column - 2);
             const right = lineContent.charCodeAt(column - 1);
-            if (left !== 95  && right === 95 ) {
+            if (left !== CharCode.Underline && right === CharCode.Underline) {
                 return ( new Position(lineNumber, column));
             }
-            if (left !== 45  && right === 45 ) {
+            if (left !== CharCode.Dash && right === CharCode.Dash) {
                 return ( new Position(lineNumber, column));
             }
             if ((isLowerAsciiLetter(left) || isAsciiDigit(left)) && isUpperAsciiLetter(right)) {
@@ -317,7 +331,7 @@ class WordOperations {
             }
         }
         let prevWordOnLine = WordOperations._findPreviousWordOnLine(wordSeparators, model, position);
-        if (wordNavigationType === 0 ) {
+        if (wordNavigationType === WordNavigationType.WordStart) {
             if (prevWordOnLine) {
                 column = prevWordOnLine.start + 1;
             }
@@ -363,7 +377,7 @@ class WordOperations {
     }
     static _charAtIsWhitespace(str, index) {
         const charCode = str.charCodeAt(index);
-        return (charCode === 32  || charCode === 9) ;
+        return (charCode === CharCode.Space || charCode === CharCode.Tab);
     }
     static _deleteInsideWordWhitespace(model, position) {
         const lineContent = model.getLineContent(position.lineNumber);
@@ -505,7 +519,7 @@ class WordOperations {
             }
         }
         let nextWordOnLine = WordOperations._findNextWordOnLine(wordSeparators, model, position);
-        if (wordNavigationType === 2 ) {
+        if (wordNavigationType === WordNavigationType.WordEnd) {
             if (nextWordOnLine) {
                 column = nextWordOnLine.end + 1;
             }
@@ -569,11 +583,11 @@ class WordOperations {
     static getWordAtPosition(model, _wordSeparators, _intlSegmenterLocales, position) {
         const wordSeparators = getMapForWordSeparators(_wordSeparators, _intlSegmenterLocales);
         const prevWord = WordOperations._findPreviousWordOnLine(wordSeparators, model, position);
-        if (prevWord && prevWord.wordType === 1  && prevWord.start <= position.column - 1 && position.column - 1 <= prevWord.end) {
+        if (prevWord && prevWord.wordType === WordType.Regular && prevWord.start <= position.column - 1 && position.column - 1 <= prevWord.end) {
             return WordOperations._createWordAtPosition(model, position.lineNumber, prevWord);
         }
         const nextWord = WordOperations._findNextWordOnLine(wordSeparators, model, position);
-        if (nextWord && nextWord.wordType === 1  && nextWord.start <= position.column - 1 && position.column - 1 <= nextWord.end) {
+        if (nextWord && nextWord.wordType === WordType.Regular && nextWord.start <= position.column - 1 && position.column - 1 <= nextWord.end) {
             return WordOperations._createWordAtPosition(model, position.lineNumber, nextWord);
         }
         return null;
@@ -585,11 +599,11 @@ class WordOperations {
         if (!inSelectionMode) {
             let startColumn;
             let endColumn;
-            if (prevWord && prevWord.wordType === 1  && prevWord.start <= position.column - 1 && position.column - 1 <= prevWord.end) {
+            if (prevWord && prevWord.wordType === WordType.Regular && prevWord.start <= position.column - 1 && position.column - 1 <= prevWord.end) {
                 startColumn = prevWord.start + 1;
                 endColumn = prevWord.end + 1;
             }
-            else if (nextWord && nextWord.wordType === 1  && nextWord.start <= position.column - 1 && position.column - 1 <= nextWord.end) {
+            else if (nextWord && nextWord.wordType === WordType.Regular && nextWord.start <= position.column - 1 && position.column - 1 <= nextWord.end) {
                 startColumn = nextWord.start + 1;
                 endColumn = nextWord.end + 1;
             }
@@ -607,15 +621,15 @@ class WordOperations {
                     endColumn = model.getLineMaxColumn(position.lineNumber);
                 }
             }
-            return ( new SingleCursorState(( new Range(position.lineNumber, startColumn, position.lineNumber, endColumn)), 1 , 0, ( new Position(position.lineNumber, endColumn)), 0));
+            return ( new SingleCursorState(( new Range(position.lineNumber, startColumn, position.lineNumber, endColumn)), SelectionStartKind.Word, 0, ( new Position(position.lineNumber, endColumn)), 0));
         }
         let startColumn;
         let endColumn;
-        if (prevWord && prevWord.wordType === 1  && prevWord.start < position.column - 1 && position.column - 1 < prevWord.end) {
+        if (prevWord && prevWord.wordType === WordType.Regular && prevWord.start < position.column - 1 && position.column - 1 < prevWord.end) {
             startColumn = prevWord.start + 1;
             endColumn = prevWord.end + 1;
         }
-        else if (nextWord && nextWord.wordType === 1  && nextWord.start < position.column - 1 && position.column - 1 < nextWord.end) {
+        else if (nextWord && nextWord.wordType === WordType.Regular && nextWord.start < position.column - 1 && position.column - 1 < nextWord.end) {
             startColumn = nextWord.start + 1;
             endColumn = nextWord.end + 1;
         }
@@ -648,8 +662,8 @@ class WordOperations {
 class WordPartOperations extends WordOperations {
     static deleteWordPartLeft(ctx) {
         const candidates = enforceDefined([
-            WordOperations.deleteWordLeft(ctx, 0 ),
-            WordOperations.deleteWordLeft(ctx, 2 ),
+            WordOperations.deleteWordLeft(ctx, WordNavigationType.WordStart),
+            WordOperations.deleteWordLeft(ctx, WordNavigationType.WordEnd),
             WordOperations._deleteWordPartLeft(ctx.model, ctx.selection)
         ]);
         candidates.sort(Range.compareRangesUsingEnds);
@@ -657,8 +671,8 @@ class WordPartOperations extends WordOperations {
     }
     static deleteWordPartRight(ctx) {
         const candidates = enforceDefined([
-            WordOperations.deleteWordRight(ctx, 0 ),
-            WordOperations.deleteWordRight(ctx, 2 ),
+            WordOperations.deleteWordRight(ctx, WordNavigationType.WordStart),
+            WordOperations.deleteWordRight(ctx, WordNavigationType.WordEnd),
             WordOperations._deleteWordPartRight(ctx.model, ctx.selection)
         ]);
         candidates.sort(Range.compareRangesUsingStarts);
@@ -666,8 +680,8 @@ class WordPartOperations extends WordOperations {
     }
     static moveWordPartLeft(wordSeparators, model, position) {
         const candidates = enforceDefined([
-            WordOperations.moveWordLeft(wordSeparators, model, position, 0 ),
-            WordOperations.moveWordLeft(wordSeparators, model, position, 2 ),
+            WordOperations.moveWordLeft(wordSeparators, model, position, WordNavigationType.WordStart),
+            WordOperations.moveWordLeft(wordSeparators, model, position, WordNavigationType.WordEnd),
             WordOperations._moveWordPartLeft(model, position)
         ]);
         candidates.sort(Position.compare);
@@ -675,8 +689,8 @@ class WordPartOperations extends WordOperations {
     }
     static moveWordPartRight(wordSeparators, model, position) {
         const candidates = enforceDefined([
-            WordOperations.moveWordRight(wordSeparators, model, position, 0 ),
-            WordOperations.moveWordRight(wordSeparators, model, position, 2 ),
+            WordOperations.moveWordRight(wordSeparators, model, position, WordNavigationType.WordStart),
+            WordOperations.moveWordRight(wordSeparators, model, position, WordNavigationType.WordEnd),
             WordOperations._moveWordPartRight(model, position)
         ]);
         candidates.sort(Position.compare);
@@ -686,4 +700,4 @@ class WordPartOperations extends WordOperations {
 function enforceDefined(arr) {
     return arr.filter(el => Boolean(el));
 }
-export { WordOperations, WordPartOperations };
+export { WordNavigationType, WordOperations, WordPartOperations };

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

@@ -1,12 +1,13 @@
-import { SingleCursorState, CursorState } from '../cursorCommon.js';
+import { SingleCursorState, SelectionStartKind, CursorState } from '../cursorCommon.js';
 import { Position } from '../core/position.js';
 import { Range } from '../core/range.js';
 import { Selection } from '../core/selection.js';
+import { TrackedRangeStickiness, PositionAffinity } from '../model.js';
 class Cursor {
     constructor(context) {
         this._selTrackedRange = null;
         this._trackSelection = true;
-        this._setState(context, ( new SingleCursorState(( new Range(1, 1, 1, 1)), 0 , 0, ( new Position(1, 1)), 0)), ( new SingleCursorState(( new Range(1, 1, 1, 1)), 0 , 0, ( new Position(1, 1)), 0)));
+        this._setState(context, ( new SingleCursorState(( new Range(1, 1, 1, 1)), SelectionStartKind.Simple, 0, ( new Position(1, 1)), 0)), ( new SingleCursorState(( new Range(1, 1, 1, 1)), SelectionStartKind.Simple, 0, ( new Position(1, 1)), 0)));
     }
     dispose(context) {
         this._removeTrackedRange(context);
@@ -23,10 +24,10 @@ class Cursor {
         if (!this._trackSelection) {
             return;
         }
-        this._selTrackedRange = context.model._setTrackedRange(this._selTrackedRange, this.modelState.selection, 0 );
+        this._selTrackedRange = context.model._setTrackedRange(this._selTrackedRange, this.modelState.selection, TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges);
     }
     _removeTrackedRange(context) {
-        this._selTrackedRange = context.model._setTrackedRange(this._selTrackedRange, null, 0 );
+        this._selTrackedRange = context.model._setTrackedRange(this._selTrackedRange, null, TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges);
     }
     asCursorState() {
         return ( new CursorState(this.modelState, this.viewState));
@@ -48,13 +49,13 @@ class Cursor {
         if (position.equals(cacheInput)) {
             return cacheOutput;
         }
-        return viewModel.normalizePosition(position, 2 );
+        return viewModel.normalizePosition(position, PositionAffinity.None);
     }
     static _validateViewState(viewModel, viewState) {
         const position = viewState.position;
         const sStartPosition = viewState.selectionStart.getStartPosition();
         const sEndPosition = viewState.selectionStart.getEndPosition();
-        const validPosition = viewModel.normalizePosition(position, 2 );
+        const validPosition = viewModel.normalizePosition(position, PositionAffinity.None);
         const validSStartPosition = this._validatePositionWithCache(viewModel, sStartPosition, position, validPosition);
         const validSEndPosition = this._validatePositionWithCache(viewModel, sEndPosition, sStartPosition, validSStartPosition);
         if (position.equals(validPosition) && sStartPosition.equals(validSStartPosition) && sEndPosition.equals(validSEndPosition)) {

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

@@ -1,61 +1,71 @@
+import { EditorOption } from './config/editorOptions.js';
 import { Position } from './core/position.js';
 import { Range } from './core/range.js';
 import { Selection } from './core/selection.js';
 import { createScopedLineTokens } from './languages/supports.js';
 import { CursorColumns } from './core/cursorColumns.js';
 import { normalizeIndentation } from './core/indentation.js';
+var EditOperationType;
+( (function(EditOperationType) {
+    EditOperationType[EditOperationType["Other"] = 0] = "Other";
+    EditOperationType[EditOperationType["DeletingLeft"] = 2] = "DeletingLeft";
+    EditOperationType[EditOperationType["DeletingRight"] = 3] = "DeletingRight";
+    EditOperationType[EditOperationType["TypingOther"] = 4] = "TypingOther";
+    EditOperationType[EditOperationType["TypingFirstSpace"] = 5] = "TypingFirstSpace";
+    EditOperationType[EditOperationType["TypingConsecutiveSpace"] = 6] = "TypingConsecutiveSpace";
+})(EditOperationType || (EditOperationType = {})));
 const autoCloseAlways = () => true;
 const autoCloseNever = () => false;
 const autoCloseBeforeWhitespace = (chr) => (chr === ' ' || chr === '\t');
 class CursorConfiguration {
     static shouldRecreate(e) {
-        return (e.hasChanged(145 )
-            || e.hasChanged(131 )
-            || e.hasChanged(37 )
-            || e.hasChanged(77 )
-            || e.hasChanged(79 )
-            || e.hasChanged(80 )
-            || e.hasChanged(6 )
-            || e.hasChanged(7 )
-            || e.hasChanged(11 )
-            || e.hasChanged(9 )
-            || e.hasChanged(10 )
-            || e.hasChanged(14 )
-            || e.hasChanged(128 )
-            || e.hasChanged(50 )
-            || e.hasChanged(91 )
-            || e.hasChanged(130 ));
+        return (e.hasChanged(EditorOption.layoutInfo)
+            || e.hasChanged(EditorOption.wordSeparators)
+            || e.hasChanged(EditorOption.emptySelectionClipboard)
+            || e.hasChanged(EditorOption.multiCursorMergeOverlapping)
+            || e.hasChanged(EditorOption.multiCursorPaste)
+            || e.hasChanged(EditorOption.multiCursorLimit)
+            || e.hasChanged(EditorOption.autoClosingBrackets)
+            || e.hasChanged(EditorOption.autoClosingComments)
+            || e.hasChanged(EditorOption.autoClosingQuotes)
+            || e.hasChanged(EditorOption.autoClosingDelete)
+            || e.hasChanged(EditorOption.autoClosingOvertype)
+            || e.hasChanged(EditorOption.autoSurround)
+            || e.hasChanged(EditorOption.useTabStops)
+            || e.hasChanged(EditorOption.fontInfo)
+            || e.hasChanged(EditorOption.readOnly)
+            || e.hasChanged(EditorOption.wordSegmenterLocales));
     }
     constructor(languageId, modelOptions, configuration, languageConfigurationService) {
         this.languageConfigurationService = languageConfigurationService;
         this._cursorMoveConfigurationBrand = undefined;
         this._languageId = languageId;
         const options = configuration.options;
-        const layoutInfo = options.get(145 );
-        const fontInfo = options.get(50 );
-        this.readOnly = options.get(91 );
+        const layoutInfo = options.get(EditorOption.layoutInfo);
+        const fontInfo = options.get(EditorOption.fontInfo);
+        this.readOnly = options.get(EditorOption.readOnly);
         this.tabSize = modelOptions.tabSize;
         this.indentSize = modelOptions.indentSize;
         this.insertSpaces = modelOptions.insertSpaces;
-        this.stickyTabStops = options.get(116 );
+        this.stickyTabStops = options.get(EditorOption.stickyTabStops);
         this.lineHeight = fontInfo.lineHeight;
         this.typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
         this.pageSize = Math.max(1, Math.floor(layoutInfo.height / this.lineHeight) - 2);
-        this.useTabStops = options.get(128 );
-        this.wordSeparators = options.get(131 );
-        this.emptySelectionClipboard = options.get(37 );
-        this.copyWithSyntaxHighlighting = options.get(25 );
-        this.multiCursorMergeOverlapping = options.get(77 );
-        this.multiCursorPaste = options.get(79 );
-        this.multiCursorLimit = options.get(80 );
-        this.autoClosingBrackets = options.get(6 );
-        this.autoClosingComments = options.get(7 );
-        this.autoClosingQuotes = options.get(11 );
-        this.autoClosingDelete = options.get(9 );
-        this.autoClosingOvertype = options.get(10 );
-        this.autoSurround = options.get(14 );
-        this.autoIndent = options.get(12 );
-        this.wordSegmenterLocales = options.get(130 );
+        this.useTabStops = options.get(EditorOption.useTabStops);
+        this.wordSeparators = options.get(EditorOption.wordSeparators);
+        this.emptySelectionClipboard = options.get(EditorOption.emptySelectionClipboard);
+        this.copyWithSyntaxHighlighting = options.get(EditorOption.copyWithSyntaxHighlighting);
+        this.multiCursorMergeOverlapping = options.get(EditorOption.multiCursorMergeOverlapping);
+        this.multiCursorPaste = options.get(EditorOption.multiCursorPaste);
+        this.multiCursorLimit = options.get(EditorOption.multiCursorLimit);
+        this.autoClosingBrackets = options.get(EditorOption.autoClosingBrackets);
+        this.autoClosingComments = options.get(EditorOption.autoClosingComments);
+        this.autoClosingQuotes = options.get(EditorOption.autoClosingQuotes);
+        this.autoClosingDelete = options.get(EditorOption.autoClosingDelete);
+        this.autoClosingOvertype = options.get(EditorOption.autoClosingOvertype);
+        this.autoSurround = options.get(EditorOption.autoSurround);
+        this.autoIndent = options.get(EditorOption.autoIndent);
+        this.wordSegmenterLocales = options.get(EditorOption.wordSegmenterLocales);
         this.surroundingPairs = {};
         this._electricChars = null;
         this.shouldAutoCloseBefore = {
@@ -139,7 +149,7 @@ class CursorState {
         const selection = Selection.liftSelection(modelSelection);
         const modelState = ( new SingleCursorState(
             Range.fromPositions(selection.getSelectionStart()),
-            0 ,
+            SelectionStartKind.Simple,
             0,
             selection.getPosition(),
             0
@@ -174,6 +184,12 @@ class PartialViewCursorState {
         this.viewState = viewState;
     }
 }
+var SelectionStartKind;
+( (function(SelectionStartKind) {
+    SelectionStartKind[SelectionStartKind["Simple"] = 0] = "Simple";
+    SelectionStartKind[SelectionStartKind["Word"] = 1] = "Word";
+    SelectionStartKind[SelectionStartKind["Line"] = 2] = "Line";
+})(SelectionStartKind || (SelectionStartKind = {})));
 class SingleCursorState {
     constructor(selectionStart, selectionStartKind, selectionStartLeftoverVisibleColumns, position, leftoverVisibleColumns) {
         this.selectionStart = selectionStart;
@@ -205,7 +221,7 @@ class SingleCursorState {
             ));
         }
         else {
-            return ( new SingleCursorState(( new Range(lineNumber, column, lineNumber, column)), 0 , leftoverVisibleColumns, ( new Position(lineNumber, column)), leftoverVisibleColumns));
+            return ( new SingleCursorState(( new Range(lineNumber, column, lineNumber, column)), SelectionStartKind.Simple, leftoverVisibleColumns, ( new Position(lineNumber, column)), leftoverVisibleColumns));
         }
     }
     static _computeSelection(selectionStart, position) {
@@ -229,4 +245,4 @@ class EditOperationResult {
 function isQuote(ch) {
     return (ch === '\'' || ch === '"' || ch === '`');
 }
-export { CursorConfiguration, CursorState, EditOperationResult, PartialModelCursorState, PartialViewCursorState, SingleCursorState, isQuote };
+export { CursorConfiguration, CursorState, EditOperationResult, EditOperationType, PartialModelCursorState, PartialViewCursorState, SelectionStartKind, SingleCursorState, isQuote };

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

@@ -0,0 +1,11 @@
+var CursorChangeReason;
+( (function(CursorChangeReason) {
+    CursorChangeReason[CursorChangeReason["NotSet"] = 0] = "NotSet";
+    CursorChangeReason[CursorChangeReason["ContentFlush"] = 1] = "ContentFlush";
+    CursorChangeReason[CursorChangeReason["RecoverFromMarkers"] = 2] = "RecoverFromMarkers";
+    CursorChangeReason[CursorChangeReason["Explicit"] = 3] = "Explicit";
+    CursorChangeReason[CursorChangeReason["Paste"] = 4] = "Paste";
+    CursorChangeReason[CursorChangeReason["Undo"] = 5] = "Undo";
+    CursorChangeReason[CursorChangeReason["Redo"] = 6] = "Redo";
+})(CursorChangeReason || (CursorChangeReason = {})));
+export { CursorChangeReason };

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/defaultLinesDiffComputer.js

@@ -61,7 +61,7 @@ class DefaultLinesDiffComputer {
                         : 1 + Math.log(1 + modifiedLines[offset2].length)
                     : 0.99);
             }
-            return this.myersDiffingAlgorithm.compute(sequence1, sequence2);
+            return this.myersDiffingAlgorithm.compute(sequence1, sequence2, timeout);
         })();
         let lineAlignments = lineAlignmentResult.diffs;
         let hitTimeout = lineAlignmentResult.hitTimeout;

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/lineSequence.js

@@ -1,3 +1,4 @@
+import { CharCode } from '../../../../base/common/charCode.js';
 class LineSequence {
     constructor(trimmedHash, lines) {
         this.trimmedHash = trimmedHash;
@@ -23,7 +24,7 @@ class LineSequence {
 }
 function getIndentation(str) {
     let i = 0;
-    while (i < str.length && (str.charCodeAt(i) === 32  || str.charCodeAt(i) === 9 )) {
+    while (i < str.length && (str.charCodeAt(i) === CharCode.Space || str.charCodeAt(i) === CharCode.Tab)) {
         i++;
     }
     return i;