@codingame/monaco-vscode-api 7.0.11 → 7.1.1

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

@@ -1,93 +1,76 @@
-import { localizeWithPath } from '../../nls.js';
+import { localize } 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(_moduleId, 0, "Whether the editor text has focus (cursor is blinking)")))));
-    EditorContextKeys.focus = ( (new RawContextKey('editorFocus', false, ( localizeWithPath(
-     _moduleId,
-     1,
+    EditorContextKeys.editorTextFocus = ( (new RawContextKey('editorTextFocus', false, ( localize(871, "Whether the editor text has focus (cursor is blinking)")))));
+    EditorContextKeys.focus = ( (new RawContextKey('editorFocus', false, ( localize(
+     872,
      "Whether the editor or an editor widget has focus (e.g. focus is in the find widget)"
     )))));
-    EditorContextKeys.textInputFocus = ( (new RawContextKey('textInputFocus', false, ( localizeWithPath(
-     _moduleId,
-     2,
+    EditorContextKeys.textInputFocus = ( (new RawContextKey('textInputFocus', false, ( localize(
+     873,
      "Whether an editor or a rich text input has focus (cursor is blinking)"
     )))));
-    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,
+    EditorContextKeys.readOnly = ( (new RawContextKey('editorReadonly', false, ( localize(874, "Whether the editor is read-only")))));
+    EditorContextKeys.inDiffEditor = ( (new RawContextKey('inDiffEditor', false, ( localize(875, "Whether the context is a diff editor")))));
+    EditorContextKeys.isEmbeddedDiffEditor = ( (new RawContextKey('isEmbeddedDiffEditor', false, ( localize(876, "Whether the context is an embedded diff editor")))));
+    EditorContextKeys.inMultiDiffEditor = ( (new RawContextKey('inMultiDiffEditor', false, ( localize(877, "Whether the context is a multi diff editor")))));
+    EditorContextKeys.multiDiffEditorAllCollapsed = ( (new RawContextKey('multiDiffEditorAllCollapsed', undefined, ( localize(878, "Whether all files in multi diff editor are collapsed")))));
+    EditorContextKeys.hasChanges = ( (new RawContextKey('diffEditorHasChanges', false, ( localize(879, "Whether the diff editor has changes")))));
+    EditorContextKeys.comparingMovedCode = ( (new RawContextKey('comparingMovedCode', false, ( localize(880, "Whether a moved code block is selected for comparison")))));
+    EditorContextKeys.accessibleDiffViewerVisible = ( (new RawContextKey('accessibleDiffViewerVisible', false, ( localize(881, "Whether the accessible diff viewer is visible")))));
+    EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached = ( (new RawContextKey('diffEditorRenderSideBySideInlineBreakpointReached', false, ( localize(
+     882,
      "Whether the diff editor render side by side inline breakpoint is reached"
     )))));
-    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.diffEditorInlineMode = ( (new RawContextKey('diffEditorInlineMode', false, ( localize(883, "Whether inline mode is active")))));
+    EditorContextKeys.diffEditorOriginalWritable = ( (new RawContextKey('diffEditorOriginalWritable', false, ( localize(884, "Whether modified is writable in the diff editor")))));
+    EditorContextKeys.diffEditorModifiedWritable = ( (new RawContextKey('diffEditorModifiedWritable', false, ( localize(885, "Whether modified is writable in the diff editor")))));
+    EditorContextKeys.diffEditorOriginalUri = ( (new RawContextKey('diffEditorOriginalUri', '', ( localize(886, "The uri of the original document")))));
+    EditorContextKeys.diffEditorModifiedUri = ( (new RawContextKey('diffEditorModifiedUri', '', ( localize(887, "The uri of the modified document")))));
+    EditorContextKeys.columnSelection = ( (new RawContextKey('editorColumnSelection', false, ( localize(888, "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.hasNonEmptySelection = ( (new RawContextKey('editorHasSelection', false, ( localize(889, "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.hasMultipleSelections = ( (new RawContextKey('editorHasMultipleSelections', false, ( localize(890, "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.tabMovesFocus = ( (new RawContextKey('editorTabMovesFocus', false, ( localize(891, "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.hoverVisible = ( (new RawContextKey('editorHoverVisible', false, ( localize(892, "Whether the editor hover is visible")))));
+    EditorContextKeys.hoverFocused = ( (new RawContextKey('editorHoverFocused', false, ( localize(893, "Whether the editor hover is focused")))));
+    EditorContextKeys.stickyScrollFocused = ( (new RawContextKey('stickyScrollFocused', false, ( localize(894, "Whether the sticky scroll is focused")))));
+    EditorContextKeys.stickyScrollVisible = ( (new RawContextKey('stickyScrollVisible', false, ( localize(895, "Whether the sticky scroll is visible")))));
+    EditorContextKeys.standaloneColorPickerVisible = ( (new RawContextKey('standaloneColorPickerVisible', false, ( localize(896, "Whether the standalone color picker is visible")))));
+    EditorContextKeys.standaloneColorPickerFocused = ( (new RawContextKey('standaloneColorPickerFocused', false, ( localize(897, "Whether the standalone color picker is focused")))));
+    EditorContextKeys.inCompositeEditor = ( (new RawContextKey('inCompositeEditor', undefined, ( localize(898, "Whether the editor is part of a larger editor (e.g. notebooks)")))));
     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(
-     _moduleId,
-     45,
-     "Whether the editor has multiple document formatting providers"
-    )))));
+    EditorContextKeys.languageId = ( (new RawContextKey('editorLangId', '', ( localize(899, "The language identifier of the editor")))));
+    EditorContextKeys.hasCompletionItemProvider = ( (new RawContextKey('editorHasCompletionItemProvider', false, ( localize(900, "Whether the editor has a completion item provider")))));
+    EditorContextKeys.hasCodeActionsProvider = ( (new RawContextKey('editorHasCodeActionsProvider', false, ( localize(901, "Whether the editor has a code actions provider")))));
+    EditorContextKeys.hasCodeLensProvider = ( (new RawContextKey('editorHasCodeLensProvider', false, ( localize(902, "Whether the editor has a code lens provider")))));
+    EditorContextKeys.hasDefinitionProvider = ( (new RawContextKey('editorHasDefinitionProvider', false, ( localize(903, "Whether the editor has a definition provider")))));
+    EditorContextKeys.hasDeclarationProvider = ( (new RawContextKey('editorHasDeclarationProvider', false, ( localize(904, "Whether the editor has a declaration provider")))));
+    EditorContextKeys.hasImplementationProvider = ( (new RawContextKey('editorHasImplementationProvider', false, ( localize(905, "Whether the editor has an implementation provider")))));
+    EditorContextKeys.hasTypeDefinitionProvider = ( (new RawContextKey('editorHasTypeDefinitionProvider', false, ( localize(906, "Whether the editor has a type definition provider")))));
+    EditorContextKeys.hasHoverProvider = ( (new RawContextKey('editorHasHoverProvider', false, ( localize(907, "Whether the editor has a hover provider")))));
+    EditorContextKeys.hasDocumentHighlightProvider = ( (new RawContextKey('editorHasDocumentHighlightProvider', false, ( localize(908, "Whether the editor has a document highlight provider")))));
+    EditorContextKeys.hasDocumentSymbolProvider = ( (new RawContextKey('editorHasDocumentSymbolProvider', false, ( localize(909, "Whether the editor has a document symbol provider")))));
+    EditorContextKeys.hasReferenceProvider = ( (new RawContextKey('editorHasReferenceProvider', false, ( localize(910, "Whether the editor has a reference provider")))));
+    EditorContextKeys.hasRenameProvider = ( (new RawContextKey('editorHasRenameProvider', false, ( localize(911, "Whether the editor has a rename provider")))));
+    EditorContextKeys.hasSignatureHelpProvider = ( (new RawContextKey('editorHasSignatureHelpProvider', false, ( localize(912, "Whether the editor has a signature help provider")))));
+    EditorContextKeys.hasInlayHintsProvider = ( (new RawContextKey('editorHasInlayHintsProvider', false, ( localize(913, "Whether the editor has an inline hints provider")))));
+    EditorContextKeys.hasDocumentFormattingProvider = ( (new RawContextKey('editorHasDocumentFormattingProvider', false, ( localize(914, "Whether the editor has a document formatting provider")))));
+    EditorContextKeys.hasDocumentSelectionFormattingProvider = ( (new RawContextKey('editorHasDocumentSelectionFormattingProvider', false, ( localize(915, "Whether the editor has a document selection formatting provider")))));
+    EditorContextKeys.hasMultipleDocumentFormattingProvider = ( (new RawContextKey('editorHasMultipleDocumentFormattingProvider', false, ( localize(916, "Whether the editor has multiple document formatting providers")))));
     EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider = ( (new RawContextKey(
      'editorHasMultipleDocumentSelectionFormattingProvider',
      false,
-     ( localizeWithPath(
-      _moduleId,
-      46,
+     ( localize(
+      917,
       "Whether the editor has multiple document selection formatting providers"
      ))
     )));

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

@@ -22,7 +22,7 @@ declare class LanguageFeatureRegistry<T> {
     has(model: ITextModel): boolean;
     all(model: ITextModel): T[];
     allNoModel(): T[];
-    ordered(model: ITextModel): T[];
+    ordered(model: ITextModel, recursive?: boolean): T[];
     orderedGroups(model: ITextModel): T[][];
     private _orderedForEach;
     private _lastCandidate;

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

@@ -14,17 +14,19 @@ function isExclusive(selector) {
     }
 }
 class MatchCandidate {
-    constructor(uri, languageId, notebookUri, notebookType) {
+    constructor(uri, languageId, notebookUri, notebookType, recursive) {
         this.uri = uri;
         this.languageId = languageId;
         this.notebookUri = notebookUri;
         this.notebookType = notebookType;
+        this.recursive = recursive;
     }
     equals(other) {
         return this.notebookType === other.notebookType
             && this.languageId === other.languageId
             && ( this.uri.toString()) === ( other.uri.toString())
-            && this.notebookUri?.toString() === other.notebookUri?.toString();
+            && this.notebookUri?.toString() === other.notebookUri?.toString()
+            && this.recursive === other.recursive;
     }
 }
 class LanguageFeatureRegistry {
@@ -64,7 +66,7 @@ class LanguageFeatureRegistry {
         if (!model) {
             return [];
         }
-        this._updateScores(model);
+        this._updateScores(model, false);
         const result = [];
         for (const entry of this._entries) {
             if (entry._score > 0) {
@@ -76,16 +78,16 @@ class LanguageFeatureRegistry {
     allNoModel() {
         return ( this._entries.map(entry => entry.provider));
     }
-    ordered(model) {
+    ordered(model, recursive = false) {
         const result = [];
-        this._orderedForEach(model, entry => result.push(entry.provider));
+        this._orderedForEach(model, recursive, entry => result.push(entry.provider));
         return result;
     }
     orderedGroups(model) {
         const result = [];
         let lastBucket;
         let lastBucketScore;
-        this._orderedForEach(model, entry => {
+        this._orderedForEach(model, false, entry => {
             if (lastBucket && lastBucketScore === entry._score) {
                 lastBucket.push(entry.provider);
             }
@@ -97,19 +99,25 @@ class LanguageFeatureRegistry {
         });
         return result;
     }
-    _orderedForEach(model, callback) {
-        this._updateScores(model);
+    _orderedForEach(model, recursive, callback) {
+        this._updateScores(model, recursive);
         for (const entry of this._entries) {
             if (entry._score > 0) {
                 callback(entry);
             }
         }
     }
-    _updateScores(model) {
+    _updateScores(model, recursive) {
         const notebookInfo = this._notebookInfoResolver?.(model.uri);
         const candidate = notebookInfo
-            ? ( new MatchCandidate(model.uri, model.getLanguageId(), notebookInfo.uri, notebookInfo.type))
-            : ( new MatchCandidate(model.uri, model.getLanguageId(), undefined, undefined));
+            ? ( new MatchCandidate(
+            model.uri,
+            model.getLanguageId(),
+            notebookInfo.uri,
+            notebookInfo.type,
+            recursive
+        ))
+            : ( new MatchCandidate(model.uri, model.getLanguageId(), undefined, undefined, recursive));
         if (this._lastCandidate?.equals(candidate)) {
             return;
         }
@@ -117,11 +125,16 @@ class LanguageFeatureRegistry {
         for (const entry of this._entries) {
             entry._score = score(entry.selector, candidate.uri, candidate.languageId, shouldSynchronizeModel(model), candidate.notebookUri, candidate.notebookType);
             if (isExclusive(entry.selector) && entry._score > 0) {
-                for (const entry of this._entries) {
+                if (recursive) {
                     entry._score = 0;
                 }
-                entry._score = 1000;
-                break;
+                else {
+                    for (const entry of this._entries) {
+                        entry._score = 0;
+                    }
+                    entry._score = 1000;
+                    break;
+                }
             }
         }
         this._entries.sort(LanguageFeatureRegistry._compareByScoreAndTime);

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

@@ -1,9 +1,8 @@
-import { localizeWithPath } from '../../../nls.js';
+import { localize } from '../../../nls.js';
 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'
 };
@@ -38,7 +37,7 @@ const PLAINTEXT_EXTENSION = '.txt';
 ModesRegistry.registerLanguage({
     id: PLAINTEXT_LANGUAGE_ID,
     extensions: [PLAINTEXT_EXTENSION],
-    aliases: [( localizeWithPath(_moduleId, 0, "Plain Text")), 'text'],
+    aliases: [( localize(870, "Plain Text")), 'text'],
     mimetypes: [Mimes.text]
 });
 ( (Registry.as(Extensions$1.Configuration)))

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

@@ -1384,6 +1384,10 @@ interface MappedEditsContext {
     documents: DocumentContextItem[][];
 }
 interface MappedEditsProvider {
+    /**
+     * @internal
+     */
+    readonly displayName: string;
     /**
      * Provider maps code blocks from the chat into a workspace edit.
      *

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

@@ -3,8 +3,7 @@ import { URI } from '../../base/common/uri.js';
 import { EditOperation } from './core/editOperation.js';
 import { Range } from './core/range.js';
 import { TokenizationRegistry as TokenizationRegistry$1 } from './tokenizationRegistry.js';
-import { localizeWithPath } from '../../nls.js';
-const _moduleId = "vs/editor/common/languages";
+import { localize } from '../../nls.js';
 class Token {
     constructor(offset, type, language) {
         this.offset = offset;
@@ -247,35 +246,35 @@ var SymbolKind;
     SymbolKind[SymbolKind["TypeParameter"] = 25] = "TypeParameter";
 })(SymbolKind || (SymbolKind = {}))));
 const symbolKindNames = {
-    [SymbolKind.Array]: ( localizeWithPath(_moduleId, 0, "array")),
-    [SymbolKind.Boolean]: ( localizeWithPath(_moduleId, 1, "boolean")),
-    [SymbolKind.Class]: ( localizeWithPath(_moduleId, 2, "class")),
-    [SymbolKind.Constant]: ( localizeWithPath(_moduleId, 3, "constant")),
-    [SymbolKind.Constructor]: ( localizeWithPath(_moduleId, 4, "constructor")),
-    [SymbolKind.Enum]: ( localizeWithPath(_moduleId, 5, "enumeration")),
-    [SymbolKind.EnumMember]: ( localizeWithPath(_moduleId, 6, "enumeration member")),
-    [SymbolKind.Event]: ( localizeWithPath(_moduleId, 7, "event")),
-    [SymbolKind.Field]: ( localizeWithPath(_moduleId, 8, "field")),
-    [SymbolKind.File]: ( localizeWithPath(_moduleId, 9, "file")),
-    [SymbolKind.Function]: ( localizeWithPath(_moduleId, 10, "function")),
-    [SymbolKind.Interface]: ( localizeWithPath(_moduleId, 11, "interface")),
-    [SymbolKind.Key]: ( localizeWithPath(_moduleId, 12, "key")),
-    [SymbolKind.Method]: ( localizeWithPath(_moduleId, 13, "method")),
-    [SymbolKind.Module]: ( localizeWithPath(_moduleId, 14, "module")),
-    [SymbolKind.Namespace]: ( localizeWithPath(_moduleId, 15, "namespace")),
-    [SymbolKind.Null]: ( localizeWithPath(_moduleId, 16, "null")),
-    [SymbolKind.Number]: ( localizeWithPath(_moduleId, 17, "number")),
-    [SymbolKind.Object]: ( localizeWithPath(_moduleId, 18, "object")),
-    [SymbolKind.Operator]: ( localizeWithPath(_moduleId, 19, "operator")),
-    [SymbolKind.Package]: ( localizeWithPath(_moduleId, 20, "package")),
-    [SymbolKind.Property]: ( localizeWithPath(_moduleId, 21, "property")),
-    [SymbolKind.String]: ( localizeWithPath(_moduleId, 22, "string")),
-    [SymbolKind.Struct]: ( localizeWithPath(_moduleId, 23, "struct")),
-    [SymbolKind.TypeParameter]: ( localizeWithPath(_moduleId, 24, "type parameter")),
-    [SymbolKind.Variable]: ( localizeWithPath(_moduleId, 25, "variable")),
+    [SymbolKind.Array]: ( localize(918, "array")),
+    [SymbolKind.Boolean]: ( localize(919, "boolean")),
+    [SymbolKind.Class]: ( localize(920, "class")),
+    [SymbolKind.Constant]: ( localize(921, "constant")),
+    [SymbolKind.Constructor]: ( localize(922, "constructor")),
+    [SymbolKind.Enum]: ( localize(923, "enumeration")),
+    [SymbolKind.EnumMember]: ( localize(924, "enumeration member")),
+    [SymbolKind.Event]: ( localize(925, "event")),
+    [SymbolKind.Field]: ( localize(926, "field")),
+    [SymbolKind.File]: ( localize(927, "file")),
+    [SymbolKind.Function]: ( localize(928, "function")),
+    [SymbolKind.Interface]: ( localize(929, "interface")),
+    [SymbolKind.Key]: ( localize(930, "key")),
+    [SymbolKind.Method]: ( localize(931, "method")),
+    [SymbolKind.Module]: ( localize(932, "module")),
+    [SymbolKind.Namespace]: ( localize(933, "namespace")),
+    [SymbolKind.Null]: ( localize(934, "null")),
+    [SymbolKind.Number]: ( localize(935, "number")),
+    [SymbolKind.Object]: ( localize(936, "object")),
+    [SymbolKind.Operator]: ( localize(937, "operator")),
+    [SymbolKind.Package]: ( localize(938, "package")),
+    [SymbolKind.Property]: ( localize(939, "property")),
+    [SymbolKind.String]: ( localize(940, "string")),
+    [SymbolKind.Struct]: ( localize(941, "struct")),
+    [SymbolKind.TypeParameter]: ( localize(942, "type parameter")),
+    [SymbolKind.Variable]: ( localize(943, "variable")),
 };
 function getAriaLabelForSymbol(symbolName, kind) {
-    return ( localizeWithPath(_moduleId, 26, '{0} ({1})', symbolName, symbolKindNames[kind]));
+    return ( localize(944, '{0} ({1})', symbolName, symbolKindNames[kind]));
 }
 var SymbolTag;
 ( ((function(SymbolTag) {

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

@@ -1,4 +1,4 @@
-import { localizeWithPath } from '../../../nls.js';
+import { localize } from '../../../nls.js';
 import { onUnexpectedError } from '../../../base/common/errors.js';
 import { Selection } from '../core/selection.js';
 import { EndOfLineSequence } from '../model.js';
@@ -7,7 +7,6 @@ import { URI } from '../../../base/common/uri.js';
 import { compressConsecutiveTextChanges, TextChange } from '../core/textChange.js';
 import { writeUInt32BE, writeUInt8, readUInt32BE, readUInt8 } from '../../../base/common/buffer.js';
 import { basename } from '../../../base/common/resources.js';
-const _moduleId = "vs/editor/common/model/editStack";
 function uriGetComparisonKey(resource) {
     return (
          (resource.toString())
@@ -362,7 +361,7 @@ class EditStack {
         if (isEditStackElement(lastElement) && lastElement.canAppend(this._model)) {
             return lastElement;
         }
-        const newElement = ( (new SingleModelEditStackElement(( localizeWithPath(_moduleId, 0, "Typing")), 'undoredo.textBufferEdit', this._model, beforeCursorState)));
+        const newElement = ( (new SingleModelEditStackElement(( localize(4647, "Typing")), 'undoredo.textBufferEdit', this._model, beforeCursorState)));
         this._undoRedoService.pushElement(newElement, group);
         return newElement;
     }

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

@@ -203,7 +203,7 @@ class GuidesTextModelPart extends TextModelPart {
                 activePosition.lineNumber <= endLineNumber
                 ? bracketPairs
                 : this.textModel.bracketPairs.getBracketPairsInRange(Range.fromPositions(activePosition)).toArray()).filter((bp) => Range.strictContainsPosition(bp.range, activePosition));
-            activeBracketPairRange = findLast(bracketsContainingActivePosition, (i) => includeSingleLinePairs )?.range;
+            activeBracketPairRange = findLast(bracketsContainingActivePosition, (i) => includeSingleLinePairs)?.range;
         }
         const independentColorPoolPerBracketType = this.textModel.getOptions().bracketPairColorizationOptions.independentColorPoolPerBracketType;
         const colorProvider = ( new BracketPairGuidesClassNames());

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

@@ -1,87 +1,90 @@
-import { localizeWithPath } from '../../nls.js';
-const _moduleId = "vs/editor/common/standaloneStrings";
+import { localize } from '../../nls.js';
 var AccessibilityHelpNLS;
 ( ((function(AccessibilityHelpNLS) {
-    AccessibilityHelpNLS.accessibilityHelpTitle = ( localizeWithPath(_moduleId, 0, "Accessibility Help"));
-    AccessibilityHelpNLS.openingDocs = ( localizeWithPath(_moduleId, 1, "Opening the Accessibility documentation page."));
-    AccessibilityHelpNLS.readonlyDiffEditor = ( localizeWithPath(_moduleId, 2, "You are in a read-only pane of a diff editor."));
-    AccessibilityHelpNLS.editableDiffEditor = ( localizeWithPath(_moduleId, 3, "You are in a pane of a diff editor."));
-    AccessibilityHelpNLS.readonlyEditor = ( localizeWithPath(_moduleId, 4, "You are in a read-only code editor."));
-    AccessibilityHelpNLS.editableEditor = ( localizeWithPath(_moduleId, 5, "You are in a code editor."));
-    AccessibilityHelpNLS.changeConfigToOnMac = ( localizeWithPath(
-        _moduleId,
-        6,
+    AccessibilityHelpNLS.accessibilityHelpTitle = ( localize(776, "Accessibility Help"));
+    AccessibilityHelpNLS.openingDocs = ( localize(777, "Opening the Accessibility documentation page."));
+    AccessibilityHelpNLS.readonlyDiffEditor = ( localize(778, "You are in a read-only pane of a diff editor."));
+    AccessibilityHelpNLS.editableDiffEditor = ( localize(779, "You are in a pane of a diff editor."));
+    AccessibilityHelpNLS.readonlyEditor = ( localize(780, "You are in a read-only code editor."));
+    AccessibilityHelpNLS.editableEditor = ( localize(781, "You are in a code editor."));
+    AccessibilityHelpNLS.changeConfigToOnMac = ( localize(
+        782,
         "Configure the application to be optimized for usage with a Screen Reader (Command+E)."
     ));
-    AccessibilityHelpNLS.changeConfigToOnWinLinux = ( localizeWithPath(
-        _moduleId,
-        7,
+    AccessibilityHelpNLS.changeConfigToOnWinLinux = ( localize(
+        783,
         "Configure the application to be optimized for usage with a Screen Reader (Control+E)."
     ));
-    AccessibilityHelpNLS.auto_on = ( localizeWithPath(
-        _moduleId,
-        8,
+    AccessibilityHelpNLS.auto_on = ( localize(
+        784,
         "The application is configured to be optimized for usage with a Screen Reader."
     ));
-    AccessibilityHelpNLS.auto_off = ( localizeWithPath(
-        _moduleId,
-        9,
+    AccessibilityHelpNLS.auto_off = ( localize(
+        785,
         "The application is configured to never be optimized for usage with a Screen Reader."
     ));
-    AccessibilityHelpNLS.screenReaderModeEnabled = ( localizeWithPath(_moduleId, 10, "Screen Reader Optimized Mode enabled."));
-    AccessibilityHelpNLS.screenReaderModeDisabled = ( localizeWithPath(_moduleId, 11, "Screen Reader Optimized Mode disabled."));
-    AccessibilityHelpNLS.tabFocusModeOnMsg = ( localizeWithPath(
-        _moduleId,
-        12,
-        "Pressing Tab in the current editor will move focus to the next focusable element. Toggle this behavior<keybinding:editor.action.toggleTabFocusMode>"
+    AccessibilityHelpNLS.screenReaderModeEnabled = ( localize(786, "Screen Reader Optimized Mode enabled."));
+    AccessibilityHelpNLS.screenReaderModeDisabled = ( localize(787, "Screen Reader Optimized Mode disabled."));
+    AccessibilityHelpNLS.tabFocusModeOnMsg = ( localize(
+        788,
+        "Pressing Tab in the current editor will move focus to the next focusable element. Toggle this behavior{0}.",
+        '<keybinding:editor.action.toggleTabFocusMode>'
     ));
-    AccessibilityHelpNLS.tabFocusModeOffMsg = ( localizeWithPath(
-        _moduleId,
-        13,
-        "Pressing Tab in the current editor will insert the tab character. Toggle this behavior<keybinding:editor.action.toggleTabFocusMode>"
+    AccessibilityHelpNLS.tabFocusModeOffMsg = ( localize(
+        789,
+        "Pressing Tab in the current editor will insert the tab character. Toggle this behavior{0}",
+        '<keybinding:editor.action.toggleTabFocusMode>'
     ));
-    AccessibilityHelpNLS.stickScroll = ( localizeWithPath(
-        _moduleId,
-        14,
-        "Focus Sticky Scroll<keybinding:editor.action.focusStickyScroll> to focus the currently nested scopes."
+    AccessibilityHelpNLS.stickScroll = ( localize(
+        790,
+        "Focus Sticky Scroll{0} to focus the currently nested scopes.",
+        '<keybinding:editor.action.focusStickyDebugConsole>'
     ));
-    AccessibilityHelpNLS.showAccessibilityHelpAction = ( localizeWithPath(_moduleId, 15, "Show Accessibility Help"));
-    AccessibilityHelpNLS.listSignalSounds = ( localizeWithPath(
-        _moduleId,
-        16,
+    AccessibilityHelpNLS.showAccessibilityHelpAction = ( localize(791, "Show Accessibility Help"));
+    AccessibilityHelpNLS.listSignalSounds = ( localize(
+        792,
         "Run the command: List Signal Sounds for an overview of all sounds and their current status."
     ));
-    AccessibilityHelpNLS.listAlerts = ( localizeWithPath(
-        _moduleId,
-        17,
+    AccessibilityHelpNLS.listAlerts = ( localize(
+        793,
         "Run the command: List Signal Announcements for an overview of announcements and their current status."
     ));
-    AccessibilityHelpNLS.quickChat = ( localizeWithPath(
-        _moduleId,
-        18,
-        "Toggle quick chat<keybinding:workbench.action.quickchat.toggle> to open or close a chat session."
+    AccessibilityHelpNLS.quickChat = ( localize(
+        794,
+        "Toggle quick chat{0} to open or close a chat session.",
+        '<keybinding:workbench.action.quickchat.toggle>'
     ));
-    AccessibilityHelpNLS.startInlineChat = ( localizeWithPath(
-        _moduleId,
-        19,
-        "Start inline chat<keybinding:inlineChat.start> to create an in editor chat session."
+    AccessibilityHelpNLS.startInlineChat = ( localize(
+        795,
+        "Start inline chat{0} to create an in editor chat session.",
+        '<keybinding:inlineChat.start>'
+    ));
+    AccessibilityHelpNLS.setBreakpoint = ( localize(
+        796,
+        "The Debug: Inline Breakpoint command{0} will set or unset a breakpoint at the current cursor position in the active editor.",
+        '<keybinding:editor.debug.action.toggleInlineBreakpoint>'
+    ));
+    AccessibilityHelpNLS.debugExecuteSelection = ( localize(
+        797,
+        "The Debug: Execute Selection command{0} will execute the selected text in the debug console.",
+        '<keybinding:editor.debug.action.selectionToRepl>'
     ));
 })(AccessibilityHelpNLS || (AccessibilityHelpNLS = {}))));
 var InspectTokensNLS;
 ( ((function(InspectTokensNLS) {
-    InspectTokensNLS.inspectTokensAction = ( localizeWithPath(_moduleId, 20, "Developer: Inspect Tokens"));
+    InspectTokensNLS.inspectTokensAction = ( localize(798, "Developer: Inspect Tokens"));
 })(InspectTokensNLS || (InspectTokensNLS = {}))));
 var StandaloneCodeEditorNLS;
 ( ((function(StandaloneCodeEditorNLS) {
-    StandaloneCodeEditorNLS.editorViewAccessibleLabel = ( localizeWithPath(_moduleId, 27, "Editor content"));
-    StandaloneCodeEditorNLS.accessibilityHelpMessage = ( localizeWithPath(_moduleId, 28, "Press Alt+F1 for Accessibility Options."));
+    StandaloneCodeEditorNLS.editorViewAccessibleLabel = ( localize(805, "Editor content"));
+    StandaloneCodeEditorNLS.accessibilityHelpMessage = ( localize(806, "Press Alt+F1 for Accessibility Options."));
 })(StandaloneCodeEditorNLS || (StandaloneCodeEditorNLS = {}))));
 var ToggleHighContrastNLS;
 ( ((function(ToggleHighContrastNLS) {
-    ToggleHighContrastNLS.toggleHighContrast = ( localizeWithPath(_moduleId, 29, "Toggle High Contrast Theme"));
+    ToggleHighContrastNLS.toggleHighContrast = ( localize(807, "Toggle High Contrast Theme"));
 })(ToggleHighContrastNLS || (ToggleHighContrastNLS = {}))));
 var StandaloneServicesNLS;
 ( ((function(StandaloneServicesNLS) {
-    StandaloneServicesNLS.bulkEditServiceSummary = ( localizeWithPath(_moduleId, 30, "Made {0} edits in {1} files"));
+    StandaloneServicesNLS.bulkEditServiceSummary = ( localize(808, "Made {0} edits in {1} files"));
 })(StandaloneServicesNLS || (StandaloneServicesNLS = {}))));
 export { AccessibilityHelpNLS, InspectTokensNLS, StandaloneCodeEditorNLS, StandaloneServicesNLS, ToggleHighContrastNLS };

package/vscode/src/vs/editor/common/viewLayout/viewLineRenderer.js

@@ -1,11 +1,10 @@
-import { localizeWithPath } from '../../../nls.js';
+import { localize } from '../../../nls.js';
 import { CharCode } from '../../../base/common/charCode.js';
 import { containsRTL, firstNonWhitespaceIndex, lastNonWhitespaceIndex, isFullWidthCharacter } from '../../../base/common/strings.js';
 import { StringBuilder } from '../core/stringBuilder.js';
 import { LineDecoration, LineDecorationsNormalizer } from './lineDecorations.js';
 import { InlineDecorationType } from '../viewModel.js';
 import { LinePart, LinePartMetadata } from './linePart.js';
-const _moduleId = "vs/editor/common/viewLayout/viewLineRenderer";
 var RenderWhitespace;
 ( ((function(RenderWhitespace) {
     RenderWhitespace[RenderWhitespace["None"] = 0] = "None";
@@ -894,12 +893,7 @@ function _renderLine(input, sb) {
     }
     if (isOverflowing) {
         sb.appendString('<span class="mtkoverflow">');
-        sb.appendString(( localizeWithPath(
-            _moduleId,
-            0,
-            "Show more ({0})",
-            renderOverflowingCharCount(overflowingCharCount)
-        )));
+        sb.appendString(( localize(9830, "Show more ({0})", renderOverflowingCharCount(overflowingCharCount))));
         sb.appendString('</span>');
     }
     sb.appendString('</span>');
@@ -912,7 +906,7 @@ function to4CharHex(n) {
 }
 function renderOverflowingCharCount(n) {
     if (n < 1024) {
-        return ( localizeWithPath(_moduleId, 1, "{0} chars", n));
+        return ( localize(9831, "{0} chars", n));
     }
     if (n < 1024 * 1024) {
         return `${(n / 1024).toFixed(1)} KB`;

package/vscode/src/vs/editor/common/viewModel/modelLineProjection.js

@@ -2,7 +2,7 @@ import { LineTokens } from '../tokens/lineTokens.js';
 import { Position } from '../core/position.js';
 import { PositionAffinity } from '../model.js';
 import { LineInjectedText } from '../textModelEvents.js';
-import { ViewLineData, SingleLineInlineDecoration } from '../viewModel.js';
+import { SingleLineInlineDecoration, ViewLineData } from '../viewModel.js';
 function createModelLineProjection(lineBreakData, isVisible) {
     if (lineBreakData === null) {
         if (isVisible) {