@codingame/monaco-vscode-api 26.2.2 → 28.0.0

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

@@ -256,6 +256,8 @@ class CursorMoveCommands {
             {
                 if (unit === CursorMove.Unit.WrappedLine) {
                     return this._moveUpByViewLines(viewModel, cursors, inSelectionMode, value);
+                } else if (unit === CursorMove.Unit.FoldedLine) {
+                    return this._moveUpByFoldedLines(viewModel, cursors, inSelectionMode, value);
                 } else {
                     return this._moveUpByModelLines(viewModel, cursors, inSelectionMode, value);
                 }
@@ -264,6 +266,8 @@ class CursorMoveCommands {
             {
                 if (unit === CursorMove.Unit.WrappedLine) {
                     return this._moveDownByViewLines(viewModel, cursors, inSelectionMode, value);
+                } else if (unit === CursorMove.Unit.FoldedLine) {
+                    return this._moveDownByFoldedLines(viewModel, cursors, inSelectionMode, value);
                 } else {
                     return this._moveDownByModelLines(viewModel, cursors, inSelectionMode, value);
                 }
@@ -533,6 +537,85 @@ class CursorMoveCommands {
         }
         return result;
     }
+    static _moveDownByFoldedLines(viewModel, cursors, inSelectionMode, count) {
+        const model = viewModel.model;
+        const lineCount = model.getLineCount();
+        const hiddenAreas = viewModel.getHiddenAreas();
+        return ( cursors.map(cursor => {
+            const startLine = cursor.modelState.hasSelection() && !inSelectionMode ? cursor.modelState.selection.endLineNumber : cursor.modelState.position.lineNumber;
+            const targetLine = CursorMoveCommands._targetFoldedDown(startLine, count, hiddenAreas, lineCount);
+            const delta = targetLine - startLine;
+            if (delta === 0) {
+                return CursorState.fromModelState(cursor.modelState);
+            }
+            return CursorState.fromModelState(
+                MoveOperations.moveDown(viewModel.cursorConfig, model, cursor.modelState, inSelectionMode, delta)
+            );
+        }));
+    }
+    static _moveUpByFoldedLines(viewModel, cursors, inSelectionMode, count) {
+        const model = viewModel.model;
+        const hiddenAreas = viewModel.getHiddenAreas();
+        return ( cursors.map(cursor => {
+            const startLine = cursor.modelState.hasSelection() && !inSelectionMode ? cursor.modelState.selection.startLineNumber : cursor.modelState.position.lineNumber;
+            const targetLine = CursorMoveCommands._targetFoldedUp(startLine, count, hiddenAreas);
+            const delta = startLine - targetLine;
+            if (delta === 0) {
+                return CursorState.fromModelState(cursor.modelState);
+            }
+            return CursorState.fromModelState(
+                MoveOperations.moveUp(viewModel.cursorConfig, model, cursor.modelState, inSelectionMode, delta)
+            );
+        }));
+    }
+    static _targetFoldedDown(startLine, count, hiddenAreas, lineCount) {
+        let line = startLine;
+        let i = 0;
+        while (i < hiddenAreas.length && hiddenAreas[i].endLineNumber < line + 1) {
+            i++;
+        }
+        for (let step = 0; step < count; step++) {
+            if (line >= lineCount) {
+                return lineCount;
+            }
+            let candidate = line + 1;
+            while (i < hiddenAreas.length && hiddenAreas[i].endLineNumber < candidate) {
+                i++;
+            }
+            if (i < hiddenAreas.length && hiddenAreas[i].startLineNumber <= candidate) {
+                candidate = hiddenAreas[i].endLineNumber + 1;
+            }
+            if (candidate > lineCount) {
+                return line;
+            }
+            line = candidate;
+        }
+        return line;
+    }
+    static _targetFoldedUp(startLine, count, hiddenAreas) {
+        let line = startLine;
+        let i = hiddenAreas.length - 1;
+        while (i >= 0 && hiddenAreas[i].startLineNumber > line - 1) {
+            i--;
+        }
+        for (let step = 0; step < count; step++) {
+            if (line <= 1) {
+                return 1;
+            }
+            let candidate = line - 1;
+            while (i >= 0 && hiddenAreas[i].startLineNumber > candidate) {
+                i--;
+            }
+            if (i >= 0 && hiddenAreas[i].endLineNumber >= candidate) {
+                candidate = hiddenAreas[i].startLineNumber - 1;
+            }
+            if (candidate < 1) {
+                return line;
+            }
+            line = candidate;
+        }
+        return line;
+    }
     static _moveToViewPosition(viewModel, cursor, inSelectionMode, toViewLineNumber, toViewColumn) {
         return CursorState.fromViewState(cursor.viewState.move(inSelectionMode, toViewLineNumber, toViewColumn, 0));
     }
@@ -632,8 +715,10 @@ var CursorMove;
                         \`\`\`
                     * 'by': Unit to move. Default is computed based on 'to' value.
                         \`\`\`
-                        'line', 'wrappedLine', 'character', 'halfLine'
+                        'line', 'wrappedLine', 'character', 'halfLine', 'foldedLine'
                         \`\`\`
+                        Use 'foldedLine' with 'up'/'down' to move by logical lines while treating each
+                        folded region as a single step.
                     * 'value': Number of units to move. Default is '1'.
                     * 'select': If 'true' makes the selection. Default is 'false'.
                     * 'noHistory': If 'true' does not add the movement to navigation history. Default is 'false'.
@@ -665,7 +750,7 @@ var CursorMove;
                     },
                     "by": {
                         "type": "string",
-                        "enum": ["line", "wrappedLine", "character", "halfLine"]
+                        "enum": ["line", "wrappedLine", "character", "halfLine", "foldedLine"]
                     },
                     "value": {
                         "type": "number",
@@ -704,7 +789,8 @@ var CursorMove;
         Line: "line",
         WrappedLine: "wrappedLine",
         Character: "character",
-        HalfLine: "halfLine"
+        HalfLine: "halfLine",
+        FoldedLine: "foldedLine"
     };
     function parse(args) {
         if (!args.to) {
@@ -774,6 +860,9 @@ var CursorMove;
         case CursorMove.RawUnit.HalfLine:
             unit = Unit.HalfLine;
             break;
+        case CursorMove.RawUnit.FoldedLine:
+            unit = Unit.FoldedLine;
+            break;
         }
         return {
             direction: direction,
@@ -809,6 +898,7 @@ var CursorMove;
         Unit[Unit["WrappedLine"] = 2] = "WrappedLine";
         Unit[Unit["Character"] = 3] = "Character";
         Unit[Unit["HalfLine"] = 4] = "HalfLine";
+        Unit[Unit["FoldedLine"] = 5] = "FoldedLine";
     })(Unit = CursorMove.Unit || (CursorMove.Unit = {}));
 })(CursorMove || (CursorMove = {}));
 

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

@@ -71,4 +71,5 @@ export declare namespace EditorContextKeys {
     const hasDocumentSelectionFormattingProvider: RawContextKey<boolean>;
     const hasMultipleDocumentFormattingProvider: RawContextKey<boolean>;
     const hasMultipleDocumentSelectionFormattingProvider: RawContextKey<boolean>;
+    const selectionHasDiagnostics: RawContextKey<boolean>;
 }

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

@@ -5,78 +5,79 @@ 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(755, "Whether the editor text has focus (cursor is blinking)"))));
+    EditorContextKeys.editorTextFocus = ( new RawContextKey("editorTextFocus", false, ( localize(773, "Whether the editor text has focus (cursor is blinking)"))));
     EditorContextKeys.focus = ( new RawContextKey("editorFocus", false, ( localize(
-        756,
+        774,
         "Whether the editor or an editor widget has focus (e.g. focus is in the find widget)"
     ))));
     EditorContextKeys.textInputFocus = ( new RawContextKey("textInputFocus", false, ( localize(
-        757,
+        775,
         "Whether an editor or a rich text input has focus (cursor is blinking)"
     ))));
-    EditorContextKeys.readOnly = ( new RawContextKey("editorReadonly", false, ( localize(758, "Whether the editor is read-only"))));
-    EditorContextKeys.inDiffEditor = ( new RawContextKey("inDiffEditor", false, ( localize(759, "Whether the context is a diff editor"))));
-    EditorContextKeys.isEmbeddedDiffEditor = ( new RawContextKey("isEmbeddedDiffEditor", false, ( localize(760, "Whether the context is an embedded diff editor"))));
-    EditorContextKeys.inMultiDiffEditor = ( new RawContextKey("inMultiDiffEditor", false, ( localize(761, "Whether the context is a multi diff editor"))));
-    EditorContextKeys.multiDiffEditorAllCollapsed = ( new RawContextKey("multiDiffEditorAllCollapsed", undefined, ( localize(762, "Whether all files in multi diff editor are collapsed"))));
-    EditorContextKeys.hasChanges = ( new RawContextKey("diffEditorHasChanges", false, ( localize(763, "Whether the diff editor has changes"))));
-    EditorContextKeys.comparingMovedCode = ( new RawContextKey("comparingMovedCode", false, ( localize(764, "Whether a moved code block is selected for comparison"))));
-    EditorContextKeys.accessibleDiffViewerVisible = ( new RawContextKey("accessibleDiffViewerVisible", false, ( localize(765, "Whether the accessible diff viewer is visible"))));
+    EditorContextKeys.readOnly = ( new RawContextKey("editorReadonly", false, ( localize(776, "Whether the editor is read-only"))));
+    EditorContextKeys.inDiffEditor = ( new RawContextKey("inDiffEditor", false, ( localize(777, "Whether the context is a diff editor"))));
+    EditorContextKeys.isEmbeddedDiffEditor = ( new RawContextKey("isEmbeddedDiffEditor", false, ( localize(778, "Whether the context is an embedded diff editor"))));
+    EditorContextKeys.inMultiDiffEditor = ( new RawContextKey("inMultiDiffEditor", false, ( localize(779, "Whether the context is a multi diff editor"))));
+    EditorContextKeys.multiDiffEditorAllCollapsed = ( new RawContextKey("multiDiffEditorAllCollapsed", undefined, ( localize(780, "Whether all files in multi diff editor are collapsed"))));
+    EditorContextKeys.hasChanges = ( new RawContextKey("diffEditorHasChanges", false, ( localize(781, "Whether the diff editor has changes"))));
+    EditorContextKeys.comparingMovedCode = ( new RawContextKey("comparingMovedCode", false, ( localize(782, "Whether a moved code block is selected for comparison"))));
+    EditorContextKeys.accessibleDiffViewerVisible = ( new RawContextKey("accessibleDiffViewerVisible", false, ( localize(783, "Whether the accessible diff viewer is visible"))));
     EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached = ( new RawContextKey("diffEditorRenderSideBySideInlineBreakpointReached", false, ( localize(
-        766,
+        784,
         "Whether the diff editor render side by side inline breakpoint is reached"
     ))));
-    EditorContextKeys.diffEditorInlineMode = ( new RawContextKey("diffEditorInlineMode", false, ( localize(767, "Whether inline mode is active"))));
-    EditorContextKeys.diffEditorOriginalWritable = ( new RawContextKey("diffEditorOriginalWritable", false, ( localize(768, "Whether modified is writable in the diff editor"))));
-    EditorContextKeys.diffEditorModifiedWritable = ( new RawContextKey("diffEditorModifiedWritable", false, ( localize(769, "Whether modified is writable in the diff editor"))));
-    EditorContextKeys.diffEditorOriginalUri = ( new RawContextKey("diffEditorOriginalUri", "", ( localize(770, "The uri of the original document"))));
-    EditorContextKeys.diffEditorModifiedUri = ( new RawContextKey("diffEditorModifiedUri", "", ( localize(771, "The uri of the modified document"))));
-    EditorContextKeys.columnSelection = ( new RawContextKey("editorColumnSelection", false, ( localize(772, "Whether `editor.columnSelection` is enabled"))));
+    EditorContextKeys.diffEditorInlineMode = ( new RawContextKey("diffEditorInlineMode", false, ( localize(785, "Whether inline mode is active"))));
+    EditorContextKeys.diffEditorOriginalWritable = ( new RawContextKey("diffEditorOriginalWritable", false, ( localize(786, "Whether modified is writable in the diff editor"))));
+    EditorContextKeys.diffEditorModifiedWritable = ( new RawContextKey("diffEditorModifiedWritable", false, ( localize(787, "Whether modified is writable in the diff editor"))));
+    EditorContextKeys.diffEditorOriginalUri = ( new RawContextKey("diffEditorOriginalUri", "", ( localize(788, "The uri of the original document"))));
+    EditorContextKeys.diffEditorModifiedUri = ( new RawContextKey("diffEditorModifiedUri", "", ( localize(789, "The uri of the modified document"))));
+    EditorContextKeys.columnSelection = ( new RawContextKey("editorColumnSelection", false, ( localize(790, "Whether `editor.columnSelection` is enabled"))));
     EditorContextKeys.writable = ( EditorContextKeys.readOnly.toNegated());
-    EditorContextKeys.hasNonEmptySelection = ( new RawContextKey("editorHasSelection", false, ( localize(773, "Whether the editor has text selected"))));
+    EditorContextKeys.hasNonEmptySelection = ( new RawContextKey("editorHasSelection", false, ( localize(791, "Whether the editor has text selected"))));
     EditorContextKeys.hasOnlyEmptySelection = ( EditorContextKeys.hasNonEmptySelection.toNegated());
-    EditorContextKeys.hasMultipleSelections = ( new RawContextKey("editorHasMultipleSelections", false, ( localize(774, "Whether the editor has multiple selections"))));
+    EditorContextKeys.hasMultipleSelections = ( new RawContextKey("editorHasMultipleSelections", false, ( localize(792, "Whether the editor has multiple selections"))));
     EditorContextKeys.hasSingleSelection = ( EditorContextKeys.hasMultipleSelections.toNegated());
-    EditorContextKeys.tabMovesFocus = ( new RawContextKey("editorTabMovesFocus", false, ( localize(775, "Whether `Tab` will move focus out of the editor"))));
+    EditorContextKeys.tabMovesFocus = ( new RawContextKey("editorTabMovesFocus", false, ( localize(793, "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(776, "Whether the editor hover is visible"))));
-    EditorContextKeys.hoverFocused = ( new RawContextKey("editorHoverFocused", false, ( localize(777, "Whether the editor hover is focused"))));
-    EditorContextKeys.stickyScrollFocused = ( new RawContextKey("stickyScrollFocused", false, ( localize(778, "Whether the sticky scroll is focused"))));
-    EditorContextKeys.stickyScrollVisible = ( new RawContextKey("stickyScrollVisible", false, ( localize(779, "Whether the sticky scroll is visible"))));
-    EditorContextKeys.standaloneColorPickerVisible = ( new RawContextKey("standaloneColorPickerVisible", false, ( localize(780, "Whether the standalone color picker is visible"))));
-    EditorContextKeys.standaloneColorPickerFocused = ( new RawContextKey("standaloneColorPickerFocused", false, ( localize(781, "Whether the standalone color picker is focused"))));
-    EditorContextKeys.isComposing = ( new RawContextKey("isComposing", false, ( localize(782, "Whether the editor is in the composition mode"))));
-    EditorContextKeys.inCompositeEditor = ( new RawContextKey("inCompositeEditor", undefined, ( localize(783, "Whether the editor is part of a larger editor (e.g. notebooks)"))));
+    EditorContextKeys.hoverVisible = ( new RawContextKey("editorHoverVisible", false, ( localize(794, "Whether the editor hover is visible"))));
+    EditorContextKeys.hoverFocused = ( new RawContextKey("editorHoverFocused", false, ( localize(795, "Whether the editor hover is focused"))));
+    EditorContextKeys.stickyScrollFocused = ( new RawContextKey("stickyScrollFocused", false, ( localize(796, "Whether the sticky scroll is focused"))));
+    EditorContextKeys.stickyScrollVisible = ( new RawContextKey("stickyScrollVisible", false, ( localize(797, "Whether the sticky scroll is visible"))));
+    EditorContextKeys.standaloneColorPickerVisible = ( new RawContextKey("standaloneColorPickerVisible", false, ( localize(798, "Whether the standalone color picker is visible"))));
+    EditorContextKeys.standaloneColorPickerFocused = ( new RawContextKey("standaloneColorPickerFocused", false, ( localize(799, "Whether the standalone color picker is focused"))));
+    EditorContextKeys.isComposing = ( new RawContextKey("isComposing", false, ( localize(800, "Whether the editor is in the composition mode"))));
+    EditorContextKeys.inCompositeEditor = ( new RawContextKey("inCompositeEditor", undefined, ( localize(801, "Whether the editor is part of a larger editor (e.g. notebooks)"))));
     EditorContextKeys.notInCompositeEditor = ( EditorContextKeys.inCompositeEditor.toNegated());
-    EditorContextKeys.languageId = ( new RawContextKey("editorLangId", "", ( localize(784, "The language identifier of the editor"))));
-    EditorContextKeys.hasCompletionItemProvider = ( new RawContextKey("editorHasCompletionItemProvider", false, ( localize(785, "Whether the editor has a completion item provider"))));
-    EditorContextKeys.hasCodeActionsProvider = ( new RawContextKey("editorHasCodeActionsProvider", false, ( localize(786, "Whether the editor has a code actions provider"))));
-    EditorContextKeys.hasCodeLensProvider = ( new RawContextKey("editorHasCodeLensProvider", false, ( localize(787, "Whether the editor has a code lens provider"))));
-    EditorContextKeys.hasDefinitionProvider = ( new RawContextKey("editorHasDefinitionProvider", false, ( localize(788, "Whether the editor has a definition provider"))));
-    EditorContextKeys.hasDeclarationProvider = ( new RawContextKey("editorHasDeclarationProvider", false, ( localize(789, "Whether the editor has a declaration provider"))));
-    EditorContextKeys.hasImplementationProvider = ( new RawContextKey("editorHasImplementationProvider", false, ( localize(790, "Whether the editor has an implementation provider"))));
-    EditorContextKeys.hasTypeDefinitionProvider = ( new RawContextKey("editorHasTypeDefinitionProvider", false, ( localize(791, "Whether the editor has a type definition provider"))));
-    EditorContextKeys.hasHoverProvider = ( new RawContextKey("editorHasHoverProvider", false, ( localize(792, "Whether the editor has a hover provider"))));
-    EditorContextKeys.hasDocumentHighlightProvider = ( new RawContextKey("editorHasDocumentHighlightProvider", false, ( localize(793, "Whether the editor has a document highlight provider"))));
-    EditorContextKeys.hasDocumentSymbolProvider = ( new RawContextKey("editorHasDocumentSymbolProvider", false, ( localize(794, "Whether the editor has a document symbol provider"))));
-    EditorContextKeys.hasReferenceProvider = ( new RawContextKey("editorHasReferenceProvider", false, ( localize(795, "Whether the editor has a reference provider"))));
-    EditorContextKeys.hasRenameProvider = ( new RawContextKey("editorHasRenameProvider", false, ( localize(796, "Whether the editor has a rename provider"))));
-    EditorContextKeys.hasSignatureHelpProvider = ( new RawContextKey("editorHasSignatureHelpProvider", false, ( localize(797, "Whether the editor has a signature help provider"))));
-    EditorContextKeys.hasInlayHintsProvider = ( new RawContextKey("editorHasInlayHintsProvider", false, ( localize(798, "Whether the editor has an inline hints provider"))));
-    EditorContextKeys.hasDocumentFormattingProvider = ( new RawContextKey("editorHasDocumentFormattingProvider", false, ( localize(799, "Whether the editor has a document formatting provider"))));
-    EditorContextKeys.hasDocumentSelectionFormattingProvider = ( new RawContextKey("editorHasDocumentSelectionFormattingProvider", false, ( localize(800, "Whether the editor has a document selection formatting provider"))));
-    EditorContextKeys.hasMultipleDocumentFormattingProvider = ( new RawContextKey("editorHasMultipleDocumentFormattingProvider", false, ( localize(801, "Whether the editor has multiple document formatting providers"))));
+    EditorContextKeys.languageId = ( new RawContextKey("editorLangId", "", ( localize(802, "The language identifier of the editor"))));
+    EditorContextKeys.hasCompletionItemProvider = ( new RawContextKey("editorHasCompletionItemProvider", false, ( localize(803, "Whether the editor has a completion item provider"))));
+    EditorContextKeys.hasCodeActionsProvider = ( new RawContextKey("editorHasCodeActionsProvider", false, ( localize(804, "Whether the editor has a code actions provider"))));
+    EditorContextKeys.hasCodeLensProvider = ( new RawContextKey("editorHasCodeLensProvider", false, ( localize(805, "Whether the editor has a code lens provider"))));
+    EditorContextKeys.hasDefinitionProvider = ( new RawContextKey("editorHasDefinitionProvider", false, ( localize(806, "Whether the editor has a definition provider"))));
+    EditorContextKeys.hasDeclarationProvider = ( new RawContextKey("editorHasDeclarationProvider", false, ( localize(807, "Whether the editor has a declaration provider"))));
+    EditorContextKeys.hasImplementationProvider = ( new RawContextKey("editorHasImplementationProvider", false, ( localize(808, "Whether the editor has an implementation provider"))));
+    EditorContextKeys.hasTypeDefinitionProvider = ( new RawContextKey("editorHasTypeDefinitionProvider", false, ( localize(809, "Whether the editor has a type definition provider"))));
+    EditorContextKeys.hasHoverProvider = ( new RawContextKey("editorHasHoverProvider", false, ( localize(810, "Whether the editor has a hover provider"))));
+    EditorContextKeys.hasDocumentHighlightProvider = ( new RawContextKey("editorHasDocumentHighlightProvider", false, ( localize(811, "Whether the editor has a document highlight provider"))));
+    EditorContextKeys.hasDocumentSymbolProvider = ( new RawContextKey("editorHasDocumentSymbolProvider", false, ( localize(812, "Whether the editor has a document symbol provider"))));
+    EditorContextKeys.hasReferenceProvider = ( new RawContextKey("editorHasReferenceProvider", false, ( localize(813, "Whether the editor has a reference provider"))));
+    EditorContextKeys.hasRenameProvider = ( new RawContextKey("editorHasRenameProvider", false, ( localize(814, "Whether the editor has a rename provider"))));
+    EditorContextKeys.hasSignatureHelpProvider = ( new RawContextKey("editorHasSignatureHelpProvider", false, ( localize(815, "Whether the editor has a signature help provider"))));
+    EditorContextKeys.hasInlayHintsProvider = ( new RawContextKey("editorHasInlayHintsProvider", false, ( localize(816, "Whether the editor has an inline hints provider"))));
+    EditorContextKeys.hasDocumentFormattingProvider = ( new RawContextKey("editorHasDocumentFormattingProvider", false, ( localize(817, "Whether the editor has a document formatting provider"))));
+    EditorContextKeys.hasDocumentSelectionFormattingProvider = ( new RawContextKey("editorHasDocumentSelectionFormattingProvider", false, ( localize(818, "Whether the editor has a document selection formatting provider"))));
+    EditorContextKeys.hasMultipleDocumentFormattingProvider = ( new RawContextKey("editorHasMultipleDocumentFormattingProvider", false, ( localize(819, "Whether the editor has multiple document formatting providers"))));
     EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider = ( new RawContextKey(
         "editorHasMultipleDocumentSelectionFormattingProvider",
         false,
         ( localize(
-        802,
+        820,
         "Whether the editor has multiple document selection formatting providers"
     ))
     ));
+    EditorContextKeys.selectionHasDiagnostics = ( new RawContextKey("editorSelectionHasDiagnostics", false, ( localize(821, "Whether any diagnostic is present in the current editor selection"))));
 })(EditorContextKeys || (EditorContextKeys = {}));
 
 export { EditorContextKeys };

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

@@ -20,6 +20,7 @@ export declare class LanguageFeatureRegistry<T> {
     has(model: ITextModel): boolean;
     all(model: ITextModel): T[];
     allNoModel(): T[];
+    get registeredLanguageIds(): ReadonlySet<string>;
     ordered(model: ITextModel, recursive?: boolean): T[];
     orderedGroups(model: ITextModel): T[][];
     private _orderedForEach;

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

@@ -2,7 +2,7 @@
 import { Emitter } from '../../base/common/event.js';
 import { toDisposable } from '../../base/common/lifecycle.js';
 import { shouldSynchronizeModel } from './model.js';
-import { score } from './languageSelector.js';
+import { selectLanguageIds, score } from './languageSelector.js';
 
 function isExclusive(selector) {
     if (typeof selector === "string") {
@@ -76,6 +76,13 @@ class LanguageFeatureRegistry {
     allNoModel() {
         return ( this._entries.map(entry => entry.provider));
     }
+    get registeredLanguageIds() {
+        const result = ( new Set());
+        for (const entry of this._entries) {
+            selectLanguageIds(entry.selector, result);
+        }
+        return result;
+    }
     ordered(model, recursive = false) {
         const result = [];
         this._orderedForEach(model, recursive, entry => result.push(entry.provider));

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

@@ -18,3 +18,4 @@ export interface LanguageFilter {
 export type LanguageSelector = string | LanguageFilter | ReadonlyArray<string | LanguageFilter>;
 export declare function score(selector: LanguageSelector | undefined, candidateUri: URI, candidateLanguage: string, candidateIsSynchronized: boolean, candidateNotebookUri: URI | undefined, candidateNotebookType: string | undefined): number;
 export declare function targetsNotebooks(selector: LanguageSelector): boolean;
+export declare function selectLanguageIds(selector: LanguageSelector, into: Set<string>): void;

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

@@ -112,5 +112,19 @@ function targetsNotebooks(selector) {
         return !!selector.notebookType;
     }
 }
+function selectLanguageIds(selector, into) {
+    if (typeof selector === "string") {
+        into.add(selector);
+    } else if (Array.isArray(selector)) {
+        for (const item of selector) {
+            selectLanguageIds(item, into);
+        }
+    } else {
+        const language = selector.language;
+        if (language) {
+            into.add(language);
+        }
+    }
+}
 
-export { score, targetsNotebooks };
+export { score, selectLanguageIds, targetsNotebooks };

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

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

@@ -612,6 +612,16 @@ export interface IInlineCompletionModel {
     name: string;
     id: string;
 }
+export interface IInlineCompletionProviderOption {
+    readonly id: string;
+    readonly label: string;
+    readonly values: readonly IInlineCompletionProviderOptionValue[];
+    readonly currentValueId: string;
+}
+export interface IInlineCompletionProviderOptionValue {
+    readonly id: string;
+    readonly label: string;
+}
 export declare class SelectedSuggestionInfo {
     readonly range: IRange;
     readonly text: string;
@@ -759,6 +769,9 @@ export interface InlineCompletionsProvider<T extends InlineCompletions = InlineC
     modelInfo?: IInlineCompletionModelInfo;
     onDidModelInfoChange?: Event<void>;
     setModelId?(modelId: string): Promise<void>;
+    providerOptions?: readonly IInlineCompletionProviderOption[];
+    onDidProviderOptionsChange?: Event<void>;
+    setProviderOption?(optionId: string, valueId: string): Promise<void>;
     toString?(): string;
 }
 /** @internal */

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

@@ -118,63 +118,63 @@ var CompletionItemKinds;
     function toLabel(kind) {
         switch (kind) {
         case CompletionItemKind.Method:
-            return localize(803, "Method");
+            return localize(822, "Method");
         case CompletionItemKind.Function:
-            return localize(804, "Function");
+            return localize(823, "Function");
         case CompletionItemKind.Constructor:
-            return localize(805, "Constructor");
+            return localize(824, "Constructor");
         case CompletionItemKind.Field:
-            return localize(806, "Field");
+            return localize(825, "Field");
         case CompletionItemKind.Variable:
-            return localize(807, "Variable");
+            return localize(826, "Variable");
         case CompletionItemKind.Class:
-            return localize(808, "Class");
+            return localize(827, "Class");
         case CompletionItemKind.Struct:
-            return localize(809, "Struct");
+            return localize(828, "Struct");
         case CompletionItemKind.Interface:
-            return localize(810, "Interface");
+            return localize(829, "Interface");
         case CompletionItemKind.Module:
-            return localize(811, "Module");
+            return localize(830, "Module");
         case CompletionItemKind.Property:
-            return localize(812, "Property");
+            return localize(831, "Property");
         case CompletionItemKind.Event:
-            return localize(813, "Event");
+            return localize(832, "Event");
         case CompletionItemKind.Operator:
-            return localize(814, "Operator");
+            return localize(833, "Operator");
         case CompletionItemKind.Unit:
-            return localize(815, "Unit");
+            return localize(834, "Unit");
         case CompletionItemKind.Value:
-            return localize(816, "Value");
+            return localize(835, "Value");
         case CompletionItemKind.Constant:
-            return localize(817, "Constant");
+            return localize(836, "Constant");
         case CompletionItemKind.Enum:
-            return localize(818, "Enum");
+            return localize(837, "Enum");
         case CompletionItemKind.EnumMember:
-            return localize(819, "Enum Member");
+            return localize(838, "Enum Member");
         case CompletionItemKind.Keyword:
-            return localize(820, "Keyword");
+            return localize(839, "Keyword");
         case CompletionItemKind.Text:
-            return localize(821, "Text");
+            return localize(840, "Text");
         case CompletionItemKind.Color:
-            return localize(822, "Color");
+            return localize(841, "Color");
         case CompletionItemKind.File:
-            return localize(823, "File");
+            return localize(842, "File");
         case CompletionItemKind.Reference:
-            return localize(824, "Reference");
+            return localize(843, "Reference");
         case CompletionItemKind.Customcolor:
-            return localize(825, "Custom Color");
+            return localize(844, "Custom Color");
         case CompletionItemKind.Folder:
-            return localize(826, "Folder");
+            return localize(845, "Folder");
         case CompletionItemKind.TypeParameter:
-            return localize(827, "Type Parameter");
+            return localize(846, "Type Parameter");
         case CompletionItemKind.User:
-            return localize(828, "User");
+            return localize(847, "User");
         case CompletionItemKind.Issue:
-            return localize(829, "Issue");
+            return localize(848, "Issue");
         case CompletionItemKind.Tool:
-            return localize(830, "Tool");
+            return localize(849, "Tool");
         case CompletionItemKind.Snippet:
-            return localize(831, "Snippet");
+            return localize(850, "Snippet");
         default:
             return "";
         }
@@ -381,35 +381,35 @@ var SymbolKind;
     SymbolKind[SymbolKind["TypeParameter"] = 25] = "TypeParameter";
 })(SymbolKind || (SymbolKind = {}));
 const symbolKindNames = {
-    [SymbolKind.Array]: ( localize(832, "array")),
-    [SymbolKind.Boolean]: ( localize(833, "boolean")),
-    [SymbolKind.Class]: ( localize(834, "class")),
-    [SymbolKind.Constant]: ( localize(835, "constant")),
-    [SymbolKind.Constructor]: ( localize(836, "constructor")),
-    [SymbolKind.Enum]: ( localize(837, "enumeration")),
-    [SymbolKind.EnumMember]: ( localize(838, "enumeration member")),
-    [SymbolKind.Event]: ( localize(839, "event")),
-    [SymbolKind.Field]: ( localize(840, "field")),
-    [SymbolKind.File]: ( localize(841, "file")),
-    [SymbolKind.Function]: ( localize(842, "function")),
-    [SymbolKind.Interface]: ( localize(843, "interface")),
-    [SymbolKind.Key]: ( localize(844, "key")),
-    [SymbolKind.Method]: ( localize(845, "method")),
-    [SymbolKind.Module]: ( localize(846, "module")),
-    [SymbolKind.Namespace]: ( localize(847, "namespace")),
-    [SymbolKind.Null]: ( localize(848, "null")),
-    [SymbolKind.Number]: ( localize(849, "number")),
-    [SymbolKind.Object]: ( localize(850, "object")),
-    [SymbolKind.Operator]: ( localize(851, "operator")),
-    [SymbolKind.Package]: ( localize(852, "package")),
-    [SymbolKind.Property]: ( localize(853, "property")),
-    [SymbolKind.String]: ( localize(854, "string")),
-    [SymbolKind.Struct]: ( localize(855, "struct")),
-    [SymbolKind.TypeParameter]: ( localize(856, "type parameter")),
-    [SymbolKind.Variable]: ( localize(857, "variable"))
+    [SymbolKind.Array]: ( localize(851, "array")),
+    [SymbolKind.Boolean]: ( localize(852, "boolean")),
+    [SymbolKind.Class]: ( localize(853, "class")),
+    [SymbolKind.Constant]: ( localize(854, "constant")),
+    [SymbolKind.Constructor]: ( localize(855, "constructor")),
+    [SymbolKind.Enum]: ( localize(856, "enumeration")),
+    [SymbolKind.EnumMember]: ( localize(857, "enumeration member")),
+    [SymbolKind.Event]: ( localize(858, "event")),
+    [SymbolKind.Field]: ( localize(859, "field")),
+    [SymbolKind.File]: ( localize(860, "file")),
+    [SymbolKind.Function]: ( localize(861, "function")),
+    [SymbolKind.Interface]: ( localize(862, "interface")),
+    [SymbolKind.Key]: ( localize(863, "key")),
+    [SymbolKind.Method]: ( localize(864, "method")),
+    [SymbolKind.Module]: ( localize(865, "module")),
+    [SymbolKind.Namespace]: ( localize(866, "namespace")),
+    [SymbolKind.Null]: ( localize(867, "null")),
+    [SymbolKind.Number]: ( localize(868, "number")),
+    [SymbolKind.Object]: ( localize(869, "object")),
+    [SymbolKind.Operator]: ( localize(870, "operator")),
+    [SymbolKind.Package]: ( localize(871, "package")),
+    [SymbolKind.Property]: ( localize(872, "property")),
+    [SymbolKind.String]: ( localize(873, "string")),
+    [SymbolKind.Struct]: ( localize(874, "struct")),
+    [SymbolKind.TypeParameter]: ( localize(875, "type parameter")),
+    [SymbolKind.Variable]: ( localize(876, "variable"))
 };
 function getAriaLabelForSymbol(symbolName, kind) {
-    return localize(858, "{0} ({1})", symbolName, symbolKindNames[kind]);
+    return localize(877, "{0} ({1})", symbolName, symbolKindNames[kind]);
 }
 var SymbolTag;
 (function(SymbolTag) {

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsImpl.js

@@ -17,7 +17,7 @@ class BracketPairsTextModelPart extends Disposable {
         this.textModel = textModel;
         this.languageConfigurationService = languageConfigurationService;
         this.bracketPairsTree = this._register(( new MutableDisposable()));
-        this.onDidChangeEmitter = ( new Emitter());
+        this.onDidChangeEmitter = this._register(( new Emitter()));
         this.onDidChange = this.onDidChangeEmitter.event;
         this.bracketsRequested = false;
     }

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/bracketPairsTree.js

@@ -21,7 +21,7 @@ class BracketPairsTree extends Disposable {
         super();
         this.textModel = textModel;
         this.getLanguageConfiguration = getLanguageConfiguration;
-        this.didChangeEmitter = ( new Emitter());
+        this.didChangeEmitter = this._register(( new Emitter()));
         this.denseKeyProvider = ( new DenseKeyProvider());
         this.brackets = ( new LanguageAgnosticBracketTokens(this.denseKeyProvider, this.getLanguageConfiguration));
         this.onDidChange = this.didChangeEmitter.event;

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/colorizedBracketPairsDecorationProvider.js

@@ -10,7 +10,7 @@ class ColorizedBracketPairsDecorationProvider extends Disposable {
         super();
         this.textModel = textModel;
         this.colorProvider = ( new ColorProvider());
-        this.onDidChangeEmitter = ( new Emitter());
+        this.onDidChangeEmitter = this._register(( new Emitter()));
         this.onDidChange = this.onDidChangeEmitter.event;
         this.colorizationOptions = textModel.getOptions().bracketPairColorizationOptions;
         this._register(textModel.bracketPairs.onDidChange(e => {

package/vscode/src/vs/editor/common/model/editStack.js

@@ -356,7 +356,7 @@ class EditStack {
         if (isEditStackElement(lastElement) && lastElement.canAppend(this._model)) {
             return lastElement;
         }
-        const newElement = ( new SingleModelEditStackElement(( localize(860, "Typing")), "undoredo.textBufferEdit", this._model, beforeCursorState));
+        const newElement = ( new SingleModelEditStackElement(( localize(879, "Typing")), "undoredo.textBufferEdit", this._model, beforeCursorState));
         this._undoRedoService.pushElement(newElement, group);
         return newElement;
     }

package/vscode/src/vs/editor/common/model/prefixSumComputer.js

@@ -148,6 +148,11 @@ class ConstantTimePrefixSumComputer {
     getIndexOf(sum) {
         this._ensureValid();
         const idx = this._indexBySum[sum];
+        if (idx === undefined) {
+            const lastIdx = Math.max(0, this._values.length - 1);
+            const lastPrefixSum = lastIdx > 0 ? this._prefixSum[lastIdx - 1] : 0;
+            return ( new PrefixSumIndexOfResult(lastIdx, sum - lastPrefixSum));
+        }
         const viewLinesAbove = idx > 0 ? this._prefixSum[idx - 1] : 0;
         return ( new PrefixSumIndexOfResult(idx, sum - viewLinesAbove));
     }
@@ -176,7 +181,7 @@ class ConstantTimePrefixSumComputer {
             }
         }
         this._prefixSum.length = this._values.length;
-        this._indexBySum.length = this._prefixSum[this._prefixSum.length - 1];
+        this._indexBySum.length = this._values.length > 0 ? this._prefixSum[this._values.length - 1] : 0;
         this._isValid = true;
         this._validEndIndex = this._values.length - 1;
     }