@codingame/monaco-vscode-api 4.5.1 → 5.0.0

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

@@ -0,0 +1,21 @@
+import { ISingleEditOperation } from './editOperation.js';
+import { Position } from './position.js';
+import { Range } from './range.js';
+import { TextLength } from './textLength.js';
+
+declare class SingleTextEdit {
+    readonly range: Range;
+    readonly text: string;
+    constructor(range: Range, text: string);
+    get isEmpty(): boolean;
+    static equals(first: SingleTextEdit, second: SingleTextEdit): boolean;
+    toSingleEditOperation(): ISingleEditOperation;
+}
+declare abstract class AbstractText {
+    abstract getValueOfRange(range: Range): string;
+    abstract readonly length: TextLength;
+    get endPositionExclusive(): Position;
+    getValue(): string;
+}
+
+export { AbstractText, SingleTextEdit };

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

@@ -5,6 +5,9 @@ import { PositionOffsetTransformer } from './positionToOffset.js';
 import { Range } from './range.js';
 import { TextLength } from './textLength.js';
 class TextEdit {
+    static single(originalRange, newText) {
+        return ( new TextEdit([( new SingleTextEdit(originalRange, newText))]));
+    }
     constructor(edits) {
         this.edits = edits;
         assertFn(() => checkAdjacentItems(edits, (a, b) => a.range.getEndPosition().isBeforeOrEqual(b.range.getStartPosition())));
@@ -138,10 +141,19 @@ class SingleTextEdit {
     static equals(first, second) {
         return first.range.equalsRange(second.range) && first.text === second.text;
     }
+    toSingleEditOperation() {
+        return {
+            range: this.range,
+            text: this.text,
+        };
+    }
 }
 function rangeFromPositions(start, end) {
-    if (!start.isBeforeOrEqual(end)) {
-        throw new BugIndicatingError('start must be before end');
+    if (start.lineNumber === end.lineNumber && start.column === Number.MAX_SAFE_INTEGER) {
+        return Range.fromPositions(end, end);
+    }
+    else if (!start.isBeforeOrEqual(end)) {
+        throw ( new BugIndicatingError('start must be before end'));
     }
     return ( new Range(start.lineNumber, start.column, end.lineNumber, end.column));
 }

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

@@ -0,0 +1,29 @@
+import { Position } from './position.js';
+import { Range } from './range.js';
+
+/**
+ * Represents a non-negative length of text in terms of line and column count.
+*/
+declare class TextLength {
+    readonly lineCount: number;
+    readonly columnCount: number;
+    static zero: TextLength;
+    static lengthDiffNonNegative(start: TextLength, end: TextLength): TextLength;
+    static betweenPositions(position1: Position, position2: Position): TextLength;
+    static ofRange(range: Range): TextLength;
+    static ofText(text: string): TextLength;
+    constructor(lineCount: number, columnCount: number);
+    isZero(): boolean;
+    isLessThan(other: TextLength): boolean;
+    isGreaterThan(other: TextLength): boolean;
+    isGreaterThanOrEqualTo(other: TextLength): boolean;
+    equals(other: TextLength): boolean;
+    compare(other: TextLength): number;
+    add(other: TextLength): TextLength;
+    createRange(startPosition: Position): Range;
+    toRange(): Range;
+    addToPosition(position: Position): Position;
+    toString(): string;
+}
+
+export { TextLength };

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

@@ -57,6 +57,12 @@ class TextLength {
         }
         return this.columnCount > other.columnCount;
     }
+    isGreaterThanOrEqualTo(other) {
+        if (this.lineCount !== other.lineCount) {
+            return this.lineCount > other.lineCount;
+        }
+        return this.columnCount >= other.columnCount;
+    }
     equals(other) {
         return this.lineCount === other.lineCount && this.columnCount === other.columnCount;
     }

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

@@ -1,5 +1,5 @@
 import { compareBy } from '../../../base/common/arrays.js';
-import { findFirstMinBy, findLastMaxBy } from '../../../base/common/arraysFind.js';
+import { findFirstMin, findLastMax } from '../../../base/common/arraysFind.js';
 import { CursorState } from '../cursorCommon.js';
 import { Cursor } from './oneCursor.js';
 import { Position } from '../core/position.js';
@@ -44,10 +44,10 @@ class CursorCollection {
         return ( this.cursors.map(c => c.viewState.position));
     }
     getTopMostViewPosition() {
-        return findFirstMinBy(this.cursors, compareBy(c => c.viewState.position, Position.compare)).viewState.position;
+        return findFirstMin(this.cursors, compareBy(c => c.viewState.position, Position.compare)).viewState.position;
     }
     getBottomMostViewPosition() {
-        return findLastMaxBy(this.cursors, compareBy(c => c.viewState.position, Position.compare)).viewState.position;
+        return findLastMax(this.cursors, compareBy(c => c.viewState.position, Position.compare)).viewState.position;
     }
     getSelections() {
         return ( this.cursors.map(c => c.modelState.selection));

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

@@ -109,7 +109,7 @@ class DateTimeout {
         this.startTime = Date.now();
         this.valid = true;
         if (timeout <= 0) {
-            throw new BugIndicatingError('timeout must be positive');
+            throw ( new BugIndicatingError('timeout must be positive'));
         }
     }
     isValid() {

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

@@ -24,7 +24,17 @@ class DefaultLinesDiffComputer {
         if (originalLines.length === 1 && originalLines[0].length === 0 || modifiedLines.length === 1 && modifiedLines[0].length === 0) {
             return ( new LinesDiff([
                 ( new DetailedLineRangeMapping(( new LineRange(1, originalLines.length + 1)), ( new LineRange(1, modifiedLines.length + 1)), [
-                    ( new RangeMapping(( new Range(1, 1, originalLines.length, originalLines[0].length + 1)), ( new Range(1, 1, modifiedLines.length, modifiedLines[0].length + 1))))
+                    ( new RangeMapping(( new Range(
+                        1,
+                        1,
+                        originalLines.length,
+                        originalLines[originalLines.length - 1].length + 1
+                    )), ( new Range(
+                        1,
+                        1,
+                        modifiedLines.length,
+                        modifiedLines[modifiedLines.length - 1].length + 1
+                    ))))
                 ]))
             ], [], false));
         }

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

@@ -137,7 +137,7 @@ class CharSequence {
     }
     _assertIndex(index, arr) {
         if (index < 0 || index >= arr.length) {
-            throw new Error(`Illegal index`);
+            throw ( new Error(`Illegal index`));
         }
     }
     getElements() {

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

@@ -1,5 +1,6 @@
 import { LineRange } from '../core/lineRange.js';
 import { Range } from '../core/range.js';
+import { AbstractText, SingleTextEdit } from '../core/textEdit.js';
 
 /**
  * Maps a line range in the original text model to a line range in the modified text model.
@@ -20,6 +21,12 @@ declare class LineRangeMapping {
     flip(): LineRangeMapping;
     join(other: LineRangeMapping): LineRangeMapping;
     get changedLineCount(): number;
+    /**
+     * This method assumes that the LineRangeMapping describes a valid diff!
+     * I.e. if one range is empty, the other range cannot be the entire document.
+     * It avoids various problems when the line range points to non-existing line-numbers.
+    */
+    toRangeMapping(): RangeMapping;
 }
 /**
  * Maps a line range in the original text model to a line range in the modified text model.
@@ -53,6 +60,10 @@ declare class RangeMapping {
     constructor(originalRange: Range, modifiedRange: Range);
     toString(): string;
     flip(): RangeMapping;
+    /**
+     * Creates a single text edit that describes the change from the original to the modified text.
+    */
+    toTextEdit(modified: AbstractText): SingleTextEdit;
 }
 
 export { DetailedLineRangeMapping, LineRangeMapping, RangeMapping };

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

@@ -1,4 +1,7 @@
+import { BugIndicatingError } from '../../../base/common/errors.js';
 import { LineRange } from '../core/lineRange.js';
+import { Range } from '../core/range.js';
+import { SingleTextEdit } from '../core/textEdit.js';
 class LineRangeMapping {
     static inverse(mapping, originalLineCount, modifiedLineCount) {
         const result = [];
@@ -45,6 +48,32 @@ class LineRangeMapping {
     get changedLineCount() {
         return Math.max(this.original.length, this.modified.length);
     }
+    toRangeMapping() {
+        const origInclusiveRange = this.original.toInclusiveRange();
+        const modInclusiveRange = this.modified.toInclusiveRange();
+        if (origInclusiveRange && modInclusiveRange) {
+            return ( new RangeMapping(origInclusiveRange, modInclusiveRange));
+        }
+        else if (this.original.startLineNumber === 1 || this.modified.startLineNumber === 1) {
+            if (!(this.modified.startLineNumber === 1 && this.original.startLineNumber === 1)) {
+                throw ( new BugIndicatingError('not a valid diff'));
+            }
+            return ( new RangeMapping(( new Range(this.original.startLineNumber, 1, this.original.endLineNumberExclusive, 1)), ( new Range(this.modified.startLineNumber, 1, this.modified.endLineNumberExclusive, 1))));
+        }
+        else {
+            return ( new RangeMapping(( new Range(
+                this.original.startLineNumber - 1,
+                Number.MAX_SAFE_INTEGER,
+                this.original.endLineNumberExclusive - 1,
+                Number.MAX_SAFE_INTEGER
+            )), ( new Range(
+                this.modified.startLineNumber - 1,
+                Number.MAX_SAFE_INTEGER,
+                this.modified.endLineNumberExclusive - 1,
+                Number.MAX_SAFE_INTEGER
+            ))));
+        }
+    }
 }
 class DetailedLineRangeMapping extends LineRangeMapping {
     static fromRangeMappings(rangeMappings) {
@@ -60,9 +89,7 @@ class DetailedLineRangeMapping extends LineRangeMapping {
         return ( new DetailedLineRangeMapping(this.modified, this.original, this.innerChanges?.map(c => c.flip())));
     }
     withInnerChangesFromLineRanges() {
-        return ( new DetailedLineRangeMapping(this.original, this.modified, [
-            ( new RangeMapping(this.original.toExclusiveRange(), this.modified.toExclusiveRange())),
-        ]));
+        return ( new DetailedLineRangeMapping(this.original, this.modified, [this.toRangeMapping()]));
     }
 }
 class RangeMapping {
@@ -76,5 +103,9 @@ class RangeMapping {
     flip() {
         return ( new RangeMapping(this.modifiedRange, this.originalRange));
     }
+    toTextEdit(modified) {
+        const newText = modified.getValueOfRange(this.modifiedRange);
+        return ( new SingleTextEdit(this.originalRange, newText));
+    }
 }
 export { DetailedLineRangeMapping, LineRangeMapping, RangeMapping };

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

@@ -1,254 +1,95 @@
 import { localizeWithPath } from '../../nls.js';
 import { RawContextKey } from '../../platform/contextkey/common/contextkey.js';
+const _moduleId = "vs/editor/common/editorContextKeys";
 var EditorContextKeys;
-( (function(EditorContextKeys) {
-    EditorContextKeys.editorSimpleInput = ( new RawContextKey('editorSimpleInput', false, true));
-    EditorContextKeys.editorTextFocus = ( new RawContextKey('editorTextFocus', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorTextFocus',
-     "Whether the editor text has focus (cursor is blinking)"
-    ))));
-    EditorContextKeys.focus = ( new RawContextKey('editorFocus', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorFocus',
+( ((function(EditorContextKeys) {
+    EditorContextKeys.editorSimpleInput = ( (new RawContextKey('editorSimpleInput', false, true)));
+    EditorContextKeys.editorTextFocus = ( (new RawContextKey('editorTextFocus', false, ( localizeWithPath(_moduleId, 0, "Whether the editor text has focus (cursor is blinking)")))));
+    EditorContextKeys.focus = ( (new RawContextKey('editorFocus', false, ( localizeWithPath(
+     _moduleId,
+     1,
      "Whether the editor or an editor widget has focus (e.g. focus is in the find widget)"
-    ))));
-    EditorContextKeys.textInputFocus = ( new RawContextKey('textInputFocus', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'textInputFocus',
+    )))));
+    EditorContextKeys.textInputFocus = ( (new RawContextKey('textInputFocus', false, ( localizeWithPath(
+     _moduleId,
+     2,
      "Whether an editor or a rich text input has focus (cursor is blinking)"
-    ))));
-    EditorContextKeys.readOnly = ( new RawContextKey('editorReadonly', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorReadonly',
-     "Whether the editor is read-only"
-    ))));
-    EditorContextKeys.inDiffEditor = ( new RawContextKey('inDiffEditor', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'inDiffEditor',
-     "Whether the context is a diff editor"
-    ))));
-    EditorContextKeys.isEmbeddedDiffEditor = ( new RawContextKey('isEmbeddedDiffEditor', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'isEmbeddedDiffEditor',
-     "Whether the context is an embedded diff editor"
-    ))));
-    EditorContextKeys.inMultiDiffEditor = ( new RawContextKey('inMultiDiffEditor', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'inMultiDiffEditor',
-     "Whether the context is a multi diff editor"
-    ))));
-    EditorContextKeys.multiDiffEditorAllCollapsed = ( new RawContextKey('multiDiffEditorAllCollapsed', undefined, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'multiDiffEditorAllCollapsed',
-     "Whether all files in multi diff editor are collapsed"
-    ))));
-    EditorContextKeys.hasChanges = ( new RawContextKey('diffEditorHasChanges', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'diffEditorHasChanges',
-     "Whether the diff editor has changes"
-    ))));
-    EditorContextKeys.comparingMovedCode = ( new RawContextKey('comparingMovedCode', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'comparingMovedCode',
-     "Whether a moved code block is selected for comparison"
-    ))));
-    EditorContextKeys.accessibleDiffViewerVisible = ( new RawContextKey('accessibleDiffViewerVisible', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'accessibleDiffViewerVisible',
-     "Whether the accessible diff viewer is visible"
-    ))));
-    EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached = ( new RawContextKey('diffEditorRenderSideBySideInlineBreakpointReached', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'diffEditorRenderSideBySideInlineBreakpointReached',
+    )))));
+    EditorContextKeys.readOnly = ( (new RawContextKey('editorReadonly', false, ( localizeWithPath(_moduleId, 3, "Whether the editor is read-only")))));
+    EditorContextKeys.inDiffEditor = ( (new RawContextKey('inDiffEditor', false, ( localizeWithPath(_moduleId, 4, "Whether the context is a diff editor")))));
+    EditorContextKeys.isEmbeddedDiffEditor = ( (new RawContextKey('isEmbeddedDiffEditor', false, ( localizeWithPath(_moduleId, 5, "Whether the context is an embedded diff editor")))));
+    EditorContextKeys.inMultiDiffEditor = ( (new RawContextKey('inMultiDiffEditor', false, ( localizeWithPath(_moduleId, 6, "Whether the context is a multi diff editor")))));
+    EditorContextKeys.multiDiffEditorAllCollapsed = ( (new RawContextKey('multiDiffEditorAllCollapsed', undefined, ( localizeWithPath(_moduleId, 7, "Whether all files in multi diff editor are collapsed")))));
+    EditorContextKeys.hasChanges = ( (new RawContextKey('diffEditorHasChanges', false, ( localizeWithPath(_moduleId, 8, "Whether the diff editor has changes")))));
+    EditorContextKeys.comparingMovedCode = ( (new RawContextKey('comparingMovedCode', false, ( localizeWithPath(_moduleId, 9, "Whether a moved code block is selected for comparison")))));
+    EditorContextKeys.accessibleDiffViewerVisible = ( (new RawContextKey('accessibleDiffViewerVisible', false, ( localizeWithPath(_moduleId, 10, "Whether the accessible diff viewer is visible")))));
+    EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached = ( (new RawContextKey('diffEditorRenderSideBySideInlineBreakpointReached', false, ( localizeWithPath(
+     _moduleId,
+     11,
      "Whether the diff editor render side by side inline breakpoint is reached"
-    ))));
-    EditorContextKeys.diffEditorInlineMode = ( new RawContextKey('diffEditorInlineMode', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'diffEditorInlineMode',
-     "Whether inline mode is active"
-    ))));
-    EditorContextKeys.diffEditorOriginalWritable = ( new RawContextKey('diffEditorOriginalWritable', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'diffEditorOriginalWritable',
-     "Whether modified is writable in the diff editor"
-    ))));
-    EditorContextKeys.diffEditorModifiedWritable = ( new RawContextKey('diffEditorModifiedWritable', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'diffEditorModifiedWritable',
-     "Whether modified is writable in the diff editor"
-    ))));
-    EditorContextKeys.diffEditorOriginalUri = ( new RawContextKey('diffEditorOriginalUri', '', ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'diffEditorOriginalUri',
-     "The uri of the original document"
-    ))));
-    EditorContextKeys.diffEditorModifiedUri = ( new RawContextKey('diffEditorModifiedUri', '', ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'diffEditorModifiedUri',
-     "The uri of the modified document"
-    ))));
-    EditorContextKeys.columnSelection = ( new RawContextKey('editorColumnSelection', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorColumnSelection',
-     "Whether `editor.columnSelection` is enabled"
-    ))));
-    EditorContextKeys.writable = ( EditorContextKeys.readOnly.toNegated());
-    EditorContextKeys.hasNonEmptySelection = ( new RawContextKey('editorHasSelection', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasSelection',
-     "Whether the editor has text selected"
-    ))));
-    EditorContextKeys.hasOnlyEmptySelection = ( EditorContextKeys.hasNonEmptySelection.toNegated());
-    EditorContextKeys.hasMultipleSelections = ( new RawContextKey('editorHasMultipleSelections', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasMultipleSelections',
-     "Whether the editor has multiple selections"
-    ))));
-    EditorContextKeys.hasSingleSelection = ( EditorContextKeys.hasMultipleSelections.toNegated());
-    EditorContextKeys.tabMovesFocus = ( new RawContextKey('editorTabMovesFocus', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorTabMovesFocus',
-     "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, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHoverVisible',
-     "Whether the editor hover is visible"
-    ))));
-    EditorContextKeys.hoverFocused = ( new RawContextKey('editorHoverFocused', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHoverFocused',
-     "Whether the editor hover is focused"
-    ))));
-    EditorContextKeys.stickyScrollFocused = ( new RawContextKey('stickyScrollFocused', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'stickyScrollFocused',
-     "Whether the sticky scroll is focused"
-    ))));
-    EditorContextKeys.stickyScrollVisible = ( new RawContextKey('stickyScrollVisible', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'stickyScrollVisible',
-     "Whether the sticky scroll is visible"
-    ))));
-    EditorContextKeys.standaloneColorPickerVisible = ( new RawContextKey('standaloneColorPickerVisible', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'standaloneColorPickerVisible',
-     "Whether the standalone color picker is visible"
-    ))));
-    EditorContextKeys.standaloneColorPickerFocused = ( new RawContextKey('standaloneColorPickerFocused', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'standaloneColorPickerFocused',
-     "Whether the standalone color picker is focused"
-    ))));
-    EditorContextKeys.inCompositeEditor = ( new RawContextKey('inCompositeEditor', undefined, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'inCompositeEditor',
+    )))));
+    EditorContextKeys.diffEditorInlineMode = ( (new RawContextKey('diffEditorInlineMode', false, ( localizeWithPath(_moduleId, 12, "Whether inline mode is active")))));
+    EditorContextKeys.diffEditorOriginalWritable = ( (new RawContextKey('diffEditorOriginalWritable', false, ( localizeWithPath(_moduleId, 13, "Whether modified is writable in the diff editor")))));
+    EditorContextKeys.diffEditorModifiedWritable = ( (new RawContextKey('diffEditorModifiedWritable', false, ( localizeWithPath(_moduleId, 14, "Whether modified is writable in the diff editor")))));
+    EditorContextKeys.diffEditorOriginalUri = ( (new RawContextKey('diffEditorOriginalUri', '', ( localizeWithPath(_moduleId, 15, "The uri of the original document")))));
+    EditorContextKeys.diffEditorModifiedUri = ( (new RawContextKey('diffEditorModifiedUri', '', ( localizeWithPath(_moduleId, 16, "The uri of the modified document")))));
+    EditorContextKeys.columnSelection = ( (new RawContextKey('editorColumnSelection', false, ( localizeWithPath(_moduleId, 17, "Whether `editor.columnSelection` is enabled")))));
+    EditorContextKeys.writable = ( (EditorContextKeys.readOnly.toNegated()));
+    EditorContextKeys.hasNonEmptySelection = ( (new RawContextKey('editorHasSelection', false, ( localizeWithPath(_moduleId, 18, "Whether the editor has text selected")))));
+    EditorContextKeys.hasOnlyEmptySelection = ( (EditorContextKeys.hasNonEmptySelection.toNegated()));
+    EditorContextKeys.hasMultipleSelections = ( (new RawContextKey('editorHasMultipleSelections', false, ( localizeWithPath(_moduleId, 19, "Whether the editor has multiple selections")))));
+    EditorContextKeys.hasSingleSelection = ( (EditorContextKeys.hasMultipleSelections.toNegated()));
+    EditorContextKeys.tabMovesFocus = ( (new RawContextKey('editorTabMovesFocus', false, ( localizeWithPath(_moduleId, 20, "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, ( localizeWithPath(_moduleId, 21, "Whether the editor hover is visible")))));
+    EditorContextKeys.hoverFocused = ( (new RawContextKey('editorHoverFocused', false, ( localizeWithPath(_moduleId, 22, "Whether the editor hover is focused")))));
+    EditorContextKeys.stickyScrollFocused = ( (new RawContextKey('stickyScrollFocused', false, ( localizeWithPath(_moduleId, 23, "Whether the sticky scroll is focused")))));
+    EditorContextKeys.stickyScrollVisible = ( (new RawContextKey('stickyScrollVisible', false, ( localizeWithPath(_moduleId, 24, "Whether the sticky scroll is visible")))));
+    EditorContextKeys.standaloneColorPickerVisible = ( (new RawContextKey('standaloneColorPickerVisible', false, ( localizeWithPath(_moduleId, 25, "Whether the standalone color picker is visible")))));
+    EditorContextKeys.standaloneColorPickerFocused = ( (new RawContextKey('standaloneColorPickerFocused', false, ( localizeWithPath(_moduleId, 26, "Whether the standalone color picker is focused")))));
+    EditorContextKeys.inCompositeEditor = ( (new RawContextKey('inCompositeEditor', undefined, ( localizeWithPath(
+     _moduleId,
+     27,
      "Whether the editor is part of a larger editor (e.g. notebooks)"
-    ))));
-    EditorContextKeys.notInCompositeEditor = ( EditorContextKeys.inCompositeEditor.toNegated());
-    EditorContextKeys.languageId = ( new RawContextKey('editorLangId', '', ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorLangId',
-     "The language identifier of the editor"
-    ))));
-    EditorContextKeys.hasCompletionItemProvider = ( new RawContextKey('editorHasCompletionItemProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasCompletionItemProvider',
-     "Whether the editor has a completion item provider"
-    ))));
-    EditorContextKeys.hasCodeActionsProvider = ( new RawContextKey('editorHasCodeActionsProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasCodeActionsProvider',
-     "Whether the editor has a code actions provider"
-    ))));
-    EditorContextKeys.hasCodeLensProvider = ( new RawContextKey('editorHasCodeLensProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasCodeLensProvider',
-     "Whether the editor has a code lens provider"
-    ))));
-    EditorContextKeys.hasDefinitionProvider = ( new RawContextKey('editorHasDefinitionProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasDefinitionProvider',
-     "Whether the editor has a definition provider"
-    ))));
-    EditorContextKeys.hasDeclarationProvider = ( new RawContextKey('editorHasDeclarationProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasDeclarationProvider',
-     "Whether the editor has a declaration provider"
-    ))));
-    EditorContextKeys.hasImplementationProvider = ( new RawContextKey('editorHasImplementationProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasImplementationProvider',
-     "Whether the editor has an implementation provider"
-    ))));
-    EditorContextKeys.hasTypeDefinitionProvider = ( new RawContextKey('editorHasTypeDefinitionProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasTypeDefinitionProvider',
-     "Whether the editor has a type definition provider"
-    ))));
-    EditorContextKeys.hasHoverProvider = ( new RawContextKey('editorHasHoverProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasHoverProvider',
-     "Whether the editor has a hover provider"
-    ))));
-    EditorContextKeys.hasDocumentHighlightProvider = ( new RawContextKey('editorHasDocumentHighlightProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasDocumentHighlightProvider',
-     "Whether the editor has a document highlight provider"
-    ))));
-    EditorContextKeys.hasDocumentSymbolProvider = ( new RawContextKey('editorHasDocumentSymbolProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasDocumentSymbolProvider',
-     "Whether the editor has a document symbol provider"
-    ))));
-    EditorContextKeys.hasReferenceProvider = ( new RawContextKey('editorHasReferenceProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasReferenceProvider',
-     "Whether the editor has a reference provider"
-    ))));
-    EditorContextKeys.hasRenameProvider = ( new RawContextKey('editorHasRenameProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasRenameProvider',
-     "Whether the editor has a rename provider"
-    ))));
-    EditorContextKeys.hasSignatureHelpProvider = ( new RawContextKey('editorHasSignatureHelpProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasSignatureHelpProvider',
-     "Whether the editor has a signature help provider"
-    ))));
-    EditorContextKeys.hasInlayHintsProvider = ( new RawContextKey('editorHasInlayHintsProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasInlayHintsProvider',
-     "Whether the editor has an inline hints provider"
-    ))));
-    EditorContextKeys.hasDocumentFormattingProvider = ( new RawContextKey('editorHasDocumentFormattingProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasDocumentFormattingProvider',
-     "Whether the editor has a document formatting provider"
-    ))));
-    EditorContextKeys.hasDocumentSelectionFormattingProvider = ( new RawContextKey('editorHasDocumentSelectionFormattingProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasDocumentSelectionFormattingProvider',
+    )))));
+    EditorContextKeys.notInCompositeEditor = ( (EditorContextKeys.inCompositeEditor.toNegated()));
+    EditorContextKeys.languageId = ( (new RawContextKey('editorLangId', '', ( localizeWithPath(_moduleId, 28, "The language identifier of the editor")))));
+    EditorContextKeys.hasCompletionItemProvider = ( (new RawContextKey('editorHasCompletionItemProvider', false, ( localizeWithPath(_moduleId, 29, "Whether the editor has a completion item provider")))));
+    EditorContextKeys.hasCodeActionsProvider = ( (new RawContextKey('editorHasCodeActionsProvider', false, ( localizeWithPath(_moduleId, 30, "Whether the editor has a code actions provider")))));
+    EditorContextKeys.hasCodeLensProvider = ( (new RawContextKey('editorHasCodeLensProvider', false, ( localizeWithPath(_moduleId, 31, "Whether the editor has a code lens provider")))));
+    EditorContextKeys.hasDefinitionProvider = ( (new RawContextKey('editorHasDefinitionProvider', false, ( localizeWithPath(_moduleId, 32, "Whether the editor has a definition provider")))));
+    EditorContextKeys.hasDeclarationProvider = ( (new RawContextKey('editorHasDeclarationProvider', false, ( localizeWithPath(_moduleId, 33, "Whether the editor has a declaration provider")))));
+    EditorContextKeys.hasImplementationProvider = ( (new RawContextKey('editorHasImplementationProvider', false, ( localizeWithPath(_moduleId, 34, "Whether the editor has an implementation provider")))));
+    EditorContextKeys.hasTypeDefinitionProvider = ( (new RawContextKey('editorHasTypeDefinitionProvider', false, ( localizeWithPath(_moduleId, 35, "Whether the editor has a type definition provider")))));
+    EditorContextKeys.hasHoverProvider = ( (new RawContextKey('editorHasHoverProvider', false, ( localizeWithPath(_moduleId, 36, "Whether the editor has a hover provider")))));
+    EditorContextKeys.hasDocumentHighlightProvider = ( (new RawContextKey('editorHasDocumentHighlightProvider', false, ( localizeWithPath(_moduleId, 37, "Whether the editor has a document highlight provider")))));
+    EditorContextKeys.hasDocumentSymbolProvider = ( (new RawContextKey('editorHasDocumentSymbolProvider', false, ( localizeWithPath(_moduleId, 38, "Whether the editor has a document symbol provider")))));
+    EditorContextKeys.hasReferenceProvider = ( (new RawContextKey('editorHasReferenceProvider', false, ( localizeWithPath(_moduleId, 39, "Whether the editor has a reference provider")))));
+    EditorContextKeys.hasRenameProvider = ( (new RawContextKey('editorHasRenameProvider', false, ( localizeWithPath(_moduleId, 40, "Whether the editor has a rename provider")))));
+    EditorContextKeys.hasSignatureHelpProvider = ( (new RawContextKey('editorHasSignatureHelpProvider', false, ( localizeWithPath(_moduleId, 41, "Whether the editor has a signature help provider")))));
+    EditorContextKeys.hasInlayHintsProvider = ( (new RawContextKey('editorHasInlayHintsProvider', false, ( localizeWithPath(_moduleId, 42, "Whether the editor has an inline hints provider")))));
+    EditorContextKeys.hasDocumentFormattingProvider = ( (new RawContextKey('editorHasDocumentFormattingProvider', false, ( localizeWithPath(_moduleId, 43, "Whether the editor has a document formatting provider")))));
+    EditorContextKeys.hasDocumentSelectionFormattingProvider = ( (new RawContextKey('editorHasDocumentSelectionFormattingProvider', false, ( localizeWithPath(
+     _moduleId,
+     44,
      "Whether the editor has a document selection formatting provider"
-    ))));
-    EditorContextKeys.hasMultipleDocumentFormattingProvider = ( new RawContextKey('editorHasMultipleDocumentFormattingProvider', false, ( localizeWithPath(
-     'vs/editor/common/editorContextKeys',
-     'editorHasMultipleDocumentFormattingProvider',
+    )))));
+    EditorContextKeys.hasMultipleDocumentFormattingProvider = ( (new RawContextKey('editorHasMultipleDocumentFormattingProvider', false, ( localizeWithPath(
+     _moduleId,
+     45,
      "Whether the editor has multiple document formatting providers"
-    ))));
-    EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider = ( new RawContextKey(
+    )))));
+    EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider = ( (new RawContextKey(
      'editorHasMultipleDocumentSelectionFormattingProvider',
      false,
      ( localizeWithPath(
-      'vs/editor/common/editorContextKeys',
-      'editorHasMultipleDocumentSelectionFormattingProvider',
+      _moduleId,
+      46,
       "Whether the editor has multiple document selection formatting providers"
      ))
-    ));
-})(EditorContextKeys || (EditorContextKeys = {})));
+    )));
+})(EditorContextKeys || (EditorContextKeys = {}))));
 export { EditorContextKeys };

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

@@ -3,12 +3,13 @@ import { Emitter } from '../../../base/common/event.js';
 import { Registry } from '../../../platform/registry/common/platform.js';
 import { Mimes } from '../../../base/common/mime.js';
 import { Extensions as Extensions$1 } from '../../../platform/configuration/common/configurationRegistry.js';
+const _moduleId = "vs/editor/common/languages/modesRegistry";
 const Extensions = {
     ModesRegistry: 'editor.modesRegistry'
 };
 class EditorModesRegistry {
     constructor() {
-        this._onDidChangeLanguages = ( new Emitter());
+        this._onDidChangeLanguages = ( (new Emitter()));
         this.onDidChangeLanguages = this._onDidChangeLanguages.event;
         this._languages = [];
     }
@@ -30,21 +31,17 @@ class EditorModesRegistry {
         return this._languages;
     }
 }
-const ModesRegistry = ( new EditorModesRegistry());
+const ModesRegistry = ( (new EditorModesRegistry()));
 Registry.add(Extensions.ModesRegistry, ModesRegistry);
 const PLAINTEXT_LANGUAGE_ID = 'plaintext';
 const PLAINTEXT_EXTENSION = '.txt';
 ModesRegistry.registerLanguage({
     id: PLAINTEXT_LANGUAGE_ID,
     extensions: [PLAINTEXT_EXTENSION],
-    aliases: [( localizeWithPath(
-        'vs/editor/common/languages/modesRegistry',
-        'plainText.alias',
-        "Plain Text"
-    )), 'text'],
+    aliases: [( localizeWithPath(_moduleId, 0, "Plain Text")), 'text'],
     mimetypes: [Mimes.text]
 });
-( Registry.as(Extensions$1.Configuration))
+( (Registry.as(Extensions$1.Configuration)))
     .registerDefaultConfigurations([{
         overrides: {
             '[plaintext]': {