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

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline.js

@@ -1,5 +1,7 @@
 import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { clearNode, WindowIdleValue } from 'vscode/vscode/vs/base/browser/dom';
+import { ToolBar } from 'vscode/vscode/vs/base/browser/ui/toolbar/toolbar';
 import { IconLabel } from 'vscode/vscode/vs/base/browser/ui/iconLabel/iconLabel';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { createMatches } from 'vscode/vscode/vs/base/common/filters';
@@ -11,7 +13,17 @@ import { Extensions as Extensions$1 } from 'vscode/vscode/vs/platform/configurat
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { MarkerSeverity } from 'vscode/vscode/vs/platform/markers/common/markers';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { listErrorForeground, listWarningForeground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
+import 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
+import { listErrorForeground, listWarningForeground } from 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
 import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
 import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
 import { NotebookEditor } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditor';
@@ -21,25 +33,41 @@ import { SIDE_GROUP, IEditorService } from 'vscode/vscode/vs/workbench/services/
 import { IOutlineService } from 'vscode/vscode/vs/workbench/services/outline/browser/outline';
 import { Range } from 'vscode/vscode/vs/editor/common/core/range';
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
-import { WindowIdleValue } from 'vscode/vscode/vs/base/browser/dom';
+import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
+import { MenuRegistry, MenuId, registerAction2, Action2, MenuItemAction, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { MenuEntryActionViewItem, createAndFillInActionBarActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { disposableTimeout } from 'vscode/vscode/vs/base/common/async';
+import { IOutlinePane } from 'vscode/vscode/vs/workbench/contrib/outline/browser/outline';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { NOTEBOOK_IS_ACTIVE_EDITOR } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
 
 var NotebookCellOutline_1;
 class NotebookOutlineTemplate {
     static { this.templateId = 'NotebookOutlineRenderer'; }
-    constructor(container, iconClass, iconLabel, decoration) {
+    constructor(container, iconClass, iconLabel, decoration, actionMenu, elementDisposables) {
         this.container = container;
         this.iconClass = iconClass;
         this.iconLabel = iconLabel;
         this.decoration = decoration;
+        this.actionMenu = actionMenu;
+        this.elementDisposables = elementDisposables;
     }
 }
 let NotebookOutlineRenderer = class NotebookOutlineRenderer {
-    constructor(_themeService, _configurationService) {
+    constructor(_editor, _target, _themeService, _configurationService, _contextMenuService, _contextKeyService, _menuService, _instantiationService) {
+        this._editor = _editor;
+        this._target = _target;
         this._themeService = _themeService;
         this._configurationService = _configurationService;
+        this._contextMenuService = _contextMenuService;
+        this._contextKeyService = _contextKeyService;
+        this._menuService = _menuService;
+        this._instantiationService = _instantiationService;
         this.templateId = NotebookOutlineTemplate.templateId;
     }
     renderTemplate(container) {
+        const elementDisposables = ( new DisposableStore());
         container.classList.add('notebook-outline-element', 'show-file-icons');
         const iconClass = document.createElement('div');
         container.append(iconClass);
@@ -47,7 +75,17 @@ let NotebookOutlineRenderer = class NotebookOutlineRenderer {
         const decoration = document.createElement('div');
         decoration.className = 'element-decoration';
         container.append(decoration);
-        return ( new NotebookOutlineTemplate(container, iconClass, iconLabel, decoration));
+        const actionMenu = document.createElement('div');
+        actionMenu.className = 'action-menu';
+        container.append(actionMenu);
+        return ( new NotebookOutlineTemplate(
+            container,
+            iconClass,
+            iconLabel,
+            decoration,
+            actionMenu,
+            elementDisposables
+        ));
     }
     renderElement(node, _index, template, _height) {
         const extraClasses = [];
@@ -56,14 +94,18 @@ let NotebookOutlineRenderer = class NotebookOutlineRenderer {
             labelEscapeNewLines: true,
             extraClasses,
         };
-        if (node.element.cell.cellKind === CellKind.Code && this._themeService.getFileIconTheme().hasFileIcons && !node.element.isExecuting) {
+        const isCodeCell = node.element.cell.cellKind === CellKind.Code;
+        if (node.element.level >= 8) {
+            template.iconClass.className = 'element-icon ' + ThemeIcon.asClassNameArray(node.element.icon).join(' ');
+        }
+        else if (isCodeCell && this._themeService.getFileIconTheme().hasFileIcons && !node.element.isExecuting) {
             template.iconClass.className = '';
             extraClasses.push(...getIconClassesForLanguageId(node.element.cell.language ?? ''));
         }
         else {
             template.iconClass.className = 'element-icon ' + ThemeIcon.asClassNameArray(node.element.icon).join(' ');
         }
-        template.iconLabel.setLabel(node.element.label, undefined, options);
+        template.iconLabel.setLabel(' ' + node.element.label, undefined, options);
         const { markerInfo } = node.element;
         template.container.style.removeProperty('--outline-element-color');
         template.decoration.innerText = '';
@@ -95,15 +137,101 @@ let NotebookOutlineRenderer = class NotebookOutlineRenderer {
                 template.container.style.setProperty('--outline-element-color', color?.toString() ?? 'inherit');
             }
         }
+        if (this._target === 1 ) {
+            const nbCell = node.element.cell;
+            const nbViewModel = this._editor?.getViewModel();
+            if (!nbViewModel) {
+                return;
+            }
+            const idx = nbViewModel.getCellIndex(nbCell);
+            const length = isCodeCell ? 0 : nbViewModel.getFoldedLength(idx);
+            const scopedContextKeyService = template.elementDisposables.add(this._contextKeyService.createScoped(template.container));
+            NotebookOutlineContext.CellKind.bindTo(scopedContextKeyService).set(isCodeCell ? CellKind.Code : CellKind.Markup);
+            NotebookOutlineContext.CellHasChildren.bindTo(scopedContextKeyService).set(length > 0);
+            NotebookOutlineContext.CellHasHeader.bindTo(scopedContextKeyService).set(node.element.level !== 7);
+            NotebookOutlineContext.OutlineElementTarget.bindTo(scopedContextKeyService).set(this._target);
+            this.setupFolding(isCodeCell, nbViewModel, scopedContextKeyService, template, nbCell);
+            const outlineEntryToolbar = template.elementDisposables.add(( new ToolBar(template.actionMenu, this._contextMenuService, {
+                actionViewItemProvider: action => {
+                    if (action instanceof MenuItemAction) {
+                        return this._instantiationService.createInstance(MenuEntryActionViewItem, action, undefined);
+                    }
+                    return undefined;
+                },
+            })));
+            const menu = template.elementDisposables.add(this._menuService.createMenu(MenuId.NotebookOutlineActionMenu, scopedContextKeyService));
+            const actions = getOutlineToolbarActions(menu, { notebookEditor: this._editor, outlineEntry: node.element });
+            outlineEntryToolbar.setActions(actions.primary, actions.secondary);
+            this.setupToolbarListeners(outlineEntryToolbar, menu, actions, node.element, template);
+            template.actionMenu.style.padding = '0 0.8em 0 0.4em';
+        }
     }
     disposeTemplate(templateData) {
         templateData.iconLabel.dispose();
+        templateData.elementDisposables.clear();
+    }
+    disposeElement(element, index, templateData, height) {
+        templateData.elementDisposables.clear();
+        clearNode(templateData.actionMenu);
+    }
+    setupFolding(isCodeCell, nbViewModel, scopedContextKeyService, template, nbCell) {
+        const foldingState = isCodeCell ? 0  : (nbCell.foldingState);
+        const foldingStateCtx = NotebookOutlineContext.CellFoldingState.bindTo(scopedContextKeyService);
+        foldingStateCtx.set(foldingState);
+        if (!isCodeCell) {
+            template.elementDisposables.add(nbViewModel.onDidFoldingStateChanged(() => {
+                const foldingState = nbCell.foldingState;
+                NotebookOutlineContext.CellFoldingState.bindTo(scopedContextKeyService).set(foldingState);
+                foldingStateCtx.set(foldingState);
+            }));
+        }
+    }
+    setupToolbarListeners(toolbar, menu, initActions, entry, templateData) {
+        let dropdownIsVisible = false;
+        let deferredUpdate;
+        toolbar.setActions(initActions.primary, initActions.secondary);
+        templateData.elementDisposables.add(menu.onDidChange(() => {
+            if (dropdownIsVisible) {
+                const actions = getOutlineToolbarActions(menu, { notebookEditor: this._editor, outlineEntry: entry });
+                deferredUpdate = () => toolbar.setActions(actions.primary, actions.secondary);
+                return;
+            }
+            const actions = getOutlineToolbarActions(menu, { notebookEditor: this._editor, outlineEntry: entry });
+            toolbar.setActions(actions.primary, actions.secondary);
+        }));
+        templateData.container.classList.remove('notebook-outline-toolbar-dropdown-active');
+        templateData.elementDisposables.add(toolbar.onDidChangeDropdownVisibility(visible => {
+            dropdownIsVisible = visible;
+            if (visible) {
+                templateData.container.classList.add('notebook-outline-toolbar-dropdown-active');
+            }
+            else {
+                templateData.container.classList.remove('notebook-outline-toolbar-dropdown-active');
+            }
+            if (deferredUpdate && !visible) {
+                disposableTimeout(() => {
+                    deferredUpdate?.();
+                }, 0, templateData.elementDisposables);
+                deferredUpdate = undefined;
+            }
+        }));
     }
 };
 NotebookOutlineRenderer = ( __decorate([
-    ( __param(0, IThemeService)),
-    ( __param(1, IConfigurationService))
+    ( __param(2, IThemeService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IContextMenuService)),
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IMenuService)),
+    ( __param(7, IInstantiationService))
 ], NotebookOutlineRenderer));
+function getOutlineToolbarActions(menu, args) {
+    const primary = [];
+    const secondary = [];
+    const result = { primary, secondary };
+    createAndFillInActionBarActions(menu, { shouldForwardArgs: true, arg: args }, result);
+    return result;
+}
 class NotebookOutlineAccessibility {
     getAriaLabel(element) {
         return element.label;
@@ -154,7 +282,7 @@ NotebookQuickPickProvider = ( __decorate([
 ], NotebookQuickPickProvider));
 class NotebookComparator {
     constructor() {
-        this._collator = ( new WindowIdleValue(mainWindow, () => new Intl.Collator(undefined, { numeric: true })));
+        this._collator = new WindowIdleValue(mainWindow, () => new Intl.Collator(undefined, { numeric: true }));
     }
     compareByPosition(a, b) {
         return a.index - b.index;
@@ -202,9 +330,13 @@ let NotebookCellOutline = NotebookCellOutline_1 = class NotebookCellOutline {
             installSelectionListener();
         }));
         installSelectionListener();
-        const treeDataSource = { getChildren: parent => parent instanceof NotebookCellOutline_1 ? (this._outlineProvider?.entries ?? []) : parent.children };
+        const treeDataSource = {
+            getChildren: parent => {
+                return this.getChildren(parent, _configurationService);
+            }
+        };
         const delegate = ( new NotebookOutlineVirtualDelegate());
-        const renderers = [instantiationService.createInstance(NotebookOutlineRenderer)];
+        const renderers = [instantiationService.createInstance(NotebookOutlineRenderer, this._editor.getControl(), _target)];
         const comparator = ( new NotebookComparator());
         const options = {
             collapseByDefault: _target === 2  || ((_target === 1  && _configurationService.getValue("outline.collapseItems" ) === "alwaysCollapse") ),
@@ -234,6 +366,29 @@ let NotebookCellOutline = NotebookCellOutline_1 = class NotebookCellOutline {
             options
         };
     }
+    *getChildren(parent, configurationService) {
+        const showCodeCells = configurationService.getValue(NotebookSetting.outlineShowCodeCells);
+        const showCodeCellSymbols = configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
+        const showMarkdownHeadersOnly = configurationService.getValue(NotebookSetting.outlineShowMarkdownHeadersOnly);
+        for (const entry of parent instanceof NotebookCellOutline_1 ? (this._outlineProvider?.entries ?? []) : parent.children) {
+            if (entry.cell.cellKind === CellKind.Markup) {
+                if (!showMarkdownHeadersOnly) {
+                    yield entry;
+                }
+                else if (entry.level < 7) {
+                    yield entry;
+                }
+            }
+            else if (showCodeCells && entry.cell.cellKind === CellKind.Code) {
+                if (showCodeCellSymbols) {
+                    yield entry;
+                }
+                else if (entry.level === 7) {
+                    yield entry;
+                }
+            }
+        }
+    }
     async setFullSymbols(cancelToken) {
         await this._outlineProvider?.setFullSymbols(cancelToken);
     }
@@ -332,8 +487,12 @@ let NotebookOutlineCreator = class NotebookOutlineCreator {
     }
     async createOutline(editor, target, cancelToken) {
         const outline = this._instantiationService.createInstance(NotebookCellOutline, editor, target);
-        const showAllSymbols = this._configurationService.getValue(NotebookSetting.gotoSymbolsAllSymbols);
-        if (target === 4  && showAllSymbols) {
+        const showAllGotoSymbols = this._configurationService.getValue(NotebookSetting.gotoSymbolsAllSymbols);
+        const showAllOutlineSymbols = this._configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
+        if (target === 4  && showAllGotoSymbols) {
+            await outline.setFullSymbols(cancelToken);
+        }
+        else if (target === 1  && showAllOutlineSymbols) {
             await outline.setFullSymbols(cancelToken);
         }
         return outline;
@@ -344,28 +503,53 @@ NotebookOutlineCreator = ( __decorate([
     ( __param(1, IInstantiationService)),
     ( __param(2, IConfigurationService))
 ], NotebookOutlineCreator));
+const NotebookOutlineContext = {
+    CellKind: ( new RawContextKey('notebookCellKind', undefined)),
+    CellHasChildren: ( new RawContextKey('notebookCellHasChildren', false)),
+    CellHasHeader: ( new RawContextKey('notebookCellHasHeader', false)),
+    CellFoldingState: ( new RawContextKey('notebookCellFoldingState', 0 )),
+    OutlineElementTarget: ( new RawContextKey('notebookOutlineElementTarget', undefined)),
+};
 ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(NotebookOutlineCreator, 4 );
 ( Registry.as(Extensions$1.Configuration)).registerConfiguration({
     id: 'notebook',
     order: 100,
     type: 'object',
     'properties': {
-        'notebook.outline.showCodeCells': {
+        [NotebookSetting.outlineShowMarkdownHeadersOnly]: {
+            type: 'boolean',
+            default: true,
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
+                'outline.showMarkdownHeadersOnly',
+                "When enabled, notebook outline will show only markdown cells containing a header."
+            ))
+        },
+        [NotebookSetting.outlineShowCodeCells]: {
             type: 'boolean',
             default: false,
             markdownDescription: ( localizeWithPath(
                 'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
                 'outline.showCodeCells',
-                "When enabled notebook outline shows code cells."
+                "When enabled, notebook outline shows code cells."
+            ))
+        },
+        [NotebookSetting.outlineShowCodeCellSymbols]: {
+            type: 'boolean',
+            default: true,
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
+                'outline.showCodeCellSymbols',
+                "When enabled, notebook outline shows code cell symbols. Relies on `notebook.outline.showCodeCells` being enabled."
             ))
         },
-        'notebook.breadcrumbs.showCodeCells': {
+        [NotebookSetting.breadcrumbsShowCodeCells]: {
             type: 'boolean',
             default: true,
             markdownDescription: ( localizeWithPath(
                 'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
                 'breadcrumbs.showCodeCells',
-                "When enabled notebook breadcrumbs contain code cells."
+                "When enabled, notebook breadcrumbs contain code cells."
             ))
         },
         [NotebookSetting.gotoSymbolsAllSymbols]: {
@@ -374,10 +558,99 @@ NotebookOutlineCreator = ( __decorate([
             markdownDescription: ( localizeWithPath(
                 'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
                 'notebook.gotoSymbols.showAllSymbols',
-                "When enabled the Go to Symbol Quick Pick will display full code symbols from the notebook, as well as Markdown headers."
+                "When enabled, the Go to Symbol Quick Pick will display full code symbols from the notebook, as well as Markdown headers."
             ))
         },
     }
 });
+MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
+    submenu: MenuId.NotebookOutlineFilter,
+    title: ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
+        'filter',
+        "Filter Entries"
+    )),
+    icon: Codicon.filter,
+    group: 'navigation',
+    order: -1,
+    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', IOutlinePane.Id)), NOTEBOOK_IS_ACTIVE_EDITOR)),
+});
+registerAction2(class ToggleShowMarkdownHeadersOnly extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.outline.toggleShowMarkdownHeadersOnly',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
+                'toggleShowMarkdownHeadersOnly',
+                "Markdown Headers Only"
+            )),
+            f1: false,
+            toggled: {
+                condition: ( ContextKeyExpr.equals('config.notebook.outline.showMarkdownHeadersOnly', true))
+            },
+            menu: {
+                id: MenuId.NotebookOutlineFilter,
+                group: '0_markdown_cells',
+            }
+        });
+    }
+    run(accessor, ...args) {
+        const configurationService = accessor.get(IConfigurationService);
+        const showMarkdownHeadersOnly = configurationService.getValue(NotebookSetting.outlineShowMarkdownHeadersOnly);
+        configurationService.updateValue(NotebookSetting.outlineShowMarkdownHeadersOnly, !showMarkdownHeadersOnly);
+    }
+});
+registerAction2(class ToggleCodeCellEntries extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.outline.toggleCodeCells',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
+                'toggleCodeCells',
+                "Code Cells"
+            )),
+            f1: false,
+            toggled: {
+                condition: ( ContextKeyExpr.equals('config.notebook.outline.showCodeCells', true))
+            },
+            menu: {
+                id: MenuId.NotebookOutlineFilter,
+                order: 1,
+                group: '1_code_cells',
+            }
+        });
+    }
+    run(accessor, ...args) {
+        const configurationService = accessor.get(IConfigurationService);
+        const showCodeCells = configurationService.getValue(NotebookSetting.outlineShowCodeCells);
+        configurationService.updateValue(NotebookSetting.outlineShowCodeCells, !showCodeCells);
+    }
+});
+registerAction2(class ToggleCodeCellSymbolEntries extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.outline.toggleCodeCellSymbols',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
+                'toggleCodeCellSymbols',
+                "Code Cell Symbols"
+            )),
+            f1: false,
+            toggled: {
+                condition: ( ContextKeyExpr.equals('config.notebook.outline.showCodeCellSymbols', true))
+            },
+            menu: {
+                id: MenuId.NotebookOutlineFilter,
+                order: 2,
+                group: '1_code_cells',
+            }
+        });
+    }
+    run(accessor, ...args) {
+        const configurationService = accessor.get(IConfigurationService);
+        const showCodeCellSymbols = configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
+        configurationService.updateValue(NotebookSetting.outlineShowCodeCellSymbols, !showCodeCellSymbols);
+    }
+});
 
-export { NotebookCellOutline, NotebookOutlineCreator };
+export { NotebookCellOutline, NotebookOutlineContext, NotebookOutlineCreator };

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

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+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';
@@ -13,6 +13,7 @@ import { applyCodeAction, ApplyCodeActionReason, getCodeActions } from 'vscode/v
 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';
@@ -91,11 +92,13 @@ let TrimWhitespaceParticipant = class TrimWhitespaceParticipant {
         this.bulkEditService = bulkEditService;
     }
     async participate(workingCopy, context, progress, _token) {
-        if (this.configurationService.getValue('files.trimTrailingWhitespace')) {
-            await this.doTrimTrailingWhitespace(workingCopy, context.reason === 2 , progress);
+        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, progress) {
+    async doTrimTrailingWhitespace(workingCopy, isAutoSaved, trimInRegexesAndStrings, progress) {
         if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
             return;
         }
@@ -125,7 +128,7 @@ let TrimWhitespaceParticipant = class TrimWhitespaceParticipant {
                         }
                     }
                 }
-                const ops = trimTrailingWhitespace(model, cursors);
+                const ops = trimTrailingWhitespace(model, cursors, trimInRegexesAndStrings);
                 if (!ops.length) {
                     return [];
                 }
@@ -193,6 +196,9 @@ let TrimFinalNewLinesParticipant = class TrimFinalNewLinesParticipant {
                 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,
@@ -226,7 +232,7 @@ TrimFinalNewLinesParticipant = ( __decorate([
     ( __param(1, IEditorService)),
     ( __param(2, IBulkEditService))
 ], TrimFinalNewLinesParticipant));
-let FinalNewLineParticipant = class FinalNewLineParticipant {
+let InsertFinalNewLineParticipant = class InsertFinalNewLineParticipant {
     constructor(configurationService, bulkEditService, editorService) {
         this.configurationService = configurationService;
         this.bulkEditService = bulkEditService;
@@ -281,11 +287,11 @@ let FinalNewLineParticipant = class FinalNewLineParticipant {
         }
     }
 };
-FinalNewLineParticipant = ( __decorate([
+InsertFinalNewLineParticipant = ( __decorate([
     ( __param(0, IConfigurationService)),
     ( __param(1, IBulkEditService)),
     ( __param(2, IEditorService))
-], FinalNewLineParticipant));
+], InsertFinalNewLineParticipant));
 let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
     constructor(configurationService, logService, workspaceTrustManagementService, languageFeaturesService, textModelService, instantiationService) {
         this.configurationService = configurationService;
@@ -391,7 +397,7 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
         }
     }
     createCodeActionsOnSave(settingItems) {
-        const kinds = ( settingItems.map(x => ( new CodeActionKind(x))));
+        const kinds = ( settingItems.map(x => ( new HierarchicalKind(x))));
         return kinds.filter(kind => {
             return kinds.every(otherKind => otherKind.equals(kind) || !otherKind.contains(kind));
         });
@@ -497,7 +503,7 @@ let SaveParticipantsContribution = class SaveParticipantsContribution extends Di
         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(FinalNewLineParticipant)));
+        this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(InsertFinalNewLineParticipant)));
         this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(TrimFinalNewLinesParticipant)));
     }
 };