@codingame/monaco-vscode-api 19.1.4 → 20.0.0

package/vscode/src/vs/editor/common/core/edits/textEdit.js

@@ -290,6 +290,11 @@ class TextReplacement {
         ));
         return this.extendToCoverRange(newRange, initialValue);
     }
+    removeCommonPrefixAndSuffix(text) {
+        const prefix = this.removeCommonPrefix(text);
+        const suffix = prefix.removeCommonSuffix(text);
+        return suffix;
+    }
     removeCommonPrefix(text) {
         const normalizedOriginalText = text.getValueOfRange(this.range).replaceAll('\r\n', '\n');
         const normalizedModifiedText = this.text.replaceAll('\r\n', '\n');
@@ -300,6 +305,16 @@ class TextReplacement {
         const range = Range.fromPositions(start, this.range.getEndPosition());
         return ( new TextReplacement(range, newText));
     }
+    removeCommonSuffix(text) {
+        const normalizedOriginalText = text.getValueOfRange(this.range).replaceAll('\r\n', '\n');
+        const normalizedModifiedText = this.text.replaceAll('\r\n', '\n');
+        const commonSuffixLen = commonSuffixLength(normalizedOriginalText, normalizedModifiedText);
+        const end = TextLength.ofText(normalizedOriginalText.substring(0, normalizedOriginalText.length - commonSuffixLen))
+            .addToPosition(this.range.getStartPosition());
+        const newText = normalizedModifiedText.substring(0, normalizedModifiedText.length - commonSuffixLen);
+        const range = Range.fromPositions(this.range.getStartPosition(), end);
+        return ( new TextReplacement(range, newText));
+    }
     isEffectiveDeletion(text) {
         let newText = this.text.replaceAll('\r\n', '\n');
         let existingText = text.getValueOfRange(this.range).replaceAll('\r\n', '\n');
@@ -311,6 +326,11 @@ class TextReplacement {
         existingText = existingText.substring(0, existingText.length - r);
         return newText === '';
     }
+    toString() {
+        const start = this.range.getStartPosition();
+        const end = this.range.getEndPosition();
+        return `(${start.lineNumber},${start.column} -> ${end.lineNumber},${end.column}): "${this.text}"`;
+    }
 }
 function rangeFromPositions(start, end) {
     if (start.lineNumber === end.lineNumber && start.column === Number.MAX_SAFE_INTEGER) {

package/vscode/src/vs/editor/common/core/text/abstractText.d.ts

@@ -3,12 +3,14 @@ import { PositionOffsetTransformer } from "./positionToOffsetImpl.js";
 import { Range } from "../range.js";
 import { LineRange } from "../ranges/lineRange.js";
 import { TextLength } from "./textLength.js";
+import { OffsetRange } from "../ranges/offsetRange.js";
 export declare abstract class AbstractText {
     abstract getValueOfRange(range: Range): string;
     abstract readonly length: TextLength;
     get endPositionExclusive(): Position;
     get lineRange(): LineRange;
     getValue(): string;
+    getValueOfOffsetRange(range: OffsetRange): string;
     getLineLength(lineNumber: number): number;
     private _transformer;
     getTransformer(): PositionOffsetTransformer;

package/vscode/src/vs/editor/common/core/text/abstractText.js

@@ -19,6 +19,9 @@ class AbstractText {
     getValue() {
         return this.getValueOfRange(this.length.toRange());
     }
+    getValueOfOffsetRange(range) {
+        return this.getValueOfRange(this.getTransformer().getRange(range));
+    }
     getLineLength(lineNumber) {
         return this.getValueOfRange(( new Range(lineNumber, 1, lineNumber, Number.MAX_SAFE_INTEGER))).length;
     }

package/vscode/src/vs/editor/common/core/text/positionToOffsetImpl.d.ts

@@ -11,7 +11,7 @@ export declare abstract class PositionOffsetTransformerBase {
     getRange(offsetRange: OffsetRange): Range;
     getStringEdit(edit: TextEdit): StringEdit;
     getStringReplacement(edit: TextReplacement): StringReplacement;
-    getSingleTextEdit(edit: StringReplacement): TextReplacement;
+    getTextReplacement(edit: StringReplacement): TextReplacement;
     getTextEdit(edit: StringEdit): TextEdit;
 }
 interface IDeps {

package/vscode/src/vs/editor/common/core/text/positionToOffsetImpl.js

@@ -21,11 +21,11 @@ class PositionOffsetTransformerBase {
     getStringReplacement(edit) {
         return new Deps.deps.StringReplacement(this.getOffsetRange(edit.range), edit.text);
     }
-    getSingleTextEdit(edit) {
+    getTextReplacement(edit) {
         return new Deps.deps.TextReplacement(this.getRange(edit.replaceRange), edit.newText);
     }
     getTextEdit(edit) {
-        const edits = ( edit.replacements.map(e => this.getSingleTextEdit(e)));
+        const edits = ( edit.replacements.map(e => this.getTextReplacement(e)));
         return new Deps.deps.TextEdit(edits);
     }
 }

package/vscode/src/vs/editor/common/cursor/cursor.d.ts

@@ -9,9 +9,9 @@ import { ITextModel, ICursorStateComputer, IIdentifiedSingleEditOperation } from
 import { ModelInjectedTextChangedEvent, InternalModelContentChangeEvent } from "../textModelEvents.js";
 import { VerticalRevealType } from "../viewEvents.js";
 import { Disposable } from "../../../base/common/lifecycle.js";
-import { ICoordinatesConverter } from "../viewModel.js";
 import { ViewModelEventsCollector } from "../viewModelEventDispatcher.js";
-import { TextModelEditReason } from "../textModelEditReason.js";
+import { TextModelEditSource } from "../textModelEditSource.js";
+import { ICoordinatesConverter } from "../coordinatesConverter.js";
 export declare class CursorsController extends Disposable {
     private readonly _model;
     private _knownModelVersionId;
@@ -55,7 +55,7 @@ export declare class CursorsController extends Disposable {
     private _interpretCommandResult;
     private _emitStateChangedIfNecessary;
     private _findAutoClosingPairs;
-    executeEdits(eventsCollector: ViewModelEventsCollector, source: string | null | undefined, edits: IIdentifiedSingleEditOperation[], cursorStateComputer: ICursorStateComputer, reason: TextModelEditReason): void;
+    executeEdits(eventsCollector: ViewModelEventsCollector, source: string | null | undefined, edits: IIdentifiedSingleEditOperation[], cursorStateComputer: ICursorStateComputer, reason: TextModelEditSource): void;
     private _executeEdit;
     getAutoClosedCharacters(): Range[];
     startComposition(eventsCollector: ViewModelEventsCollector): void;
@@ -68,7 +68,7 @@ export declare class CursorsController extends Disposable {
     executeCommands(eventsCollector: ViewModelEventsCollector, commands: editorCommon.ICommand[], source?: string | null | undefined): void;
 }
 export declare class CommandExecutor {
-    static executeCommands(model: ITextModel, selectionsBefore: Selection[], commands: (editorCommon.ICommand | null)[], editReason?: TextModelEditReason): Selection[] | null;
+    static executeCommands(model: ITextModel, selectionsBefore: Selection[], commands: (editorCommon.ICommand | null)[], editReason?: TextModelEditSource): Selection[] | null;
     private static _innerExecuteCommands;
     private static _arrayIsEmpty;
     private static _getEditOperations;

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

@@ -16,7 +16,7 @@ import { ModelInjectedTextChangedEvent, RawContentChangedType } from '../textMod
 import { ViewRevealRangeRequestEvent, VerticalRevealType, ViewCursorStateChangedEvent } from '../viewEvents.js';
 import { Disposable, dispose } from '../../../base/common/lifecycle.js';
 import { CursorStateChangedEvent } from '../viewModelEventDispatcher.js';
-import { EditReasons } from '../textModelEditReason.js';
+import { EditSources } from '../textModelEditSource.js';
 
 class CursorsController extends Disposable {
     constructor(model, viewModel, coordinatesConverter, cursorConfig) {
@@ -437,7 +437,7 @@ class CursorsController extends Disposable {
         this._compositionState = ( new CompositionState(this._model, this.getSelections()));
     }
     endComposition(eventsCollector, source) {
-        const reason = EditReasons.cursor({ kind: 'compositionEnd', detailedSource: source });
+        const reason = EditSources.cursor({ kind: 'compositionEnd', detailedSource: source });
         const compositionOutcome = this._compositionState ? this._compositionState.deduceOutcome(this._model, this.getSelections()) : null;
         this._compositionState = null;
         this._executeEdit(() => {
@@ -447,7 +447,7 @@ class CursorsController extends Disposable {
         }, eventsCollector, source);
     }
     type(eventsCollector, text, source) {
-        const reason = EditReasons.cursor({ kind: 'type', detailedSource: source });
+        const reason = EditSources.cursor({ kind: 'type', detailedSource: source });
         this._executeEdit(() => {
             if (source === 'keyboard') {
                 const len = text.length;
@@ -465,7 +465,7 @@ class CursorsController extends Disposable {
         }, eventsCollector, source);
     }
     compositionType(eventsCollector, text, replacePrevCharCnt, replaceNextCharCnt, positionDelta, source) {
-        const reason = EditReasons.cursor({ kind: 'compositionType', detailedSource: source });
+        const reason = EditSources.cursor({ kind: 'compositionType', detailedSource: source });
         if (text.length === 0 && replacePrevCharCnt === 0 && replaceNextCharCnt === 0) {
             if (positionDelta !== 0) {
                 const newSelections = ( this.getSelections().map(selection => {
@@ -486,19 +486,19 @@ class CursorsController extends Disposable {
         }, eventsCollector, source);
     }
     paste(eventsCollector, text, pasteOnNewLine, multicursorText, source) {
-        const reason = EditReasons.cursor({ kind: 'paste', detailedSource: source });
+        const reason = EditSources.cursor({ kind: 'paste', detailedSource: source });
         this._executeEdit(() => {
             this._executeEditOperation(TypeOperations.paste(this.context.cursorConfig, this._model, this.getSelections(), text, pasteOnNewLine, multicursorText || []), reason);
         }, eventsCollector, source, CursorChangeReason.Paste);
     }
     cut(eventsCollector, source) {
-        const reason = EditReasons.cursor({ kind: 'cut', detailedSource: source });
+        const reason = EditSources.cursor({ kind: 'cut', detailedSource: source });
         this._executeEdit(() => {
             this._executeEditOperation(DeleteOperations.cut(this.context.cursorConfig, this._model, this.getSelections()), reason);
         }, eventsCollector, source);
     }
     executeCommand(eventsCollector, command, source) {
-        const reason = EditReasons.cursor({ kind: 'executeCommand', detailedSource: source });
+        const reason = EditSources.cursor({ kind: 'executeCommand', detailedSource: source });
         this._executeEdit(() => {
             this._cursors.killSecondaryCursors();
             this._executeEditOperation(( new EditOperationResult(EditOperationType.Other, [command], {
@@ -508,7 +508,7 @@ class CursorsController extends Disposable {
         }, eventsCollector, source);
     }
     executeCommands(eventsCollector, commands, source) {
-        const reason = EditReasons.cursor({ kind: 'executeCommands', detailedSource: source });
+        const reason = EditSources.cursor({ kind: 'executeCommands', detailedSource: source });
         this._executeEdit(() => {
             this._executeEditOperation(( new EditOperationResult(EditOperationType.Other, commands, {
                 shouldPushStackElementBefore: false,
@@ -595,7 +595,7 @@ class AutoClosedAction {
     }
 }
 class CommandExecutor {
-    static executeCommands(model, selectionsBefore, commands, editReason = EditReasons.unknown({ name: 'executeCommands' })) {
+    static executeCommands(model, selectionsBefore, commands, editReason = EditSources.unknown({ name: 'executeCommands' })) {
         const ctx = {
             model: model,
             selectionsBefore: selectionsBefore,

package/vscode/src/vs/editor/common/cursor/cursorContext.d.ts

@@ -1,6 +1,6 @@
 import { ITextModel } from "../model.js";
-import { ICoordinatesConverter } from "../viewModel.js";
 import { CursorConfiguration, ICursorSimpleModel } from "../cursorCommon.js";
+import { ICoordinatesConverter } from "../coordinatesConverter.js";
 export declare class CursorContext {
     _cursorContextBrand: void;
     readonly model: ITextModel;

package/vscode/src/vs/editor/common/cursor/cursorDeleteOperations.d.ts

@@ -9,13 +9,14 @@ export declare class DeleteOperations {
         boolean,
         Array<ICommand | null>
     ];
+    private static getDeleteRightRange;
     static isAutoClosingPairDelete(autoClosingDelete: EditorAutoClosingEditStrategy, autoClosingBrackets: EditorAutoClosingStrategy, autoClosingQuotes: EditorAutoClosingStrategy, autoClosingPairsOpen: Map<string, StandardAutoClosingPairConditional[]>, model: ICursorSimpleModel, selections: Selection[], autoClosedCharacters: Range[]): boolean;
     private static _runAutoClosingPairDelete;
     static deleteLeft(prevEditOperationType: EditOperationType, config: CursorConfiguration, model: ICursorSimpleModel, selections: Selection[], autoClosedCharacters: Range[]): [
         boolean,
         Array<ICommand | null>
     ];
-    private static getDeleteRange;
+    private static getDeleteLeftRange;
     private static getPositionAfterDeleteLeft;
     static cut(config: CursorConfiguration, model: ICursorSimpleModel, selections: Selection[]): EditOperationResult;
 }

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

@@ -13,17 +13,7 @@ class DeleteOperations {
         let shouldPushStackElementBefore = (prevEditOperationType !== EditOperationType.DeletingRight);
         for (let i = 0, len = selections.length; i < len; i++) {
             const selection = selections[i];
-            let deleteSelection = selection;
-            if (deleteSelection.isEmpty()) {
-                const position = selection.getPosition();
-                const rightOfPosition = MoveOperations.right(config, model, position);
-                deleteSelection = ( new Range(
-                    rightOfPosition.lineNumber,
-                    rightOfPosition.column,
-                    position.lineNumber,
-                    position.column
-                ));
-            }
+            const deleteSelection = this.getDeleteRightRange(selection, model, config);
             if (deleteSelection.isEmpty()) {
                 commands[i] = null;
                 continue;
@@ -35,6 +25,31 @@ class DeleteOperations {
         }
         return [shouldPushStackElementBefore, commands];
     }
+    static getDeleteRightRange(selection, model, config) {
+        if (!selection.isEmpty()) {
+            return selection;
+        }
+        const position = selection.getPosition();
+        const rightOfPosition = MoveOperations.right(config, model, position);
+        if (config.trimWhitespaceOnDelete && rightOfPosition.lineNumber !== position.lineNumber) {
+            const currentLineHasContent = (model.getLineFirstNonWhitespaceColumn(position.lineNumber) > 0);
+            const firstNonWhitespaceColumn = model.getLineFirstNonWhitespaceColumn(rightOfPosition.lineNumber);
+            if (currentLineHasContent && firstNonWhitespaceColumn > 0) {
+                return ( new Range(
+                    rightOfPosition.lineNumber,
+                    firstNonWhitespaceColumn,
+                    position.lineNumber,
+                    position.column
+                ));
+            }
+        }
+        return ( new Range(
+            rightOfPosition.lineNumber,
+            rightOfPosition.column,
+            position.lineNumber,
+            position.column
+        ));
+    }
     static isAutoClosingPairDelete(autoClosingDelete, autoClosingBrackets, autoClosingQuotes, autoClosingPairsOpen, model, selections, autoClosedCharacters) {
         if (autoClosingBrackets === 'never' && autoClosingQuotes === 'never') {
             return false;
@@ -114,7 +129,7 @@ class DeleteOperations {
         const commands = [];
         let shouldPushStackElementBefore = (prevEditOperationType !== EditOperationType.DeletingLeft);
         for (let i = 0, len = selections.length; i < len; i++) {
-            const deleteRange = DeleteOperations.getDeleteRange(selections[i], model, config);
+            const deleteRange = DeleteOperations.getDeleteLeftRange(selections[i], model, config);
             if (deleteRange.isEmpty()) {
                 commands[i] = null;
                 continue;
@@ -126,7 +141,7 @@ class DeleteOperations {
         }
         return [shouldPushStackElementBefore, commands];
     }
-    static getDeleteRange(selection, model, config) {
+    static getDeleteLeftRange(selection, model, config) {
         if (!selection.isEmpty()) {
             return selection;
         }

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

@@ -5,6 +5,7 @@ import { MoveOperations } from './cursorMoveOperations.js';
 import { WordOperations } from './cursorWordOperations.js';
 import { Position } from '../core/position.js';
 import { Range } from '../core/range.js';
+import { TextDirection } from '../model.js';
 
 class CursorMoveCommands {
     static addCursorDown(viewModel, cursors, useLogicalLine) {
@@ -337,9 +338,13 @@ class CursorMoveCommands {
         return Math.max(startLineNumber, range.endLineNumber - count + 1);
     }
     static _moveLeft(viewModel, cursors, inSelectionMode, noOfColumns) {
-        return ( cursors.map(
-            cursor => CursorState.fromViewState(MoveOperations.moveLeft(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode, noOfColumns))
-        ));
+        return ( cursors.map(cursor => {
+            const direction = viewModel.getTextDirection(cursor.viewState.position.lineNumber);
+            const isRtl = direction === TextDirection.RTL;
+            return CursorState.fromViewState(isRtl
+                ? MoveOperations.moveRight(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode, noOfColumns)
+                : MoveOperations.moveLeft(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode, noOfColumns));
+        }));
     }
     static _moveHalfLineLeft(viewModel, cursors, inSelectionMode) {
         const result = [];
@@ -352,9 +357,13 @@ class CursorMoveCommands {
         return result;
     }
     static _moveRight(viewModel, cursors, inSelectionMode, noOfColumns) {
-        return ( cursors.map(
-            cursor => CursorState.fromViewState(MoveOperations.moveRight(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode, noOfColumns))
-        ));
+        return ( cursors.map(cursor => {
+            const direction = viewModel.getTextDirection(cursor.viewState.position.lineNumber);
+            const isRtl = direction === TextDirection.RTL;
+            return CursorState.fromViewState(isRtl
+                ? MoveOperations.moveLeft(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode, noOfColumns)
+                : MoveOperations.moveRight(viewModel.cursorConfig, viewModel, cursor.viewState, inSelectionMode, noOfColumns));
+        }));
     }
     static _moveHalfLineRight(viewModel, cursors, inSelectionMode) {
         const result = [];

package/vscode/src/vs/editor/common/cursorCommon.d.ts

@@ -39,6 +39,7 @@ export declare class CursorConfiguration {
     readonly lineHeight: number;
     readonly typicalHalfwidthCharacterWidth: number;
     readonly useTabStops: boolean;
+    readonly trimWhitespaceOnDelete: boolean;
     readonly wordSeparators: string;
     readonly emptySelectionClipboard: boolean;
     readonly copyWithSyntaxHighlighting: boolean;

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

@@ -35,6 +35,7 @@ class CursorConfiguration {
             || e.hasChanged(EditorOption.autoClosingOvertype)
             || e.hasChanged(EditorOption.autoSurround)
             || e.hasChanged(EditorOption.useTabStops)
+            || e.hasChanged(EditorOption.trimWhitespaceOnDelete)
             || e.hasChanged(EditorOption.fontInfo)
             || e.hasChanged(EditorOption.readOnly)
             || e.hasChanged(EditorOption.wordSegmenterLocales)
@@ -56,6 +57,7 @@ class CursorConfiguration {
         this.typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
         this.pageSize = Math.max(1, Math.floor(layoutInfo.height / this.lineHeight) - 2);
         this.useTabStops = options.get(EditorOption.useTabStops);
+        this.trimWhitespaceOnDelete = options.get(EditorOption.trimWhitespaceOnDelete);
         this.wordSeparators = options.get(EditorOption.wordSeparators);
         this.emptySelectionClipboard = options.get(EditorOption.emptySelectionClipboard);
         this.copyWithSyntaxHighlighting = options.get(EditorOption.copyWithSyntaxHighlighting);

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

@@ -5,73 +5,73 @@ import { RawContextKey } from '../../platform/contextkey/common/contextkey.js';
 var EditorContextKeys;
 (function (EditorContextKeys) {
     EditorContextKeys.editorSimpleInput = ( new RawContextKey('editorSimpleInput', false, true));
-    EditorContextKeys.editorTextFocus = ( new RawContextKey('editorTextFocus', false, ( localize(730, "Whether the editor text has focus (cursor is blinking)"))));
+    EditorContextKeys.editorTextFocus = ( new RawContextKey('editorTextFocus', false, ( localize(740, "Whether the editor text has focus (cursor is blinking)"))));
     EditorContextKeys.focus = ( new RawContextKey('editorFocus', false, ( localize(
-     731,
+     741,
      "Whether the editor or an editor widget has focus (e.g. focus is in the find widget)"
     ))));
     EditorContextKeys.textInputFocus = ( new RawContextKey('textInputFocus', false, ( localize(
-     732,
+     742,
      "Whether an editor or a rich text input has focus (cursor is blinking)"
     ))));
-    EditorContextKeys.readOnly = ( new RawContextKey('editorReadonly', false, ( localize(733, "Whether the editor is read-only"))));
-    EditorContextKeys.inDiffEditor = ( new RawContextKey('inDiffEditor', false, ( localize(734, "Whether the context is a diff editor"))));
-    EditorContextKeys.isEmbeddedDiffEditor = ( new RawContextKey('isEmbeddedDiffEditor', false, ( localize(735, "Whether the context is an embedded diff editor"))));
-    EditorContextKeys.multiDiffEditorAllCollapsed = ( new RawContextKey('multiDiffEditorAllCollapsed', undefined, ( localize(736, "Whether all files in multi diff editor are collapsed"))));
-    EditorContextKeys.hasChanges = ( new RawContextKey('diffEditorHasChanges', false, ( localize(737, "Whether the diff editor has changes"))));
-    EditorContextKeys.comparingMovedCode = ( new RawContextKey('comparingMovedCode', false, ( localize(738, "Whether a moved code block is selected for comparison"))));
-    EditorContextKeys.accessibleDiffViewerVisible = ( new RawContextKey('accessibleDiffViewerVisible', false, ( localize(739, "Whether the accessible diff viewer is visible"))));
+    EditorContextKeys.readOnly = ( new RawContextKey('editorReadonly', false, ( localize(743, "Whether the editor is read-only"))));
+    EditorContextKeys.inDiffEditor = ( new RawContextKey('inDiffEditor', false, ( localize(744, "Whether the context is a diff editor"))));
+    EditorContextKeys.isEmbeddedDiffEditor = ( new RawContextKey('isEmbeddedDiffEditor', false, ( localize(745, "Whether the context is an embedded diff editor"))));
+    EditorContextKeys.multiDiffEditorAllCollapsed = ( new RawContextKey('multiDiffEditorAllCollapsed', undefined, ( localize(746, "Whether all files in multi diff editor are collapsed"))));
+    EditorContextKeys.hasChanges = ( new RawContextKey('diffEditorHasChanges', false, ( localize(747, "Whether the diff editor has changes"))));
+    EditorContextKeys.comparingMovedCode = ( new RawContextKey('comparingMovedCode', false, ( localize(748, "Whether a moved code block is selected for comparison"))));
+    EditorContextKeys.accessibleDiffViewerVisible = ( new RawContextKey('accessibleDiffViewerVisible', false, ( localize(749, "Whether the accessible diff viewer is visible"))));
     EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached = ( new RawContextKey('diffEditorRenderSideBySideInlineBreakpointReached', false, ( localize(
-     740,
+     750,
      "Whether the diff editor render side by side inline breakpoint is reached"
     ))));
-    EditorContextKeys.diffEditorInlineMode = ( new RawContextKey('diffEditorInlineMode', false, ( localize(741, "Whether inline mode is active"))));
-    EditorContextKeys.diffEditorOriginalWritable = ( new RawContextKey('diffEditorOriginalWritable', false, ( localize(742, "Whether modified is writable in the diff editor"))));
-    EditorContextKeys.diffEditorModifiedWritable = ( new RawContextKey('diffEditorModifiedWritable', false, ( localize(743, "Whether modified is writable in the diff editor"))));
-    EditorContextKeys.diffEditorOriginalUri = ( new RawContextKey('diffEditorOriginalUri', '', ( localize(744, "The uri of the original document"))));
-    EditorContextKeys.diffEditorModifiedUri = ( new RawContextKey('diffEditorModifiedUri', '', ( localize(745, "The uri of the modified document"))));
-    EditorContextKeys.columnSelection = ( new RawContextKey('editorColumnSelection', false, ( localize(746, "Whether `editor.columnSelection` is enabled"))));
+    EditorContextKeys.diffEditorInlineMode = ( new RawContextKey('diffEditorInlineMode', false, ( localize(751, "Whether inline mode is active"))));
+    EditorContextKeys.diffEditorOriginalWritable = ( new RawContextKey('diffEditorOriginalWritable', false, ( localize(752, "Whether modified is writable in the diff editor"))));
+    EditorContextKeys.diffEditorModifiedWritable = ( new RawContextKey('diffEditorModifiedWritable', false, ( localize(753, "Whether modified is writable in the diff editor"))));
+    EditorContextKeys.diffEditorOriginalUri = ( new RawContextKey('diffEditorOriginalUri', '', ( localize(754, "The uri of the original document"))));
+    EditorContextKeys.diffEditorModifiedUri = ( new RawContextKey('diffEditorModifiedUri', '', ( localize(755, "The uri of the modified document"))));
+    EditorContextKeys.columnSelection = ( new RawContextKey('editorColumnSelection', false, ( localize(756, "Whether `editor.columnSelection` is enabled"))));
     EditorContextKeys.writable = ( EditorContextKeys.readOnly.toNegated());
-    EditorContextKeys.hasNonEmptySelection = ( new RawContextKey('editorHasSelection', false, ( localize(747, "Whether the editor has text selected"))));
+    EditorContextKeys.hasNonEmptySelection = ( new RawContextKey('editorHasSelection', false, ( localize(757, "Whether the editor has text selected"))));
     EditorContextKeys.hasOnlyEmptySelection = ( EditorContextKeys.hasNonEmptySelection.toNegated());
-    EditorContextKeys.hasMultipleSelections = ( new RawContextKey('editorHasMultipleSelections', false, ( localize(748, "Whether the editor has multiple selections"))));
+    EditorContextKeys.hasMultipleSelections = ( new RawContextKey('editorHasMultipleSelections', false, ( localize(758, "Whether the editor has multiple selections"))));
     EditorContextKeys.hasSingleSelection = ( EditorContextKeys.hasMultipleSelections.toNegated());
-    EditorContextKeys.tabMovesFocus = ( new RawContextKey('editorTabMovesFocus', false, ( localize(749, "Whether `Tab` will move focus out of the editor"))));
+    EditorContextKeys.tabMovesFocus = ( new RawContextKey('editorTabMovesFocus', false, ( localize(759, "Whether `Tab` will move focus out of the editor"))));
     EditorContextKeys.tabDoesNotMoveFocus = ( EditorContextKeys.tabMovesFocus.toNegated());
     EditorContextKeys.isInEmbeddedEditor = ( new RawContextKey('isInEmbeddedEditor', false, true));
     EditorContextKeys.canUndo = ( new RawContextKey('canUndo', false, true));
     EditorContextKeys.canRedo = ( new RawContextKey('canRedo', false, true));
-    EditorContextKeys.hoverVisible = ( new RawContextKey('editorHoverVisible', false, ( localize(750, "Whether the editor hover is visible"))));
-    EditorContextKeys.hoverFocused = ( new RawContextKey('editorHoverFocused', false, ( localize(751, "Whether the editor hover is focused"))));
-    EditorContextKeys.stickyScrollFocused = ( new RawContextKey('stickyScrollFocused', false, ( localize(752, "Whether the sticky scroll is focused"))));
-    EditorContextKeys.stickyScrollVisible = ( new RawContextKey('stickyScrollVisible', false, ( localize(753, "Whether the sticky scroll is visible"))));
-    EditorContextKeys.standaloneColorPickerVisible = ( new RawContextKey('standaloneColorPickerVisible', false, ( localize(754, "Whether the standalone color picker is visible"))));
-    EditorContextKeys.standaloneColorPickerFocused = ( new RawContextKey('standaloneColorPickerFocused', false, ( localize(755, "Whether the standalone color picker is focused"))));
-    EditorContextKeys.inCompositeEditor = ( new RawContextKey('inCompositeEditor', undefined, ( localize(756, "Whether the editor is part of a larger editor (e.g. notebooks)"))));
+    EditorContextKeys.hoverVisible = ( new RawContextKey('editorHoverVisible', false, ( localize(760, "Whether the editor hover is visible"))));
+    EditorContextKeys.hoverFocused = ( new RawContextKey('editorHoverFocused', false, ( localize(761, "Whether the editor hover is focused"))));
+    EditorContextKeys.stickyScrollFocused = ( new RawContextKey('stickyScrollFocused', false, ( localize(762, "Whether the sticky scroll is focused"))));
+    EditorContextKeys.stickyScrollVisible = ( new RawContextKey('stickyScrollVisible', false, ( localize(763, "Whether the sticky scroll is visible"))));
+    EditorContextKeys.standaloneColorPickerVisible = ( new RawContextKey('standaloneColorPickerVisible', false, ( localize(764, "Whether the standalone color picker is visible"))));
+    EditorContextKeys.standaloneColorPickerFocused = ( new RawContextKey('standaloneColorPickerFocused', false, ( localize(765, "Whether the standalone color picker is focused"))));
+    EditorContextKeys.inCompositeEditor = ( new RawContextKey('inCompositeEditor', undefined, ( localize(766, "Whether the editor is part of a larger editor (e.g. notebooks)"))));
     EditorContextKeys.notInCompositeEditor = ( EditorContextKeys.inCompositeEditor.toNegated());
-    EditorContextKeys.languageId = ( new RawContextKey('editorLangId', '', ( localize(757, "The language identifier of the editor"))));
-    EditorContextKeys.hasCompletionItemProvider = ( new RawContextKey('editorHasCompletionItemProvider', false, ( localize(758, "Whether the editor has a completion item provider"))));
-    EditorContextKeys.hasCodeActionsProvider = ( new RawContextKey('editorHasCodeActionsProvider', false, ( localize(759, "Whether the editor has a code actions provider"))));
-    EditorContextKeys.hasCodeLensProvider = ( new RawContextKey('editorHasCodeLensProvider', false, ( localize(760, "Whether the editor has a code lens provider"))));
-    EditorContextKeys.hasDefinitionProvider = ( new RawContextKey('editorHasDefinitionProvider', false, ( localize(761, "Whether the editor has a definition provider"))));
-    EditorContextKeys.hasDeclarationProvider = ( new RawContextKey('editorHasDeclarationProvider', false, ( localize(762, "Whether the editor has a declaration provider"))));
-    EditorContextKeys.hasImplementationProvider = ( new RawContextKey('editorHasImplementationProvider', false, ( localize(763, "Whether the editor has an implementation provider"))));
-    EditorContextKeys.hasTypeDefinitionProvider = ( new RawContextKey('editorHasTypeDefinitionProvider', false, ( localize(764, "Whether the editor has a type definition provider"))));
-    EditorContextKeys.hasHoverProvider = ( new RawContextKey('editorHasHoverProvider', false, ( localize(765, "Whether the editor has a hover provider"))));
-    EditorContextKeys.hasDocumentHighlightProvider = ( new RawContextKey('editorHasDocumentHighlightProvider', false, ( localize(766, "Whether the editor has a document highlight provider"))));
-    EditorContextKeys.hasDocumentSymbolProvider = ( new RawContextKey('editorHasDocumentSymbolProvider', false, ( localize(767, "Whether the editor has a document symbol provider"))));
-    EditorContextKeys.hasReferenceProvider = ( new RawContextKey('editorHasReferenceProvider', false, ( localize(768, "Whether the editor has a reference provider"))));
-    EditorContextKeys.hasRenameProvider = ( new RawContextKey('editorHasRenameProvider', false, ( localize(769, "Whether the editor has a rename provider"))));
-    EditorContextKeys.hasSignatureHelpProvider = ( new RawContextKey('editorHasSignatureHelpProvider', false, ( localize(770, "Whether the editor has a signature help provider"))));
-    EditorContextKeys.hasInlayHintsProvider = ( new RawContextKey('editorHasInlayHintsProvider', false, ( localize(771, "Whether the editor has an inline hints provider"))));
-    EditorContextKeys.hasDocumentFormattingProvider = ( new RawContextKey('editorHasDocumentFormattingProvider', false, ( localize(772, "Whether the editor has a document formatting provider"))));
-    EditorContextKeys.hasDocumentSelectionFormattingProvider = ( new RawContextKey('editorHasDocumentSelectionFormattingProvider', false, ( localize(773, "Whether the editor has a document selection formatting provider"))));
-    EditorContextKeys.hasMultipleDocumentFormattingProvider = ( new RawContextKey('editorHasMultipleDocumentFormattingProvider', false, ( localize(774, "Whether the editor has multiple document formatting providers"))));
+    EditorContextKeys.languageId = ( new RawContextKey('editorLangId', '', ( localize(767, "The language identifier of the editor"))));
+    EditorContextKeys.hasCompletionItemProvider = ( new RawContextKey('editorHasCompletionItemProvider', false, ( localize(768, "Whether the editor has a completion item provider"))));
+    EditorContextKeys.hasCodeActionsProvider = ( new RawContextKey('editorHasCodeActionsProvider', false, ( localize(769, "Whether the editor has a code actions provider"))));
+    EditorContextKeys.hasCodeLensProvider = ( new RawContextKey('editorHasCodeLensProvider', false, ( localize(770, "Whether the editor has a code lens provider"))));
+    EditorContextKeys.hasDefinitionProvider = ( new RawContextKey('editorHasDefinitionProvider', false, ( localize(771, "Whether the editor has a definition provider"))));
+    EditorContextKeys.hasDeclarationProvider = ( new RawContextKey('editorHasDeclarationProvider', false, ( localize(772, "Whether the editor has a declaration provider"))));
+    EditorContextKeys.hasImplementationProvider = ( new RawContextKey('editorHasImplementationProvider', false, ( localize(773, "Whether the editor has an implementation provider"))));
+    EditorContextKeys.hasTypeDefinitionProvider = ( new RawContextKey('editorHasTypeDefinitionProvider', false, ( localize(774, "Whether the editor has a type definition provider"))));
+    EditorContextKeys.hasHoverProvider = ( new RawContextKey('editorHasHoverProvider', false, ( localize(775, "Whether the editor has a hover provider"))));
+    EditorContextKeys.hasDocumentHighlightProvider = ( new RawContextKey('editorHasDocumentHighlightProvider', false, ( localize(776, "Whether the editor has a document highlight provider"))));
+    EditorContextKeys.hasDocumentSymbolProvider = ( new RawContextKey('editorHasDocumentSymbolProvider', false, ( localize(777, "Whether the editor has a document symbol provider"))));
+    EditorContextKeys.hasReferenceProvider = ( new RawContextKey('editorHasReferenceProvider', false, ( localize(778, "Whether the editor has a reference provider"))));
+    EditorContextKeys.hasRenameProvider = ( new RawContextKey('editorHasRenameProvider', false, ( localize(779, "Whether the editor has a rename provider"))));
+    EditorContextKeys.hasSignatureHelpProvider = ( new RawContextKey('editorHasSignatureHelpProvider', false, ( localize(780, "Whether the editor has a signature help provider"))));
+    EditorContextKeys.hasInlayHintsProvider = ( new RawContextKey('editorHasInlayHintsProvider', false, ( localize(781, "Whether the editor has an inline hints provider"))));
+    EditorContextKeys.hasDocumentFormattingProvider = ( new RawContextKey('editorHasDocumentFormattingProvider', false, ( localize(782, "Whether the editor has a document formatting provider"))));
+    EditorContextKeys.hasDocumentSelectionFormattingProvider = ( new RawContextKey('editorHasDocumentSelectionFormattingProvider', false, ( localize(783, "Whether the editor has a document selection formatting provider"))));
+    EditorContextKeys.hasMultipleDocumentFormattingProvider = ( new RawContextKey('editorHasMultipleDocumentFormattingProvider', false, ( localize(784, "Whether the editor has multiple document formatting providers"))));
     EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider = ( new RawContextKey(
      'editorHasMultipleDocumentSelectionFormattingProvider',
      false,
      ( localize(
-     775,
+     785,
      "Whether the editor has multiple document selection formatting providers"
     ))
     ));

package/vscode/src/vs/editor/common/languages/defaultDocumentColorsComputer.js

@@ -87,7 +87,7 @@ function _findMatches(model, regex) {
 }
 function computeColors(model) {
     const result = [];
-    const initialValidationRegex = /\b(rgb|rgba|hsl|hsla)(\([0-9\s,.\%]*\))|^(#)([A-Fa-f0-9]{6})\b|^(#)([A-Fa-f0-9]{8})\b|(?<=['"\s])(#)([A-Fa-f0-9]{6})\b|(?<=['"\s])(#)([A-Fa-f0-9]{8})\b/gm;
+    const initialValidationRegex = /\b(rgb|rgba|hsl|hsla)(\([0-9\s,.\%]*\))|^(#)([A-Fa-f0-9]{3})\b|^(#)([A-Fa-f0-9]{4})\b|^(#)([A-Fa-f0-9]{6})\b|^(#)([A-Fa-f0-9]{8})\b|(?<=['"\s])(#)([A-Fa-f0-9]{3})\b|(?<=['"\s])(#)([A-Fa-f0-9]{4})\b|(?<=['"\s])(#)([A-Fa-f0-9]{6})\b|(?<=['"\s])(#)([A-Fa-f0-9]{8})\b/gm;
     const initialValidationMatches = _findMatches(model, initialValidationRegex);
     if (initialValidationMatches.length > 0) {
         for (const initialMatch of initialValidationMatches) {
@@ -107,11 +107,11 @@ function computeColors(model) {
                 colorInformation = _findRGBColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), true);
             }
             else if (colorScheme === 'hsl') {
-                const regexParameters = /^\(\s*(36[0]|3[0-5][0-9]|[12][0-9][0-9]|[1-9]?[0-9])\s*,\s*(100|\d{1,2}[.]\d*|\d{1,2})%\s*,\s*(100|\d{1,2}[.]\d*|\d{1,2})%\s*\)$/gm;
+                const regexParameters = /^\(\s*((?:360(?:\.0+)?|(?:36[0]|3[0-5][0-9]|[12][0-9][0-9]|[1-9]?[0-9])(?:\.\d+)?))\s*[\s,]\s*(100|\d{1,2}[.]\d*|\d{1,2})%\s*[\s,]\s*(100|\d{1,2}[.]\d*|\d{1,2})%\s*\)$/gm;
                 colorInformation = _findHSLColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), false);
             }
             else if (colorScheme === 'hsla') {
-                const regexParameters = /^\(\s*(36[0]|3[0-5][0-9]|[12][0-9][0-9]|[1-9]?[0-9])\s*,\s*(100|\d{1,2}[.]\d*|\d{1,2})%\s*,\s*(100|\d{1,2}[.]\d*|\d{1,2})%\s*,\s*(0[.][0-9]+|[.][0-9]+|[01][.]|[01])\s*\)$/gm;
+                const regexParameters = /^\(\s*((?:360(?:\.0+)?|(?:36[0]|3[0-5][0-9]|[12][0-9][0-9]|[1-9]?[0-9])(?:\.\d+)?))\s*[\s,]\s*(100|\d{1,2}[.]\d*|\d{1,2})%\s*[\s,]\s*(100|\d{1,2}[.]\d*|\d{1,2})%\s*[\s,]\s*(0[.][0-9]+|[.][0-9]+|[01][.]0*|[01])\s*\)$/gm;
                 colorInformation = _findHSLColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), true);
             }
             else if (colorScheme === '#') {

package/vscode/src/vs/editor/common/languages/linkComputer.js

@@ -110,7 +110,7 @@ let _classifier = null;
 function getClassifier() {
     if (_classifier === null) {
         _classifier = ( new CharacterClassifier(CharacterClass.None));
-        const FORCE_TERMINATION_CHARACTERS = ' \t<>\'\"、。｡､，．：；‘〈「『〔（［｛｢｣｝］）〕』」〉’｀～…';
+        const FORCE_TERMINATION_CHARACTERS = ' \t<>\'\"、。｡､，．：；‘〈「『〔（［｛｢｣｝］）〕』」〉’｀～…|';
         for (let i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) {
             _classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), CharacterClass.ForceTermination);
         }
@@ -210,9 +210,6 @@ class LinkComputer {
                         case CharCode.Asterisk:
                             chClass = (linkBeginChCode === CharCode.Asterisk) ? CharacterClass.ForceTermination : CharacterClass.None;
                             break;
-                        case CharCode.Pipe:
-                            chClass = (linkBeginChCode === CharCode.Pipe) ? CharacterClass.ForceTermination : CharacterClass.None;
-                            break;
                         case CharCode.Space:
                             chClass = (inSquareBrackets ? CharacterClass.None : CharacterClass.ForceTermination);
                             break;

package/vscode/src/vs/editor/common/languages/modesRegistry.js

@@ -41,7 +41,7 @@ const PLAINTEXT_EXTENSION = '.txt';
 ModesRegistry.registerLanguage({
     id: PLAINTEXT_LANGUAGE_ID,
     extensions: [PLAINTEXT_EXTENSION],
-    aliases: [( localize(832, "Plain Text")), 'text'],
+    aliases: [( localize(842, "Plain Text")), 'text'],
     mimetypes: [Mimes.text]
 });
 ( Registry.as(Extensions$1.Configuration))

package/vscode/src/vs/editor/common/languages.d.ts

@@ -244,6 +244,7 @@ export interface InlineCompletionContext {
     readonly requestUuid: string;
     readonly includeInlineEdits: boolean;
     readonly includeInlineCompletions: boolean;
+    readonly requestIssuedDateTime: number;
 }
 export declare class SelectedSuggestionInfo {
     readonly range: IRange;
@@ -299,11 +300,26 @@ export interface InlineCompletionsProvider<T extends InlineCompletions = InlineC
     disposeInlineCompletions(completions: T, reason: InlineCompletionsDisposeReason): void;
     onDidChangeInlineCompletions?: Event<void>;
     groupId?: InlineCompletionProviderGroupId;
+    providerId?: ProviderId;
     yieldsToGroupIds?: InlineCompletionProviderGroupId[];
     displayName?: string;
     debounceDelayMs?: number;
     toString?(): string;
 }
+export declare class ProviderId {
+    readonly extensionId: string | undefined;
+    readonly extensionVersion: string | undefined;
+    readonly providerId: string | undefined;
+    static fromExtensionId(extensionId: string | undefined): ProviderId;
+    constructor(extensionId: string | undefined, extensionVersion: string | undefined, providerId: string | undefined);
+    toString(): string;
+}
+export declare class VersionedExtensionId {
+    readonly extensionId: string;
+    readonly version: string;
+    constructor(extensionId: string, version: string);
+    toString(): string;
+}
 export type InlineCompletionsDisposeReason = {
     kind: "lostRace" | "tokenCancellation" | "other" | "empty" | "notTaken";
 };
@@ -331,6 +347,7 @@ export type LifetimeSummary = {
     editorType: string;
     viewKind: string | undefined;
     error: string | undefined;
+    preceeded: boolean;
     languageId: string;
     requestReason: string;
     cursorColumnDistance?: number;
@@ -341,6 +358,8 @@ export type LifetimeSummary = {
     characterCountModified?: number;
     disjointReplacements?: number;
     sameShapeReplacements?: boolean;
+    typingInterval: number;
+    typingIntervalCharacterCount: number;
 };
 export interface CodeAction {
     title: string;