@codingame/monaco-vscode-notebook-service-override 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/profile/notebookProfile.js

@@ -1,77 +0,0 @@
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { NotebookSetting } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-
-var NotebookProfileType;
-( (function(NotebookProfileType) {
-    NotebookProfileType["default"] = "default";
-    NotebookProfileType["jupyter"] = "jupyter";
-    NotebookProfileType["colab"] = "colab";
-})(NotebookProfileType || (NotebookProfileType = {})));
-const profiles = {
-    [NotebookProfileType.default]: {
-        [NotebookSetting.focusIndicator]: 'gutter',
-        [NotebookSetting.insertToolbarLocation]: 'both',
-        [NotebookSetting.globalToolbar]: true,
-        [NotebookSetting.cellToolbarLocation]: { default: 'right' },
-        [NotebookSetting.compactView]: true,
-        [NotebookSetting.showCellStatusBar]: 'visible',
-        [NotebookSetting.consolidatedRunButton]: true,
-        [NotebookSetting.undoRedoPerCell]: false
-    },
-    [NotebookProfileType.jupyter]: {
-        [NotebookSetting.focusIndicator]: 'gutter',
-        [NotebookSetting.insertToolbarLocation]: 'notebookToolbar',
-        [NotebookSetting.globalToolbar]: true,
-        [NotebookSetting.cellToolbarLocation]: { default: 'left' },
-        [NotebookSetting.compactView]: true,
-        [NotebookSetting.showCellStatusBar]: 'visible',
-        [NotebookSetting.consolidatedRunButton]: false,
-        [NotebookSetting.undoRedoPerCell]: true
-    },
-    [NotebookProfileType.colab]: {
-        [NotebookSetting.focusIndicator]: 'border',
-        [NotebookSetting.insertToolbarLocation]: 'betweenCells',
-        [NotebookSetting.globalToolbar]: false,
-        [NotebookSetting.cellToolbarLocation]: { default: 'right' },
-        [NotebookSetting.compactView]: false,
-        [NotebookSetting.showCellStatusBar]: 'hidden',
-        [NotebookSetting.consolidatedRunButton]: true,
-        [NotebookSetting.undoRedoPerCell]: false
-    }
-};
-async function applyProfile(configService, profile) {
-    const promises = [];
-    for (const settingKey in profile) {
-        promises.push(configService.updateValue(settingKey, profile[settingKey]));
-    }
-    await Promise.all(promises);
-}
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'notebook.setProfile',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/profile/notebookProfile',
-                'setProfileTitle',
-                "Set Profile"
-            ))
-        });
-    }
-    async run(accessor, args) {
-        if (!isSetProfileArgs(args)) {
-            return;
-        }
-        const configService = accessor.get(IConfigurationService);
-        return applyProfile(configService, profiles[args.profile]);
-    }
-});
-function isSetProfileArgs(args) {
-    const setProfileArgs = args;
-    return setProfileArgs.profile === NotebookProfileType.colab ||
-        setProfileArgs.profile === NotebookProfileType.default ||
-        setProfileArgs.profile === NotebookProfileType.jupyter;
-}
-
-export { NotebookProfileType };

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

@@ -1,517 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { HierarchicalKind } from 'vscode/vscode/vs/base/common/hierarchicalKind';
-import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { isEqual } from 'vscode/vscode/vs/base/common/resources';
-import { ResourceTextEdit, IBulkEditService } from 'vscode/vscode/vs/editor/browser/services/bulkEditService';
-import { trimTrailingWhitespace } from 'vscode/vscode/vs/editor/common/commands/trimTrailingWhitespaceCommand';
-import { Position } from 'vscode/vscode/vs/editor/common/core/position';
-import { Range } from 'vscode/vscode/vs/editor/common/core/range';
-import { IEditorWorkerService } from 'vscode/vscode/vs/editor/common/services/editorWorker';
-import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
-import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
-import { applyCodeAction, ApplyCodeActionReason, getCodeActions } from 'vscode/vscode/vs/editor/contrib/codeAction/browser/codeAction';
-import { CodeActionKind, CodeActionTriggerSource } from 'vscode/vscode/vs/editor/contrib/codeAction/common/types';
-import { getDocumentFormattingEditsUntilResult } from 'vscode/vscode/vs/editor/contrib/format/browser/format';
-import { SnippetController2 } from 'vscode/vscode/vs/editor/contrib/snippet/browser/snippetController2';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { IWorkspaceTrustManagementService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust';
-import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
-import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
-import { NotebookSetting, CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { NotebookFileWorkingCopyModel } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorModel';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
-
-let FormatOnSaveParticipant = class FormatOnSaveParticipant {
-    constructor(editorWorkerService, languageFeaturesService, textModelService, bulkEditService, configurationService) {
-        this.editorWorkerService = editorWorkerService;
-        this.languageFeaturesService = languageFeaturesService;
-        this.textModelService = textModelService;
-        this.bulkEditService = bulkEditService;
-        this.configurationService = configurationService;
-    }
-    async participate(workingCopy, context, progress, token) {
-        if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
-            return;
-        }
-        if (context.reason === 2 ) {
-            return undefined;
-        }
-        const enabled = this.configurationService.getValue(NotebookSetting.formatOnSave);
-        if (!enabled) {
-            return undefined;
-        }
-        const notebook = workingCopy.model.notebookModel;
-        progress.report({ message: ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-            'notebookFormatSave.formatting',
-            "Formatting"
-        )) });
-        const disposable = ( new DisposableStore());
-        try {
-            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 getDocumentFormattingEditsUntilResult(this.editorWorkerService, this.languageFeaturesService, model, model.getOptions(), token);
-                const edits = [];
-                if (formatEdits) {
-                    edits.push(...( formatEdits.map(edit => ( new ResourceTextEdit(model.uri, edit, model.getVersionId())))));
-                    return edits;
-                }
-                return [];
-            })));
-            await this.bulkEditService.apply( allCellEdits.flat(), { label: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-                'formatNotebook',
-                "Format Notebook"
-            )), code: 'undoredo.formatNotebook', });
-        }
-        finally {
-            progress.report({ increment: 100 });
-            disposable.dispose();
-        }
-    }
-};
-FormatOnSaveParticipant = ( __decorate([
-    ( __param(0, IEditorWorkerService)),
-    ( __param(1, ILanguageFeaturesService)),
-    ( __param(2, ITextModelService)),
-    ( __param(3, IBulkEditService)),
-    ( __param(4, IConfigurationService))
-], FormatOnSaveParticipant));
-let TrimWhitespaceParticipant = class TrimWhitespaceParticipant {
-    constructor(configurationService, editorService, textModelService, bulkEditService) {
-        this.configurationService = configurationService;
-        this.editorService = editorService;
-        this.textModelService = textModelService;
-        this.bulkEditService = bulkEditService;
-    }
-    async participate(workingCopy, context, progress, _token) {
-        const trimTrailingWhitespaceOption = this.configurationService.getValue('files.trimTrailingWhitespace');
-        const trimInRegexAndStrings = this.configurationService.getValue('files.trimTrailingWhitespaceInRegexAndStrings');
-        if (trimTrailingWhitespaceOption) {
-            await this.doTrimTrailingWhitespace(workingCopy, context.reason === 2 , trimInRegexAndStrings, progress);
-        }
-    }
-    async doTrimTrailingWhitespace(workingCopy, isAutoSaved, trimInRegexesAndStrings, progress) {
-        if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
-            return;
-        }
-        const disposable = ( new DisposableStore());
-        const notebook = workingCopy.model.notebookModel;
-        const activeCellEditor = getActiveCellCodeEditor(this.editorService);
-        let cursors = [];
-        let prevSelection = [];
-        try {
-            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
-                if (cell.cellKind !== CellKind.Code) {
-                    return [];
-                }
-                const ref = await this.textModelService.createModelReference(cell.uri);
-                disposable.add(ref);
-                const model = ref.object.textEditorModel;
-                const isActiveCell = (activeCellEditor && ( cell.uri.toString()) === activeCellEditor.getModel()?.uri.toString());
-                if (isActiveCell) {
-                    prevSelection = activeCellEditor.getSelections() ?? [];
-                    if (isAutoSaved) {
-                        cursors = ( prevSelection.map(s => s.getPosition()));
-                        const snippetsRange = SnippetController2.get(activeCellEditor)?.getSessionEnclosingRange();
-                        if (snippetsRange) {
-                            for (let lineNumber = snippetsRange.startLineNumber; lineNumber <= snippetsRange.endLineNumber; lineNumber++) {
-                                cursors.push(( new Position(lineNumber, model.getLineMaxColumn(lineNumber))));
-                            }
-                        }
-                    }
-                }
-                const ops = trimTrailingWhitespace(model, cursors, trimInRegexesAndStrings);
-                if (!ops.length) {
-                    return [];
-                }
-                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: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-                'trimNotebookWhitespace',
-                "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));
-let TrimFinalNewLinesParticipant = class TrimFinalNewLinesParticipant {
-    constructor(configurationService, editorService, bulkEditService) {
-        this.configurationService = configurationService;
-        this.editorService = editorService;
-        this.bulkEditService = bulkEditService;
-    }
-    async participate(workingCopy, context, progress, _token) {
-        if (this.configurationService.getValue('files.trimFinalNewlines')) {
-            await this.doTrimFinalNewLines(workingCopy, context.reason === 2 , progress);
-        }
-    }
-    findLastNonEmptyLine(textBuffer) {
-        for (let lineNumber = textBuffer.getLineCount(); lineNumber >= 1; lineNumber--) {
-            const lineLength = textBuffer.getLineLength(lineNumber);
-            if (lineLength) {
-                return lineNumber;
-            }
-        }
-        return 0;
-    }
-    async doTrimFinalNewLines(workingCopy, isAutoSaved, progress) {
-        if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
-            return;
-        }
-        const disposable = ( new DisposableStore());
-        const notebook = workingCopy.model.notebookModel;
-        const activeCellEditor = getActiveCellCodeEditor(this.editorService);
-        try {
-            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
-                if (cell.cellKind !== CellKind.Code) {
-                    return;
-                }
-                let cannotTouchLineNumber = 0;
-                const isActiveCell = (activeCellEditor && ( cell.uri.toString()) === activeCellEditor.getModel()?.uri.toString());
-                if (isAutoSaved && isActiveCell) {
-                    const selections = activeCellEditor.getSelections() ?? [];
-                    for (const sel of selections) {
-                        cannotTouchLineNumber = Math.max(cannotTouchLineNumber, sel.selectionStartLineNumber);
-                    }
-                }
-                const textBuffer = cell.textBuffer;
-                const lastNonEmptyLine = this.findLastNonEmptyLine(textBuffer);
-                const deleteFromLineNumber = Math.max(lastNonEmptyLine + 1, cannotTouchLineNumber + 1);
-                if (deleteFromLineNumber > textBuffer.getLineCount()) {
-                    return;
-                }
-                const deletionRange = ( new Range(
-                    deleteFromLineNumber,
-                    1,
-                    textBuffer.getLineCount(),
-                    textBuffer.getLineLastNonWhitespaceColumn(textBuffer.getLineCount())
-                ));
-                if (deletionRange.isEmpty()) {
-                    return;
-                }
-                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: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-                'trimNotebookNewlines',
-                "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));
-let InsertFinalNewLineParticipant = class InsertFinalNewLineParticipant {
-    constructor(configurationService, bulkEditService, editorService) {
-        this.configurationService = configurationService;
-        this.bulkEditService = bulkEditService;
-        this.editorService = editorService;
-    }
-    async participate(workingCopy, context, progress, _token) {
-        if (this.configurationService.getValue(NotebookSetting.insertFinalNewline)) {
-            await this.doInsertFinalNewLine(workingCopy, context.reason === 2 , progress);
-        }
-    }
-    async doInsertFinalNewLine(workingCopy, isAutoSaved, progress) {
-        if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
-            return;
-        }
-        const disposable = ( new DisposableStore());
-        const notebook = workingCopy.model.notebookModel;
-        const activeCellEditor = getActiveCellCodeEditor(this.editorService);
-        let selections;
-        if (activeCellEditor) {
-            selections = activeCellEditor.getSelections() ?? [];
-        }
-        try {
-            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
-                if (cell.cellKind !== CellKind.Code) {
-                    return;
-                }
-                const lineCount = cell.textBuffer.getLineCount();
-                const lastLineIsEmptyOrWhitespace = cell.textBuffer.getLineFirstNonWhitespaceColumn(lineCount) === 0;
-                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()));
-            })));
-            const filteredEdits = allCellEdits.filter(edit => edit !== undefined);
-            await this.bulkEditService.apply(filteredEdits, { label: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-                'insertFinalNewLine',
-                "Insert Final New Line"
-            )), code: 'undoredo.insertFinalNewLine' });
-            if (activeCellEditor && selections) {
-                activeCellEditor.setSelections(selections);
-            }
-        }
-        finally {
-            progress.report({ increment: 100 });
-            disposable.dispose();
-        }
-    }
-};
-InsertFinalNewLineParticipant = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IBulkEditService)),
-    ( __param(2, IEditorService))
-], InsertFinalNewLineParticipant));
-let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
-    constructor(configurationService, logService, workspaceTrustManagementService, languageFeaturesService, textModelService, instantiationService) {
-        this.configurationService = configurationService;
-        this.logService = logService;
-        this.workspaceTrustManagementService = workspaceTrustManagementService;
-        this.languageFeaturesService = languageFeaturesService;
-        this.textModelService = textModelService;
-        this.instantiationService = instantiationService;
-    }
-    async participate(workingCopy, context, progress, token) {
-        const nbDisposable = ( new DisposableStore());
-        const isTrusted = this.workspaceTrustManagementService.isWorkspaceTrusted();
-        if (!isTrusted) {
-            return;
-        }
-        if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
-            return;
-        }
-        let saveTrigger = '';
-        if (context.reason === 2 ) {
-            return undefined;
-        }
-        else if (context.reason === 1 ) {
-            saveTrigger = 'explicit';
-        }
-        else {
-            return undefined;
-        }
-        const notebookModel = workingCopy.model.notebookModel;
-        const setting = this.configurationService.getValue(NotebookSetting.codeActionsOnSave);
-        if (!setting) {
-            return undefined;
-        }
-        const settingItems = Array.isArray(setting)
-            ? setting
-            : ( Object.keys(setting)).filter(x => setting[x]);
-        if (!settingItems.length) {
-            return undefined;
-        }
-        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 editorCodeActionsOnSave = includedActions.filter(x => !CodeActionKind.Notebook.contains(x));
-        const notebookCodeActionsOnSave = includedActions.filter(x => CodeActionKind.Notebook.contains(x));
-        if (!editorCodeActionsOnSave.length && !notebookCodeActionsOnSave.length) {
-            return undefined;
-        }
-        if (!Array.isArray(setting)) {
-            editorCodeActionsOnSave.sort((a, b) => {
-                if (CodeActionKind.SourceFixAll.contains(a)) {
-                    if (CodeActionKind.SourceFixAll.contains(b)) {
-                        return 0;
-                    }
-                    return -1;
-                }
-                if (CodeActionKind.SourceFixAll.contains(b)) {
-                    return 1;
-                }
-                return 0;
-            });
-        }
-        progress.report({ message: ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-            'notebookSaveParticipants.notebookCodeActions',
-            "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.applyOnSaveActions(textEditorModel, notebookCodeActionsOnSave, excludedActions, progress, token);
-        }
-        catch {
-            this.logService.error('Failed to apply notebook code action on save');
-        }
-        finally {
-            progress.report({ increment: 100 });
-            nbDisposable.dispose();
-        }
-        const disposable = ( new DisposableStore());
-        progress.report({ message: ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-            'notebookSaveParticipants.cellCodeActions',
-            "Running 'Cell' code actions"
-        )) });
-        try {
-            await Promise.all(( notebookModel.cells.map(async (cell) => {
-                const ref = await this.textModelService.createModelReference(cell.uri);
-                disposable.add(ref);
-                const textEditorModel = ref.object.textEditorModel;
-                await this.applyOnSaveActions(textEditorModel, editorCodeActionsOnSave, excludedActions, progress, token);
-            })));
-        }
-        catch {
-            this.logService.error('Failed to apply code action on save');
-        }
-        finally {
-            progress.report({ increment: 100 });
-            disposable.dispose();
-        }
-    }
-    createCodeActionsOnSave(settingItems) {
-        const kinds = ( settingItems.map(x => ( new HierarchicalKind(x))));
-        return kinds.filter(kind => {
-            return kinds.every(otherKind => otherKind.equals(kind) || !otherKind.contains(kind));
-        });
-    }
-    async applyOnSaveActions(model, codeActionsOnSave, excludes, progress, token) {
-        const getActionProgress = new (class {
-            constructor() {
-                this._names = ( new Set());
-            }
-            _report() {
-                progress.report({
-                    message: ( localizeWithPath(
-                        'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-                        { key: 'codeaction.get2', comment: ['[configure]({1}) is a link. Only translate `configure`. Do not change brackets and parentheses or {1}'] },
-                        "Getting code actions from '{0}' ([configure]({1})).",
-                        ( [...this._names].map(name => `'${name}'`)).join(', '),
-                        'command:workbench.action.openSettings?%5B%22editor.codeActionsOnSave%22%5D'
-                    ))
-                });
-            }
-            report(provider) {
-                if (provider.displayName && !( this._names.has(provider.displayName))) {
-                    this._names.add(provider.displayName);
-                    this._report();
-                }
-            }
-        });
-        for (const codeActionKind of codeActionsOnSave) {
-            const actionsToRun = await this.getActionsToRun(model, codeActionKind, excludes, getActionProgress, token);
-            if (token.isCancellationRequested) {
-                actionsToRun.dispose();
-                return;
-            }
-            try {
-                for (const action of actionsToRun.validActions) {
-                    const codeActionEdits = action.action.edit?.edits;
-                    let breakFlag = false;
-                    if (!action.action.kind?.startsWith('notebook')) {
-                        for (const edit of codeActionEdits ?? []) {
-                            const workspaceTextEdit = edit;
-                            if (workspaceTextEdit.resource && isEqual(workspaceTextEdit.resource, model.uri)) {
-                                continue;
-                            }
-                            else {
-                                breakFlag = true;
-                                break;
-                            }
-                        }
-                    }
-                    if (breakFlag) {
-                        this.logService.warn('Failed to apply code action on save, applied to multiple resources.');
-                        continue;
-                    }
-                    progress.report({ message: ( localizeWithPath(
-                        'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-                        'codeAction.apply',
-                        "Applying code action '{0}'.",
-                        action.action.title
-                    )) });
-                    await this.instantiationService.invokeFunction(applyCodeAction, action, ApplyCodeActionReason.OnSave, {}, token);
-                    if (token.isCancellationRequested) {
-                        return;
-                    }
-                }
-            }
-            catch {
-            }
-            finally {
-                actionsToRun.dispose();
-            }
-        }
-    }
-    getActionsToRun(model, codeActionKind, excludes, progress, token) {
-        return getCodeActions(this.languageFeaturesService.codeActionProvider, model, model.getFullModelRange(), {
-            type: 1 ,
-            triggerAction: CodeActionTriggerSource.OnSave,
-            filter: { include: codeActionKind, excludes: excludes, includeSourceActions: true },
-        }, progress, token);
-    }
-};
-CodeActionOnSaveParticipant = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, ILogService)),
-    ( __param(2, IWorkspaceTrustManagementService)),
-    ( __param(3, ILanguageFeaturesService)),
-    ( __param(4, ITextModelService)),
-    ( __param(5, IInstantiationService))
-], CodeActionOnSaveParticipant));
-function getActiveCellCodeEditor(editorService) {
-    const activePane = editorService.activeEditorPane;
-    const notebookEditor = getNotebookEditorFromEditorPane(activePane);
-    const activeCodeEditor = notebookEditor?.activeCodeEditor;
-    return activeCodeEditor;
-}
-let SaveParticipantsContribution = class SaveParticipantsContribution extends Disposable {
-    constructor(instantiationService, workingCopyFileService) {
-        super();
-        this.instantiationService = instantiationService;
-        this.workingCopyFileService = workingCopyFileService;
-        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)));
-    }
-};
-SaveParticipantsContribution = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IWorkingCopyFileService))
-], SaveParticipantsContribution));
-const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
-workbenchContributionsRegistry.registerWorkbenchContribution(SaveParticipantsContribution, 3 );
-
-export { SaveParticipantsContribution };