@codingame/monaco-vscode-api 4.5.1 → 4.5.2

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/coreActions.js

@@ -9,12 +9,9 @@ import { IEditorService } from '../../../../services/editor/common/editorService
 import { INotebookEditorService } from '../services/notebookEditorService.service.js';
 import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.service.js';
 import { isEqual } from '../../../../../base/common/resources.js';
+const _moduleId = "vs/workbench/contrib/notebook/browser/controller/coreActions";
 const SELECT_KERNEL_ID = '_notebook.selectKernel';
-const NOTEBOOK_ACTIONS_CATEGORY = ( localize2WithPath(
-    'vs/workbench/contrib/notebook/browser/controller/coreActions',
-    'notebookActions.category',
-    'Notebook'
-));
+const NOTEBOOK_ACTIONS_CATEGORY = ( localize2WithPath(_moduleId, 0, 'Notebook'));
 const CELL_TITLE_CELL_GROUP_ID = 'inline/cell';
 const CELL_TITLE_OUTPUT_GROUP_ID = 'inline/output';
 const NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT = 100 ;
@@ -34,7 +31,7 @@ function getContextFromActiveEditor(editorService) {
 }
 function getWidgetFromUri(accessor, uri) {
     const notebookEditorService = accessor.get(INotebookEditorService);
-    const widget = notebookEditorService.listNotebookEditors().find(widget => widget.hasModel() && ( widget.textModel.uri.toString()) === ( uri.toString()));
+    const widget = notebookEditorService.listNotebookEditors().find(widget => widget.hasModel() && ( (widget.textModel.uri.toString())) === ( (uri.toString())));
     if (widget && widget.hasModel()) {
         return widget;
     }
@@ -68,7 +65,7 @@ class NotebookAction extends Action2 {
             desc.f1 = false;
             const f1Menu = {
                 id: MenuId.CommandPalette,
-                when: ( ContextKeyExpr.or(NOTEBOOK_IS_ACTIVE_EDITOR, INTERACTIVE_WINDOW_IS_ACTIVE_EDITOR))
+                when: ( (ContextKeyExpr.or(NOTEBOOK_IS_ACTIVE_EDITOR, INTERACTIVE_WINDOW_IS_ACTIVE_EDITOR)))
             };
             if (!desc.menu) {
                 desc.menu = [];
@@ -186,10 +183,10 @@ class NotebookCellAction extends NotebookAction {
         }
     }
 }
-const executeNotebookCondition = ( ContextKeyExpr.or(
+const executeNotebookCondition = ( (ContextKeyExpr.or(
     ContextKeyExpr.greater(NOTEBOOK_KERNEL_COUNT.key, 0),
     ContextKeyExpr.greater(NOTEBOOK_KERNEL_SOURCE_COUNT.key, 0)
-));
+)));
 function isMultiCellArgs(arg) {
     if (arg === undefined) {
         return false;
@@ -198,7 +195,7 @@ function isMultiCellArgs(arg) {
     if (!ranges) {
         return false;
     }
-    if (!Array.isArray(ranges) || ( ranges.some(range => !isICellRange(range)))) {
+    if (!Array.isArray(ranges) || ( (ranges.some(range => !isICellRange(range))))) {
         return false;
     }
     if (arg.document) {
@@ -228,7 +225,7 @@ function parseMultiCellExecutionArgs(accessor, ...args) {
             return;
         }
         const ranges = firstArg.ranges;
-        const selectedCells = ( ranges.map(range => editor.getCellsInRange(range).slice(0))).flat();
+        const selectedCells = ( (ranges.map(range => editor.getCellsInRange(range).slice(0)))).flat();
         const autoReveal = firstArg.autoReveal;
         return {
             ui: false,
@@ -297,30 +294,18 @@ const cellExecutionArgs = [
 ];
 MenuRegistry.appendMenuItem(MenuId.NotebookCellTitle, {
     submenu: MenuId.NotebookCellInsert,
-    title: ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/controller/coreActions',
-        'notebookMenu.insertCell',
-        "Insert Cell"
-    )),
+    title: ( localizeWithPath(_moduleId, 1, "Insert Cell")),
     group: "2_insert" ,
-    when: ( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true))
+    when: ( (NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)))
 });
 MenuRegistry.appendMenuItem(MenuId.EditorContext, {
     submenu: MenuId.NotebookCellTitle,
-    title: ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/controller/coreActions',
-        'notebookMenu.cellTitle',
-        "Notebook Cell"
-    )),
+    title: ( localizeWithPath(_moduleId, 2, "Notebook Cell")),
     group: "2_insert" ,
     when: NOTEBOOK_EDITOR_FOCUSED
 });
 MenuRegistry.appendMenuItem(MenuId.NotebookCellTitle, {
-    title: ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/controller/coreActions',
-        'miShare',
-        "Share"
-    )),
+    title: ( localizeWithPath(_moduleId, 3, "Share")),
     submenu: MenuId.EditorContextShare,
     group: "4_share"
 });

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/editActions.js

@@ -26,6 +26,7 @@ import { INotebookKernelService } from '../../common/notebookKernelService.servi
 import { IEditorService } from '../../../../services/editor/common/editorService.service.js';
 import { ILanguageDetectionService } from '../../../../services/languageDetection/common/languageDetectionWorkerService.service.js';
 import { editIcon, stopEditIcon, deleteCellIcon, clearIcon } from '../notebookIcons.js';
+const _moduleId = "vs/workbench/contrib/notebook/browser/controller/editActions";
 const CLEAR_ALL_CELLS_OUTPUTS_COMMAND_ID = 'notebook.clearAllCellsOutputs';
 const EDIT_CELL_COMMAND_ID = 'notebook.cell.edit';
 const DELETE_CELL_COMMAND_ID = 'notebook.cell.delete';
@@ -35,24 +36,25 @@ registerAction2(class EditCellAction extends NotebookCellAction {
     constructor() {
         super({
             id: EDIT_CELL_COMMAND_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/editActions',
-                'notebookActions.editCell',
-                "Edit Cell"
-            )),
+            title: ( localizeWithPath(_moduleId, 0, "Edit Cell")),
             keybinding: {
-                when: ( ContextKeyExpr.and(
+                when: ( (ContextKeyExpr.and(
                     NOTEBOOK_CELL_LIST_FOCUSED,
                     ContextKeyExpr.not(InputFocusedContextKey),
-                    ( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)),
-                    ( EditorContextKeys.hoverFocused.toNegated())
-                )),
+                     (NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)),
+                     (EditorContextKeys.hoverFocused.toNegated())
+                ))),
                 primary: 3 ,
                 weight: 200
             },
             menu: {
                 id: MenuId.NotebookCellTitle,
-                when: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)), ( NOTEBOOK_CELL_TYPE.isEqualTo('markup')), ( NOTEBOOK_CELL_MARKDOWN_EDIT_MODE.toNegated()), NOTEBOOK_CELL_EDITABLE)),
+                when: ( (ContextKeyExpr.and(
+                     (NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)),
+                     (NOTEBOOK_CELL_TYPE.isEqualTo('markup')),
+                     (NOTEBOOK_CELL_MARKDOWN_EDIT_MODE.toNegated()),
+                    NOTEBOOK_CELL_EDITABLE
+                ))),
                 order: 0 ,
                 group: CELL_TITLE_CELL_GROUP_ID
             },
@@ -70,36 +72,45 @@ registerAction2(class EditCellAction extends NotebookCellAction {
         }
     }
 });
-const quitEditCondition = ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, InputFocusedContext, ( CTX_INLINE_CHAT_FOCUSED.toNegated())));
+const quitEditCondition = ( (ContextKeyExpr.and(
+    NOTEBOOK_EDITOR_FOCUSED,
+    InputFocusedContext,
+     (CTX_INLINE_CHAT_FOCUSED.toNegated())
+)));
 registerAction2(class QuitEditCellAction extends NotebookCellAction {
     constructor() {
         super({
             id: QUIT_EDIT_CELL_COMMAND_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/editActions',
-                'notebookActions.quitEdit',
-                "Stop Editing Cell"
-            )),
+            title: ( localizeWithPath(_moduleId, 1, "Stop Editing Cell")),
             menu: {
                 id: MenuId.NotebookCellTitle,
-                when: ( ContextKeyExpr.and(( NOTEBOOK_CELL_TYPE.isEqualTo('markup')), NOTEBOOK_CELL_MARKDOWN_EDIT_MODE, NOTEBOOK_CELL_EDITABLE)),
+                when: ( (ContextKeyExpr.and(
+                     (NOTEBOOK_CELL_TYPE.isEqualTo('markup')),
+                    NOTEBOOK_CELL_MARKDOWN_EDIT_MODE,
+                    NOTEBOOK_CELL_EDITABLE
+                ))),
                 order: 3 ,
                 group: CELL_TITLE_CELL_GROUP_ID
             },
             icon: stopEditIcon,
             keybinding: [
                 {
-                    when: ( ContextKeyExpr.and(quitEditCondition, ( EditorContextKeys.hoverVisible.toNegated()), ( EditorContextKeys.hasNonEmptySelection.toNegated()), ( EditorContextKeys.hasMultipleSelections.toNegated()))),
+                    when: ( (ContextKeyExpr.and(
+                        quitEditCondition,
+                         (EditorContextKeys.hoverVisible.toNegated()),
+                         (EditorContextKeys.hasNonEmptySelection.toNegated()),
+                         (EditorContextKeys.hasMultipleSelections.toNegated())
+                    ))),
                     primary: 9 ,
                     weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT - 5
                 },
                 {
-                    when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_OUTPUT_FOCUSED)),
+                    when: ( (ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_OUTPUT_FOCUSED))),
                     primary: 9 ,
                     weight: 200  + 5
                 },
                 {
-                    when: ( ContextKeyExpr.and(quitEditCondition, ( NOTEBOOK_CELL_TYPE.isEqualTo('markup')))),
+                    when: ( (ContextKeyExpr.and(quitEditCondition,  (NOTEBOOK_CELL_TYPE.isEqualTo('markup'))))),
                     primary: 256  | 3 ,
                     win: {
                         primary: 2048  | 512  | 3
@@ -120,17 +131,13 @@ registerAction2(class DeleteCellAction extends NotebookCellAction {
     constructor() {
         super({
             id: DELETE_CELL_COMMAND_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/editActions',
-                'notebookActions.deleteCell',
-                "Delete Cell"
-            )),
+            title: ( localizeWithPath(_moduleId, 2, "Delete Cell")),
             keybinding: {
                 primary: 20 ,
                 mac: {
                     primary: 2048  | 1
                 },
-                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),
+                when: ( (ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey)))),
                 weight: 200
             },
             menu: [
@@ -157,25 +164,13 @@ registerAction2(class DeleteCellAction extends NotebookCellAction {
         const configService = accessor.get(IConfigurationService);
         if (runState === NotebookCellExecutionState.Executing && configService.getValue(NotebookSetting.confirmDeleteRunningCell)) {
             const dialogService = accessor.get(IDialogService);
-            const primaryButton = ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/editActions',
-                'confirmDeleteButton',
-                "Delete"
-            ));
+            const primaryButton = ( localizeWithPath(_moduleId, 3, "Delete"));
             confirmation = await dialogService.confirm({
                 type: 'question',
-                message: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/controller/editActions',
-                    'confirmDeleteButtonMessage',
-                    "This cell is running, are you sure you want to delete it?"
-                )),
+                message: ( localizeWithPath(_moduleId, 4, "This cell is running, are you sure you want to delete it?")),
                 primaryButton: primaryButton,
                 checkbox: {
-                    label: ( localizeWithPath(
-                        'vs/workbench/contrib/notebook/browser/controller/editActions',
-                        'doNotAskAgain',
-                        "Do not ask me again"
-                    ))
+                    label: ( localizeWithPath(_moduleId, 5, "Do not ask me again"))
                 }
             });
         }
@@ -195,35 +190,38 @@ registerAction2(class ClearCellOutputsAction extends NotebookCellAction {
     constructor() {
         super({
             id: CLEAR_CELL_OUTPUTS_COMMAND_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/editActions',
-                'clearCellOutputs',
-                'Clear Cell Outputs'
-            )),
+            title: ( localizeWithPath(_moduleId, 6, 'Clear Cell Outputs')),
             menu: [
                 {
                     id: MenuId.NotebookCellTitle,
-                    when: ( ContextKeyExpr.and(( NOTEBOOK_CELL_TYPE.isEqualTo('code')), executeNotebookCondition, NOTEBOOK_CELL_HAS_OUTPUTS, NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_CELL_EDITABLE, ( NOTEBOOK_USE_CONSOLIDATED_OUTPUT_BUTTON.toNegated()))),
+                    when: ( (ContextKeyExpr.and(
+                         (NOTEBOOK_CELL_TYPE.isEqualTo('code')),
+                        executeNotebookCondition,
+                        NOTEBOOK_CELL_HAS_OUTPUTS,
+                        NOTEBOOK_EDITOR_EDITABLE,
+                        NOTEBOOK_CELL_EDITABLE,
+                         (NOTEBOOK_USE_CONSOLIDATED_OUTPUT_BUTTON.toNegated())
+                    ))),
                     order: 5 ,
                     group: CELL_TITLE_OUTPUT_GROUP_ID
                 },
                 {
                     id: MenuId.NotebookOutputToolbar,
-                    when: ( ContextKeyExpr.and(
+                    when: ( (ContextKeyExpr.and(
                         NOTEBOOK_CELL_HAS_OUTPUTS,
                         NOTEBOOK_EDITOR_EDITABLE,
                         NOTEBOOK_CELL_EDITABLE
-                    ))
+                    )))
                 },
             ],
             keybinding: {
-                when: ( ContextKeyExpr.and(
+                when: ( (ContextKeyExpr.and(
                     NOTEBOOK_EDITOR_FOCUSED,
                     ContextKeyExpr.not(InputFocusedContextKey),
                     NOTEBOOK_CELL_HAS_OUTPUTS,
                     NOTEBOOK_EDITOR_EDITABLE,
                     NOTEBOOK_CELL_EDITABLE
-                )),
+                ))),
                 primary: 512  | 20 ,
                 weight: 200
             },
@@ -261,22 +259,24 @@ registerAction2(class ClearAllCellOutputsAction extends NotebookAction {
     constructor() {
         super({
             id: CLEAR_ALL_CELLS_OUTPUTS_COMMAND_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/editActions',
-                'clearAllCellsOutputs',
-                'Clear All Outputs'
-            )),
+            title: ( localizeWithPath(_moduleId, 7, 'Clear All Outputs')),
             precondition: NOTEBOOK_HAS_OUTPUTS,
             menu: [
                 {
                     id: MenuId.EditorTitle,
-                    when: ( ContextKeyExpr.and(NOTEBOOK_IS_ACTIVE_EDITOR, ( ContextKeyExpr.notEquals('config.notebook.globalToolbar', true)))),
+                    when: ( (ContextKeyExpr.and(
+                        NOTEBOOK_IS_ACTIVE_EDITOR,
+                         (ContextKeyExpr.notEquals('config.notebook.globalToolbar', true))
+                    ))),
                     group: 'navigation',
                     order: 0
                 },
                 {
                     id: MenuId.NotebookToolbar,
-                    when: ( ContextKeyExpr.and(executeNotebookCondition, ( ContextKeyExpr.equals('config.notebook.globalToolbar', true)))),
+                    when: ( (ContextKeyExpr.and(
+                        executeNotebookCondition,
+                         (ContextKeyExpr.equals('config.notebook.globalToolbar', true))
+                    ))),
                     group: 'navigation/execute',
                     order: 10
                 }
@@ -291,10 +291,10 @@ registerAction2(class ClearAllCellOutputsAction extends NotebookAction {
             return;
         }
         const computeUndoRedo = !editor.isReadOnly;
-        editor.textModel.applyEdits(( editor.textModel.cells.map((cell, index) => ({
+        editor.textModel.applyEdits(( (editor.textModel.cells.map((cell, index) => ({
             editType: 2 , index, outputs: []
-        }))), true, undefined, () => undefined, undefined, computeUndoRedo);
-        const clearExecutionMetadataEdits = ( editor.textModel.cells.map((cell, index) => {
+        })))), true, undefined, () => undefined, undefined, computeUndoRedo);
+        const clearExecutionMetadataEdits = ( (editor.textModel.cells.map((cell, index) => {
             const runState = notebookExecutionStateService.getCellExecution(cell.uri)?.state;
             if (runState !== NotebookCellExecutionState.Executing) {
                 return {
@@ -310,7 +310,7 @@ registerAction2(class ClearAllCellOutputsAction extends NotebookAction {
             else {
                 return undefined;
             }
-        })).filter(edit => !!edit);
+        }))).filter(edit => !!edit);
         if (clearExecutionMetadataEdits.length) {
             context.notebookEditor.textModel.applyEdits(clearExecutionMetadataEdits, true, undefined, () => undefined, undefined, computeUndoRedo);
         }
@@ -320,17 +320,9 @@ registerAction2(class ChangeCellLanguageAction extends NotebookCellAction {
     constructor() {
         super({
             id: CHANGE_CELL_LANGUAGE,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/editActions',
-                'changeLanguage',
-                'Change Cell Language'
-            )),
+            title: ( localizeWithPath(_moduleId, 8, 'Change Cell Language')),
             metadata: {
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/controller/editActions',
-                    'changeLanguage',
-                    'Change Cell Language'
-                )),
+                description: ( localizeWithPath(_moduleId, 8, 'Change Cell Language')),
                 args: [
                     {
                         name: 'range',
@@ -396,27 +388,17 @@ registerAction2(class ChangeCellLanguageAction extends NotebookCellAction {
             const allSupportedLanguages = matchResult.all.flatMap(kernel => kernel.supportedLanguages);
             languages = allSupportedLanguages.length > 0 ? allSupportedLanguages : languageService.getRegisteredLanguageIds();
         }
-        const providerLanguages = ( new Set([
+        const providerLanguages = ( (new Set([
             ...languages,
             'markdown'
-        ]));
+        ])));
         providerLanguages.forEach(languageId => {
             let description;
             if (context.cell.cellKind === CellKind.Markup ? (languageId === 'markdown') : (languageId === context.cell.language)) {
-                description = ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/controller/editActions',
-                    'languageDescription',
-                    "({0}) - Current Language",
-                    languageId
-                ));
+                description = ( localizeWithPath(_moduleId, 9, "({0}) - Current Language", languageId));
             }
             else {
-                description = ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/controller/editActions',
-                    'languageDescriptionConfigured',
-                    "({0})",
-                    languageId
-                ));
+                description = ( localizeWithPath(_moduleId, 10, "({0})", languageId));
             }
             const languageName = languageService.getLanguageName(languageId);
             if (!languageName) {
@@ -439,28 +421,16 @@ registerAction2(class ChangeCellLanguageAction extends NotebookCellAction {
             return a.description.localeCompare(b.description);
         });
         const autoDetectMode = {
-            label: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/editActions',
-                'autoDetect',
-                "Auto Detect"
-            ))
+            label: ( localizeWithPath(_moduleId, 11, "Auto Detect"))
         };
         const picks = [
             autoDetectMode,
-            { type: 'separator', label: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/editActions',
-                'languagesPicks',
-                "languages (identifier)"
-            )) },
+            { type: 'separator', label: ( localizeWithPath(_moduleId, 12, "languages (identifier)")) },
             ...topItems,
             { type: 'separator' },
             ...mainItems
         ];
-        const selection = await quickInputService.pick(picks, { placeHolder: ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/controller/editActions',
-            'pickLanguageToConfigure',
-            "Select Language Mode"
-        )) });
+        const selection = await quickInputService.pick(picks, { placeHolder: ( localizeWithPath(_moduleId, 13, "Select Language Mode")) });
         const languageId = selection === autoDetectMode
             ? await languageDetectionService.detectLanguage(context.cell.uri)
             : selection?.languageId;
@@ -493,13 +463,9 @@ registerAction2(class DetectCellLanguageAction extends NotebookCellAction {
     constructor() {
         super({
             id: DETECT_CELL_LANGUAGE,
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/notebook/browser/controller/editActions',
-                'detectLanguage',
-                "Accept Detected Language for Cell"
-            )),
+            title: ( localize2WithPath(_moduleId, 14, "Accept Detected Language for Cell")),
             f1: true,
-            precondition: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_CELL_EDITABLE)),
+            precondition: ( (ContextKeyExpr.and(NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_CELL_EDITABLE))),
             keybinding: { primary: 34  | 512  | 1024 , weight: 200  }
         });
     }
@@ -515,11 +481,7 @@ registerAction2(class DetectCellLanguageAction extends NotebookCellAction {
             setCellToLanguage(detection, context);
         }
         else {
-            notificationService.warn(( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/editActions',
-                'noDetection',
-                "Unable to detect cell language"
-            )));
+            notificationService.warn(( localizeWithPath(_moduleId, 15, "Unable to detect cell language")));
         }
     }
 });
@@ -544,17 +506,13 @@ registerAction2(class SelectNotebookIndentation extends NotebookAction {
     constructor() {
         super({
             id: SELECT_NOTEBOOK_INDENTATION_ID,
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/notebook/browser/controller/editActions',
-                'selectNotebookIndentation',
-                'Select Indentation'
-            )),
+            title: ( localize2WithPath(_moduleId, 16, 'Select Indentation')),
             f1: true,
-            precondition: ( ContextKeyExpr.and(
+            precondition: ( (ContextKeyExpr.and(
                 NOTEBOOK_IS_ACTIVE_EDITOR,
                 NOTEBOOK_EDITOR_EDITABLE,
                 NOTEBOOK_CELL_EDITABLE
-            )),
+            ))),
         });
     }
     async runWithContext(accessor, context) {
@@ -566,54 +524,34 @@ registerAction2(class SelectNotebookIndentation extends NotebookAction {
         const instantiationService = accessor.get(IInstantiationService);
         const activeNotebook = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
         if (!activeNotebook || activeNotebook.isDisposed) {
-            return quickInputService.pick([{ label: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/editActions',
-                'noNotebookEditor',
-                "No notebook editor active at this time"
-            )) }]);
+            return quickInputService.pick([{ label: ( localizeWithPath(_moduleId, 17, "No notebook editor active at this time")) }]);
         }
         if (activeNotebook.isReadOnly) {
-            return quickInputService.pick([{ label: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/editActions',
-                'noWritableCodeEditor',
-                "The active notebook editor is read-only."
-            )) }]);
+            return quickInputService.pick([{ label: ( localizeWithPath(_moduleId, 18, "The active notebook editor is read-only.")) }]);
         }
-        const picks = ( [
+        const picks = ( ([
             (
-            new NotebookIndentUsingTabs()),
+            (new NotebookIndentUsingTabs())),
             (
-            new NotebookIndentUsingSpaces()),
+            (new NotebookIndentUsingSpaces())),
             (
-            new NotebookChangeTabDisplaySize()),
+            (new NotebookChangeTabDisplaySize())),
             (
-            new NotebookIndentationToTabsAction()),
+            (new NotebookIndentationToTabsAction())),
             (
-            new NotebookIndentationToSpacesAction())
+            (new NotebookIndentationToSpacesAction()))
         ].map(item => {
             return {
                 id: item.desc.id,
-                label: ( item.desc.title.toString()),
+                label: ( (item.desc.title.toString())),
                 run: () => {
                     instantiationService.invokeFunction(item.run);
                 }
             };
-        }));
-        picks.splice(3, 0, { type: 'separator', label: ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/controller/editActions',
-            'indentConvert',
-            "convert file"
-        )) });
-        picks.unshift({ type: 'separator', label: ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/controller/editActions',
-            'indentView',
-            "change view"
-        )) });
-        const action = await quickInputService.pick(picks, { placeHolder: ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/controller/editActions',
-            'pickAction',
-            "Select Action"
-        )), matchOnDetail: true });
+        })));
+        picks.splice(3, 0, { type: 'separator', label: ( localizeWithPath(_moduleId, 19, "convert file")) });
+        picks.unshift({ type: 'separator', label: ( localizeWithPath(_moduleId, 20, "change view")) });
+        const action = await quickInputService.pick(picks, { placeHolder: ( localizeWithPath(_moduleId, 21, "Select Action")), matchOnDetail: true });
         if (!action) {
             return;
         }

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/foldingController.js

@@ -10,13 +10,14 @@ import { InputFocusedContextKey } from '../../../../../platform/contextkey/commo
 import { IEditorService } from '../../../../services/editor/common/editorService.service.js';
 import { NOTEBOOK_ACTIONS_CATEGORY } from './coreActions.js';
 import { localize2WithPath, localizeWithPath } from '../../../../../nls.js';
+const _moduleId = "vs/workbench/contrib/notebook/browser/controller/foldingController";
 class FoldingController extends Disposable {
     static { this.id = 'workbench.notebook.foldingController'; }
     constructor(_notebookEditor) {
         super();
         this._notebookEditor = _notebookEditor;
         this._foldingModel = null;
-        this._localStore = this._register(( new DisposableStore()));
+        this._localStore = this._register(( (new DisposableStore())));
         this._register(this._notebookEditor.onMouseUp(e => { this.onMouseUp(e); }));
         this._register(this._notebookEditor.onDidChangeModel(() => {
             this._localStore.clear();
@@ -28,7 +29,7 @@ class FoldingController extends Disposable {
                     this._foldingModel?.recompute();
                 }
             }));
-            this._foldingModel = ( new FoldingModel());
+            this._foldingModel = ( (new FoldingModel()));
             this._localStore.add(this._foldingModel);
             this._foldingModel.attachViewModel(this._notebookEditor.getViewModel());
             this._localStore.add(this._foldingModel.onDidFoldingRegionChanged(() => {
@@ -106,16 +107,8 @@ class FoldingController extends Disposable {
     }
 }
 registerNotebookContribution(FoldingController.id, FoldingController);
-const NOTEBOOK_FOLD_COMMAND_LABEL = ( localizeWithPath(
-    'vs/workbench/contrib/notebook/browser/controller/foldingController',
-    'fold.cell',
-    "Fold Cell"
-));
-const NOTEBOOK_UNFOLD_COMMAND_LABEL = ( localize2WithPath(
-    'vs/workbench/contrib/notebook/browser/controller/foldingController',
-    'unfold.cell',
-    "Unfold Cell"
-));
+const NOTEBOOK_FOLD_COMMAND_LABEL = ( localizeWithPath(_moduleId, 0, "Fold Cell"));
+const NOTEBOOK_UNFOLD_COMMAND_LABEL = ( localize2WithPath(_moduleId, 1, "Unfold Cell"));
 const FOLDING_COMMAND_ARGS = {
     args: [{
             isOptional: true,
@@ -145,14 +138,10 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'notebook.fold',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/notebook/browser/controller/foldingController',
-                'fold.cell',
-                "Fold Cell"
-            )),
+            title: ( localize2WithPath(_moduleId, 0, "Fold Cell")),
             category: NOTEBOOK_ACTIONS_CATEGORY,
             keybinding: {
-                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),
+                when: ( (ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey)))),
                 primary: 2048  | 1024  | 92 ,
                 mac: {
                     primary: 2048  | 512  | 92 ,
@@ -215,7 +204,7 @@ registerAction2(class extends Action2 {
             title: NOTEBOOK_UNFOLD_COMMAND_LABEL,
             category: NOTEBOOK_ACTIONS_CATEGORY,
             keybinding: {
-                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),
+                when: ( (ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey)))),
                 primary: 2048  | 1024  | 94 ,
                 mac: {
                     primary: 2048  | 512  | 94 ,