@codingame/monaco-vscode-api 18.4.0 → 19.0.1

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

@@ -0,0 +1,37 @@
+import { StringEdit, StringReplacement } from "../edits/stringEdit.js";
+import { OffsetRange } from "../ranges/offsetRange.js";
+import { Position } from "../position.js";
+import { Range } from "../range.js";
+import type { TextReplacement, TextEdit } from "../edits/textEdit.js";
+import type { TextLength } from "./textLength.js";
+export declare abstract class PositionOffsetTransformerBase {
+    abstract getOffset(position: Position): number;
+    getOffsetRange(range: Range): OffsetRange;
+    abstract getPosition(offset: number): Position;
+    getRange(offsetRange: OffsetRange): Range;
+    getStringEdit(edit: TextEdit): StringEdit;
+    getStringReplacement(edit: TextReplacement): StringReplacement;
+    getSingleTextEdit(edit: StringReplacement): TextReplacement;
+    getTextEdit(edit: StringEdit): TextEdit;
+}
+interface IDeps {
+    StringEdit: typeof StringEdit;
+    StringReplacement: typeof StringReplacement;
+    TextReplacement: typeof TextReplacement;
+    TextEdit: typeof TextEdit;
+    TextLength: typeof TextLength;
+}
+export declare function _setPositionOffsetTransformerDependencies(deps: IDeps): void;
+export declare class PositionOffsetTransformer extends PositionOffsetTransformerBase {
+    readonly text: string;
+    private readonly lineStartOffsetByLineIdx;
+    private readonly lineEndOffsetByLineIdx;
+    constructor(text: string);
+    getOffset(position: Position): number;
+    private _validatePosition;
+    getPosition(offset: number): Position;
+    getTextLength(offsetRange: OffsetRange): TextLength;
+    get textLength(): TextLength;
+    getLineLength(lineNumber: number): number;
+}
+export {};

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

@@ -0,0 +1,104 @@
+
+import { findLastIdxMonotonous } from '../../../../base/common/arraysFind.js';
+import { OffsetRange } from '../ranges/offsetRange.js';
+import { Position } from '../position.js';
+import { Range } from '../range.js';
+
+class PositionOffsetTransformerBase {
+    getOffsetRange(range) {
+        return ( new OffsetRange(
+            this.getOffset(range.getStartPosition()),
+            this.getOffset(range.getEndPosition())
+        ));
+    }
+    getRange(offsetRange) {
+        return Range.fromPositions(this.getPosition(offsetRange.start), this.getPosition(offsetRange.endExclusive));
+    }
+    getStringEdit(edit) {
+        const edits = ( edit.replacements.map(e => this.getStringReplacement(e)));
+        return new Deps.deps.StringEdit(edits);
+    }
+    getStringReplacement(edit) {
+        return new Deps.deps.StringReplacement(this.getOffsetRange(edit.range), edit.text);
+    }
+    getSingleTextEdit(edit) {
+        return new Deps.deps.TextReplacement(this.getRange(edit.replaceRange), edit.newText);
+    }
+    getTextEdit(edit) {
+        const edits = ( edit.replacements.map(e => this.getSingleTextEdit(e)));
+        return new Deps.deps.TextEdit(edits);
+    }
+}
+class Deps {
+    static { this._deps = undefined; }
+    static get deps() {
+        if (!this._deps) {
+            throw ( new Error('Dependencies not set. Call _setDependencies first.'));
+        }
+        return this._deps;
+    }
+}
+function _setPositionOffsetTransformerDependencies(deps) {
+    Deps._deps = deps;
+}
+class PositionOffsetTransformer extends PositionOffsetTransformerBase {
+    constructor(text) {
+        super();
+        this.text = text;
+        this.lineStartOffsetByLineIdx = [];
+        this.lineEndOffsetByLineIdx = [];
+        this.lineStartOffsetByLineIdx.push(0);
+        for (let i = 0; i < text.length; i++) {
+            if (text.charAt(i) === '\n') {
+                this.lineStartOffsetByLineIdx.push(i + 1);
+                if (i > 0 && text.charAt(i - 1) === '\r') {
+                    this.lineEndOffsetByLineIdx.push(i - 1);
+                }
+                else {
+                    this.lineEndOffsetByLineIdx.push(i);
+                }
+            }
+        }
+        this.lineEndOffsetByLineIdx.push(text.length);
+    }
+    getOffset(position) {
+        const valPos = this._validatePosition(position);
+        return this.lineStartOffsetByLineIdx[valPos.lineNumber - 1] + valPos.column - 1;
+    }
+    _validatePosition(position) {
+        if (position.lineNumber < 1) {
+            return ( new Position(1, 1));
+        }
+        const lineCount = this.textLength.lineCount + 1;
+        if (position.lineNumber > lineCount) {
+            const lineLength = this.getLineLength(lineCount);
+            return ( new Position(lineCount, lineLength + 1));
+        }
+        if (position.column < 1) {
+            return ( new Position(position.lineNumber, 1));
+        }
+        const lineLength = this.getLineLength(position.lineNumber);
+        if (position.column - 1 > lineLength) {
+            return ( new Position(position.lineNumber, lineLength + 1));
+        }
+        return position;
+    }
+    getPosition(offset) {
+        const idx = findLastIdxMonotonous(this.lineStartOffsetByLineIdx, i => i <= offset);
+        const lineNumber = idx + 1;
+        const column = offset - this.lineStartOffsetByLineIdx[idx] + 1;
+        return ( new Position(lineNumber, column));
+    }
+    getTextLength(offsetRange) {
+        return Deps.deps.TextLength.ofRange(this.getRange(offsetRange));
+    }
+    get textLength() {
+        const lineIdx = this.lineStartOffsetByLineIdx.length - 1;
+        return new Deps.deps.TextLength(lineIdx, this.text.length - this.lineStartOffsetByLineIdx[lineIdx]);
+    }
+    getLineLength(lineNumber) {
+        return this.lineEndOffsetByLineIdx[lineNumber - 1] - this.lineStartOffsetByLineIdx[lineNumber - 1];
+    }
+}
+
+export { PositionOffsetTransformer, PositionOffsetTransformerBase, _setPositionOffsetTransformerDependencies };

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

@@ -11,6 +11,7 @@ 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";
 export declare class CursorsController extends Disposable {
     private readonly _model;
     private _knownModelVersionId;
@@ -54,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): void;
+    executeEdits(eventsCollector: ViewModelEventsCollector, source: string | null | undefined, edits: IIdentifiedSingleEditOperation[], cursorStateComputer: ICursorStateComputer, reason: TextModelEditReason): void;
     private _executeEdit;
     getAutoClosedCharacters(): Range[];
     startComposition(eventsCollector: ViewModelEventsCollector): void;
@@ -67,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)[]): Selection[] | null;
+    static executeCommands(model: ITextModel, selectionsBefore: Selection[], commands: (editorCommon.ICommand | null)[], editReason?: TextModelEditReason): Selection[] | null;
     private static _innerExecuteCommands;
     private static _arrayIsEmpty;
     private static _getEditOperations;

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

@@ -16,6 +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';
 
 class CursorsController extends Disposable {
     constructor(model, viewModel, coordinatesConverter, cursorConfig) {
@@ -280,14 +281,14 @@ class CursorsController extends Disposable {
             autoClosedEnclosingDecorations
         )));
     }
-    _executeEditOperation(opResult) {
+    _executeEditOperation(opResult, editReason) {
         if (!opResult) {
             return;
         }
         if (opResult.shouldPushStackElementBefore) {
             this._model.pushStackElement();
         }
-        const result = CommandExecutor.executeCommands(this._model, this._cursors.getSelections(), opResult.commands);
+        const result = CommandExecutor.executeCommands(this._model, this._cursors.getSelections(), opResult.commands, editReason);
         if (result) {
             this._interpretCommandResult(result);
             const autoClosedCharactersRanges = [];
@@ -372,7 +373,7 @@ class CursorsController extends Disposable {
         }
         return indices;
     }
-    executeEdits(eventsCollector, source, edits, cursorStateComputer) {
+    executeEdits(eventsCollector, source, edits, cursorStateComputer, reason) {
         let autoClosingIndices = null;
         if (source === 'snippet') {
             autoClosingIndices = this._findAutoClosingPairs(edits);
@@ -399,7 +400,7 @@ class CursorsController extends Disposable {
                 this._isHandling = true;
             }
             return selections;
-        });
+        }, undefined, reason);
         if (selections) {
             this._isHandling = false;
             this.setSelections(eventsCollector, source, selections, CursorChangeReason.NotSet);
@@ -436,15 +437,17 @@ class CursorsController extends Disposable {
         this._compositionState = ( new CompositionState(this._model, this.getSelections()));
     }
     endComposition(eventsCollector, source) {
+        const reason = EditReasons.cursor({ kind: 'compositionEnd', detailedSource: source });
         const compositionOutcome = this._compositionState ? this._compositionState.deduceOutcome(this._model, this.getSelections()) : null;
         this._compositionState = null;
         this._executeEdit(() => {
             if (source === 'keyboard') {
-                this._executeEditOperation(TypeOperations.compositionEndWithInterceptors(this._prevEditOperationType, this.context.cursorConfig, this._model, compositionOutcome, this.getSelections(), this.getAutoClosedCharacters()));
+                this._executeEditOperation(TypeOperations.compositionEndWithInterceptors(this._prevEditOperationType, this.context.cursorConfig, this._model, compositionOutcome, this.getSelections(), this.getAutoClosedCharacters()), reason);
             }
         }, eventsCollector, source);
     }
     type(eventsCollector, text, source) {
+        const reason = EditReasons.cursor({ kind: 'type', detailedSource: source });
         this._executeEdit(() => {
             if (source === 'keyboard') {
                 const len = text.length;
@@ -452,16 +455,17 @@ class CursorsController extends Disposable {
                 while (offset < len) {
                     const charLength = nextCharLength(text, offset);
                     const chr = text.substr(offset, charLength);
-                    this._executeEditOperation(TypeOperations.typeWithInterceptors(!!this._compositionState, this._prevEditOperationType, this.context.cursorConfig, this._model, this.getSelections(), this.getAutoClosedCharacters(), chr));
+                    this._executeEditOperation(TypeOperations.typeWithInterceptors(!!this._compositionState, this._prevEditOperationType, this.context.cursorConfig, this._model, this.getSelections(), this.getAutoClosedCharacters(), chr), reason);
                     offset += charLength;
                 }
             }
             else {
-                this._executeEditOperation(TypeOperations.typeWithoutInterceptors(this._prevEditOperationType, this.context.cursorConfig, this._model, this.getSelections(), text));
+                this._executeEditOperation(TypeOperations.typeWithoutInterceptors(this._prevEditOperationType, this.context.cursorConfig, this._model, this.getSelections(), text), reason);
             }
         }, eventsCollector, source);
     }
     compositionType(eventsCollector, text, replacePrevCharCnt, replaceNextCharCnt, positionDelta, source) {
+        const reason = EditReasons.cursor({ kind: 'compositionType', detailedSource: source });
         if (text.length === 0 && replacePrevCharCnt === 0 && replaceNextCharCnt === 0) {
             if (positionDelta !== 0) {
                 const newSelections = ( this.getSelections().map(selection => {
@@ -478,34 +482,38 @@ class CursorsController extends Disposable {
             return;
         }
         this._executeEdit(() => {
-            this._executeEditOperation(TypeOperations.compositionType(this._prevEditOperationType, this.context.cursorConfig, this._model, this.getSelections(), text, replacePrevCharCnt, replaceNextCharCnt, positionDelta));
+            this._executeEditOperation(TypeOperations.compositionType(this._prevEditOperationType, this.context.cursorConfig, this._model, this.getSelections(), text, replacePrevCharCnt, replaceNextCharCnt, positionDelta), reason);
         }, eventsCollector, source);
     }
     paste(eventsCollector, text, pasteOnNewLine, multicursorText, source) {
+        const reason = EditReasons.cursor({ kind: 'paste', detailedSource: source });
         this._executeEdit(() => {
-            this._executeEditOperation(TypeOperations.paste(this.context.cursorConfig, this._model, this.getSelections(), text, pasteOnNewLine, multicursorText || []));
+            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 });
         this._executeEdit(() => {
-            this._executeEditOperation(DeleteOperations.cut(this.context.cursorConfig, this._model, this.getSelections()));
+            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 });
         this._executeEdit(() => {
             this._cursors.killSecondaryCursors();
             this._executeEditOperation(( new EditOperationResult(EditOperationType.Other, [command], {
                 shouldPushStackElementBefore: false,
                 shouldPushStackElementAfter: false
-            })));
+            })), reason);
         }, eventsCollector, source);
     }
     executeCommands(eventsCollector, commands, source) {
+        const reason = EditReasons.cursor({ kind: 'executeCommands', detailedSource: source });
         this._executeEdit(() => {
             this._executeEditOperation(( new EditOperationResult(EditOperationType.Other, commands, {
                 shouldPushStackElementBefore: false,
                 shouldPushStackElementAfter: false
-            })));
+            })), reason);
         }, eventsCollector, source);
     }
 }
@@ -587,20 +595,20 @@ class AutoClosedAction {
     }
 }
 class CommandExecutor {
-    static executeCommands(model, selectionsBefore, commands) {
+    static executeCommands(model, selectionsBefore, commands, editReason = EditReasons.unknown({ name: 'executeCommands' })) {
         const ctx = {
             model: model,
             selectionsBefore: selectionsBefore,
             trackedRanges: [],
             trackedRangesDirection: []
         };
-        const result = this._innerExecuteCommands(ctx, commands);
+        const result = this._innerExecuteCommands(ctx, commands, editReason);
         for (let i = 0, len = ctx.trackedRanges.length; i < len; i++) {
             ctx.model._setTrackedRange(ctx.trackedRanges[i], null, TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges);
         }
         return result;
     }
-    static _innerExecuteCommands(ctx, commands) {
+    static _innerExecuteCommands(ctx, commands, editReason) {
         if (this._arrayIsEmpty(commands)) {
             return null;
         }
@@ -670,7 +678,7 @@ class CommandExecutor {
                 }
             }
             return cursorSelections;
-        });
+        }, undefined, editReason);
         if (!selectionsAfter) {
             selectionsAfter = ctx.selectionsBefore;
         }

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

@@ -106,7 +106,9 @@ class DefaultLinesDiffComputer {
             }
         }
         scanForWhitespaceChanges(originalLines.length - seq1LastStart);
-        const changes = lineRangeMappingFromRangeMappings(alignments, ( new ArrayText(originalLines)), ( new ArrayText(modifiedLines)));
+        const original = ( new ArrayText(originalLines));
+        const modified = ( new ArrayText(modifiedLines));
+        const changes = lineRangeMappingFromRangeMappings(alignments, original, modified);
         let moves = [];
         if (options.computeMoves) {
             moves = this.computeMoves(changes, originalLines, modifiedLines, originalLinesHashes, modifiedLinesHashes, timeout, considerWhitespaceChanges, options);

package/vscode/src/vs/editor/common/diff/rangeMapping.d.ts

@@ -17,6 +17,7 @@ export declare class LineRangeMapping {
     toRangeMapping2(original: string[], modified: string[]): RangeMapping;
 }
 export declare class DetailedLineRangeMapping extends LineRangeMapping {
+    static toTextEdit(mapping: readonly DetailedLineRangeMapping[], modified: AbstractText): TextEdit;
     static fromRangeMappings(rangeMappings: RangeMapping[]): DetailedLineRangeMapping;
     readonly innerChanges: RangeMapping[] | undefined;
     constructor(originalRange: LineRange, modifiedRange: LineRange, innerChanges: RangeMapping[] | undefined);

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

@@ -5,7 +5,7 @@ import { BugIndicatingError } from '../../../base/common/errors.js';
 import { LineRange } from '../core/ranges/lineRange.js';
 import { Position } from '../core/position.js';
 import { Range } from '../core/range.js';
-import { TextReplacement } from '../core/edits/textEdit.js';
+import { TextEdit, TextReplacement } from '../core/edits/textEdit.js';
 
 class LineRangeMapping {
     static inverse(mapping, originalLineCount, modifiedLineCount) {
@@ -110,6 +110,16 @@ function isValidLineNumber(lineNumber, lines) {
     return lineNumber >= 1 && lineNumber <= lines.length;
 }
 class DetailedLineRangeMapping extends LineRangeMapping {
+    static toTextEdit(mapping, modified) {
+        const replacements = [];
+        for (const m of mapping) {
+            for (const r of m.innerChanges ?? []) {
+                const replacement = r.toTextEdit(modified);
+                replacements.push(replacement);
+            }
+        }
+        return ( new TextEdit(replacements));
+    }
     static fromRangeMappings(rangeMappings) {
         const originalRange = LineRange.join(( rangeMappings.map(r => LineRange.fromRangeInclusive(r.originalRange))));
         const modifiedRange = LineRange.join(( rangeMappings.map(r => LineRange.fromRangeInclusive(r.modifiedRange))));

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

@@ -56,7 +56,7 @@ export interface IContentSizeChangedEvent {
 export interface ITriggerEditorOperationEvent {
     source: string | null | undefined;
     handlerId: string;
-    payload: any;
+    payload: unknown;
 }
 export interface INewScrollPosition {
     scrollLeft?: number;
@@ -143,6 +143,7 @@ export interface IThemeDecorationRenderOptions {
     borderWidth?: string;
     fontStyle?: string;
     fontWeight?: string;
+    fontFamily?: string;
     fontSize?: string;
     lineHeight?: number;
     textDecoration?: string;

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(719, "Whether the editor text has focus (cursor is blinking)"))));
+    EditorContextKeys.editorTextFocus = ( new RawContextKey('editorTextFocus', false, ( localize(730, "Whether the editor text has focus (cursor is blinking)"))));
     EditorContextKeys.focus = ( new RawContextKey('editorFocus', false, ( localize(
-     720,
+     731,
      "Whether the editor or an editor widget has focus (e.g. focus is in the find widget)"
     ))));
     EditorContextKeys.textInputFocus = ( new RawContextKey('textInputFocus', false, ( localize(
-     721,
+     732,
      "Whether an editor or a rich text input has focus (cursor is blinking)"
     ))));
-    EditorContextKeys.readOnly = ( new RawContextKey('editorReadonly', false, ( localize(722, "Whether the editor is read-only"))));
-    EditorContextKeys.inDiffEditor = ( new RawContextKey('inDiffEditor', false, ( localize(723, "Whether the context is a diff editor"))));
-    EditorContextKeys.isEmbeddedDiffEditor = ( new RawContextKey('isEmbeddedDiffEditor', false, ( localize(724, "Whether the context is an embedded diff editor"))));
-    EditorContextKeys.multiDiffEditorAllCollapsed = ( new RawContextKey('multiDiffEditorAllCollapsed', undefined, ( localize(725, "Whether all files in multi diff editor are collapsed"))));
-    EditorContextKeys.hasChanges = ( new RawContextKey('diffEditorHasChanges', false, ( localize(726, "Whether the diff editor has changes"))));
-    EditorContextKeys.comparingMovedCode = ( new RawContextKey('comparingMovedCode', false, ( localize(727, "Whether a moved code block is selected for comparison"))));
-    EditorContextKeys.accessibleDiffViewerVisible = ( new RawContextKey('accessibleDiffViewerVisible', false, ( localize(728, "Whether the accessible diff viewer is visible"))));
+    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.diffEditorRenderSideBySideInlineBreakpointReached = ( new RawContextKey('diffEditorRenderSideBySideInlineBreakpointReached', false, ( localize(
-     729,
+     740,
      "Whether the diff editor render side by side inline breakpoint is reached"
     ))));
-    EditorContextKeys.diffEditorInlineMode = ( new RawContextKey('diffEditorInlineMode', false, ( localize(730, "Whether inline mode is active"))));
-    EditorContextKeys.diffEditorOriginalWritable = ( new RawContextKey('diffEditorOriginalWritable', false, ( localize(731, "Whether modified is writable in the diff editor"))));
-    EditorContextKeys.diffEditorModifiedWritable = ( new RawContextKey('diffEditorModifiedWritable', false, ( localize(732, "Whether modified is writable in the diff editor"))));
-    EditorContextKeys.diffEditorOriginalUri = ( new RawContextKey('diffEditorOriginalUri', '', ( localize(733, "The uri of the original document"))));
-    EditorContextKeys.diffEditorModifiedUri = ( new RawContextKey('diffEditorModifiedUri', '', ( localize(734, "The uri of the modified document"))));
-    EditorContextKeys.columnSelection = ( new RawContextKey('editorColumnSelection', false, ( localize(735, "Whether `editor.columnSelection` is enabled"))));
+    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.writable = ( EditorContextKeys.readOnly.toNegated());
-    EditorContextKeys.hasNonEmptySelection = ( new RawContextKey('editorHasSelection', false, ( localize(736, "Whether the editor has text selected"))));
+    EditorContextKeys.hasNonEmptySelection = ( new RawContextKey('editorHasSelection', false, ( localize(747, "Whether the editor has text selected"))));
     EditorContextKeys.hasOnlyEmptySelection = ( EditorContextKeys.hasNonEmptySelection.toNegated());
-    EditorContextKeys.hasMultipleSelections = ( new RawContextKey('editorHasMultipleSelections', false, ( localize(737, "Whether the editor has multiple selections"))));
+    EditorContextKeys.hasMultipleSelections = ( new RawContextKey('editorHasMultipleSelections', false, ( localize(748, "Whether the editor has multiple selections"))));
     EditorContextKeys.hasSingleSelection = ( EditorContextKeys.hasMultipleSelections.toNegated());
-    EditorContextKeys.tabMovesFocus = ( new RawContextKey('editorTabMovesFocus', false, ( localize(738, "Whether `Tab` will move focus out of the editor"))));
+    EditorContextKeys.tabMovesFocus = ( new RawContextKey('editorTabMovesFocus', false, ( localize(749, "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(739, "Whether the editor hover is visible"))));
-    EditorContextKeys.hoverFocused = ( new RawContextKey('editorHoverFocused', false, ( localize(740, "Whether the editor hover is focused"))));
-    EditorContextKeys.stickyScrollFocused = ( new RawContextKey('stickyScrollFocused', false, ( localize(741, "Whether the sticky scroll is focused"))));
-    EditorContextKeys.stickyScrollVisible = ( new RawContextKey('stickyScrollVisible', false, ( localize(742, "Whether the sticky scroll is visible"))));
-    EditorContextKeys.standaloneColorPickerVisible = ( new RawContextKey('standaloneColorPickerVisible', false, ( localize(743, "Whether the standalone color picker is visible"))));
-    EditorContextKeys.standaloneColorPickerFocused = ( new RawContextKey('standaloneColorPickerFocused', false, ( localize(744, "Whether the standalone color picker is focused"))));
-    EditorContextKeys.inCompositeEditor = ( new RawContextKey('inCompositeEditor', undefined, ( localize(745, "Whether the editor is part of a larger editor (e.g. notebooks)"))));
+    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.notInCompositeEditor = ( EditorContextKeys.inCompositeEditor.toNegated());
-    EditorContextKeys.languageId = ( new RawContextKey('editorLangId', '', ( localize(746, "The language identifier of the editor"))));
-    EditorContextKeys.hasCompletionItemProvider = ( new RawContextKey('editorHasCompletionItemProvider', false, ( localize(747, "Whether the editor has a completion item provider"))));
-    EditorContextKeys.hasCodeActionsProvider = ( new RawContextKey('editorHasCodeActionsProvider', false, ( localize(748, "Whether the editor has a code actions provider"))));
-    EditorContextKeys.hasCodeLensProvider = ( new RawContextKey('editorHasCodeLensProvider', false, ( localize(749, "Whether the editor has a code lens provider"))));
-    EditorContextKeys.hasDefinitionProvider = ( new RawContextKey('editorHasDefinitionProvider', false, ( localize(750, "Whether the editor has a definition provider"))));
-    EditorContextKeys.hasDeclarationProvider = ( new RawContextKey('editorHasDeclarationProvider', false, ( localize(751, "Whether the editor has a declaration provider"))));
-    EditorContextKeys.hasImplementationProvider = ( new RawContextKey('editorHasImplementationProvider', false, ( localize(752, "Whether the editor has an implementation provider"))));
-    EditorContextKeys.hasTypeDefinitionProvider = ( new RawContextKey('editorHasTypeDefinitionProvider', false, ( localize(753, "Whether the editor has a type definition provider"))));
-    EditorContextKeys.hasHoverProvider = ( new RawContextKey('editorHasHoverProvider', false, ( localize(754, "Whether the editor has a hover provider"))));
-    EditorContextKeys.hasDocumentHighlightProvider = ( new RawContextKey('editorHasDocumentHighlightProvider', false, ( localize(755, "Whether the editor has a document highlight provider"))));
-    EditorContextKeys.hasDocumentSymbolProvider = ( new RawContextKey('editorHasDocumentSymbolProvider', false, ( localize(756, "Whether the editor has a document symbol provider"))));
-    EditorContextKeys.hasReferenceProvider = ( new RawContextKey('editorHasReferenceProvider', false, ( localize(757, "Whether the editor has a reference provider"))));
-    EditorContextKeys.hasRenameProvider = ( new RawContextKey('editorHasRenameProvider', false, ( localize(758, "Whether the editor has a rename provider"))));
-    EditorContextKeys.hasSignatureHelpProvider = ( new RawContextKey('editorHasSignatureHelpProvider', false, ( localize(759, "Whether the editor has a signature help provider"))));
-    EditorContextKeys.hasInlayHintsProvider = ( new RawContextKey('editorHasInlayHintsProvider', false, ( localize(760, "Whether the editor has an inline hints provider"))));
-    EditorContextKeys.hasDocumentFormattingProvider = ( new RawContextKey('editorHasDocumentFormattingProvider', false, ( localize(761, "Whether the editor has a document formatting provider"))));
-    EditorContextKeys.hasDocumentSelectionFormattingProvider = ( new RawContextKey('editorHasDocumentSelectionFormattingProvider', false, ( localize(762, "Whether the editor has a document selection formatting provider"))));
-    EditorContextKeys.hasMultipleDocumentFormattingProvider = ( new RawContextKey('editorHasMultipleDocumentFormattingProvider', false, ( localize(763, "Whether the editor has multiple document formatting providers"))));
+    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.hasMultipleDocumentSelectionFormattingProvider = ( new RawContextKey(
      'editorHasMultipleDocumentSelectionFormattingProvider',
      false,
      ( localize(
-     764,
+     775,
      "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,.\%]*\))|\s+(#)([A-Fa-f0-9]{6})\b|\s+(#)([A-Fa-f0-9]{8})\b|^(#)([A-Fa-f0-9]{6})\b|^(#)([A-Fa-f0-9]{8})\b/gm;
+    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 initialValidationMatches = _findMatches(model, initialValidationRegex);
     if (initialValidationMatches.length > 0) {
         for (const initialMatch of initialValidationMatches) {

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

@@ -1,7 +1,11 @@
 import { StandardTokenType } from "../encodedTokenAttributes.js";
 import { ScopedLineTokens } from "./supports.js";
+export interface LineCommentConfig {
+    comment: string;
+    noIndent?: boolean;
+}
 export interface CommentRule {
-    lineComment?: string | null;
+    lineComment?: string | LineCommentConfig | null;
     blockComment?: CharacterPair | null;
 }
 export interface LanguageConfiguration {

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

@@ -13,6 +13,7 @@ import { LanguageBracketsConfiguration } from "./supports/languageBracketsConfig
 import { ILanguageConfigurationService } from "./languageConfigurationRegistry.service.js";
 export interface ICommentsConfiguration {
     lineCommentToken?: string;
+    lineCommentNoIndent?: boolean;
     blockCommentStartToken?: string;
     blockCommentEndToken?: string;
 }

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

@@ -317,7 +317,13 @@ class ResolvedLanguageConfiguration {
         }
         const comments = {};
         if (commentRule.lineComment) {
-            comments.lineCommentToken = commentRule.lineComment;
+            if (typeof commentRule.lineComment === 'string') {
+                comments.lineCommentToken = commentRule.lineComment;
+            }
+            else {
+                comments.lineCommentToken = commentRule.lineComment.comment;
+                comments.lineCommentNoIndent = commentRule.lineComment.noIndent;
+            }
         }
         if (commentRule.blockComment) {
             const [blockStart, blockEnd] = commentRule.blockComment;

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(821, "Plain Text")), 'text'],
+    aliases: [( localize(832, "Plain Text")), 'text'],
     mimetypes: [Mimes.text]
 });
 ( Registry.as(Extensions$1.Configuration))