@codingame/monaco-vscode-api 36.2.7 → 37.0.0

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

@@ -5,79 +5,92 @@ 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(788, "Whether the editor text has focus (cursor is blinking)"))));
+    EditorContextKeys.editorTextFocus = ( new RawContextKey("editorTextFocus", false, ( localize(792, "Whether the editor text has focus (cursor is blinking)"))));
     EditorContextKeys.focus = ( new RawContextKey("editorFocus", false, ( localize(
-        789,
+        793,
         "Whether the editor or an editor widget has focus (e.g. focus is in the find widget)"
     ))));
     EditorContextKeys.textInputFocus = ( new RawContextKey("textInputFocus", false, ( localize(
-        790,
+        794,
         "Whether an editor or a rich text input has focus (cursor is blinking)"
     ))));
-    EditorContextKeys.readOnly = ( new RawContextKey("editorReadonly", false, ( localize(791, "Whether the editor is read-only"))));
-    EditorContextKeys.inDiffEditor = ( new RawContextKey("inDiffEditor", false, ( localize(792, "Whether the context is a diff editor"))));
-    EditorContextKeys.isEmbeddedDiffEditor = ( new RawContextKey("isEmbeddedDiffEditor", false, ( localize(793, "Whether the context is an embedded diff editor"))));
-    EditorContextKeys.inMultiDiffEditor = ( new RawContextKey("inMultiDiffEditor", false, ( localize(794, "Whether the context is a multi diff editor"))));
-    EditorContextKeys.multiDiffEditorAllCollapsed = ( new RawContextKey("multiDiffEditorAllCollapsed", undefined, ( localize(795, "Whether all files in multi diff editor are collapsed"))));
-    EditorContextKeys.hasChanges = ( new RawContextKey("diffEditorHasChanges", false, ( localize(796, "Whether the diff editor has changes"))));
-    EditorContextKeys.comparingMovedCode = ( new RawContextKey("comparingMovedCode", false, ( localize(797, "Whether a moved code block is selected for comparison"))));
-    EditorContextKeys.accessibleDiffViewerVisible = ( new RawContextKey("accessibleDiffViewerVisible", false, ( localize(798, "Whether the accessible diff viewer is visible"))));
+    EditorContextKeys.readOnly = ( new RawContextKey("editorReadonly", false, ( localize(795, "Whether the editor is read-only"))));
+    EditorContextKeys.inDiffEditor = ( new RawContextKey("inDiffEditor", false, ( localize(796, "Whether the context is a diff editor"))));
+    EditorContextKeys.isEmbeddedDiffEditor = ( new RawContextKey("isEmbeddedDiffEditor", false, ( localize(797, "Whether the context is an embedded diff editor"))));
+    EditorContextKeys.inMultiDiffEditor = ( new RawContextKey("inMultiDiffEditor", false, ( localize(798, "Whether the context is a multi diff editor"))));
+    EditorContextKeys.multiDiffEditorAllCollapsed = ( new RawContextKey("multiDiffEditorAllCollapsed", undefined, ( localize(799, "Whether all files in multi diff editor are collapsed"))));
+    EditorContextKeys.multiDiffEditorItemAllUnchangedRegionsShown = ( new RawContextKey("multiDiffEditorItemAllUnchangedRegionsShown", false, ( localize(
+        800,
+        "Whether all unchanged regions of a multi diff editor file are revealed"
+    ))));
+    EditorContextKeys.multiDiffEditorRenderSideBySide = ( new RawContextKey("multiDiffEditorRenderSideBySide", true, ( localize(
+        801,
+        "Whether the multi diff editor renders diffs side by side instead of inline"
+    ))));
+    EditorContextKeys.hasChanges = ( new RawContextKey("diffEditorHasChanges", false, ( localize(802, "Whether the diff editor has changes"))));
+    EditorContextKeys.comparingMovedCode = ( new RawContextKey("comparingMovedCode", false, ( localize(803, "Whether a moved code block is selected for comparison"))));
+    EditorContextKeys.accessibleDiffViewerVisible = ( new RawContextKey("accessibleDiffViewerVisible", false, ( localize(804, "Whether the accessible diff viewer is visible"))));
     EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached = ( new RawContextKey("diffEditorRenderSideBySideInlineBreakpointReached", false, ( localize(
-        799,
+        805,
         "Whether the diff editor render side by side inline breakpoint is reached"
     ))));
-    EditorContextKeys.diffEditorInlineMode = ( new RawContextKey("diffEditorInlineMode", false, ( localize(800, "Whether inline mode is active"))));
-    EditorContextKeys.diffEditorOriginalWritable = ( new RawContextKey("diffEditorOriginalWritable", false, ( localize(801, "Whether modified is writable in the diff editor"))));
-    EditorContextKeys.diffEditorModifiedWritable = ( new RawContextKey("diffEditorModifiedWritable", false, ( localize(802, "Whether modified is writable in the diff editor"))));
-    EditorContextKeys.diffEditorOriginalUri = ( new RawContextKey("diffEditorOriginalUri", "", ( localize(803, "The uri of the original document"))));
-    EditorContextKeys.diffEditorModifiedUri = ( new RawContextKey("diffEditorModifiedUri", "", ( localize(804, "The uri of the modified document"))));
-    EditorContextKeys.columnSelection = ( new RawContextKey("editorColumnSelection", false, ( localize(805, "Whether `editor.columnSelection` is enabled"))));
+    EditorContextKeys.diffEditorInlineMode = ( new RawContextKey("diffEditorInlineMode", false, ( localize(806, "Whether inline mode is active"))));
+    EditorContextKeys.diffEditorTemporaryInlineMode = ( new RawContextKey("diffEditorTemporaryInlineMode", false, ( localize(
+        807,
+        "Whether inline mode is temporarily active after manually resizing the diff editor"
+    ))));
+    EditorContextKeys.diffEditorAutomaticRenderSideBySide = ( new RawContextKey("diffEditorAutomaticRenderSideBySide", true, ( localize(808, "Whether automatic diff editor layout would render side by side"))));
+    EditorContextKeys.diffEditorOriginalWritable = ( new RawContextKey("diffEditorOriginalWritable", false, ( localize(809, "Whether modified is writable in the diff editor"))));
+    EditorContextKeys.diffEditorModifiedWritable = ( new RawContextKey("diffEditorModifiedWritable", false, ( localize(810, "Whether modified is writable in the diff editor"))));
+    EditorContextKeys.diffEditorOriginalUri = ( new RawContextKey("diffEditorOriginalUri", "", ( localize(811, "The uri of the original document"))));
+    EditorContextKeys.diffEditorModifiedUri = ( new RawContextKey("diffEditorModifiedUri", "", ( localize(812, "The uri of the modified document"))));
+    EditorContextKeys.columnSelection = ( new RawContextKey("editorColumnSelection", false, ( localize(813, "Whether `editor.columnSelection` is enabled"))));
     EditorContextKeys.writable = ( EditorContextKeys.readOnly.toNegated());
-    EditorContextKeys.hasNonEmptySelection = ( new RawContextKey("editorHasSelection", false, ( localize(806, "Whether the editor has text selected"))));
+    EditorContextKeys.hasNonEmptySelection = ( new RawContextKey("editorHasSelection", false, ( localize(814, "Whether the editor has text selected"))));
     EditorContextKeys.hasOnlyEmptySelection = ( EditorContextKeys.hasNonEmptySelection.toNegated());
-    EditorContextKeys.hasMultipleSelections = ( new RawContextKey("editorHasMultipleSelections", false, ( localize(807, "Whether the editor has multiple selections"))));
+    EditorContextKeys.hasMultipleSelections = ( new RawContextKey("editorHasMultipleSelections", false, ( localize(815, "Whether the editor has multiple selections"))));
     EditorContextKeys.hasSingleSelection = ( EditorContextKeys.hasMultipleSelections.toNegated());
-    EditorContextKeys.tabMovesFocus = ( new RawContextKey("editorTabMovesFocus", false, ( localize(808, "Whether `Tab` will move focus out of the editor"))));
+    EditorContextKeys.tabMovesFocus = ( new RawContextKey("editorTabMovesFocus", false, ( localize(816, "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(809, "Whether the editor hover is visible"))));
-    EditorContextKeys.hoverFocused = ( new RawContextKey("editorHoverFocused", false, ( localize(810, "Whether the editor hover is focused"))));
-    EditorContextKeys.stickyScrollFocused = ( new RawContextKey("stickyScrollFocused", false, ( localize(811, "Whether the sticky scroll is focused"))));
-    EditorContextKeys.stickyScrollVisible = ( new RawContextKey("stickyScrollVisible", false, ( localize(812, "Whether the sticky scroll is visible"))));
-    EditorContextKeys.standaloneColorPickerVisible = ( new RawContextKey("standaloneColorPickerVisible", false, ( localize(813, "Whether the standalone color picker is visible"))));
-    EditorContextKeys.standaloneColorPickerFocused = ( new RawContextKey("standaloneColorPickerFocused", false, ( localize(814, "Whether the standalone color picker is focused"))));
-    EditorContextKeys.isComposing = ( new RawContextKey("isComposing", false, ( localize(815, "Whether the editor is in the composition mode"))));
-    EditorContextKeys.inCompositeEditor = ( new RawContextKey("inCompositeEditor", undefined, ( localize(816, "Whether the editor is part of a larger editor (e.g. notebooks)"))));
+    EditorContextKeys.hoverVisible = ( new RawContextKey("editorHoverVisible", false, ( localize(817, "Whether the editor hover is visible"))));
+    EditorContextKeys.hoverFocused = ( new RawContextKey("editorHoverFocused", false, ( localize(818, "Whether the editor hover is focused"))));
+    EditorContextKeys.stickyScrollFocused = ( new RawContextKey("stickyScrollFocused", false, ( localize(819, "Whether the sticky scroll is focused"))));
+    EditorContextKeys.stickyScrollVisible = ( new RawContextKey("stickyScrollVisible", false, ( localize(820, "Whether the sticky scroll is visible"))));
+    EditorContextKeys.standaloneColorPickerVisible = ( new RawContextKey("standaloneColorPickerVisible", false, ( localize(821, "Whether the standalone color picker is visible"))));
+    EditorContextKeys.standaloneColorPickerFocused = ( new RawContextKey("standaloneColorPickerFocused", false, ( localize(822, "Whether the standalone color picker is focused"))));
+    EditorContextKeys.isComposing = ( new RawContextKey("isComposing", false, ( localize(823, "Whether the editor is in the composition mode"))));
+    EditorContextKeys.inCompositeEditor = ( new RawContextKey("inCompositeEditor", undefined, ( localize(824, "Whether the editor is part of a larger editor (e.g. notebooks)"))));
     EditorContextKeys.notInCompositeEditor = ( EditorContextKeys.inCompositeEditor.toNegated());
-    EditorContextKeys.languageId = ( new RawContextKey("editorLangId", "", ( localize(817, "The language identifier of the editor"))));
-    EditorContextKeys.hasCompletionItemProvider = ( new RawContextKey("editorHasCompletionItemProvider", false, ( localize(818, "Whether the editor has a completion item provider"))));
-    EditorContextKeys.hasCodeActionsProvider = ( new RawContextKey("editorHasCodeActionsProvider", false, ( localize(819, "Whether the editor has a code actions provider"))));
-    EditorContextKeys.hasCodeLensProvider = ( new RawContextKey("editorHasCodeLensProvider", false, ( localize(820, "Whether the editor has a code lens provider"))));
-    EditorContextKeys.hasDefinitionProvider = ( new RawContextKey("editorHasDefinitionProvider", false, ( localize(821, "Whether the editor has a definition provider"))));
-    EditorContextKeys.hasDeclarationProvider = ( new RawContextKey("editorHasDeclarationProvider", false, ( localize(822, "Whether the editor has a declaration provider"))));
-    EditorContextKeys.hasImplementationProvider = ( new RawContextKey("editorHasImplementationProvider", false, ( localize(823, "Whether the editor has an implementation provider"))));
-    EditorContextKeys.hasTypeDefinitionProvider = ( new RawContextKey("editorHasTypeDefinitionProvider", false, ( localize(824, "Whether the editor has a type definition provider"))));
-    EditorContextKeys.hasHoverProvider = ( new RawContextKey("editorHasHoverProvider", false, ( localize(825, "Whether the editor has a hover provider"))));
-    EditorContextKeys.hasDocumentHighlightProvider = ( new RawContextKey("editorHasDocumentHighlightProvider", false, ( localize(826, "Whether the editor has a document highlight provider"))));
-    EditorContextKeys.hasDocumentSymbolProvider = ( new RawContextKey("editorHasDocumentSymbolProvider", false, ( localize(827, "Whether the editor has a document symbol provider"))));
-    EditorContextKeys.hasReferenceProvider = ( new RawContextKey("editorHasReferenceProvider", false, ( localize(828, "Whether the editor has a reference provider"))));
-    EditorContextKeys.hasRenameProvider = ( new RawContextKey("editorHasRenameProvider", false, ( localize(829, "Whether the editor has a rename provider"))));
-    EditorContextKeys.hasSignatureHelpProvider = ( new RawContextKey("editorHasSignatureHelpProvider", false, ( localize(830, "Whether the editor has a signature help provider"))));
-    EditorContextKeys.hasInlayHintsProvider = ( new RawContextKey("editorHasInlayHintsProvider", false, ( localize(831, "Whether the editor has an inline hints provider"))));
-    EditorContextKeys.hasDocumentFormattingProvider = ( new RawContextKey("editorHasDocumentFormattingProvider", false, ( localize(832, "Whether the editor has a document formatting provider"))));
-    EditorContextKeys.hasDocumentSelectionFormattingProvider = ( new RawContextKey("editorHasDocumentSelectionFormattingProvider", false, ( localize(833, "Whether the editor has a document selection formatting provider"))));
-    EditorContextKeys.hasMultipleDocumentFormattingProvider = ( new RawContextKey("editorHasMultipleDocumentFormattingProvider", false, ( localize(834, "Whether the editor has multiple document formatting providers"))));
+    EditorContextKeys.languageId = ( new RawContextKey("editorLangId", "", ( localize(825, "The language identifier of the editor"))));
+    EditorContextKeys.hasCompletionItemProvider = ( new RawContextKey("editorHasCompletionItemProvider", false, ( localize(826, "Whether the editor has a completion item provider"))));
+    EditorContextKeys.hasCodeActionsProvider = ( new RawContextKey("editorHasCodeActionsProvider", false, ( localize(827, "Whether the editor has a code actions provider"))));
+    EditorContextKeys.hasCodeLensProvider = ( new RawContextKey("editorHasCodeLensProvider", false, ( localize(828, "Whether the editor has a code lens provider"))));
+    EditorContextKeys.hasDefinitionProvider = ( new RawContextKey("editorHasDefinitionProvider", false, ( localize(829, "Whether the editor has a definition provider"))));
+    EditorContextKeys.hasDeclarationProvider = ( new RawContextKey("editorHasDeclarationProvider", false, ( localize(830, "Whether the editor has a declaration provider"))));
+    EditorContextKeys.hasImplementationProvider = ( new RawContextKey("editorHasImplementationProvider", false, ( localize(831, "Whether the editor has an implementation provider"))));
+    EditorContextKeys.hasTypeDefinitionProvider = ( new RawContextKey("editorHasTypeDefinitionProvider", false, ( localize(832, "Whether the editor has a type definition provider"))));
+    EditorContextKeys.hasHoverProvider = ( new RawContextKey("editorHasHoverProvider", false, ( localize(833, "Whether the editor has a hover provider"))));
+    EditorContextKeys.hasDocumentHighlightProvider = ( new RawContextKey("editorHasDocumentHighlightProvider", false, ( localize(834, "Whether the editor has a document highlight provider"))));
+    EditorContextKeys.hasDocumentSymbolProvider = ( new RawContextKey("editorHasDocumentSymbolProvider", false, ( localize(835, "Whether the editor has a document symbol provider"))));
+    EditorContextKeys.hasReferenceProvider = ( new RawContextKey("editorHasReferenceProvider", false, ( localize(836, "Whether the editor has a reference provider"))));
+    EditorContextKeys.hasRenameProvider = ( new RawContextKey("editorHasRenameProvider", false, ( localize(837, "Whether the editor has a rename provider"))));
+    EditorContextKeys.hasSignatureHelpProvider = ( new RawContextKey("editorHasSignatureHelpProvider", false, ( localize(838, "Whether the editor has a signature help provider"))));
+    EditorContextKeys.hasInlayHintsProvider = ( new RawContextKey("editorHasInlayHintsProvider", false, ( localize(839, "Whether the editor has an inline hints provider"))));
+    EditorContextKeys.hasDocumentFormattingProvider = ( new RawContextKey("editorHasDocumentFormattingProvider", false, ( localize(840, "Whether the editor has a document formatting provider"))));
+    EditorContextKeys.hasDocumentSelectionFormattingProvider = ( new RawContextKey("editorHasDocumentSelectionFormattingProvider", false, ( localize(841, "Whether the editor has a document selection formatting provider"))));
+    EditorContextKeys.hasMultipleDocumentFormattingProvider = ( new RawContextKey("editorHasMultipleDocumentFormattingProvider", false, ( localize(842, "Whether the editor has multiple document formatting providers"))));
     EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider = ( new RawContextKey(
         "editorHasMultipleDocumentSelectionFormattingProvider",
         false,
         ( localize(
-        835,
+        843,
         "Whether the editor has multiple document selection formatting providers"
     ))
     ));
-    EditorContextKeys.selectionHasDiagnostics = ( new RawContextKey("editorSelectionHasDiagnostics", false, ( localize(836, "Whether any diagnostic is present in the current editor selection"))));
+    EditorContextKeys.selectionHasDiagnostics = ( new RawContextKey("editorSelectionHasDiagnostics", false, ( localize(844, "Whether any diagnostic is present in the current editor selection"))));
 })(EditorContextKeys || (EditorContextKeys = {}));
 
 export { EditorContextKeys };

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

@@ -313,7 +313,7 @@ function getIndentActionForType(
         return indentation;
     }
     const previousLineNumber = range.startLineNumber - 1;
-    if (previousLineNumber > 0) {
+    if (range.isEmpty() && previousLineNumber > 0) {
         const previousLine = model.getLineContent(previousLineNumber);
         if (indentRulesSupport.shouldIndentNextLine(previousLine) && indentRulesSupport.shouldIncrease(textAroundRangeWithCharacter)) {
             const inheritedIndentationData = getInheritIndentForLine(

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

@@ -31,7 +31,10 @@ let LanguageConfigurationService = class LanguageConfigurationService extends Di
         this.configurationService = configurationService;
         this.languageService = languageService;
         this._registry = this._register(( new LanguageConfigurationRegistry()));
-        this.onDidChangeEmitter = this._register(( new Emitter()));
+        this.onDidChangeEmitter = this._register(( new Emitter({
+            leakWarningThreshold: 500,
+            leakWarningName: "LanguageConfigurationService.onDidChange"
+        })));
         this.onDidChange = this.onDidChangeEmitter.event;
         this.configurations = ( new Map());
         const languageConfigKeys = ( new Set(( Object.values(customizedLanguageConfigKeys))));

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

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

@@ -853,6 +853,7 @@ export type LifetimeSummary = {
     editKind: string | undefined;
     longDistanceHintVisible?: boolean;
     longDistanceHintDistance?: number;
+    isForAnotherDocument?: boolean;
 };
 export interface CodeAction {
     title: string;
@@ -1958,7 +1959,7 @@ export interface ILazyTokenizationSupport<TSupport> {
 export declare class LazyTokenizationSupport<TSupport = ITokenizationSupport> implements IDisposable, ILazyTokenizationSupport<TSupport> {
     private readonly createSupport;
     private _tokenizationSupport;
-    constructor(createSupport: () => Promise<TSupport & IDisposable | null>);
+    constructor(createSupport: () => Promise<(TSupport & IDisposable) | null>);
     dispose(): void;
     get tokenizationSupport(): Promise<TSupport | null>;
 }

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

@@ -117,63 +117,63 @@ var CompletionItemKinds;
     function toLabel(kind) {
         switch (kind) {
         case CompletionItemKind.Method:
-            return localize(837, "Method");
+            return localize(845, "Method");
         case CompletionItemKind.Function:
-            return localize(838, "Function");
+            return localize(846, "Function");
         case CompletionItemKind.Constructor:
-            return localize(839, "Constructor");
+            return localize(847, "Constructor");
         case CompletionItemKind.Field:
-            return localize(840, "Field");
+            return localize(848, "Field");
         case CompletionItemKind.Variable:
-            return localize(841, "Variable");
+            return localize(849, "Variable");
         case CompletionItemKind.Class:
-            return localize(842, "Class");
+            return localize(850, "Class");
         case CompletionItemKind.Struct:
-            return localize(843, "Struct");
+            return localize(851, "Struct");
         case CompletionItemKind.Interface:
-            return localize(844, "Interface");
+            return localize(852, "Interface");
         case CompletionItemKind.Module:
-            return localize(845, "Module");
+            return localize(853, "Module");
         case CompletionItemKind.Property:
-            return localize(846, "Property");
+            return localize(854, "Property");
         case CompletionItemKind.Event:
-            return localize(847, "Event");
+            return localize(855, "Event");
         case CompletionItemKind.Operator:
-            return localize(848, "Operator");
+            return localize(856, "Operator");
         case CompletionItemKind.Unit:
-            return localize(849, "Unit");
+            return localize(857, "Unit");
         case CompletionItemKind.Value:
-            return localize(850, "Value");
+            return localize(858, "Value");
         case CompletionItemKind.Constant:
-            return localize(851, "Constant");
+            return localize(859, "Constant");
         case CompletionItemKind.Enum:
-            return localize(852, "Enum");
+            return localize(860, "Enum");
         case CompletionItemKind.EnumMember:
-            return localize(853, "Enum Member");
+            return localize(861, "Enum Member");
         case CompletionItemKind.Keyword:
-            return localize(854, "Keyword");
+            return localize(862, "Keyword");
         case CompletionItemKind.Text:
-            return localize(855, "Text");
+            return localize(863, "Text");
         case CompletionItemKind.Color:
-            return localize(856, "Color");
+            return localize(864, "Color");
         case CompletionItemKind.File:
-            return localize(857, "File");
+            return localize(865, "File");
         case CompletionItemKind.Reference:
-            return localize(858, "Reference");
+            return localize(866, "Reference");
         case CompletionItemKind.Customcolor:
-            return localize(859, "Custom Color");
+            return localize(867, "Custom Color");
         case CompletionItemKind.Folder:
-            return localize(860, "Folder");
+            return localize(868, "Folder");
         case CompletionItemKind.TypeParameter:
-            return localize(861, "Type Parameter");
+            return localize(869, "Type Parameter");
         case CompletionItemKind.User:
-            return localize(862, "User");
+            return localize(870, "User");
         case CompletionItemKind.Issue:
-            return localize(863, "Issue");
+            return localize(871, "Issue");
         case CompletionItemKind.Tool:
-            return localize(864, "Tool");
+            return localize(872, "Tool");
         case CompletionItemKind.Snippet:
-            return localize(865, "Snippet");
+            return localize(873, "Snippet");
         default:
             return "";
         }
@@ -380,35 +380,35 @@ var SymbolKind;
     SymbolKind[SymbolKind["TypeParameter"] = 25] = "TypeParameter";
 })(SymbolKind || (SymbolKind = {}));
 const symbolKindNames = {
-    [SymbolKind.Array]: ( localize(866, "array")),
-    [SymbolKind.Boolean]: ( localize(867, "boolean")),
-    [SymbolKind.Class]: ( localize(868, "class")),
-    [SymbolKind.Constant]: ( localize(869, "constant")),
-    [SymbolKind.Constructor]: ( localize(870, "constructor")),
-    [SymbolKind.Enum]: ( localize(871, "enumeration")),
-    [SymbolKind.EnumMember]: ( localize(872, "enumeration member")),
-    [SymbolKind.Event]: ( localize(873, "event")),
-    [SymbolKind.Field]: ( localize(874, "field")),
-    [SymbolKind.File]: ( localize(875, "file")),
-    [SymbolKind.Function]: ( localize(876, "function")),
-    [SymbolKind.Interface]: ( localize(877, "interface")),
-    [SymbolKind.Key]: ( localize(878, "key")),
-    [SymbolKind.Method]: ( localize(879, "method")),
-    [SymbolKind.Module]: ( localize(880, "module")),
-    [SymbolKind.Namespace]: ( localize(881, "namespace")),
-    [SymbolKind.Null]: ( localize(882, "null")),
-    [SymbolKind.Number]: ( localize(883, "number")),
-    [SymbolKind.Object]: ( localize(884, "object")),
-    [SymbolKind.Operator]: ( localize(885, "operator")),
-    [SymbolKind.Package]: ( localize(886, "package")),
-    [SymbolKind.Property]: ( localize(887, "property")),
-    [SymbolKind.String]: ( localize(888, "string")),
-    [SymbolKind.Struct]: ( localize(889, "struct")),
-    [SymbolKind.TypeParameter]: ( localize(890, "type parameter")),
-    [SymbolKind.Variable]: ( localize(891, "variable"))
+    [SymbolKind.Array]: ( localize(874, "array")),
+    [SymbolKind.Boolean]: ( localize(875, "boolean")),
+    [SymbolKind.Class]: ( localize(876, "class")),
+    [SymbolKind.Constant]: ( localize(877, "constant")),
+    [SymbolKind.Constructor]: ( localize(878, "constructor")),
+    [SymbolKind.Enum]: ( localize(879, "enumeration")),
+    [SymbolKind.EnumMember]: ( localize(880, "enumeration member")),
+    [SymbolKind.Event]: ( localize(881, "event")),
+    [SymbolKind.Field]: ( localize(882, "field")),
+    [SymbolKind.File]: ( localize(883, "file")),
+    [SymbolKind.Function]: ( localize(884, "function")),
+    [SymbolKind.Interface]: ( localize(885, "interface")),
+    [SymbolKind.Key]: ( localize(886, "key")),
+    [SymbolKind.Method]: ( localize(887, "method")),
+    [SymbolKind.Module]: ( localize(888, "module")),
+    [SymbolKind.Namespace]: ( localize(889, "namespace")),
+    [SymbolKind.Null]: ( localize(890, "null")),
+    [SymbolKind.Number]: ( localize(891, "number")),
+    [SymbolKind.Object]: ( localize(892, "object")),
+    [SymbolKind.Operator]: ( localize(893, "operator")),
+    [SymbolKind.Package]: ( localize(894, "package")),
+    [SymbolKind.Property]: ( localize(895, "property")),
+    [SymbolKind.String]: ( localize(896, "string")),
+    [SymbolKind.Struct]: ( localize(897, "struct")),
+    [SymbolKind.TypeParameter]: ( localize(898, "type parameter")),
+    [SymbolKind.Variable]: ( localize(899, "variable"))
 };
 function getAriaLabelForSymbol(symbolName, kind) {
-    return localize(892, "{0} ({1})", symbolName, symbolKindNames[kind]);
+    return localize(900, "{0} ({1})", symbolName, symbolKindNames[kind]);
 }
 var SymbolTag;
 (function(SymbolTag) {

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsImpl.d.ts

@@ -30,6 +30,7 @@ export declare class BracketPairsTextModelPart extends Disposable implements IBr
     getBracketPairsInRange(range: Range): CallbackIterable<BracketPairInfo>;
     getBracketPairsInRangeWithMinIndentation(range: Range): CallbackIterable<BracketPairWithMinIndentationInfo>;
     getBracketsInRange(range: Range, onlyColorizedBrackets?: boolean): CallbackIterable<BracketInfo>;
+    hasUnmatchedClosingBracketAfter(_position: IPosition, openingBracket: string): boolean;
     findMatchingBracketUp(_bracket: string, _position: IPosition, maxDuration?: number): Range | null;
     matchBracket(position: IPosition, maxDuration?: number): [
         Range,

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

@@ -78,6 +78,17 @@ class BracketPairsTextModelPart extends Disposable {
         this.updateBracketPairsTree();
         return this.bracketPairsTree.value?.object.getBracketsInRange(range, onlyColorizedBrackets) || CallbackIterable.empty;
     }
+    hasUnmatchedClosingBracketAfter(_position, openingBracket) {
+        const position = this.textModel.validatePosition(_position);
+        const languageId = this.textModel.getLanguageIdAtPosition(position.lineNumber, position.column);
+        const openingBracketInfo = this.languageConfigurationService.getLanguageConfiguration(languageId).bracketsNew.getOpeningBracketInfo(openingBracket);
+        if (!openingBracketInfo) {
+            return false;
+        }
+        this.bracketsRequested = true;
+        this.updateBracketPairsTree();
+        return this.bracketPairsTree.value?.object.hasUnmatchedClosingBracketAfter(position, openingBracketInfo) ?? false;
+    }
     findMatchingBracketUp(_bracket, _position, maxDuration) {
         const position = this.textModel.validatePosition(_position);
         const languageId = this.textModel.getLanguageIdAtPosition(position.lineNumber, position.column);

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/bracketPairsTree.d.ts

@@ -6,6 +6,7 @@ import { IModelContentChangedEvent, IModelTokensChangedEvent } from "../../../te
 import { ResolvedLanguageConfiguration } from "../../../languages/languageConfigurationRegistry.js";
 import { Position } from "../../../core/position.js";
 import { CallbackIterable } from "../../../../../base/common/arrays.js";
+import { OpeningBracketKind } from "../../../languages/supports/languageBracketsConfiguration.js";
 export declare class BracketPairsTree extends Disposable {
     private readonly textModel;
     private readonly getLanguageConfiguration;
@@ -30,6 +31,7 @@ export declare class BracketPairsTree extends Disposable {
     private parseDocumentFromTextBuffer;
     getBracketsInRange(range: Range, onlyColorizedBrackets: boolean): CallbackIterable<BracketInfo>;
     getBracketPairsInRange(range: Range, includeMinIndentation: boolean): CallbackIterable<BracketPairWithMinIndentationInfo>;
+    hasUnmatchedClosingBracketAfter(position: Position, openingBracket: OpeningBracketKind): boolean;
     getFirstBracketAfter(position: Position): IFoundBracket | null;
     getFirstBracketBefore(position: Position): IFoundBracket | null;
 }

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

@@ -5,10 +5,10 @@ import { BracketInfo, BracketPairWithMinIndentationInfo } from '../../../textMod
 import { AstNodeKind } from './ast.js';
 import { TextEditInfo } from './beforeEditPositionMapper.js';
 import { LanguageAgnosticBracketTokens } from './brackets.js';
-import { toLength, lengthZero, positionToLength, lengthAdd, lengthLessThan, lengthsToRange, lengthLessThanEqual, lengthGreaterThanEqual } from './length.js';
+import { toLength, lengthZero, positionToLength, lengthGreaterThanEqual, lengthAdd, lengthLessThan, lengthsToRange, lengthLessThanEqual } from './length.js';
 import { parseDocument } from './parser.js';
 import { DenseKeyProvider } from './smallImmutableSet.js';
-import { FastTokenizer, TextBufferTokenizer } from './tokenizer.js';
+import { FastTokenizer, TextBufferTokenizer, TokenKind } from './tokenizer.js';
 import { BackgroundTokenizationState } from '../../../tokenizationTextModelPart.js';
 import { CallbackIterable } from '../../../../../base/common/arrays.js';
 import { combineTextEditInfos } from './combineTextEditInfos.js';
@@ -136,6 +136,18 @@ class BracketPairsTree extends Disposable {
             );
         }));
     }
+    hasUnmatchedClosingBracketAfter(position, openingBracket) {
+        if (!this.textModel.tokenization.hasAccurateTokensForLine(this.textModel.getLineCount())) {
+            return false;
+        }
+        this.flushQueue();
+        const openingBracketToken = this.brackets.getToken(openingBracket.bracketText, openingBracket.languageId);
+        if (!openingBracketToken || openingBracketToken.kind !== TokenKind.OpeningBracket) {
+            return false;
+        }
+        const node = this.astWithTokens;
+        return hasUnmatchedClosingBracketAfter(node, positionToLength(position), openingBracketToken);
+    }
     getFirstBracketAfter(position) {
         this.flushQueue();
         const node = this.initialAstWithoutTokens || this.astWithTokens;
@@ -147,6 +159,42 @@ class BracketPairsTree extends Disposable {
         return getFirstBracketBefore(node, lengthZero, node.length, positionToLength(position));
     }
 }
+function hasUnmatchedClosingBracketAfter(root, positionLength, openingBracketToken) {
+    const openingBracketIds = openingBracketToken.bracketIds;
+    if (!root.missingOpeningBracketIds.intersects(openingBracketIds)) {
+        return false;
+    }
+    const nodesToVisit = [{
+        node: root,
+        offset: lengthZero
+    }];
+    while (nodesToVisit.length > 0) {
+        const {
+            node,
+            offset
+        } = nodesToVisit.pop();
+        if (node.kind === AstNodeKind.UnexpectedClosingBracket) {
+            if (lengthGreaterThanEqual(offset, positionLength)) {
+                return true;
+            }
+            continue;
+        }
+        let childOffset = offset;
+        for (const child of node.children) {
+            const childEndOffset = lengthAdd(childOffset, child.length);
+            const childEndsAfterPosition = lengthGreaterThanEqual(childEndOffset, positionLength);
+            const childCanContainMatchingOrphan = child.missingOpeningBracketIds.intersects(openingBracketIds);
+            if (childEndsAfterPosition && childCanContainMatchingOrphan) {
+                nodesToVisit.push({
+                    node: child,
+                    offset: childOffset
+                });
+            }
+            childOffset = childEndOffset;
+        }
+    }
+    return false;
+}
 function getFirstBracketBefore(node, nodeOffsetStart, nodeOffsetEnd, position) {
     if (node.kind === AstNodeKind.List || node.kind === AstNodeKind.Pair) {
         const lengths = [];

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(894, "Typing")), "undoredo.textBufferEdit", this._model, beforeCursorState));
+        const newElement = ( new SingleModelEditStackElement(( localize(902, "Typing")), "undoredo.textBufferEdit", this._model, beforeCursorState));
         this._undoRedoService.pushElement(newElement, group);
         return newElement;
     }

package/vscode/src/vs/editor/common/model/textModel.d.ts

@@ -112,7 +112,7 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     get guides(): IGuidesTextModelPart;
     private readonly _attachedViews;
     private readonly _viewModels;
-    constructor(source: string | model.ITextBufferFactory, languageIdOrSelection: string | ILanguageSelection, creationOptions: model.ITextModelCreationOptions, associatedResource: (URI | null) | undefined, _undoRedoService: IUndoRedoService, _languageService: ILanguageService, _languageConfigurationService: ILanguageConfigurationService, instantiationService: IInstantiationService);
+    constructor(source: string | model.ITextBufferFactory, languageIdOrSelection: string | ILanguageSelection, creationOptions: model.ITextModelCreationOptions, associatedResource: URI | null | undefined, _undoRedoService: IUndoRedoService, _languageService: ILanguageService, _languageConfigurationService: ILanguageConfigurationService, instantiationService: IInstantiationService);
     dispose(): void;
     _hasListeners(): boolean;
     private _assertNotDisposed;
@@ -300,6 +300,7 @@ export declare class ModelDecorationInjectedTextOptions implements model.Injecte
     readonly tokens: TokenArray | null;
     readonly inlineClassName: string | null;
     readonly inlineClassNameAffectsLetterSpacing: boolean;
+    readonly widthInEm: number | undefined;
     readonly attachedData: unknown | null;
     readonly cursorStops: model.InjectedTextCursorStops | null;
     private constructor();

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

@@ -2156,6 +2156,7 @@ class ModelDecorationInjectedTextOptions {
         this.tokens = options.tokens ?? null;
         this.inlineClassName = options.inlineClassName || null;
         this.inlineClassNameAffectsLetterSpacing = options.inlineClassNameAffectsLetterSpacing || false;
+        this.widthInEm = options.widthInEm !== undefined && Number.isFinite(options.widthInEm) && options.widthInEm >= 0 ? options.widthInEm : undefined;
         this.attachedData = options.attachedData || null;
         this.cursorStops = options.cursorStops || null;
     }

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

@@ -319,6 +319,11 @@ export interface InjectedTextOptions {
      * If there is an `inlineClassName` which affects letter spacing.
      */
     readonly inlineClassNameAffectsLetterSpacing?: boolean;
+    /**
+     * Sets the width used to wrap this injected text in editor-font em units.
+     * @internal
+     */
+    readonly widthInEm?: number;
     /**
      * This field allows to attach data to this injected text.
      * The data can be read when injected texts at a given position are queried.

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

@@ -87,7 +87,7 @@ export interface ILineBreaksComputerContext {
     getLineInjectedText(lineNumber: number): LineInjectedText[] | null;
 }
 export interface ILineBreaksComputerFactory {
-    createLineBreaksComputer(context: ILineBreaksComputerContext, fontInfo: FontInfo, tabSize: number, wrappingColumn: number, wrappingIndent: WrappingIndent, wordBreak: "normal" | "keepAll", wrapOnEscapedLineFeeds: boolean): ILineBreaksComputer;
+    createLineBreaksComputer(context: ILineBreaksComputerContext, fontInfo: FontInfo, tabSize: number, wrappingColumn: number, wrappingIndent: WrappingIndent, wordBreak: "normal" | "keepAll", wrapOnEscapedLineFeeds: boolean, useTwoCellFullwidthCharacters: boolean): ILineBreaksComputer;
 }
 export interface ILineBreaksComputer {
     /**

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

@@ -0,0 +1,16 @@
+import { URI } from "../../base/common/uri.js";
+import type { ITextEditorOptions } from "../../platform/editor/common/editor.js";
+import type { IRange } from "./core/range.js";
+export type IMultiDiffResourceId = {
+    original: URI | undefined;
+    modified: URI | undefined;
+};
+export interface IMultiDiffEditorOptions extends ITextEditorOptions {
+    viewState?: IMultiDiffEditorOptionsViewState;
+}
+export interface IMultiDiffEditorOptionsViewState {
+    revealData?: {
+        resource: IMultiDiffResourceId;
+        range?: IRange;
+    };
+}

package/vscode/src/vs/editor/common/services/semanticTokensProviderStyling.d.ts

@@ -12,10 +12,12 @@ export declare class SemanticTokensProviderStyling {
     private _hasWarnedOverlappingTokens;
     private _hasWarnedInvalidLengthTokens;
     private _hasWarnedInvalidEditStart;
+    private _hasWarnedInvalidEditDeleteCount;
     constructor(_legend: SemanticTokensLegend, _themeService: IThemeService, _languageService: ILanguageService, _logService: ILogService);
     getMetadata(tokenTypeIndex: number, tokenModifierSet: number, languageId: string): number;
     warnOverlappingSemanticTokens(lineNumber: number, startColumn: number): void;
     warnInvalidLengthSemanticTokens(lineNumber: number, startColumn: number): void;
     warnInvalidEditStart(previousResultId: string | undefined, resultId: string | undefined, editIndex: number, editStart: number, maxExpectedStart: number): void;
+    warnInvalidEditDeleteCount(previousResultId: string | undefined, resultId: string | undefined, srcLength: number, deltaLength: number): void;
 }
 export declare function toMultilineTokens2(tokens: SemanticTokens, styling: SemanticTokensProviderStyling, languageId: string): SparseMultilineTokens[];

package/vscode/src/vs/editor/common/services/semanticTokensProviderStyling.js

@@ -22,6 +22,7 @@ let SemanticTokensProviderStyling = class SemanticTokensProviderStyling {
         this._hasWarnedOverlappingTokens = false;
         this._hasWarnedInvalidLengthTokens = false;
         this._hasWarnedInvalidEditStart = false;
+        this._hasWarnedInvalidEditDeleteCount = false;
         this._hashTable = ( new HashTable());
     }
     getMetadata(tokenTypeIndex, tokenModifierSet, languageId) {
@@ -102,6 +103,14 @@ let SemanticTokensProviderStyling = class SemanticTokensProviderStyling {
             );
         }
     }
+    warnInvalidEditDeleteCount(previousResultId, resultId, srcLength, deltaLength) {
+        if (!this._hasWarnedInvalidEditDeleteCount) {
+            this._hasWarnedInvalidEditDeleteCount = true;
+            this._logService.warn(
+                `Invalid semantic tokens edit detected (previousResultId: ${previousResultId}, resultId: ${resultId}): The edits delete more tokens than the previous data contains (previous length ${srcLength}, computed length ${srcLength + deltaLength}).`
+            );
+        }
+    }
 };
 SemanticTokensProviderStyling = ( __decorate([( __param(1, IThemeService)), ( __param(2, ILanguageService)), ( __param(3, ILogService))], SemanticTokensProviderStyling));
 var SemanticColoringConstants;

package/vscode/src/vs/editor/common/standalone/standaloneEnums.d.ts

@@ -328,7 +328,9 @@ export declare enum EditorOption {
     effectiveEditContext = 170,
     scrollOnMiddleClick = 171,
     effectiveAllowVariableFonts = 172,
-    doubleClickSelectsBlock = 173
+    doubleClickSelectsBlock = 173,
+    fullwidthCharacterWidth = 174,
+    effectiveFullwidthCharacterWidth = 175
 }
 /**
  * End of line character preference.