@codingame/monaco-vscode-api 24.3.0 → 25.0.1

package/vscode/src/vs/workbench/contrib/comments/browser/commentsViewActions.js

@@ -66,7 +66,7 @@ registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: 'commentsFocusViewFromFilter',
-            title: ( localize(6373, "Focus Comments view")),
+            title: ( localize(6395, "Focus Comments view")),
             keybinding: {
                 when: CommentsViewFilterFocusContextKey,
                 weight: KeybindingWeight.WorkbenchContrib,
@@ -83,7 +83,7 @@ registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: 'commentsClearFilterText',
-            title: ( localize(6374, "Clear filter text")),
+            title: ( localize(6396, "Clear filter text")),
             keybinding: {
                 when: CommentsViewFilterFocusContextKey,
                 weight: KeybindingWeight.WorkbenchContrib,
@@ -100,7 +100,7 @@ registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: 'commentsFocusFilter',
-            title: ( localize(6375, "Focus comments filter")),
+            title: ( localize(6397, "Focus comments filter")),
             keybinding: {
                 when: ( FocusedViewContext.isEqualTo(COMMENTS_VIEW_ID)),
                 weight: KeybindingWeight.WorkbenchContrib,
@@ -117,11 +117,11 @@ registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: `workbench.actions.${COMMENTS_VIEW_ID}.toggleUnResolvedComments`,
-            title: ( localize(6376, "Show Unresolved")),
-            category: ( localize(6377, "Comments")),
+            title: ( localize(6398, "Show Unresolved")),
+            category: ( localize(6399, "Comments")),
             toggled: {
                 condition: CONTEXT_KEY_SHOW_UNRESOLVED,
-                title: ( localize(6378, "Show Unresolved")),
+                title: ( localize(6400, "Show Unresolved")),
             },
             menu: {
                 id: viewFilterSubmenu,
@@ -140,11 +140,11 @@ registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: `workbench.actions.${COMMENTS_VIEW_ID}.toggleResolvedComments`,
-            title: ( localize(6379, "Show Resolved")),
-            category: ( localize(6377, "Comments")),
+            title: ( localize(6401, "Show Resolved")),
+            category: ( localize(6399, "Comments")),
             toggled: {
                 condition: CONTEXT_KEY_SHOW_RESOLVED,
-                title: ( localize(6380, "Show Resolved")),
+                title: ( localize(6402, "Show Resolved")),
             },
             menu: {
                 id: viewFilterSubmenu,
@@ -162,7 +162,7 @@ registerAction2(class extends ViewAction {
 const commentSortSubmenu = ( new MenuId('submenu.filter.commentSort'));
 MenuRegistry.appendMenuItem(viewFilterSubmenu, {
     submenu: commentSortSubmenu,
-    title: ( localize(6381, "Sort By")),
+    title: ( localize(6403, "Sort By")),
     group: '2_sort',
     icon: Codicon.history,
     when: ( ContextKeyExpr.equals('view', COMMENTS_VIEW_ID)),
@@ -171,13 +171,13 @@ registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: `workbench.actions.${COMMENTS_VIEW_ID}.toggleSortByUpdatedAt`,
-            title: ( localize(6382, "Updated Time")),
-            category: ( localize(6377, "Comments")),
+            title: ( localize(6404, "Updated Time")),
+            category: ( localize(6399, "Comments")),
             icon: Codicon.history,
             viewId: COMMENTS_VIEW_ID,
             toggled: {
                 condition: ( ContextKeyExpr.equals(CONTEXT_KEY_SORT_BY.key, CommentsSortOrder.UpdatedAtDescending)),
-                title: ( localize(6383, "Updated Time")),
+                title: ( localize(6405, "Updated Time")),
             },
             menu: {
                 id: commentSortSubmenu,
@@ -195,13 +195,13 @@ registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: `workbench.actions.${COMMENTS_VIEW_ID}.toggleSortByResource`,
-            title: ( localize(6384, "Position in File")),
-            category: ( localize(6377, "Comments")),
+            title: ( localize(6406, "Position in File")),
+            category: ( localize(6399, "Comments")),
             icon: Codicon.history,
             viewId: COMMENTS_VIEW_ID,
             toggled: {
                 condition: ( ContextKeyExpr.equals(CONTEXT_KEY_SORT_BY.key, CommentsSortOrder.ResourceAscending)),
-                title: ( localize(6385, "Position in File")),
+                title: ( localize(6407, "Position in File")),
             },
             menu: {
                 id: commentSortSubmenu,

package/vscode/src/vs/workbench/contrib/comments/browser/reactionsAction.js

@@ -9,7 +9,7 @@ import { ActionViewItem } from '../../../../base/browser/ui/actionbar/actionView
 class ToggleReactionsAction extends Action {
     static { this.ID = 'toolbar.toggle.pickReactions'; }
     constructor(toggleDropdownMenu, title) {
-        super(ToggleReactionsAction.ID, title || ( localize(6386, "Pick Reactions...")), 'toggle-reactions', true);
+        super(ToggleReactionsAction.ID, title || ( localize(6408, "Pick Reactions...")), 'toggle-reactions', true);
         this._menuActions = [];
         this.toggleDropdownMenu = toggleDropdownMenu;
     }
@@ -52,17 +52,17 @@ class ReactionActionViewItem extends ActionViewItem {
     }
     getTooltip() {
         const action = this.action;
-        const toggleMessage = action.enabled ? ( localize(6387, "Toggle reaction, ")) : '';
+        const toggleMessage = action.enabled ? ( localize(6409, "Toggle reaction, ")) : '';
         if (action.count === undefined) {
-            return localize(6388, "{0}{1} reaction", toggleMessage, action.label);
+            return localize(6410, "{0}{1} reaction", toggleMessage, action.label);
         }
         else if (action.reactors === undefined || action.reactors.length === 0) {
             if (action.count === 1) {
-                return localize(6389, "{0}1 reaction with {1}", toggleMessage, action.label);
+                return localize(6411, "{0}1 reaction with {1}", toggleMessage, action.label);
             }
             else if (action.count > 1) {
                 return localize(
-                    6390,
+                    6412,
                     "{0}{1} reactions with {2}",
                     toggleMessage,
                     action.count,
@@ -73,7 +73,7 @@ class ReactionActionViewItem extends ActionViewItem {
         else {
             if (action.reactors.length <= 10 && action.reactors.length === action.count) {
                 return localize(
-                    6391,
+                    6413,
                     "{0}{1} reacted with {2}",
                     toggleMessage,
                     action.reactors.join(', '),
@@ -83,7 +83,7 @@ class ReactionActionViewItem extends ActionViewItem {
             else if (action.count > 1) {
                 const displayedReactors = action.reactors.slice(0, 10);
                 return localize(
-                    6392,
+                    6414,
                     "{0}{1} and {2} more reacted with {3}",
                     toggleMessage,
                     displayedReactors.join(', '),

package/vscode/src/vs/workbench/contrib/comments/common/commentContextKeys.js

@@ -5,20 +5,20 @@ import { RawContextKey } from '../../../../platform/contextkey/common/contextkey
 var CommentContextKeys;
 (function (CommentContextKeys) {
     CommentContextKeys.activeCursorHasCommentingRange = ( new RawContextKey('activeCursorHasCommentingRange', false, {
-        description: ( localize(6393, "Whether the position at the active cursor has a commenting range")),
+        description: ( localize(6415, "Whether the position at the active cursor has a commenting range")),
         type: 'boolean'
     }));
     CommentContextKeys.activeCursorHasComment = ( new RawContextKey('activeCursorHasComment', false, {
-        description: ( localize(6394, "Whether the position at the active cursor has a comment")),
+        description: ( localize(6416, "Whether the position at the active cursor has a comment")),
         type: 'boolean'
     }));
     CommentContextKeys.activeEditorHasCommentingRange = ( new RawContextKey('activeEditorHasCommentingRange', false, {
-        description: ( localize(6395, "Whether the active editor has a commenting range")),
+        description: ( localize(6417, "Whether the active editor has a commenting range")),
         type: 'boolean'
     }));
     CommentContextKeys.WorkspaceHasCommenting = ( new RawContextKey('workspaceHasCommenting', false, {
         description: ( localize(
-         6396,
+         6418,
          "Whether the open workspace has either comments or commenting ranges."
         )),
         type: 'boolean'
@@ -26,19 +26,19 @@ var CommentContextKeys;
     CommentContextKeys.commentThreadIsEmpty = ( new RawContextKey(
      'commentThreadIsEmpty',
      false,
-     { type: 'boolean', description: ( localize(6397, "Set when the comment thread has no comments")) }
+     { type: 'boolean', description: ( localize(6419, "Set when the comment thread has no comments")) }
     ));
-    CommentContextKeys.commentIsEmpty = ( new RawContextKey('commentIsEmpty', false, { type: 'boolean', description: ( localize(6398, "Set when the comment has no input")) }));
-    CommentContextKeys.commentContext = ( new RawContextKey('comment', undefined, { type: 'string', description: ( localize(6399, "The context value of the comment")) }));
-    CommentContextKeys.commentThreadContext = ( new RawContextKey('commentThread', undefined, { type: 'string', description: ( localize(6400, "The context value of the comment thread")) }));
+    CommentContextKeys.commentIsEmpty = ( new RawContextKey('commentIsEmpty', false, { type: 'boolean', description: ( localize(6420, "Set when the comment has no input")) }));
+    CommentContextKeys.commentContext = ( new RawContextKey('comment', undefined, { type: 'string', description: ( localize(6421, "The context value of the comment")) }));
+    CommentContextKeys.commentThreadContext = ( new RawContextKey('commentThread', undefined, { type: 'string', description: ( localize(6422, "The context value of the comment thread")) }));
     CommentContextKeys.commentControllerContext = ( new RawContextKey(
      'commentController',
      undefined,
-     { type: 'string', description: ( localize(6401, "The comment controller id associated with a comment thread")) }
+     { type: 'string', description: ( localize(6423, "The comment controller id associated with a comment thread")) }
     ));
-    CommentContextKeys.commentFocused = ( new RawContextKey('commentFocused', false, { type: 'boolean', description: ( localize(6402, "Set when the comment is focused")) }));
+    CommentContextKeys.commentFocused = ( new RawContextKey('commentFocused', false, { type: 'boolean', description: ( localize(6424, "Set when the comment is focused")) }));
     CommentContextKeys.commentingEnabled = ( new RawContextKey('commentingEnabled', true, {
-        description: ( localize(6403, "Whether commenting functionality is enabled")),
+        description: ( localize(6425, "Whether commenting functionality is enabled")),
         type: 'boolean'
     }));
 })(CommentContextKeys || (CommentContextKeys = {}));

package/vscode/src/vs/workbench/contrib/customEditor/browser/customEditorInput.d.ts

@@ -20,12 +20,12 @@ import { IEditorGroupsService } from "../../../services/editor/common/editorGrou
 import { IFilesConfigurationService } from "../../../services/filesConfiguration/common/filesConfigurationService.service.js";
 import { IWorkbenchLayoutService } from "../../../services/layout/browser/layoutService.service.js";
 import { IThemeService } from "../../../../platform/theme/common/themeService.service.js";
-import { WebviewIcons } from "../../webviewPanel/browser/webviewEditorInput.js";
+import { WebviewIconPath } from "../../webviewPanel/browser/webviewEditorInput.js";
 interface CustomEditorInputInitInfo {
     readonly resource: URI;
     readonly viewType: string;
     readonly webviewTitle: string | undefined;
-    readonly iconPath: WebviewIcons | undefined;
+    readonly iconPath: WebviewIconPath | undefined;
 }
 export declare class CustomEditorInput extends LazilyResolvedWebviewEditorInput {
     private readonly instantiationService;

package/vscode/src/vs/workbench/contrib/customEditor/browser/customEditorInput.js

@@ -302,12 +302,12 @@ let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEdi
     claim(claimant, targetWindow, scopedContextKeyService) {
         if (this.doCanMove(targetWindow.vscodeWindowId) !== true) {
             throw createEditorOpenError(( localize(
-                6404,
+                6426,
                 "Unable to open the editor in this window, it contains modifications that can only be saved in the original window."
             )), [
                 toAction({
                     id: 'openInOriginalWindow',
-                    label: ( localize(6405, "Open in Original Window")),
+                    label: ( localize(6427, "Open in Original Window")),
                     run: async () => {
                         const originalPart = this.editorGroupsService.getPart(this.layoutService.getContainer(getWindow(this.webview.container).window));
                         const currentPart = this.editorGroupsService.getPart(this.layoutService.getContainer(targetWindow.window));
@@ -333,7 +333,7 @@ let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEdi
             const sourceWindowId = getWindow(this.webview.container).vscodeWindowId;
             if (sourceWindowId !== targetWindowId) {
                 return localize(
-                    6406,
+                    6428,
                     "Unable to move '{0}': The editor contains changes that can only be saved in its current window.",
                     this.getName()
                 );

package/vscode/src/vs/workbench/contrib/debug/browser/baseDebugView.js

@@ -88,7 +88,7 @@ let AbstractExpressionsRenderer = class AbstractExpressionsRenderer {
         const name = append(expression, $('span.name'));
         const lazyButton = append(expression, $('span.lazy-button'));
         lazyButton.classList.add(...ThemeIcon.asClassNameArray(Codicon.eye));
-        templateDisposable.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), lazyButton, ( localize(6422, "Click to expand"))));
+        templateDisposable.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), lazyButton, ( localize(6444, "Click to expand"))));
         const type = append(expression, $('span.type'));
         const value = append(expression, $('span.value'));
         const label = templateDisposable.add(( new HighlightedLabel(name)));

package/vscode/src/vs/workbench/contrib/debug/browser/breakpointEditorContribution.js

@@ -52,7 +52,7 @@ const breakpointHelperDecoration = {
     description: 'breakpoint-helper-decoration',
     glyphMarginClassName: ThemeIcon.asClassName(debugBreakpointHint),
     glyphMargin: { position: GlyphMarginLane.Right },
-    glyphMarginHoverMessage: ( new MarkdownString()).appendText(( localize(6423, "Click to add a breakpoint"))),
+    glyphMarginHoverMessage: ( new MarkdownString()).appendText(( localize(6445, "Click to add a breakpoint"))),
     stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges
 };
 function createBreakpointDecorations(accessor, model, breakpoints, state, breakpointsActivated, showBreakpointsInOverviewRuler) {
@@ -253,32 +253,32 @@ let BreakpointEditorContribution = class BreakpointEditorContribution {
                         bp => !!bp.condition || !!bp.logMessage || !!bp.hitCondition || !!bp.triggeredBy
                     ))) {
                         const logPoint = breakpoints.every(bp => !!bp.logMessage);
-                        const breakpointType = logPoint ? ( localize(6424, "Logpoint")) : ( localize(6425, "Breakpoint"));
+                        const breakpointType = logPoint ? ( localize(6446, "Logpoint")) : ( localize(6447, "Breakpoint"));
                         const disabledBreakpointDialogMessage = ( localize(
-                            6426,
+                            6448,
                             "This {0} has a {1} that will get lost on remove. Consider enabling the {0} instead.",
                             breakpointType.toLowerCase(),
-                            logPoint ? ( localize(6427, "message")) : ( localize(6428, "condition"))
+                            logPoint ? ( localize(6449, "message")) : ( localize(6450, "condition"))
                         ));
                         const enabledBreakpointDialogMessage = ( localize(
-                            6429,
+                            6451,
                             "This {0} has a {1} that will get lost on remove. Consider disabling the {0} instead.",
                             breakpointType.toLowerCase(),
-                            logPoint ? ( localize(6427, "message")) : ( localize(6428, "condition"))
+                            logPoint ? ( localize(6449, "message")) : ( localize(6450, "condition"))
                         ));
                         await this.dialogService.prompt({
                             type: Severity$1.Info,
                             message: enabled ? enabledBreakpointDialogMessage : disabledBreakpointDialogMessage,
                             buttons: [
                                 {
-                                    label: ( localize(6430, "&&Remove {0}", breakpointType)),
+                                    label: ( localize(6452, "&&Remove {0}", breakpointType)),
                                     run: () => breakpoints.forEach(bp => this.debugService.removeBreakpoints(bp.getId()))
                                 },
                                 {
                                     label: ( localize(
-                                        6431,
+                                        6453,
                                         "{0} {1}",
-                                        enabled ? ( localize(6432, "&&Disable")) : ( localize(6433, "&&Enable")),
+                                        enabled ? ( localize(6454, "&&Disable")) : ( localize(6455, "&&Enable")),
                                         breakpointType
                                     )),
                                     run: () => breakpoints.forEach(bp => this.debugService.enableOrDisableBreakpoints(!enabled, bp))
@@ -364,43 +364,43 @@ let BreakpointEditorContribution = class BreakpointEditorContribution {
     getContextMenuActions(breakpoints, uri, lineNumber, column) {
         const actions = [];
         if (breakpoints.length === 1) {
-            const breakpointType = breakpoints[0].logMessage ? ( localize(6424, "Logpoint")) : ( localize(6425, "Breakpoint"));
+            const breakpointType = breakpoints[0].logMessage ? ( localize(6446, "Logpoint")) : ( localize(6447, "Breakpoint"));
             actions.push(toAction({
-                id: 'debug.removeBreakpoint', label: ( localize(6434, "Remove {0}", breakpointType)), enabled: true, run: async () => {
+                id: 'debug.removeBreakpoint', label: ( localize(6456, "Remove {0}", breakpointType)), enabled: true, run: async () => {
                     await this.debugService.removeBreakpoints(breakpoints[0].getId());
                 }
             }));
             actions.push(toAction({
                 id: 'workbench.debug.action.editBreakpointAction',
-                label: ( localize(6435, "Edit {0}...", breakpointType)),
+                label: ( localize(6457, "Edit {0}...", breakpointType)),
                 enabled: true,
                 run: () => Promise.resolve(this.showBreakpointWidget(breakpoints[0].lineNumber, breakpoints[0].column))
             }));
             actions.push(toAction({
                 id: `workbench.debug.viewlet.action.toggleBreakpoint`,
-                label: breakpoints[0].enabled ? ( localize(6436, "Disable {0}", breakpointType)) : ( localize(6437, "Enable {0}", breakpointType)),
+                label: breakpoints[0].enabled ? ( localize(6458, "Disable {0}", breakpointType)) : ( localize(6459, "Enable {0}", breakpointType)),
                 enabled: true,
                 run: () => this.debugService.enableOrDisableBreakpoints(!breakpoints[0].enabled, breakpoints[0])
             }));
         }
         else if (breakpoints.length > 1) {
             const sorted = breakpoints.slice().sort((first, second) => (first.column && second.column) ? first.column - second.column : 1);
-            actions.push(( new SubmenuAction('debug.removeBreakpoints', ( localize(6438, "Remove Breakpoints")), ( sorted.map(bp => toAction({
+            actions.push(( new SubmenuAction('debug.removeBreakpoints', ( localize(6460, "Remove Breakpoints")), ( sorted.map(bp => toAction({
                 id: 'removeInlineBreakpoint',
-                label: bp.column ? ( localize(6439, "Remove Inline Breakpoint on Column {0}", bp.column)) : ( localize(6440, "Remove Line Breakpoint")),
+                label: bp.column ? ( localize(6461, "Remove Inline Breakpoint on Column {0}", bp.column)) : ( localize(6462, "Remove Line Breakpoint")),
                 enabled: true,
                 run: () => this.debugService.removeBreakpoints(bp.getId())
             }))))));
-            actions.push(( new SubmenuAction('debug.editBreakpoints', ( localize(6441, "Edit Breakpoints")), ( sorted.map(bp => toAction({
+            actions.push(( new SubmenuAction('debug.editBreakpoints', ( localize(6463, "Edit Breakpoints")), ( sorted.map(bp => toAction({
                 id: 'editBreakpoint',
-                label: bp.column ? ( localize(6442, "Edit Inline Breakpoint on Column {0}", bp.column)) : ( localize(6443, "Edit Line Breakpoint")),
+                label: bp.column ? ( localize(6464, "Edit Inline Breakpoint on Column {0}", bp.column)) : ( localize(6465, "Edit Line Breakpoint")),
                 enabled: true,
                 run: () => Promise.resolve(this.showBreakpointWidget(bp.lineNumber, bp.column))
             }))))));
-            actions.push(( new SubmenuAction('debug.enableDisableBreakpoints', ( localize(6444, "Enable/Disable Breakpoints")), ( sorted.map(bp => toAction({
+            actions.push(( new SubmenuAction('debug.enableDisableBreakpoints', ( localize(6466, "Enable/Disable Breakpoints")), ( sorted.map(bp => toAction({
                 id: bp.enabled ? 'disableColumnBreakpoint' : 'enableColumnBreakpoint',
-                label: bp.enabled ? (bp.column ? ( localize(6445, "Disable Inline Breakpoint on Column {0}", bp.column)) : ( localize(6446, "Disable Line Breakpoint")))
-                    : (bp.column ? ( localize(6447, "Enable Inline Breakpoint on Column {0}", bp.column)) : ( localize(6448, "Enable Line Breakpoint"))),
+                label: bp.enabled ? (bp.column ? ( localize(6467, "Disable Inline Breakpoint on Column {0}", bp.column)) : ( localize(6468, "Disable Line Breakpoint")))
+                    : (bp.column ? ( localize(6469, "Enable Inline Breakpoint on Column {0}", bp.column)) : ( localize(6470, "Enable Line Breakpoint"))),
                 enabled: true,
                 run: () => this.debugService.enableOrDisableBreakpoints(!bp.enabled, bp)
             }))))));
@@ -408,25 +408,25 @@ let BreakpointEditorContribution = class BreakpointEditorContribution {
         else {
             actions.push(toAction({
                 id: 'addBreakpoint',
-                label: ( localize(6449, "Add Breakpoint")),
+                label: ( localize(6471, "Add Breakpoint")),
                 enabled: true,
                 run: () => this.debugService.addBreakpoints(uri, [{ lineNumber, column }])
             }));
             actions.push(toAction({
                 id: 'addConditionalBreakpoint',
-                label: ( localize(6450, "Add Conditional Breakpoint...")),
+                label: ( localize(6472, "Add Conditional Breakpoint...")),
                 enabled: true,
                 run: () => Promise.resolve(this.showBreakpointWidget(lineNumber, column, BreakpointWidgetContext.CONDITION))
             }));
             actions.push(toAction({
                 id: 'addLogPoint',
-                label: ( localize(6451, "Add Logpoint...")),
+                label: ( localize(6473, "Add Logpoint...")),
                 enabled: true,
                 run: () => Promise.resolve(this.showBreakpointWidget(lineNumber, column, BreakpointWidgetContext.LOG_MESSAGE))
             }));
             actions.push(toAction({
                 id: 'addTriggeredBreakpoint',
-                label: ( localize(6452, "Add Triggered Breakpoint...")),
+                label: ( localize(6474, "Add Triggered Breakpoint...")),
                 enabled: true,
                 run: () => Promise.resolve(this.showBreakpointWidget(lineNumber, column, BreakpointWidgetContext.TRIGGER_POINT))
             }));
@@ -435,7 +435,7 @@ let BreakpointEditorContribution = class BreakpointEditorContribution {
             actions.push(( new Separator()));
             actions.push(toAction({
                 id: 'runToLine',
-                label: ( localize(6453, "Run to Line")),
+                label: ( localize(6475, "Run to Line")),
                 enabled: true,
                 run: () => this.debugService.runTo(uri, lineNumber).catch(onUnexpectedError)
             }));
@@ -790,10 +790,10 @@ registerThemingParticipant((theme, collector) => {
 		}`);
     }
 });
-const debugIconBreakpointForeground = registerColor('debugIcon.breakpointForeground', '#E51400', ( localize(6454, 'Icon color for breakpoints.')));
-const debugIconBreakpointDisabledForeground = registerColor('debugIcon.breakpointDisabledForeground', '#848484', ( localize(6455, 'Icon color for disabled breakpoints.')));
-const debugIconBreakpointUnverifiedForeground = registerColor('debugIcon.breakpointUnverifiedForeground', '#848484', ( localize(6456, 'Icon color for unverified breakpoints.')));
-const debugIconBreakpointCurrentStackframeForeground = registerColor('debugIcon.breakpointCurrentStackframeForeground', { dark: '#FFCC00', light: '#BE8700', hcDark: '#FFCC00', hcLight: '#BE8700' }, ( localize(6457, 'Icon color for the current breakpoint stack frame.')));
-const debugIconBreakpointStackframeForeground = registerColor('debugIcon.breakpointStackframeForeground', '#89D185', ( localize(6458, 'Icon color for all breakpoint stack frames.')));
+const debugIconBreakpointForeground = registerColor('debugIcon.breakpointForeground', '#E51400', ( localize(6476, 'Icon color for breakpoints.')));
+const debugIconBreakpointDisabledForeground = registerColor('debugIcon.breakpointDisabledForeground', '#848484', ( localize(6477, 'Icon color for disabled breakpoints.')));
+const debugIconBreakpointUnverifiedForeground = registerColor('debugIcon.breakpointUnverifiedForeground', '#848484', ( localize(6478, 'Icon color for unverified breakpoints.')));
+const debugIconBreakpointCurrentStackframeForeground = registerColor('debugIcon.breakpointCurrentStackframeForeground', { dark: '#FFCC00', light: '#BE8700', hcDark: '#FFCC00', hcLight: '#BE8700' }, ( localize(6479, 'Icon color for the current breakpoint stack frame.')));
+const debugIconBreakpointStackframeForeground = registerColor('debugIcon.breakpointStackframeForeground', '#89D185', ( localize(6480, 'Icon color for all breakpoint stack frames.')));
 
 export { BreakpointEditorContribution, createBreakpointDecorations, debugIconBreakpointForeground };

package/vscode/src/vs/workbench/contrib/debug/browser/breakpointWidget.js

@@ -136,21 +136,21 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
         switch (this.context) {
             case BreakpointWidgetContext.LOG_MESSAGE:
                 return localize(
-                    6459,
+                    6481,
                     "Message to log when breakpoint is hit. Expressions within {} are interpolated. '{0}' to accept, '{1}' to cancel.",
                     acceptString,
                     closeString
                 );
             case BreakpointWidgetContext.HIT_COUNT:
                 return localize(
-                    6460,
+                    6482,
                     "Break when hit count condition is met. '{0}' to accept, '{1}' to cancel.",
                     acceptString,
                     closeString
                 );
             default:
                 return localize(
-                    6461,
+                    6483,
                     "Break when expression evaluates to true. '{0}' to accept, '{1}' to cancel.",
                     acceptString,
                     closeString
@@ -199,11 +199,11 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
     _fillContainer(container) {
         this.setCssClass('breakpoint-widget');
         const selectBox = this.store.add(( new SelectBox([
-            { text: ( localize(6462, "Expression")) },
-            { text: ( localize(6463, "Hit Count")) },
-            { text: ( localize(6464, "Log Message")) },
-            { text: ( localize(6465, "Wait for Breakpoint")) },
-        ], this.context, this.contextViewService, defaultSelectBoxStyles, { ariaLabel: ( localize(6466, 'Breakpoint Type')), useCustomDrawn: !hasNativeContextMenu(this._configurationService) })));
+            { text: ( localize(6484, "Expression")) },
+            { text: ( localize(6485, "Hit Count")) },
+            { text: ( localize(6486, "Log Message")) },
+            { text: ( localize(6487, "Wait for Breakpoint")) },
+        ], this.context, this.contextViewService, defaultSelectBoxStyles, { ariaLabel: ( localize(6488, 'Breakpoint Type')), useCustomDrawn: !hasNativeContextMenu(this._configurationService) })));
         this.selectContainer = $('.breakpoint-select-container');
         selectBox.render(append(container, this.selectContainer));
         this.store.add(selectBox.onDidSelect(e => {
@@ -230,7 +230,7 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
             return;
         }
         const sb = this.selectModeBox = ( new SelectBox([
-            { text: ( localize(6467, 'Mode')), isDisabled: true },
+            { text: ( localize(6489, 'Mode')), isDisabled: true },
             ...( modes.map(mode => ({ text: mode.label, description: mode.description }))),
         ], modes.findIndex(m => m.mode === this.breakpoint?.mode) + 1, this.contextViewService, defaultSelectBoxStyles, { useCustomDrawn: !hasNativeContextMenu(this._configurationService) }));
         this.store.add(sb);
@@ -246,10 +246,10 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
     createTriggerBreakpointInput(container) {
         const breakpoints = this.debugService.getModel().getBreakpoints().filter(bp => bp !== this.breakpoint && !bp.logMessage);
         const breakpointOptions = [
-            { text: ( localize(6468, 'None')), isDisabled: true },
+            { text: ( localize(6490, 'None')), isDisabled: true },
             ...( breakpoints.map(bp => ({
                 text: `${this.labelService.getUriLabel(bp.uri, { relative: true })}: ${bp.lineNumber}`,
-                description: ( localize(6469, 'Loading...'))
+                description: ( localize(6491, 'Loading...'))
             }))),
         ];
         const index = breakpoints.findIndex((bp) => this.breakpoint?.triggeredBy === bp.getId());
@@ -262,7 +262,7 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
                     ref.dispose();
                 }
             }).catch(() => {
-                breakpointOptions[i + 1].description = ( localize(6470, 'Could not load source.'));
+                breakpointOptions[i + 1].description = ( localize(6492, 'Could not load source.'));
             });
         }
         const selectBreakpointBox = this.selectBreakpointBox = this.store.add(( new SelectBox(
@@ -270,7 +270,7 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
             index + 1,
             this.contextViewService,
             defaultSelectBoxStyles,
-            { ariaLabel: ( localize(6471, 'Select breakpoint')), useCustomDrawn: !hasNativeContextMenu(this._configurationService) }
+            { ariaLabel: ( localize(6493, 'Select breakpoint')), useCustomDrawn: !hasNativeContextMenu(this._configurationService) }
         )));
         this.store.add(selectBreakpointBox.onDidSelect(e => {
             if (e.index === 0) {
@@ -292,7 +292,7 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
         selectBreakpointBox.render(selectionWrapper);
         append(container, this.selectBreakpointContainer);
         const closeButton = ( new Button(this.selectBreakpointContainer, defaultButtonStyles));
-        closeButton.label = ( localize(6472, "OK"));
+        closeButton.label = ( localize(6494, "OK"));
         this.store.add(closeButton.onDidClick(() => this.close(true)));
         this.store.add(closeButton);
     }

package/vscode/src/vs/workbench/contrib/debug/browser/breakpointsView.d.ts

@@ -1,4 +1,5 @@
 import { ThemeIcon } from "../../../../base/common/themables.js";
+import { URI } from "../../../../base/common/uri.js";
 import { ILanguageService } from "../../../../editor/common/languages/language.service.js";
 import { IMenuService } from "../../../../platform/actions/common/actions.service.js";
 import { IConfigurationService } from "../../../../platform/configuration/common/configuration.service.js";
@@ -21,6 +22,17 @@ import { IBreakpoint, IDataBreakpoint, IDebugModel, IExceptionBreakpoint, IFunct
 import { IDebugService } from "../common/debug.service.js";
 export declare function getExpandedBodySize(model: IDebugModel, sessionId: string | undefined, countLimit: number): number;
 type BreakpointItem = IBreakpoint | IFunctionBreakpoint | IDataBreakpoint | IExceptionBreakpoint | IInstructionBreakpoint;
+/**
+ * Represents a file node in the breakpoints tree that groups breakpoints by file.
+ */
+export declare class BreakpointsFolderItem {
+    readonly uri: URI;
+    readonly breakpoints: IBreakpoint[];
+    constructor(uri: URI, breakpoints: IBreakpoint[]);
+    getId(): string;
+    get enabled(): boolean;
+    get indeterminate(): boolean;
+}
 interface InputBoxData {
     breakpoint: IFunctionBreakpoint | IExceptionBreakpoint | IDataBreakpoint;
     type: "condition" | "hitCount" | "name";
@@ -31,7 +43,7 @@ export declare class BreakpointsView extends ViewPane {
     private readonly contextViewService;
     private readonly labelService;
     private readonly languageService;
-    private list;
+    private tree;
     private needsRefresh;
     private needsStateChange;
     private ignoreLayout;
@@ -42,9 +54,11 @@ export declare class BreakpointsView extends ViewPane {
     private breakpointSupportsCondition;
     private _inputBoxData;
     breakpointInputFocused: IContextKey<boolean>;
-    private autoFocusedIndex;
+    private autoFocusedElement;
+    private collapsedState;
     private hintContainer;
     private hintDelayer;
+    private getPresentation;
     constructor(options: IViewletViewOptions, contextMenuService: IContextMenuService, debugService: IDebugService, keybindingService: IKeybindingService, instantiationService: IInstantiationService, themeService: IThemeService, editorService: IEditorService, contextViewService: IContextViewService, configurationService: IConfigurationService, viewDescriptorService: IViewDescriptorService, contextKeyService: IContextKeyService, openerService: IOpenerService, labelService: ILabelService, menuService: IMenuService, hoverService: IHoverService, languageService: ILanguageService);
     protected renderBody(container: HTMLElement): void;
     protected renderHeaderTitle(container: HTMLElement, title: string): void;
@@ -52,12 +66,14 @@ export declare class BreakpointsView extends ViewPane {
     renderInputBox(data: InputBoxData | undefined): void;
     get inputBoxData(): InputBoxData | undefined;
     protected layoutBody(height: number, width: number): void;
-    private onListContextMenu;
+    private onTreeContextMenu;
     private updateSize;
     private updateBreakpointsHint;
     private onBreakpointsChange;
     private onStateChange;
-    private get elements();
+    private setTreeInput;
+    private getTreeElements;
+    private get flatElements();
 }
 export declare function openBreakpointSource(breakpoint: IBreakpoint, sideBySide: boolean, preserveFocus: boolean, pinned: boolean, debugService: IDebugService, editorService: IEditorService): Promise<IEditorPane | undefined>;
 export declare function getBreakpointMessageAndIcon(state: State, breakpointsActivated: boolean, breakpoint: BreakpointItem, labelService: ILabelService, debugModel: IDebugModel): {