@codingame/monaco-vscode-api 36.2.6 → 37.0.0

package/vscode/src/vs/editor/contrib/codeAction/browser/codeActionModel.js

@@ -3,7 +3,7 @@ import { TimeoutTimer, createCancelablePromise } from '../../../../base/common/a
 import { isCancellationError } from '../../../../base/common/errors.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';
-import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { Disposable, MutableDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { isEqual } from '../../../../base/common/resources.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
 import { Progress } from '../../../../platform/progress/common/progress.js';
@@ -199,6 +199,7 @@ class CodeActionModel extends Disposable {
         }
         this._codeActionOracle.value = undefined;
         this.setState(CodeActionsState.Empty);
+        this.codeActionsDisposable.clear();
         const model = this._editor.getModel();
         if (model && ( this._registry.has(model)) && !this._editor.getOption(EditorOption.readOnly)) {
             const supportedActions = this._registry.all(model).flatMap(provider => provider.providedCodeActionKinds ?? []);
@@ -211,130 +212,135 @@ class CodeActionModel extends Disposable {
                 const startPosition = trigger.selection.getStartPosition();
                 const actions = createCancelablePromise(async token => {
                     if (this._settingEnabledNearbyQuickfixes() && trigger.trigger.type === CodeActionTriggerType.Invoke && (trigger.trigger.triggerAction === CodeActionTriggerSource.QuickFix || trigger.trigger.filter?.include?.contains(CodeActionKind.QuickFix))) {
-                        const codeActionSet = await getCodeActions(
-                            this._registry,
-                            model,
-                            trigger.selection,
-                            trigger.trigger,
-                            Progress.None,
-                            token
-                        );
-                        this.codeActionsDisposable.value = codeActionSet;
-                        const allCodeActions = [...codeActionSet.allActions];
-                        if (token.isCancellationRequested) {
-                            codeActionSet.dispose();
-                            return emptyCodeActionSet;
-                        }
-                        const foundQuickfix = codeActionSet.validActions?.some(action => {
-                            return action.action.kind && CodeActionKind.QuickFix.contains(( new HierarchicalKind(action.action.kind))) && !action.action.isAI;
-                        });
-                        const allMarkers = this._markerService.read({
-                            resource: model.uri
-                        });
-                        if (foundQuickfix) {
-                            for (const action of codeActionSet.validActions) {
-                                if (action.action.command?.arguments?.some(arg => typeof arg === "string" && arg.includes(APPLY_FIX_ALL_COMMAND_ID))) {
-                                    action.action.diagnostics = [...allMarkers.filter(marker => marker.relatedInformation)];
-                                }
+                        const codeActionSets = ( new DisposableStore());
+                        let codeActionSetsOwnedByResult = false;
+                        try {
+                            const codeActionSet = codeActionSets.add(await getCodeActions(
+                                this._registry,
+                                model,
+                                trigger.selection,
+                                trigger.trigger,
+                                Progress.None,
+                                token
+                            ));
+                            const allCodeActions = [...codeActionSet.allActions];
+                            if (token.isCancellationRequested) {
+                                return emptyCodeActionSet;
                             }
-                            return {
-                                validActions: codeActionSet.validActions,
-                                allActions: allCodeActions,
-                                documentation: codeActionSet.documentation,
-                                hasAutoFix: codeActionSet.hasAutoFix,
-                                hasAIFix: codeActionSet.hasAIFix,
-                                allAIFixes: codeActionSet.allAIFixes,
-                                dispose: () => {
-                                    this.codeActionsDisposable.value = codeActionSet;
-                                }
-                            };
-                        } else if (!foundQuickfix) {
-                            if (allMarkers.length > 0) {
-                                const currPosition = trigger.selection.getPosition();
-                                let trackedPosition = currPosition;
-                                let distance = Number.MAX_VALUE;
-                                const currentActions = [...codeActionSet.validActions];
-                                for (const marker of allMarkers) {
-                                    const col = marker.endColumn;
-                                    const row = marker.endLineNumber;
-                                    const startRow = marker.startLineNumber;
-                                    if ((row === currPosition.lineNumber || startRow === currPosition.lineNumber)) {
-                                        trackedPosition = ( new Position(row, col));
-                                        const newCodeActionTrigger = {
-                                            type: trigger.trigger.type,
-                                            triggerAction: trigger.trigger.triggerAction,
-                                            filter: {
-                                                include: trigger.trigger.filter?.include ? trigger.trigger.filter?.include : CodeActionKind.QuickFix
-                                            },
-                                            autoApply: trigger.trigger.autoApply,
-                                            context: {
-                                                notAvailableMessage: trigger.trigger.context?.notAvailableMessage || "",
-                                                position: trackedPosition
-                                            }
-                                        };
-                                        const selectionAsPosition = ( new Selection(
-                                            trackedPosition.lineNumber,
-                                            trackedPosition.column,
-                                            trackedPosition.lineNumber,
-                                            trackedPosition.column
-                                        ));
-                                        const actionsAtMarker = await getCodeActions(
-                                            this._registry,
-                                            model,
-                                            selectionAsPosition,
-                                            newCodeActionTrigger,
-                                            Progress.None,
-                                            token
-                                        );
-                                        if (token.isCancellationRequested) {
-                                            actionsAtMarker.dispose();
-                                            return emptyCodeActionSet;
-                                        }
-                                        if (actionsAtMarker.validActions.length !== 0) {
-                                            for (const action of actionsAtMarker.validActions) {
-                                                if (action.action.command?.arguments?.some(arg => typeof arg === "string" && arg.includes(APPLY_FIX_ALL_COMMAND_ID))) {
-                                                    action.action.diagnostics = [...allMarkers.filter(marker => marker.relatedInformation)];
-                                                }
-                                            }
-                                            if (codeActionSet.allActions.length === 0) {
-                                                allCodeActions.push(...actionsAtMarker.allActions);
-                                            }
-                                            if (Math.abs(currPosition.column - col) < distance) {
-                                                currentActions.unshift(...actionsAtMarker.validActions);
-                                            } else {
-                                                currentActions.push(...actionsAtMarker.validActions);
-                                            }
-                                        }
-                                        distance = Math.abs(currPosition.column - col);
+                            const foundQuickfix = codeActionSet.validActions?.some(action => {
+                                return action.action.kind && CodeActionKind.QuickFix.contains(( new HierarchicalKind(action.action.kind))) && !action.action.isAI;
+                            });
+                            const allMarkers = this._markerService.read({
+                                resource: model.uri
+                            });
+                            if (foundQuickfix) {
+                                for (const action of codeActionSet.validActions) {
+                                    if (action.action.command?.arguments?.some(arg => typeof arg === "string" && arg.includes(APPLY_FIX_ALL_COMMAND_ID))) {
+                                        action.action.diagnostics = [...allMarkers.filter(marker => marker.relatedInformation)];
                                     }
                                 }
-                                const filteredActions = currentActions.filter(
-                                    (action, index, self) => self.findIndex(a => a.action.title === action.action.title) === index
-                                );
-                                filteredActions.sort((a, b) => {
-                                    if (a.action.isPreferred && !b.action.isPreferred) {
-                                        return -1;
-                                    } else if (!a.action.isPreferred && b.action.isPreferred) {
-                                        return 1;
-                                    } else if (a.action.isAI && !b.action.isAI) {
-                                        return 1;
-                                    } else if (!a.action.isAI && b.action.isAI) {
-                                        return -1;
-                                    } else {
-                                        return 0;
-                                    }
-                                });
-                                return {
-                                    validActions: filteredActions,
+                                const result = this._setCodeActions({
+                                    validActions: codeActionSet.validActions,
                                     allActions: allCodeActions,
                                     documentation: codeActionSet.documentation,
                                     hasAutoFix: codeActionSet.hasAutoFix,
                                     hasAIFix: codeActionSet.hasAIFix,
                                     allAIFixes: codeActionSet.allAIFixes,
-                                    dispose: () => {
-                                        this.codeActionsDisposable.value = codeActionSet;
+                                    dispose: () => codeActionSets.dispose()
+                                });
+                                codeActionSetsOwnedByResult = true;
+                                return result;
+                            } else if (!foundQuickfix) {
+                                if (allMarkers.length > 0) {
+                                    const currPosition = trigger.selection.getPosition();
+                                    let trackedPosition = currPosition;
+                                    let distance = Number.MAX_VALUE;
+                                    const currentActions = [...codeActionSet.validActions];
+                                    for (const marker of allMarkers) {
+                                        const col = marker.endColumn;
+                                        const row = marker.endLineNumber;
+                                        const startRow = marker.startLineNumber;
+                                        if ((row === currPosition.lineNumber || startRow === currPosition.lineNumber)) {
+                                            trackedPosition = ( new Position(row, col));
+                                            const newCodeActionTrigger = {
+                                                type: trigger.trigger.type,
+                                                triggerAction: trigger.trigger.triggerAction,
+                                                filter: {
+                                                    include: trigger.trigger.filter?.include ? trigger.trigger.filter?.include : CodeActionKind.QuickFix
+                                                },
+                                                autoApply: trigger.trigger.autoApply,
+                                                context: {
+                                                    notAvailableMessage: trigger.trigger.context?.notAvailableMessage || "",
+                                                    position: trackedPosition
+                                                }
+                                            };
+                                            const selectionAsPosition = ( new Selection(
+                                                trackedPosition.lineNumber,
+                                                trackedPosition.column,
+                                                trackedPosition.lineNumber,
+                                                trackedPosition.column
+                                            ));
+                                            const actionsAtMarker = codeActionSets.add(await getCodeActions(
+                                                this._registry,
+                                                model,
+                                                selectionAsPosition,
+                                                newCodeActionTrigger,
+                                                Progress.None,
+                                                token
+                                            ));
+                                            if (token.isCancellationRequested) {
+                                                return emptyCodeActionSet;
+                                            }
+                                            if (actionsAtMarker.validActions.length !== 0) {
+                                                for (const action of actionsAtMarker.validActions) {
+                                                    if (action.action.command?.arguments?.some(arg => typeof arg === "string" && arg.includes(APPLY_FIX_ALL_COMMAND_ID))) {
+                                                        action.action.diagnostics = [...allMarkers.filter(marker => marker.relatedInformation)];
+                                                    }
+                                                }
+                                                if (codeActionSet.allActions.length === 0) {
+                                                    allCodeActions.push(...actionsAtMarker.allActions);
+                                                }
+                                                if (Math.abs(currPosition.column - col) < distance) {
+                                                    currentActions.unshift(...actionsAtMarker.validActions);
+                                                } else {
+                                                    currentActions.push(...actionsAtMarker.validActions);
+                                                }
+                                            }
+                                            distance = Math.abs(currPosition.column - col);
+                                        }
                                     }
-                                };
+                                    const filteredActions = currentActions.filter(
+                                        (action, index, self) => self.findIndex(a => a.action.title === action.action.title) === index
+                                    );
+                                    filteredActions.sort((a, b) => {
+                                        if (a.action.isPreferred && !b.action.isPreferred) {
+                                            return -1;
+                                        } else if (!a.action.isPreferred && b.action.isPreferred) {
+                                            return 1;
+                                        } else if (a.action.isAI && !b.action.isAI) {
+                                            return 1;
+                                        } else if (!a.action.isAI && b.action.isAI) {
+                                            return -1;
+                                        } else {
+                                            return 0;
+                                        }
+                                    });
+                                    const result = this._setCodeActions({
+                                        validActions: filteredActions,
+                                        allActions: allCodeActions,
+                                        documentation: codeActionSet.documentation,
+                                        hasAutoFix: codeActionSet.hasAutoFix,
+                                        hasAIFix: codeActionSet.hasAIFix,
+                                        allAIFixes: codeActionSet.allAIFixes,
+                                        dispose: () => codeActionSets.dispose()
+                                    });
+                                    codeActionSetsOwnedByResult = true;
+                                    return result;
+                                }
+                            }
+                        } finally {
+                            if (!codeActionSetsOwnedByResult) {
+                                codeActionSets.dispose();
                             }
                         }
                     }
@@ -347,8 +353,11 @@ class CodeActionModel extends Disposable {
                             Progress.None,
                             token
                         );
-                        this.codeActionsDisposable.value = codeActions;
-                        return codeActions;
+                        if (token.isCancellationRequested) {
+                            codeActions.dispose();
+                            return emptyCodeActionSet;
+                        }
+                        return this._setCodeActions(codeActions);
                     }
                     const codeActionSet = await getCodeActions(
                         this._registry,
@@ -358,8 +367,11 @@ class CodeActionModel extends Disposable {
                         Progress.None,
                         token
                     );
-                    this.codeActionsDisposable.value = codeActionSet;
-                    return codeActionSet;
+                    if (token.isCancellationRequested) {
+                        codeActionSet.dispose();
+                        return emptyCodeActionSet;
+                    }
+                    return this._setCodeActions(codeActionSet);
                 });
                 if (trigger.trigger.type === CodeActionTriggerType.Invoke) {
                     this._progressService?.showWhile(actions, 250);
@@ -387,9 +399,20 @@ class CodeActionModel extends Disposable {
             this._supportedCodeActions.reset();
         }
     }
+    _setCodeActions(actions) {
+        this.codeActionsDisposable.value = actions;
+        return actions;
+    }
+    takeCodeActions(actions) {
+        if (this.codeActionsDisposable.value !== actions) {
+            return undefined;
+        }
+        this.codeActionsDisposable.clearAndLeak();
+        return actions;
+    }
     trigger(trigger) {
         this._codeActionOracle.value?.trigger(trigger);
-        this.codeActionsDisposable.dispose();
+        this.codeActionsDisposable.clear();
     }
     setState(newState, skipNotify) {
         if (newState === this._state) {

package/vscode/src/vs/editor/contrib/codeAction/browser/lightBulbWidget.js

@@ -26,27 +26,27 @@ import { autorun } from '../../../../base/common/observableInternal/reactions/au
 var LightBulbWidget_1;
 registerCss(lightBulbWidget);
 const GUTTER_LIGHTBULB_ICON = registerIcon("gutter-lightbulb", Codicon.lightBulb, ( localize(
-    1015,
+    1024,
     "Icon which spawns code actions menu from the gutter when there is no space in the editor."
 )));
 const GUTTER_LIGHTBULB_AUTO_FIX_ICON = registerIcon("gutter-lightbulb-auto-fix", Codicon.lightbulbAutofix, ( localize(
-    1016,
+    1025,
     "Icon which spawns code actions menu from the gutter when there is no space in the editor and a quick fix is available."
 )));
 const GUTTER_LIGHTBULB_AIFIX_ICON = registerIcon("gutter-lightbulb-sparkle", Codicon.lightbulbSparkle, ( localize(
-    1017,
+    1026,
     "Icon which spawns code actions menu from the gutter when there is no space in the editor and an AI fix is available."
 )));
 const GUTTER_LIGHTBULB_AIFIX_AUTO_FIX_ICON = registerIcon(
     "gutter-lightbulb-aifix-auto-fix",
     Codicon.lightbulbSparkleAutofix,
     ( localize(
-    1018,
+    1027,
     "Icon which spawns code actions menu from the gutter when there is no space in the editor and an AI fix and a quick fix is available."
 ))
 );
 const GUTTER_SPARKLE_FILLED_ICON = registerIcon("gutter-lightbulb-sparkle-filled", Codicon.sparkleFilled, ( localize(
-    1019,
+    1028,
     "Icon which spawns code actions menu from the gutter when there is no space in the editor and an AI fix and a quick fix is available."
 )));
 var LightBulbState;
@@ -94,17 +94,17 @@ function computeLightBulbInfo(actions, trigger, preferredKbLabel, quickFixKbLabe
     }
     let title;
     if (autoRun) {
-        title = ( localize(1020, "Run: {0}", actions.validActions[0].action.title));
+        title = ( localize(1029, "Run: {0}", actions.validActions[0].action.title));
     } else if (actions.hasAutoFix && preferredKbLabel) {
         title = ( localize(
-            1021,
+            1030,
             "Show Code Actions. Preferred Quick Fix Available ({0})",
             preferredKbLabel
         ));
     } else if (!actions.hasAutoFix && quickFixKbLabel) {
-        title = ( localize(1022, "Show Code Actions ({0})", quickFixKbLabel));
+        title = ( localize(1031, "Show Code Actions ({0})", quickFixKbLabel));
     } else {
-        title = ( localize(1023, "Show Code Actions"));
+        title = ( localize(1032, "Show Code Actions"));
     }
     return {
         actions,

package/vscode/src/vs/editor/contrib/codelens/browser/codelensController.js

@@ -415,7 +415,7 @@ registerEditorAction(class ShowLensesInCurrentLine extends EditorAction {
         super({
             id: "codelens.showLensesInCurrentLine",
             precondition: EditorContextKeys.hasCodeLensProvider,
-            label: ( localize2(1024, "Show CodeLens Commands for Current Line"))
+            label: ( localize2(1033, "Show CodeLens Commands for Current Line"))
         });
     }
     async run(accessor, editor) {
@@ -448,7 +448,7 @@ registerEditorAction(class ShowLensesInCurrentLine extends EditorAction {
         }
         const item = await quickInputService.pick(items, {
             canPickMany: false,
-            placeHolder: ( localize(1025, "Select a command"))
+            placeHolder: ( localize(1034, "Select a command"))
         });
         if (!item) {
             return;

package/vscode/src/vs/editor/contrib/colorPicker/browser/colorDetector.d.ts

@@ -26,6 +26,8 @@ export declare class ColorDetector extends Disposable implements IEditorContribu
     private _defaultColorDecoratorsEnablement;
     private readonly _ruleFactory;
     private readonly _decoratorLimitReporter;
+    private static readonly colorDecoratorInnerWidthInEm;
+    private static readonly colorDecoratorMarginInEm;
     constructor(_editor: ICodeEditor, _configurationService: IConfigurationService, _languageFeaturesService: ILanguageFeaturesService, languageFeatureDebounceService: ILanguageFeatureDebounceService);
     isEnabled(): boolean;
     get limitReporter(): DecoratorLimitReporter;

package/vscode/src/vs/editor/contrib/colorPicker/browser/colorDetector.js

@@ -4,7 +4,7 @@ import { TimeoutTimer, createCancelablePromise } from '../../../../base/common/a
 import { RGBA } from '../../../../base/common/color.js';
 import { onUnexpectedError } from '../../../../base/common/errors.js';
 import { Emitter } from '../../../../base/common/event.js';
-import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Disposable, DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
 import { StopWatch } from '../../../../base/common/stopwatch.js';
 import { noBreakWhitespace } from '../../../../base/common/strings.js';
 import { DynamicCssRules } from '../../../browser/editorDom.js';
@@ -28,6 +28,12 @@ let ColorDetector = class ColorDetector extends Disposable {
     static {
         this.RECOMPUTE_TIME = 1000;
     }
+    static {
+        this.colorDecoratorInnerWidthInEm = 0.8;
+    }
+    static {
+        this.colorDecoratorMarginInEm = 0.2;
+    }
     constructor(
         _editor,
         _configurationService,
@@ -45,6 +51,19 @@ let ColorDetector = class ColorDetector extends Disposable {
         this._colorDecorationClassRefs = this._register(( new DisposableStore()));
         this._colorDecoratorIds = this._editor.createDecorationsCollection();
         this._ruleFactory = this._register(( new DynamicCssRules(this._editor)));
+        const editorDomNode = this._editor.getContainerDomNode();
+        editorDomNode.style.setProperty(
+            "--vscode-colorPicker-colorDecoratorWidth",
+            `${ColorDetector_1.colorDecoratorInnerWidthInEm}em`
+        );
+        editorDomNode.style.setProperty(
+            "--vscode-colorPicker-colorDecoratorMargin",
+            `${ColorDetector_1.colorDecoratorMarginInEm}em`
+        );
+        this._register(toDisposable(() => {
+            editorDomNode.style.removeProperty("--vscode-colorPicker-colorDecoratorWidth");
+            editorDomNode.style.removeProperty("--vscode-colorPicker-colorDecoratorMargin");
+        }));
         this._debounceInformation = languageFeatureDebounceService.for(_languageFeaturesService.colorProvider, "Document Colors", {
             min: ColorDetector_1.RECOMPUTE_TIME
         });
@@ -178,6 +197,7 @@ let ColorDetector = class ColorDetector extends Disposable {
     updateColorDecorators(colorData) {
         this._colorDecorationClassRefs.clear();
         const decorations = [];
+        const widthInEm = ColorDetector_1.colorDecoratorInnerWidthInEm + 2 * ColorDetector_1.colorDecoratorMarginInEm;
         const limit = this._editor.getOption(EditorOption.colorDecoratorsLimit);
         for (let i = 0; i < colorData.length && decorations.length < limit; i++) {
             const {
@@ -209,7 +229,8 @@ let ColorDetector = class ColorDetector extends Disposable {
                         content: noBreakWhitespace,
                         inlineClassName: `${ref.className} colorpicker-color-decoration`,
                         inlineClassNameAffectsLetterSpacing: true,
-                        attachedData: ColorDecorationInjectedTextMarker
+                        attachedData: ColorDecorationInjectedTextMarker,
+                        widthInEm
                     }
                 }
             });

package/vscode/src/vs/editor/contrib/colorPicker/browser/colorPicker.css

@@ -15,8 +15,8 @@
 .hc-light .colorpicker-color-decoration {
 	border: solid 0.1em #000;
 	box-sizing: border-box;
-	margin: 0.1em 0.2em 0 0.2em;
-	width: 0.8em;
+	margin: 0.1em var(--vscode-colorPicker-colorDecoratorMargin) 0;
+	width: var(--vscode-colorPicker-colorDecoratorWidth);
 	height: 0.8em;
 	line-height: 0.8em;
 	display: inline-block;
@@ -206,6 +206,6 @@
 	cursor: pointer;
 }
 
-.colorpicker-body .insert-button:hover{
+.colorpicker-body .insert-button:hover {
 	background: var(--vscode-button-hoverBackground);
 }

package/vscode/src/vs/editor/contrib/colorPicker/browser/colorPickerParts/colorPickerCloseButton.js

@@ -23,7 +23,7 @@ class CloseButton extends Disposable {
         innerDiv.classList.add("close-button-inner-div");
         append(this._button, innerDiv);
         const closeButton = append(innerDiv, $(
-            ".button" + ThemeIcon.asCSSSelector(registerIcon("color-picker-close", Codicon.close, ( localize(1026, "Icon to close the color picker"))))
+            ".button" + ThemeIcon.asCSSSelector(registerIcon("color-picker-close", Codicon.close, ( localize(1035, "Icon to close the color picker"))))
         ));
         closeButton.classList.add("close-icon");
         this._register(addDisposableListener(this._button, EventType.CLICK, () => {

package/vscode/src/vs/editor/contrib/colorPicker/browser/colorPickerParts/colorPickerHeader.js

@@ -33,7 +33,7 @@ class ColorPickerHeader extends Disposable {
         append(this._pickedColorNode, $("span.codicon.codicon-color-mode"));
         this._pickedColorPresentation = append(this._pickedColorNode, createElement("span"));
         this._pickedColorPresentation.classList.add("picked-color-presentation");
-        const tooltip = ( localize(1027, "Click to toggle color options (rgb/hsl/hex)"));
+        const tooltip = ( localize(1036, "Click to toggle color options (rgb/hsl/hex)"));
         this._pickedColorNode.setAttribute("title", tooltip);
         this._originalColorNode = append(this._domNode, $(".original-color"));
         this._originalColorNode.style.backgroundColor = Color.Format.CSS.format(this.model.originalColor) || "";

package/vscode/src/vs/editor/contrib/colorPicker/browser/hoverColorPicker/hoverColorPickerParticipant.js

@@ -128,7 +128,7 @@ let HoverColorPickerParticipant = class HoverColorPickerParticipant {
         return ( new RenderedHoverParts([renderedHoverPart]));
     }
     getAccessibleContent(hoverPart) {
-        return localize(1028, "There is a color picker here.");
+        return localize(1037, "There is a color picker here.");
     }
     handleResize() {
         this._colorPicker?.layout();

package/vscode/src/vs/editor/contrib/colorPicker/browser/standaloneColorPicker/standaloneColorPickerActions.js

@@ -12,8 +12,8 @@ class ShowOrFocusStandaloneColorPicker extends EditorAction2 {
         super({
             id: "editor.action.showOrFocusStandaloneColorPicker",
             title: {
-                ...( localize2(1029, "Show or Focus Standalone Color Picker")),
-                mnemonicTitle: ( localize(1030, "&&Show or Focus Standalone Color Picker"))
+                ...( localize2(1038, "Show or Focus Standalone Color Picker")),
+                mnemonicTitle: ( localize(1039, "&&Show or Focus Standalone Color Picker"))
             },
             precondition: undefined,
             menu: [{
@@ -21,7 +21,7 @@ class ShowOrFocusStandaloneColorPicker extends EditorAction2 {
             }],
             metadata: {
                 description: ( localize2(
-                    1031,
+                    1040,
                     "Show or focus a standalone color picker which uses the default color provider. It displays hex/rgb/hsl colors."
                 ))
             }
@@ -35,14 +35,14 @@ class HideStandaloneColorPicker extends EditorAction {
     constructor() {
         super({
             id: "editor.action.hideColorPicker",
-            label: ( localize2(1032, "Hide the Color Picker")),
+            label: ( localize2(1041, "Hide the Color Picker")),
             precondition: ( EditorContextKeys.standaloneColorPickerVisible.isEqualTo(true)),
             kbOpts: {
                 primary: KeyCode.Escape,
                 weight: KeybindingWeight.EditorContrib
             },
             metadata: {
-                description: ( localize2(1033, "Hide the standalone color picker."))
+                description: ( localize2(1042, "Hide the standalone color picker."))
             }
         });
     }
@@ -54,7 +54,7 @@ class InsertColorWithStandaloneColorPicker extends EditorAction {
     constructor() {
         super({
             id: "editor.action.insertColorWithStandaloneColorPicker",
-            label: ( localize2(1034, "Insert Color with Standalone Color Picker")),
+            label: ( localize2(1043, "Insert Color with Standalone Color Picker")),
             precondition: ( EditorContextKeys.standaloneColorPickerFocused.isEqualTo(true)),
             kbOpts: {
                 primary: KeyCode.Enter,
@@ -62,7 +62,7 @@ class InsertColorWithStandaloneColorPicker extends EditorAction {
             },
             metadata: {
                 description: ( localize2(
-                    1035,
+                    1044,
                     "Insert hex/rgb/hsl colors with the focused standalone color picker."
                 ))
             }

package/vscode/src/vs/editor/contrib/comment/browser/comment.js

@@ -63,7 +63,7 @@ class ToggleCommentLineAction extends CommentLineAction {
     constructor() {
         super(Type.Toggle, {
             id: "editor.action.commentLine",
-            label: ( localize2(1036, "Toggle Line Comment")),
+            label: ( localize2(1045, "Toggle Line Comment")),
             precondition: EditorContextKeys.writable,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -73,7 +73,7 @@ class ToggleCommentLineAction extends CommentLineAction {
             menuOpts: {
                 menuId: MenuId.MenubarEditMenu,
                 group: "5_insert",
-                title: ( localize(1037, "&&Toggle Line Comment")),
+                title: ( localize(1046, "&&Toggle Line Comment")),
                 order: 1
             },
             canTriggerInlineEdits: true
@@ -84,7 +84,7 @@ class AddLineCommentAction extends CommentLineAction {
     constructor() {
         super(Type.ForceAdd, {
             id: "editor.action.addCommentLine",
-            label: ( localize2(1038, "Add Line Comment")),
+            label: ( localize2(1047, "Add Line Comment")),
             precondition: EditorContextKeys.writable,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -99,7 +99,7 @@ class RemoveLineCommentAction extends CommentLineAction {
     constructor() {
         super(Type.ForceRemove, {
             id: "editor.action.removeCommentLine",
-            label: ( localize2(1039, "Remove Line Comment")),
+            label: ( localize2(1048, "Remove Line Comment")),
             precondition: EditorContextKeys.writable,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -114,7 +114,7 @@ class BlockCommentAction extends EditorAction {
     constructor() {
         super({
             id: "editor.action.blockComment",
-            label: ( localize2(1040, "Toggle Block Comment")),
+            label: ( localize2(1049, "Toggle Block Comment")),
             precondition: EditorContextKeys.writable,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -127,7 +127,7 @@ class BlockCommentAction extends EditorAction {
             menuOpts: {
                 menuId: MenuId.MenubarEditMenu,
                 group: "5_insert",
-                title: ( localize(1041, "Toggle &&Block Comment")),
+                title: ( localize(1050, "Toggle &&Block Comment")),
                 order: 2
             },
             canTriggerInlineEdits: true