@codingame/monaco-vscode-api 17.2.1 → 18.0.1

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

@@ -0,0 +1,84 @@
+
+import { assert } from '../../../../base/common/assert.js';
+import { splitLines } from '../../../../base/common/strings.js';
+import { Position } from '../position.js';
+import { PositionOffsetTransformer } from './positionToOffset.js';
+import { Range } from '../range.js';
+import { TextLength } from './textLength.js';
+
+class AbstractText {
+    constructor() {
+        this._transformer = undefined;
+    }
+    get endPositionExclusive() {
+        return this.length.addToPosition(( new Position(1, 1)));
+    }
+    get lineRange() {
+        return this.length.toLineRange();
+    }
+    getValue() {
+        return this.getValueOfRange(this.length.toRange());
+    }
+    getLineLength(lineNumber) {
+        return this.getValueOfRange(( new Range(lineNumber, 1, lineNumber, Number.MAX_SAFE_INTEGER))).length;
+    }
+    getTransformer() {
+        if (!this._transformer) {
+            this._transformer = ( new PositionOffsetTransformer(this.getValue()));
+        }
+        return this._transformer;
+    }
+    getLineAt(lineNumber) {
+        return this.getValueOfRange(( new Range(lineNumber, 1, lineNumber, Number.MAX_SAFE_INTEGER)));
+    }
+    getLines() {
+        const value = this.getValue();
+        return splitLines(value);
+    }
+}
+class LineBasedText extends AbstractText {
+    constructor(_getLineContent, _lineCount) {
+        assert(_lineCount >= 1);
+        super();
+        this._getLineContent = _getLineContent;
+        this._lineCount = _lineCount;
+    }
+    getValueOfRange(range) {
+        if (range.startLineNumber === range.endLineNumber) {
+            return this._getLineContent(range.startLineNumber).substring(range.startColumn - 1, range.endColumn - 1);
+        }
+        let result = this._getLineContent(range.startLineNumber).substring(range.startColumn - 1);
+        for (let i = range.startLineNumber + 1; i < range.endLineNumber; i++) {
+            result += '\n' + this._getLineContent(i);
+        }
+        result += '\n' + this._getLineContent(range.endLineNumber).substring(0, range.endColumn - 1);
+        return result;
+    }
+    getLineLength(lineNumber) {
+        return this._getLineContent(lineNumber).length;
+    }
+    get length() {
+        const lastLine = this._getLineContent(this._lineCount);
+        return ( new TextLength(this._lineCount - 1, lastLine.length));
+    }
+}
+class ArrayText extends LineBasedText {
+    constructor(lines) {
+        super(lineNumber => lines[lineNumber - 1], lines.length);
+    }
+}
+class StringText extends AbstractText {
+    constructor(value) {
+        super();
+        this.value = value;
+        this._t = ( new PositionOffsetTransformer(this.value));
+    }
+    getValueOfRange(range) {
+        return this._t.getOffsetRange(range).substring(this.value);
+    }
+    get length() {
+        return this._t.textLength;
+    }
+}
+
+export { AbstractText, ArrayText, LineBasedText, StringText };

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

@@ -0,0 +1,3 @@
+import { ITextModel } from "../../model.js";
+import { PositionOffsetTransformerBase } from "./positionToOffset.js";
+export declare function getPositionOffsetTransformerFromTextModel(textModel: ITextModel): PositionOffsetTransformerBase;

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

@@ -0,0 +1,20 @@
+
+import { PositionOffsetTransformerBase } from './positionToOffset.js';
+
+function getPositionOffsetTransformerFromTextModel(textModel) {
+    return ( new PositionOffsetTransformerWithTextModel(textModel));
+}
+class PositionOffsetTransformerWithTextModel extends PositionOffsetTransformerBase {
+    constructor(_textModel) {
+        super();
+        this._textModel = _textModel;
+    }
+    getOffset(position) {
+        return this._textModel.getOffsetAt(position);
+    }
+    getPosition(offset) {
+        return this._textModel.getPositionAt(offset);
+    }
+}
+
+export { getPositionOffsetTransformerFromTextModel };

package/vscode/src/vs/editor/common/core/{positionToOffset.d.ts → text/positionToOffset.d.ts}

@@ -1,19 +1,18 @@
-import { ITextModel } from "../model.js";
-import { OffsetEdit, SingleOffsetEdit } from "./offsetEdit.js";
-import { OffsetRange } from "./offsetRange.js";
-import { Position } from "./position.js";
-import { Range } from "./range.js";
-import { SingleTextEdit, TextEdit } from "./textEdit.js";
+import { StringEdit, StringReplacement } from "../edits/stringEdit.js";
+import { OffsetRange } from "../ranges/offsetRange.js";
+import { Position } from "../position.js";
+import { Range } from "../range.js";
+import { TextReplacement, TextEdit } from "../edits/textEdit.js";
 import { 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;
-    getOffsetEdit(edit: TextEdit): OffsetEdit;
-    getSingleOffsetEdit(edit: SingleTextEdit): SingleOffsetEdit;
-    getSingleTextEdit(edit: SingleOffsetEdit): SingleTextEdit;
-    getTextEdit(edit: OffsetEdit): TextEdit;
+    getStringEdit(edit: TextEdit): StringEdit;
+    getStringReplacement(edit: TextReplacement): StringReplacement;
+    getSingleTextEdit(edit: StringReplacement): TextReplacement;
+    getTextEdit(edit: StringEdit): TextEdit;
 }
 export declare class PositionOffsetTransformer extends PositionOffsetTransformerBase {
     readonly text: string;
@@ -27,4 +26,3 @@ export declare class PositionOffsetTransformer extends PositionOffsetTransformer
     get textLength(): TextLength;
     getLineLength(lineNumber: number): number;
 }
-export declare function getPositionOffsetTransformerFromTextModel(textModel: ITextModel): PositionOffsetTransformerBase;

package/vscode/src/vs/editor/common/core/{positionToOffset.js → text/positionToOffset.js}

@@ -1,10 +1,10 @@
 
-import { findLastIdxMonotonous } from '../../../base/common/arraysFind.js';
-import { OffsetEdit, SingleOffsetEdit } from './offsetEdit.js';
-import { OffsetRange } from './offsetRange.js';
-import { Position } from './position.js';
-import { Range } from './range.js';
-import { SingleTextEdit, TextEdit } from './textEdit.js';
+import { findLastIdxMonotonous } from '../../../../base/common/arraysFind.js';
+import { StringEdit, StringReplacement } from '../edits/stringEdit.js';
+import { OffsetRange } from '../ranges/offsetRange.js';
+import { Position } from '../position.js';
+import { Range } from '../range.js';
+import { TextReplacement, TextEdit } from '../edits/textEdit.js';
 import { TextLength } from './textLength.js';
 
 class PositionOffsetTransformerBase {
@@ -17,18 +17,18 @@ class PositionOffsetTransformerBase {
     getRange(offsetRange) {
         return Range.fromPositions(this.getPosition(offsetRange.start), this.getPosition(offsetRange.endExclusive));
     }
-    getOffsetEdit(edit) {
-        const edits = ( edit.edits.map(e => this.getSingleOffsetEdit(e)));
-        return ( new OffsetEdit(edits));
+    getStringEdit(edit) {
+        const edits = ( edit.replacements.map(e => this.getStringReplacement(e)));
+        return ( new StringEdit(edits));
     }
-    getSingleOffsetEdit(edit) {
-        return ( new SingleOffsetEdit(this.getOffsetRange(edit.range), edit.text));
+    getStringReplacement(edit) {
+        return ( new StringReplacement(this.getOffsetRange(edit.range), edit.text));
     }
     getSingleTextEdit(edit) {
-        return ( new SingleTextEdit(this.getRange(edit.replaceRange), edit.newText));
+        return ( new TextReplacement(this.getRange(edit.replaceRange), edit.newText));
     }
     getTextEdit(edit) {
-        const edits = ( edit.edits.map(e => this.getSingleTextEdit(e)));
+        const edits = ( edit.replacements.map(e => this.getSingleTextEdit(e)));
         return ( new TextEdit(edits));
     }
 }
@@ -91,20 +91,5 @@ class PositionOffsetTransformer extends PositionOffsetTransformerBase {
         return this.lineEndOffsetByLineIdx[lineNumber - 1] - this.lineStartOffsetByLineIdx[lineNumber - 1];
     }
 }
-function getPositionOffsetTransformerFromTextModel(textModel) {
-    return ( new PositionOffsetTransformerWithTextModel(textModel));
-}
-class PositionOffsetTransformerWithTextModel extends PositionOffsetTransformerBase {
-    constructor(_textModel) {
-        super();
-        this._textModel = _textModel;
-    }
-    getOffset(position) {
-        return this._textModel.getOffsetAt(position);
-    }
-    getPosition(offset) {
-        return this._textModel.getPositionAt(offset);
-    }
-}
 
-export { PositionOffsetTransformer, PositionOffsetTransformerBase, getPositionOffsetTransformerFromTextModel };
+export { PositionOffsetTransformer, PositionOffsetTransformerBase };

package/vscode/src/vs/editor/common/core/{textLength.d.ts → text/textLength.d.ts}

@@ -1,6 +1,6 @@
-import { LineRange } from "./lineRange.js";
-import { Position } from "./position.js";
-import { Range } from "./range.js";
+import { LineRange } from "../ranges/lineRange.js";
+import { Position } from "../position.js";
+import { Range } from "../range.js";
 export declare class TextLength {
     readonly lineCount: number;
     readonly columnCount: number;

package/vscode/src/vs/editor/common/core/{textLength.js → text/textLength.js}

@@ -1,7 +1,7 @@
 
-import { LineRange } from './lineRange.js';
-import { Position } from './position.js';
-import { Range } from './range.js';
+import { LineRange } from '../ranges/lineRange.js';
+import { Position } from '../position.js';
+import { Range } from '../range.js';
 
 class TextLength {
     static { this.zero = ( new TextLength(0, 0)); }

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

@@ -56,7 +56,7 @@ class WordCharacterClassifier extends CharacterClassifier {
             return this._cachedSegments;
         }
         this._cachedLine = line;
-        this._cachedSegments = this._filterWordSegments(this._segmenter.segment(line));
+        this._cachedSegments = this._filterWordSegments(this._segmenter.value.segment(line));
         return this._cachedSegments;
     }
     _filterWordSegments(segments) {

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

@@ -5,7 +5,7 @@ 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';
+import { normalizeIndentation } from './core/misc/indentation.js';
 import { InputMode } from './inputMode.js';
 
 var EditOperationType;

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/diffAlgorithm.d.ts

@@ -1,4 +1,4 @@
-import { OffsetRange } from "../../../core/offsetRange.js";
+import { OffsetRange } from "../../../core/ranges/offsetRange.js";
 export interface IDiffAlgorithm {
     compute(sequence1: ISequence, sequence2: ISequence, timeout?: ITimeout): DiffAlgorithmResult;
 }

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

@@ -1,7 +1,7 @@
 
 import { forEachAdjacent } from '../../../../../base/common/arrays.js';
 import { BugIndicatingError } from '../../../../../base/common/errors.js';
-import { OffsetRange } from '../../../core/offsetRange.js';
+import { OffsetRange } from '../../../core/ranges/offsetRange.js';
 
 class DiffAlgorithmResult {
     static trivial(seq1, seq2) {

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

@@ -1,5 +1,5 @@
 
-import { OffsetRange } from '../../../core/offsetRange.js';
+import { OffsetRange } from '../../../core/ranges/offsetRange.js';
 import { InfiniteTimeout, DiffAlgorithmResult, SequenceDiff } from './diffAlgorithm.js';
 import { Array2D } from '../utils.js';
 

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

@@ -1,5 +1,5 @@
 
-import { OffsetRange } from '../../../core/offsetRange.js';
+import { OffsetRange } from '../../../core/ranges/offsetRange.js';
 import { InfiniteTimeout, DiffAlgorithmResult, SequenceDiff } from './diffAlgorithm.js';
 
 class MyersDiffAlgorithm {

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

@@ -4,7 +4,7 @@ import { LineRangeMapping } from '../rangeMapping.js';
 import { pushMany, compareBy, numberComparator, reverseOrder } from '../../../../base/common/arrays.js';
 import { MonotonousArray, findLastMonotonous } from '../../../../base/common/arraysFind.js';
 import { SetMap } from '../../../../base/common/map.js';
-import { LineRange, LineRangeSet } from '../../core/lineRange.js';
+import { LineRange, LineRangeSet } from '../../core/ranges/lineRange.js';
 import { LinesSliceCharSequence } from './linesSliceCharSequence.js';
 import { LineRangeFragment, isSpace } from './utils.js';
 import { MyersDiffAlgorithm } from './algorithms/myersDiffAlgorithm.js';

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

@@ -1,10 +1,10 @@
 
 import { equals } from '../../../../base/common/arrays.js';
 import { assertFn } from '../../../../base/common/assert.js';
-import { LineRange } from '../../core/lineRange.js';
-import { OffsetRange } from '../../core/offsetRange.js';
+import { LineRange } from '../../core/ranges/lineRange.js';
+import { OffsetRange } from '../../core/ranges/offsetRange.js';
 import { Range } from '../../core/range.js';
-import { ArrayText } from '../../core/textEdit.js';
+import { ArrayText } from '../../core/text/abstractText.js';
 import { LinesDiff, MovedText } from '../linesDiffComputer.js';
 import { DetailedLineRangeMapping, RangeMapping, lineRangeMappingFromRangeMappings, LineRangeMapping } from '../rangeMapping.js';
 import { InfiniteTimeout, DateTimeout, SequenceDiff } from './algorithms/diffAlgorithm.js';

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/heuristicSequenceOptimizations.d.ts

@@ -1,4 +1,4 @@
-import { OffsetRange } from "../../core/offsetRange.js";
+import { OffsetRange } from "../../core/ranges/offsetRange.js";
 import { ISequence, SequenceDiff } from "./algorithms/diffAlgorithm.js";
 import { LineSequence } from "./lineSequence.js";
 import { LinesSliceCharSequence } from "./linesSliceCharSequence.js";

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

@@ -1,6 +1,6 @@
 
 import { forEachWithNeighbors } from '../../../../base/common/arrays.js';
-import { OffsetRange } from '../../core/offsetRange.js';
+import { OffsetRange } from '../../core/ranges/offsetRange.js';
 import { SequenceDiff, OffsetPair } from './algorithms/diffAlgorithm.js';
 
 function optimizeSequenceDiffs(sequence1, sequence2, sequenceDiffs) {

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/lineSequence.d.ts

@@ -1,4 +1,4 @@
-import { OffsetRange } from "../../core/offsetRange.js";
+import { OffsetRange } from "../../core/ranges/offsetRange.js";
 import { ISequence } from "./algorithms/diffAlgorithm.js";
 export declare class LineSequence implements ISequence {
     private readonly trimmedHash;

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/linesSliceCharSequence.d.ts

@@ -1,4 +1,4 @@
-import { OffsetRange } from "../../core/offsetRange.js";
+import { OffsetRange } from "../../core/ranges/offsetRange.js";
 import { Position } from "../../core/position.js";
 import { Range } from "../../core/range.js";
 import { ISequence } from "./algorithms/diffAlgorithm.js";

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

@@ -1,7 +1,7 @@
 
 import { findLastIdxMonotonous, findLastMonotonous, findFirstMonotonous } from '../../../../base/common/arraysFind.js';
 import { CharCode } from '../../../../base/common/charCode.js';
-import { OffsetRange } from '../../core/offsetRange.js';
+import { OffsetRange } from '../../core/ranges/offsetRange.js';
 import { Position } from '../../core/position.js';
 import { Range } from '../../core/range.js';
 import { isSpace } from './utils.js';

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/utils.d.ts

@@ -1,4 +1,4 @@
-import { LineRange } from "../../core/lineRange.js";
+import { LineRange } from "../../core/ranges/lineRange.js";
 import { DetailedLineRangeMapping } from "../rangeMapping.js";
 export declare class Array2D<T> {
     readonly width: number;

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

@@ -6,7 +6,7 @@ import { DetailedLineRangeMapping, RangeMapping } from './rangeMapping.js';
 import { firstNonWhitespaceIndex, lastNonWhitespaceIndex } from '../../../base/common/strings.js';
 import { Range } from '../core/range.js';
 import { assertFn, checkAdjacentItems } from '../../../base/common/assert.js';
-import { LineRange } from '../core/lineRange.js';
+import { LineRange } from '../core/ranges/lineRange.js';
 
 const MINIMUM_MATCHING_CHARACTER_LENGTH = 3;
 class LegacyLinesDiffComputer {

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

@@ -1,6 +1,7 @@
-import { LineRange } from "../core/lineRange.js";
+import { LineRange } from "../core/ranges/lineRange.js";
 import { Range } from "../core/range.js";
-import { AbstractText, SingleTextEdit, TextEdit } from "../core/textEdit.js";
+import { TextReplacement, TextEdit } from "../core/edits/textEdit.js";
+import { AbstractText } from "../core/text/abstractText.js";
 import { IChange } from "./legacyLinesDiffComputer.js";
 export declare class LineRangeMapping {
     static inverse(mapping: readonly LineRangeMapping[], originalLineCount: number, modifiedLineCount: number): LineRangeMapping[];
@@ -32,7 +33,7 @@ export declare class RangeMapping {
     constructor(originalRange: Range, modifiedRange: Range);
     toString(): string;
     flip(): RangeMapping;
-    toTextEdit(modified: AbstractText): SingleTextEdit;
+    toTextEdit(modified: AbstractText): TextReplacement;
     join(other: RangeMapping): RangeMapping;
 }
 export declare function lineRangeMappingFromRangeMappings(alignments: readonly RangeMapping[], originalLines: AbstractText, modifiedLines: AbstractText, dontAssertStartLine?: boolean): DetailedLineRangeMapping[];

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

@@ -2,10 +2,10 @@
 import { groupAdjacentBy } from '../../../base/common/arrays.js';
 import { assertFn, checkAdjacentItems } from '../../../base/common/assert.js';
 import { BugIndicatingError } from '../../../base/common/errors.js';
-import { LineRange } from '../core/lineRange.js';
+import { LineRange } from '../core/ranges/lineRange.js';
 import { Position } from '../core/position.js';
 import { Range } from '../core/range.js';
-import { SingleTextEdit } from '../core/textEdit.js';
+import { TextReplacement } from '../core/edits/textEdit.js';
 
 class LineRangeMapping {
     static inverse(mapping, originalLineCount, modifiedLineCount) {
@@ -129,12 +129,12 @@ class DetailedLineRangeMapping extends LineRangeMapping {
 class RangeMapping {
     static fromEdit(edit) {
         const newRanges = edit.getNewRanges();
-        const result = ( edit.edits.map((e, idx) => ( new RangeMapping(e.range, newRanges[idx]))));
+        const result = ( edit.replacements.map((e, idx) => ( new RangeMapping(e.range, newRanges[idx]))));
         return result;
     }
     static fromEditJoin(edit) {
         const newRanges = edit.getNewRanges();
-        const result = ( edit.edits.map((e, idx) => ( new RangeMapping(e.range, newRanges[idx]))));
+        const result = ( edit.replacements.map((e, idx) => ( new RangeMapping(e.range, newRanges[idx]))));
         return RangeMapping.join(result);
     }
     static join(rangeMappings) {
@@ -169,7 +169,7 @@ class RangeMapping {
     }
     toTextEdit(modified) {
         const newText = modified.getValueOfRange(this.modifiedRange);
-        return ( new SingleTextEdit(this.originalRange, newText));
+        return ( new TextReplacement(this.originalRange, newText));
     }
     join(other) {
         return ( new RangeMapping(
@@ -180,8 +180,8 @@ class RangeMapping {
 }
 function lineRangeMappingFromRangeMappings(alignments, originalLines, modifiedLines, dontAssertStartLine = false) {
     const changes = [];
-    for (const g of groupAdjacentBy(( alignments.map(a => getLineRangeMapping(a, originalLines, modifiedLines))), (a1, a2) => a1.original.overlapOrTouch(a2.original)
-        || a1.modified.overlapOrTouch(a2.modified))) {
+    for (const g of groupAdjacentBy(( alignments.map(a => getLineRangeMapping(a, originalLines, modifiedLines))), (a1, a2) => a1.original.intersectsOrTouches(a2.original)
+        || a1.modified.intersectsOrTouches(a2.modified))) {
         const first = g[0];
         const last = g[g.length - 1];
         changes.push(( new DetailedLineRangeMapping(

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

@@ -4,7 +4,7 @@ import { IDisposable } from "../../base/common/lifecycle.js";
 import { ThemeColor } from "../../base/common/themables.js";
 import { URI, UriComponents } from "../../base/common/uri.js";
 import { IEditorOptions } from "./config/editorOptions.js";
-import { IDimension } from "./core/dimension.js";
+import { IDimension } from "./core/2d/dimension.js";
 import { IPosition, Position } from "./core/position.js";
 import { IRange, Range } from "./core/range.js";
 import { ISelection, Selection } from "./core/selection.js";

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

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