@codingame/monaco-vscode-notebook-service-override 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants.js

@@ -46,7 +46,14 @@ class NotebookSaveParticipant {
     }
 }
 let FormatOnSaveParticipant = class FormatOnSaveParticipant {
-    constructor(editorWorkerService, languageFeaturesService, instantiationService, textModelService, bulkEditService, configurationService) {
+    constructor(
+        editorWorkerService,
+        languageFeaturesService,
+        instantiationService,
+        textModelService,
+        bulkEditService,
+        configurationService
+    ) {
         this.editorWorkerService = editorWorkerService;
         this.languageFeaturesService = languageFeaturesService;
         this.instantiationService = instantiationService;
@@ -65,17 +72,30 @@ let FormatOnSaveParticipant = class FormatOnSaveParticipant {
         if (!enabled) {
             return undefined;
         }
-        progress.report({ message: ( localize(9335, "Formatting")) });
+        progress.report({
+            message: ( localize(9655, "Formatting"))
+        });
         const notebook = workingCopy.model.notebookModel;
-        const formatApplied = await this.instantiationService.invokeFunction(CodeActionParticipantUtils.checkAndRunFormatCodeAction, notebook, progress, token);
+        const formatApplied = await this.instantiationService.invokeFunction(
+            CodeActionParticipantUtils.checkAndRunFormatCodeAction,
+            notebook,
+            progress,
+            token
+        );
         const disposable = ( new DisposableStore());
         try {
             if (!formatApplied) {
-                const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+                const allCellEdits = await Promise.all(( notebook.cells.map(async cell => {
                     const ref = await this.textModelService.createModelReference(cell.uri);
                     disposable.add(ref);
                     const model = ref.object.textEditorModel;
-                    const formatEdits = await getDocumentFormattingEditsWithSelectedProvider(this.editorWorkerService, this.languageFeaturesService, model, FormattingMode.Silent, token);
+                    const formatEdits = await getDocumentFormattingEditsWithSelectedProvider(
+                        this.editorWorkerService,
+                        this.languageFeaturesService,
+                        model,
+                        FormattingMode.Silent,
+                        token
+                    );
                     const edits = [];
                     if (formatEdits) {
                         edits.push(...( formatEdits.map(edit => ( new ResourceTextEdit(model.uri, edit, model.getVersionId())))));
@@ -83,23 +103,20 @@ let FormatOnSaveParticipant = class FormatOnSaveParticipant {
                     }
                     return [];
                 })));
-                await this.bulkEditService.apply( allCellEdits.flat(), { label: ( localize(9336, "Format Notebook")), code: 'undoredo.formatNotebook', });
+                await this.bulkEditService.apply( allCellEdits.flat(), {
+                    label: ( localize(9656, "Format Notebook")),
+                    code: "undoredo.formatNotebook"
+                });
             }
-        }
-        finally {
-            progress.report({ increment: 100 });
+        } finally {
+            progress.report({
+                increment: 100
+            });
             disposable.dispose();
         }
     }
 };
-FormatOnSaveParticipant = ( __decorate([
-    ( __param(0, IEditorWorkerService)),
-    ( __param(1, ILanguageFeaturesService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, ITextModelService)),
-    ( __param(4, IBulkEditService)),
-    ( __param(5, IConfigurationService))
-], FormatOnSaveParticipant));
+FormatOnSaveParticipant = ( __decorate([( __param(0, IEditorWorkerService)), ( __param(1, ILanguageFeaturesService)), ( __param(2, IInstantiationService)), ( __param(3, ITextModelService)), ( __param(4, IBulkEditService)), ( __param(5, IConfigurationService))], FormatOnSaveParticipant));
 let TrimWhitespaceParticipant = class TrimWhitespaceParticipant extends NotebookSaveParticipant {
     constructor(configurationService, editorService, textModelService, bulkEditService) {
         super(editorService);
@@ -109,10 +126,15 @@ let TrimWhitespaceParticipant = class TrimWhitespaceParticipant extends Notebook
         this.bulkEditService = bulkEditService;
     }
     async participate(workingCopy, context, progress, _token) {
-        const trimTrailingWhitespaceOption = this.configurationService.getValue('files.trimTrailingWhitespace');
-        const trimInRegexAndStrings = this.configurationService.getValue('files.trimTrailingWhitespaceInRegexAndStrings');
+        const trimTrailingWhitespaceOption = this.configurationService.getValue("files.trimTrailingWhitespace");
+        const trimInRegexAndStrings = this.configurationService.getValue("files.trimTrailingWhitespaceInRegexAndStrings");
         if (trimTrailingWhitespaceOption && this.canParticipate()) {
-            await this.doTrimTrailingWhitespace(workingCopy, context.reason === SaveReason.AUTO, trimInRegexAndStrings, progress);
+            await this.doTrimTrailingWhitespace(
+                workingCopy,
+                context.reason === SaveReason.AUTO,
+                trimInRegexAndStrings,
+                progress
+            );
         }
     }
     async doTrimTrailingWhitespace(workingCopy, isAutoSaved, trimInRegexesAndStrings, progress) {
@@ -125,7 +147,7 @@ let TrimWhitespaceParticipant = class TrimWhitespaceParticipant extends Notebook
         let cursors = [];
         let prevSelection = [];
         try {
-            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+            const allCellEdits = await Promise.all(( notebook.cells.map(async cell => {
                 if (cell.cellKind !== CellKind.Code) {
                     return [];
                 }
@@ -149,23 +171,25 @@ let TrimWhitespaceParticipant = class TrimWhitespaceParticipant extends Notebook
                 if (!ops.length) {
                     return [];
                 }
-                return ( ops.map(op => ( new ResourceTextEdit(model.uri, { ...op, text: op.text || '' }, model.getVersionId()))));
+                return ( ops.map(op => ( new ResourceTextEdit(model.uri, {
+                    ...op,
+                    text: op.text || ""
+                }, model.getVersionId()))));
             })));
             const filteredEdits = allCellEdits.flat().filter(edit => edit !== undefined);
-            await this.bulkEditService.apply(filteredEdits, { label: ( localize(9337, "Notebook Trim Trailing Whitespace")), code: 'undoredo.notebookTrimTrailingWhitespace' });
-        }
-        finally {
-            progress.report({ increment: 100 });
+            await this.bulkEditService.apply(filteredEdits, {
+                label: ( localize(9657, "Notebook Trim Trailing Whitespace")),
+                code: "undoredo.notebookTrimTrailingWhitespace"
+            });
+        } finally {
+            progress.report({
+                increment: 100
+            });
             disposable.dispose();
         }
     }
 };
-TrimWhitespaceParticipant = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IEditorService)),
-    ( __param(2, ITextModelService)),
-    ( __param(3, IBulkEditService))
-], TrimWhitespaceParticipant));
+TrimWhitespaceParticipant = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IEditorService)), ( __param(2, ITextModelService)), ( __param(3, IBulkEditService))], TrimWhitespaceParticipant));
 let TrimFinalNewLinesParticipant = class TrimFinalNewLinesParticipant extends NotebookSaveParticipant {
     constructor(configurationService, editorService, bulkEditService) {
         super(editorService);
@@ -174,7 +198,7 @@ let TrimFinalNewLinesParticipant = class TrimFinalNewLinesParticipant extends No
         this.bulkEditService = bulkEditService;
     }
     async participate(workingCopy, context, progress, _token) {
-        if (this.configurationService.getValue('files.trimFinalNewlines') && this.canParticipate()) {
+        if (this.configurationService.getValue("files.trimFinalNewlines") && this.canParticipate()) {
             await this.doTrimFinalNewLines(workingCopy, context.reason === SaveReason.AUTO, progress);
         }
     }
@@ -195,7 +219,7 @@ let TrimFinalNewLinesParticipant = class TrimFinalNewLinesParticipant extends No
         const notebook = workingCopy.model.notebookModel;
         const activeCellEditor = getActiveCellCodeEditor(this.editorService);
         try {
-            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+            const allCellEdits = await Promise.all(( notebook.cells.map(async cell => {
                 if (cell.cellKind !== CellKind.Code) {
                     return;
                 }
@@ -222,26 +246,25 @@ let TrimFinalNewLinesParticipant = class TrimFinalNewLinesParticipant extends No
                 if (deletionRange.isEmpty()) {
                     return;
                 }
-                return ( new ResourceTextEdit(
-                    cell.uri,
-                    { range: deletionRange, text: '' },
-                    cell.textModel?.getVersionId()
-                ));
+                return ( new ResourceTextEdit(cell.uri, {
+                    range: deletionRange,
+                    text: ""
+                }, cell.textModel?.getVersionId()));
             })));
             const filteredEdits = allCellEdits.flat().filter(edit => edit !== undefined);
-            await this.bulkEditService.apply(filteredEdits, { label: ( localize(9338, "Trim Final New Lines")), code: 'undoredo.trimFinalNewLines' });
-        }
-        finally {
-            progress.report({ increment: 100 });
+            await this.bulkEditService.apply(filteredEdits, {
+                label: ( localize(9658, "Trim Final New Lines")),
+                code: "undoredo.trimFinalNewLines"
+            });
+        } finally {
+            progress.report({
+                increment: 100
+            });
             disposable.dispose();
         }
     }
 };
-TrimFinalNewLinesParticipant = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IEditorService)),
-    ( __param(2, IBulkEditService))
-], TrimFinalNewLinesParticipant));
+TrimFinalNewLinesParticipant = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IEditorService)), ( __param(2, IBulkEditService))], TrimFinalNewLinesParticipant));
 let InsertFinalNewLineParticipant = class InsertFinalNewLineParticipant extends NotebookSaveParticipant {
     constructor(configurationService, bulkEditService, editorService) {
         super(editorService);
@@ -266,7 +289,7 @@ let InsertFinalNewLineParticipant = class InsertFinalNewLineParticipant extends
             selections = activeCellEditor.getSelections() ?? [];
         }
         try {
-            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+            const allCellEdits = await Promise.all(( notebook.cells.map(async cell => {
                 if (cell.cellKind !== CellKind.Code) {
                     return;
                 }
@@ -275,32 +298,41 @@ let InsertFinalNewLineParticipant = class InsertFinalNewLineParticipant extends
                 if (!lineCount || lastLineIsEmptyOrWhitespace) {
                     return;
                 }
-                return ( new ResourceTextEdit(cell.uri, { range: ( new Range(
-                    lineCount + 1,
-                    cell.textBuffer.getLineLength(lineCount),
-                    lineCount + 1,
-                    cell.textBuffer.getLineLength(lineCount)
-                )), text: cell.textBuffer.getEOL() }, cell.textModel?.getVersionId()));
+                return ( new ResourceTextEdit(cell.uri, {
+                    range: ( new Range(
+                        lineCount + 1,
+                        cell.textBuffer.getLineLength(lineCount),
+                        lineCount + 1,
+                        cell.textBuffer.getLineLength(lineCount)
+                    )),
+                    text: cell.textBuffer.getEOL()
+                }, cell.textModel?.getVersionId()));
             })));
             const filteredEdits = allCellEdits.filter(edit => edit !== undefined);
-            await this.bulkEditService.apply(filteredEdits, { label: ( localize(9339, "Insert Final New Line")), code: 'undoredo.insertFinalNewLine' });
+            await this.bulkEditService.apply(filteredEdits, {
+                label: ( localize(9659, "Insert Final New Line")),
+                code: "undoredo.insertFinalNewLine"
+            });
             if (activeCellEditor && selections) {
                 activeCellEditor.setSelections(selections);
             }
-        }
-        finally {
-            progress.report({ increment: 100 });
+        } finally {
+            progress.report({
+                increment: 100
+            });
             disposable.dispose();
         }
     }
 };
-InsertFinalNewLineParticipant = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IBulkEditService)),
-    ( __param(2, IEditorService))
-], InsertFinalNewLineParticipant));
+InsertFinalNewLineParticipant = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IBulkEditService)), ( __param(2, IEditorService))], InsertFinalNewLineParticipant));
 let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
-    constructor(configurationService, logService, workspaceTrustManagementService, textModelService, instantiationService) {
+    constructor(
+        configurationService,
+        logService,
+        workspaceTrustManagementService,
+        textModelService,
+        instantiationService
+    ) {
         this.configurationService = configurationService;
         this.logService = logService;
         this.workspaceTrustManagementService = workspaceTrustManagementService;
@@ -315,43 +347,46 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
         if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
             return;
         }
-        let saveTrigger = '';
+        let saveTrigger = "";
         if (context.reason === SaveReason.AUTO) {
             return undefined;
-        }
-        else if (context.reason === SaveReason.EXPLICIT) {
-            saveTrigger = 'explicit';
-        }
-        else {
+        } else if (context.reason === SaveReason.EXPLICIT) {
+            saveTrigger = "explicit";
+        } else {
             return undefined;
         }
         const notebookModel = workingCopy.model.notebookModel;
         const setting = this.configurationService.getValue(NotebookSetting.codeActionsOnSave);
-        const settingItems = Array.isArray(setting)
-            ? setting
-            : ( Object.keys(setting)).filter(x => setting[x]);
+        const settingItems = Array.isArray(setting) ? setting : ( Object.keys(setting)).filter(x => setting[x]);
         const allCodeActions = this.createCodeActionsOnSave(settingItems);
-        const excludedActions = allCodeActions
-            .filter(x => setting[x.value] === 'never' || setting[x.value] === false);
-        const includedActions = allCodeActions
-            .filter(x => setting[x.value] === saveTrigger || setting[x.value] === true);
+        const excludedActions = allCodeActions.filter(x => setting[x.value] === "never" || setting[x.value] === false);
+        const includedActions = allCodeActions.filter(x => setting[x.value] === saveTrigger || setting[x.value] === true);
         const editorCodeActionsOnSave = includedActions.filter(x => !CodeActionKind.Notebook.contains(x));
         const notebookCodeActionsOnSave = includedActions.filter(x => CodeActionKind.Notebook.contains(x));
         if (notebookCodeActionsOnSave.length) {
             const nbDisposable = ( new DisposableStore());
-            progress.report({ message: ( localize(9340, "Running 'Notebook' code actions")) });
+            progress.report({
+                message: ( localize(9660, "Running 'Notebook' code actions"))
+            });
             try {
                 const cell = notebookModel.cells[0];
                 const ref = await this.textModelService.createModelReference(cell.uri);
                 nbDisposable.add(ref);
                 const textEditorModel = ref.object.textEditorModel;
-                await this.instantiationService.invokeFunction(CodeActionParticipantUtils.applyOnSaveGenericCodeActions, textEditorModel, notebookCodeActionsOnSave, excludedActions, progress, token);
-            }
-            catch {
-                this.logService.error('Failed to apply notebook code action on save');
-            }
-            finally {
-                progress.report({ increment: 100 });
+                await this.instantiationService.invokeFunction(
+                    CodeActionParticipantUtils.applyOnSaveGenericCodeActions,
+                    textEditorModel,
+                    notebookCodeActionsOnSave,
+                    excludedActions,
+                    progress,
+                    token
+                );
+            } catch {
+                this.logService.error("Failed to apply notebook code action on save");
+            } finally {
+                progress.report({
+                    increment: 100
+                });
                 nbDisposable.dispose();
             }
         }
@@ -371,20 +406,29 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
                 });
             }
             const cellDisposable = ( new DisposableStore());
-            progress.report({ message: ( localize(9341, "Running 'Cell' code actions")) });
+            progress.report({
+                message: ( localize(9661, "Running 'Cell' code actions"))
+            });
             try {
-                await Promise.all(( notebookModel.cells.map(async (cell) => {
+                await Promise.all(( notebookModel.cells.map(async cell => {
                     const ref = await this.textModelService.createModelReference(cell.uri);
                     cellDisposable.add(ref);
                     const textEditorModel = ref.object.textEditorModel;
-                    await this.instantiationService.invokeFunction(CodeActionParticipantUtils.applyOnSaveGenericCodeActions, textEditorModel, editorCodeActionsOnSave, excludedActions, progress, token);
+                    await this.instantiationService.invokeFunction(
+                        CodeActionParticipantUtils.applyOnSaveGenericCodeActions,
+                        textEditorModel,
+                        editorCodeActionsOnSave,
+                        excludedActions,
+                        progress,
+                        token
+                    );
                 })));
-            }
-            catch {
-                this.logService.error('Failed to apply code action on save');
-            }
-            finally {
-                progress.report({ increment: 100 });
+            } catch {
+                this.logService.error("Failed to apply code action on save");
+            } finally {
+                progress.report({
+                    increment: 100
+                });
                 cellDisposable.dispose();
             }
         }
@@ -396,13 +440,7 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
         });
     }
 };
-CodeActionOnSaveParticipant = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, ILogService)),
-    ( __param(2, IWorkspaceTrustManagementService)),
-    ( __param(3, ITextModelService)),
-    ( __param(4, IInstantiationService))
-], CodeActionOnSaveParticipant));
+CodeActionOnSaveParticipant = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, ILogService)), ( __param(2, IWorkspaceTrustManagementService)), ( __param(3, ITextModelService)), ( __param(4, IInstantiationService))], CodeActionOnSaveParticipant));
 class CodeActionParticipantUtils {
     static async checkAndRunFormatCodeAction(accessor, notebookModel, progress, token) {
         const instantiationService = accessor.get(IInstantiationService);
@@ -411,20 +449,30 @@ class CodeActionParticipantUtils {
         const configurationService = accessor.get(IConfigurationService);
         const formatDisposable = ( new DisposableStore());
         let formatResult = false;
-        progress.report({ message: ( localize(9342, "Running 'Format' code actions")) });
+        progress.report({
+            message: ( localize(9662, "Running 'Format' code actions"))
+        });
         try {
             const cell = notebookModel.cells[0];
             const ref = await textModelService.createModelReference(cell.uri);
             formatDisposable.add(ref);
             const textEditorModel = ref.object.textEditorModel;
             const defaultFormatterExtId = configurationService.getValue(NotebookSetting.defaultFormatter);
-            formatResult = await instantiationService.invokeFunction(CodeActionParticipantUtils.applyOnSaveFormatCodeAction, textEditorModel, ( new HierarchicalKind('notebook.format')), [], defaultFormatterExtId, progress, token);
-        }
-        catch {
-            logService.error('Failed to apply notebook format action on save');
-        }
-        finally {
-            progress.report({ increment: 100 });
+            formatResult = await instantiationService.invokeFunction(
+                CodeActionParticipantUtils.applyOnSaveFormatCodeAction,
+                textEditorModel,
+                ( new HierarchicalKind("notebook.format")),
+                [],
+                defaultFormatterExtId,
+                progress,
+                token
+            );
+        } catch {
+            logService.error("Failed to apply notebook format action on save");
+        } finally {
+            progress.report({
+                increment: 100
+            });
             formatDisposable.dispose();
         }
         return formatResult;
@@ -440,10 +488,10 @@ class CodeActionParticipantUtils {
             _report() {
                 progress.report({
                     message: ( localize(
-                        9343,
+                        9663,
                         "Getting code actions from '{0}' ([configure]({1})).",
-                        ( [...this._names].map(name => `'${name}'`)).join(', '),
-                        'command:workbench.action.openSettings?%5B%22notebook.codeActionsOnSave%22%5D'
+                        ( [...this._names].map(name => `'${name}'`)).join(", "),
+                        "command:workbench.action.openSettings?%5B%22notebook.codeActionsOnSave%22%5D"
                     ))
                 });
             }
@@ -453,9 +501,16 @@ class CodeActionParticipantUtils {
                     this._report();
                 }
             }
-        });
+        })();
         for (const codeActionKind of codeActionsOnSave) {
-            const actionsToRun = await CodeActionParticipantUtils.getActionsToRun(model, codeActionKind, excludes, languageFeaturesService, getActionProgress, token);
+            const actionsToRun = await CodeActionParticipantUtils.getActionsToRun(
+                model,
+                codeActionKind,
+                excludes,
+                languageFeaturesService,
+                getActionProgress,
+                token
+            );
             if (token.isCancellationRequested) {
                 actionsToRun.dispose();
                 return;
@@ -464,37 +519,43 @@ class CodeActionParticipantUtils {
                 for (const action of actionsToRun.validActions) {
                     const codeActionEdits = action.action.edit?.edits;
                     let breakFlag = false;
-                    if (!action.action.kind?.startsWith('notebook')) {
+                    if (!action.action.kind?.startsWith("notebook")) {
                         for (const edit of codeActionEdits ?? []) {
                             const workspaceTextEdit = edit;
                             if (workspaceTextEdit.resource && isEqual(workspaceTextEdit.resource, model.uri)) {
                                 continue;
-                            }
-                            else {
+                            } else {
                                 breakFlag = true;
                                 break;
                             }
                         }
                     }
                     if (breakFlag) {
-                        logService.warn('Failed to apply code action on save, applied to multiple resources.');
+                        logService.warn("Failed to apply code action on save, applied to multiple resources.");
                         continue;
                     }
-                    progress.report({ message: ( localize(9344, "Applying code action '{0}'.", action.action.title)) });
+                    progress.report({
+                        message: ( localize(9664, "Applying code action '{0}'.", action.action.title))
+                    });
                     await instantiationService.invokeFunction(applyCodeAction, action, ApplyCodeActionReason.OnSave, {}, token);
                     if (token.isCancellationRequested) {
                         return;
                     }
                 }
-            }
-            catch {
-            }
-            finally {
+            } catch {} finally {
                 actionsToRun.dispose();
             }
         }
     }
-    static async applyOnSaveFormatCodeAction(accessor, model, formatCodeActionOnSave, excludes, extensionId, progress, token) {
+    static async applyOnSaveFormatCodeAction(
+        accessor,
+        model,
+        formatCodeActionOnSave,
+        excludes,
+        extensionId,
+        progress,
+        token
+    ) {
         const instantiationService = accessor.get(IInstantiationService);
         const languageFeaturesService = accessor.get(ILanguageFeaturesService);
         const logService = accessor.get(ILogService);
@@ -505,10 +566,10 @@ class CodeActionParticipantUtils {
             _report() {
                 progress.report({
                     message: ( localize(
-                        9343,
+                        9663,
                         "Getting code actions from '{0}' ([configure]({1})).",
-                        ( [...this._names].map(name => `'${name}'`)).join(', '),
-                        'command:workbench.action.openSettings?%5B%22notebook.defaultFormatter%22%5D'
+                        ( [...this._names].map(name => `'${name}'`)).join(", "),
+                        "command:workbench.action.openSettings?%5B%22notebook.defaultFormatter%22%5D"
                     ))
                 });
             }
@@ -518,10 +579,19 @@ class CodeActionParticipantUtils {
                     this._report();
                 }
             }
-        });
-        const providedActions = await CodeActionParticipantUtils.getActionsToRun(model, formatCodeActionOnSave, excludes, languageFeaturesService, getActionProgress, token);
+        })();
+        const providedActions = await CodeActionParticipantUtils.getActionsToRun(
+            model,
+            formatCodeActionOnSave,
+            excludes,
+            languageFeaturesService,
+            getActionProgress,
+            token
+        );
         if (providedActions.validActions.length > 1 && !extensionId) {
-            logService.warn('More than one format code action is provided, the 0th one will be used. A default can be specified via `notebook.defaultFormatter` in your settings.');
+            logService.warn(
+                "More than one format code action is provided, the 0th one will be used. A default can be specified via `notebook.defaultFormatter` in your settings."
+            );
         }
         if (token.isCancellationRequested) {
             providedActions.dispose();
@@ -532,27 +602,38 @@ class CodeActionParticipantUtils {
             if (!action) {
                 return false;
             }
-            progress.report({ message: ( localize(9344, "Applying code action '{0}'.", action.action.title)) });
+            progress.report({
+                message: ( localize(9664, "Applying code action '{0}'.", action.action.title))
+            });
             await instantiationService.invokeFunction(applyCodeAction, action, ApplyCodeActionReason.OnSave, {}, token);
             if (token.isCancellationRequested) {
                 return false;
             }
-        }
-        catch {
-            logService.error('Failed to apply notebook format code action on save');
+        } catch {
+            logService.error("Failed to apply notebook format code action on save");
             return false;
-        }
-        finally {
+        } finally {
             providedActions.dispose();
         }
         return true;
     }
     static getActionsToRun(model, codeActionKind, excludes, languageFeaturesService, progress, token) {
-        return getCodeActions(languageFeaturesService.codeActionProvider, model, model.getFullModelRange(), {
-            type: CodeActionTriggerType.Invoke,
-            triggerAction: CodeActionTriggerSource.OnSave,
-            filter: { include: codeActionKind, excludes: excludes, includeSourceActions: true },
-        }, progress, token);
+        return getCodeActions(
+            languageFeaturesService.codeActionProvider,
+            model,
+            model.getFullModelRange(),
+            {
+                type: CodeActionTriggerType.Invoke,
+                triggerAction: CodeActionTriggerSource.OnSave,
+                filter: {
+                    include: codeActionKind,
+                    excludes: excludes,
+                    includeSourceActions: true
+                }
+            },
+            progress,
+            token
+        );
     }
 }
 function getActiveCellCodeEditor(editorService) {
@@ -569,17 +650,24 @@ let SaveParticipantsContribution = class SaveParticipantsContribution extends Di
         this.registerSaveParticipants();
     }
     registerSaveParticipants() {
-        this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(TrimWhitespaceParticipant)));
-        this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(CodeActionOnSaveParticipant)));
-        this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(FormatOnSaveParticipant)));
-        this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(InsertFinalNewLineParticipant)));
-        this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(TrimFinalNewLinesParticipant)));
+        this._register(
+            this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(TrimWhitespaceParticipant))
+        );
+        this._register(
+            this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(CodeActionOnSaveParticipant))
+        );
+        this._register(
+            this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(FormatOnSaveParticipant))
+        );
+        this._register(
+            this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(InsertFinalNewLineParticipant))
+        );
+        this._register(
+            this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(TrimFinalNewLinesParticipant))
+        );
     }
 };
-SaveParticipantsContribution = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IWorkingCopyFileService))
-], SaveParticipantsContribution));
+SaveParticipantsContribution = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IWorkingCopyFileService))], SaveParticipantsContribution));
 const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
 workbenchContributionsRegistry.registerWorkbenchContribution(SaveParticipantsContribution, LifecyclePhase.Restored);