@codingame/monaco-vscode-views-service-override 1.82.6 → 1.83.1

package/vscode/src/vs/workbench/browser/parts/editor/multiRowEditorTabsControl.js

@@ -0,0 +1,152 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Dimension } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { MultiEditorTabsControl } from './multiEditorTabsControl.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { StickyEditorGroupModel, UnstickyEditorGroupModel } from '../../../common/editor/filteredEditorGroupModel.js';
+
+let MultiRowEditorControl = class MultiRowEditorControl extends Disposable {
+    constructor(parent, groupsView, groupView, model, instantiationService) {
+        super();
+        this.parent = parent;
+        this.groupsView = groupsView;
+        this.groupView = groupView;
+        this.model = model;
+        this.instantiationService = instantiationService;
+        const stickyModel = this._register(( new StickyEditorGroupModel(this.model)));
+        const unstickyModel = this._register(( new UnstickyEditorGroupModel(this.model)));
+        this.stickyEditorTabsControl = this._register(this.instantiationService.createInstance(MultiEditorTabsControl, this.parent, this.groupsView, this.groupView, stickyModel));
+        this.unstickyEditorTabsControl = this._register(this.instantiationService.createInstance(MultiEditorTabsControl, this.parent, this.groupsView, this.groupView, unstickyModel));
+        this.handlePinnedTabsSeparateRowToolbars();
+    }
+    handlePinnedTabsSeparateRowToolbars() {
+        if (this.groupView.count === 0) {
+            return;
+        }
+        if (this.groupView.count === this.groupView.stickyCount) {
+            this.parent.classList.toggle('two-tab-bars', false);
+        }
+        else {
+            this.parent.classList.toggle('two-tab-bars', true);
+        }
+    }
+    getEditorTabsController(editor) {
+        return this.model.isSticky(editor) ? this.stickyEditorTabsControl : this.unstickyEditorTabsControl;
+    }
+    openEditor(editor, options) {
+        const [editorTabController, otherTabController] = this.model.isSticky(editor) ? [this.stickyEditorTabsControl, this.unstickyEditorTabsControl] : [this.unstickyEditorTabsControl, this.stickyEditorTabsControl];
+        const didChange = editorTabController.openEditor(editor, options);
+        if (didChange) {
+            otherTabController.openEditors([]);
+            this.handleOpenedEditors();
+        }
+        return didChange;
+    }
+    openEditors(editors) {
+        const stickyEditors = editors.filter(e => this.model.isSticky(e));
+        const unstickyEditors = editors.filter(e => !this.model.isSticky(e));
+        const didChangeOpenEditorsSticky = this.stickyEditorTabsControl.openEditors(stickyEditors);
+        const didChangeOpenEditorsUnSticky = this.unstickyEditorTabsControl.openEditors(unstickyEditors);
+        const didChange = didChangeOpenEditorsSticky || didChangeOpenEditorsUnSticky;
+        if (didChange) {
+            this.handleOpenedEditors();
+        }
+        return didChange;
+    }
+    handleOpenedEditors() {
+        this.handlePinnedTabsSeparateRowToolbars();
+    }
+    beforeCloseEditor(editor) {
+        this.getEditorTabsController(editor).beforeCloseEditor(editor);
+    }
+    closeEditor(editor) {
+        this.stickyEditorTabsControl.closeEditor(editor);
+        this.unstickyEditorTabsControl.closeEditor(editor);
+        this.handleClosedEditors();
+    }
+    closeEditors(editors) {
+        const stickyEditors = editors.filter(e => this.model.isSticky(e));
+        const unstickyEditors = editors.filter(e => !this.model.isSticky(e));
+        this.stickyEditorTabsControl.closeEditors(stickyEditors);
+        this.unstickyEditorTabsControl.closeEditors(unstickyEditors);
+        this.handleClosedEditors();
+    }
+    handleClosedEditors() {
+        this.handlePinnedTabsSeparateRowToolbars();
+    }
+    moveEditor(editor, fromIndex, targetIndex, stickyStateChange) {
+        if (stickyStateChange) {
+            if (this.model.isSticky(editor)) {
+                this.stickyEditorTabsControl.openEditor(editor);
+                this.unstickyEditorTabsControl.closeEditor(editor);
+            }
+            else {
+                this.stickyEditorTabsControl.closeEditor(editor);
+                this.unstickyEditorTabsControl.openEditor(editor);
+            }
+            this.handlePinnedTabsSeparateRowToolbars();
+        }
+        else {
+            if (this.model.isSticky(editor)) {
+                this.stickyEditorTabsControl.moveEditor(editor, fromIndex, targetIndex, stickyStateChange);
+            }
+            else {
+                this.unstickyEditorTabsControl.moveEditor(editor, fromIndex - this.model.stickyCount, targetIndex - this.model.stickyCount, stickyStateChange);
+            }
+        }
+    }
+    pinEditor(editor) {
+        this.getEditorTabsController(editor).pinEditor(editor);
+    }
+    stickEditor(editor) {
+        this.unstickyEditorTabsControl.closeEditor(editor);
+        this.stickyEditorTabsControl.openEditor(editor);
+        this.handlePinnedTabsSeparateRowToolbars();
+    }
+    unstickEditor(editor) {
+        this.stickyEditorTabsControl.closeEditor(editor);
+        this.unstickyEditorTabsControl.openEditor(editor);
+        this.handlePinnedTabsSeparateRowToolbars();
+    }
+    setActive(isActive) {
+        this.stickyEditorTabsControl.setActive(isActive);
+        this.unstickyEditorTabsControl.setActive(isActive);
+    }
+    updateEditorLabel(editor) {
+        this.getEditorTabsController(editor).updateEditorLabel(editor);
+    }
+    updateEditorDirty(editor) {
+        this.getEditorTabsController(editor).updateEditorDirty(editor);
+    }
+    updateOptions(oldOptions, newOptions) {
+        this.stickyEditorTabsControl.updateOptions(oldOptions, newOptions);
+        this.unstickyEditorTabsControl.updateOptions(oldOptions, newOptions);
+    }
+    layout(dimensions) {
+        const stickyDimensions = this.stickyEditorTabsControl.layout(dimensions);
+        const unstickyAvailableDimensions = {
+            container: dimensions.container,
+            available: ( new Dimension(
+                dimensions.available.width,
+                dimensions.available.height - stickyDimensions.height
+            ))
+        };
+        const unstickyDimensions = this.unstickyEditorTabsControl.layout(unstickyAvailableDimensions);
+        return ( new Dimension(
+            dimensions.container.width,
+            stickyDimensions.height + unstickyDimensions.height
+        ));
+    }
+    getHeight() {
+        return this.stickyEditorTabsControl.getHeight() + this.unstickyEditorTabsControl.getHeight();
+    }
+    dispose() {
+        this.parent.classList.toggle('two-tab-bars', false);
+        super.dispose();
+    }
+};
+MultiRowEditorControl = ( __decorate([
+    ( __param(4, IInstantiationService))
+], MultiRowEditorControl));
+
+export { MultiRowEditorControl };

package/vscode/src/vs/workbench/browser/parts/editor/{noTabsTitleControl.js → singleEditorTabsControl.js}

@@ -1,6 +1,6 @@
-import './media/notabstitlecontrol.css.js';
+import './media/singleeditortabscontrol.css.js';
 import { preventEditorClose, EditorCloseMethod, EditorResourceAccessor, SideBySideEditor } from 'vscode/vscode/vs/workbench/common/editor';
-import { TitleControl } from './titleControl.js';
+import { EditorTabsControl } from './editorTabsControl.js';
 import { ResourceLabel } from 'vscode/vscode/vs/workbench/browser/labels';
 import { TAB_ACTIVE_FOREGROUND, TAB_UNFOCUSED_ACTIVE_FOREGROUND } from 'vscode/vscode/vs/workbench/common/theme';
 import { Gesture, EventType as EventType$1 } from 'monaco-editor/esm/vs/base/browser/touch.js';
@@ -11,14 +11,16 @@ import { assertIsDefined, assertAllDefined } from 'monaco-editor/esm/vs/base/com
 import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
 import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { defaultBreadcrumbsWidgetStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { BreadcrumbsControlFactory } from './breadcrumbsControl.js';
 
-class NoTabsTitleControl extends TitleControl {
+class SingleEditorTabsControl extends EditorTabsControl {
     constructor() {
         super(...arguments);
         this.activeLabel = Object.create(null);
     }
-    static { this.HEIGHT = 35; }
+    get breadcrumbsControl() { return this.breadcrumbsControlFactory?.control; }
     create(parent) {
+        super.create(parent);
         const titleContainer = this.titleContainer = parent;
         titleContainer.draggable = true;
         this.registerContainerListeners(titleContainer);
@@ -28,7 +30,14 @@ class NoTabsTitleControl extends TitleControl {
         titleContainer.appendChild(labelContainer);
         this.editorLabel = this._register(this.instantiationService.createInstance(ResourceLabel, labelContainer, undefined)).element;
         this._register(addDisposableListener(this.editorLabel.element, EventType.CLICK, e => this.onTitleLabelClick(e)));
-        this.createBreadcrumbsControl(labelContainer, { showFileIcons: false, showSymbolIcons: true, showDecorationColors: false, widgetStyles: { ...defaultBreadcrumbsWidgetStyles, breadcrumbsBackground: ( Color.transparent.toString()) }, showPlaceholder: false });
+        this.breadcrumbsControlFactory = this._register(this.instantiationService.createInstance(BreadcrumbsControlFactory, labelContainer, this.groupView, {
+            showFileIcons: false,
+            showSymbolIcons: true,
+            showDecorationColors: false,
+            widgetStyles: { ...defaultBreadcrumbsWidgetStyles, breadcrumbsBackground: ( Color.transparent.toString()) },
+            showPlaceholder: false
+        }));
+        this._register(this.breadcrumbsControlFactory.onDidEnablementChange(() => this.handleBreadcrumbsEnablementChange()));
         titleContainer.classList.toggle('breadcrumbs', Boolean(this.breadcrumbsControl));
         this._register(toDisposable(() => titleContainer.classList.remove('breadcrumbs')));
         const actionsContainer = document.createElement('div');
@@ -43,8 +52,8 @@ class NoTabsTitleControl extends TitleControl {
         this._register(addDisposableListener(titleContainer, EventType$1.Tap, (e) => this.onTitleTap(e)));
         for (const event of [EventType.CONTEXT_MENU, EventType$1.Contextmenu]) {
             this._register(addDisposableListener(titleContainer, event, e => {
-                if (this.group.activeEditor) {
-                    this.onContextMenu(this.group.activeEditor, e, titleContainer);
+                if (this.tabsModel.activeEditor) {
+                    this.onTabContextMenu(this.tabsModel.activeEditor, e, titleContainer);
                 }
             }));
         }
@@ -55,13 +64,13 @@ class NoTabsTitleControl extends TitleControl {
     }
     onTitleDoubleClick(e) {
         EventHelper.stop(e);
-        this.group.pinEditor();
+        this.groupView.pinEditor();
     }
     onTitleAuxClick(e) {
-        if (e.button === 1  && this.group.activeEditor) {
+        if (e.button === 1  && this.tabsModel.activeEditor) {
             EventHelper.stop(e, true );
-            if (!preventEditorClose(this.group, this.group.activeEditor, EditorCloseMethod.MOUSE, this.accessor.partOptions)) {
-                this.group.closeEditor(this.group.activeEditor);
+            if (!preventEditorClose(this.tabsModel, this.tabsModel.activeEditor, EditorCloseMethod.MOUSE, this.groupsView.partOptions)) {
+                this.groupView.closeEditor(this.tabsModel.activeEditor);
             }
         }
     }
@@ -73,16 +82,17 @@ class NoTabsTitleControl extends TitleControl {
         setTimeout(() => this.quickInputService.quickAccess.show(), 50);
     }
     openEditor(editor) {
-        this.doHandleOpenEditor();
+        return this.doHandleOpenEditor();
     }
     openEditors(editors) {
-        this.doHandleOpenEditor();
+        return this.doHandleOpenEditor();
     }
     doHandleOpenEditor() {
         const activeEditorChanged = this.ifActiveEditorChanged(() => this.redraw());
         if (!activeEditorChanged) {
             this.ifActiveEditorPropertiesChanged(() => this.redraw());
         }
+        return activeEditorChanged;
     }
     beforeCloseEditor(editor) {
     }
@@ -120,6 +130,7 @@ class NoTabsTitleControl extends TitleControl {
         });
     }
     updateOptions(oldOptions, newOptions) {
+        super.updateOptions(oldOptions, newOptions);
         if (oldOptions.labelFormat !== newOptions.labelFormat || !equals(oldOptions.decorations, newOptions.decorations)) {
             this.redraw();
         }
@@ -133,9 +144,9 @@ class NoTabsTitleControl extends TitleControl {
         this.redraw();
     }
     ifActiveEditorChanged(fn) {
-        if (!this.activeLabel.editor && this.group.activeEditor ||
-            this.activeLabel.editor && !this.group.activeEditor ||
-            (!this.activeLabel.editor || !this.group.isActive(this.activeLabel.editor))
+        if (!this.activeLabel.editor && this.tabsModel.activeEditor ||
+            this.activeLabel.editor && !this.tabsModel.activeEditor ||
+            (!this.activeLabel.editor || !this.tabsModel.isActive(this.activeLabel.editor))
         ) {
             fn();
             return true;
@@ -143,23 +154,23 @@ class NoTabsTitleControl extends TitleControl {
         return false;
     }
     ifActiveEditorPropertiesChanged(fn) {
-        if (!this.activeLabel.editor || !this.group.activeEditor) {
+        if (!this.activeLabel.editor || !this.tabsModel.activeEditor) {
             return;
         }
-        if (this.activeLabel.pinned !== this.group.isPinned(this.group.activeEditor)) {
+        if (this.activeLabel.pinned !== this.tabsModel.isPinned(this.tabsModel.activeEditor)) {
             fn();
         }
     }
     ifEditorIsActive(editor, fn) {
-        if (this.group.isActive(editor)) {
+        if (this.tabsModel.isActive(editor)) {
             fn();
         }
     }
     redraw() {
-        const editor = this.group.activeEditor ?? undefined;
-        const options = this.accessor.partOptions;
-        const isEditorPinned = editor ? this.group.isPinned(editor) : false;
-        const isGroupActive = this.accessor.activeGroup === this.group;
+        const editor = this.tabsModel.activeEditor ?? undefined;
+        const options = this.groupsView.partOptions;
+        const isEditorPinned = editor ? this.tabsModel.isPinned(editor) : false;
+        const isGroupActive = this.groupsView.activeGroup === this.groupView;
         this.activeLabel = { editor, pinned: isEditorPinned };
         if (this.breadcrumbsControl) {
             if (isGroupActive) {
@@ -178,7 +189,7 @@ class NoTabsTitleControl extends TitleControl {
         }
         else {
             this.updateEditorDirty(editor);
-            const { labelFormat } = this.accessor.partOptions;
+            const { labelFormat } = this.groupsView.partOptions;
             let description;
             if (this.breadcrumbsControl && !this.breadcrumbsControl.isHidden()) {
                 description = '';
@@ -223,7 +234,7 @@ class NoTabsTitleControl extends TitleControl {
         }
     }
     prepareEditorActions(editorActions) {
-        const isGroupActive = this.accessor.activeGroup === this.group;
+        const isGroupActive = this.groupsView.activeGroup === this.groupView;
         if (isGroupActive) {
             return editorActions;
         }
@@ -235,15 +246,12 @@ class NoTabsTitleControl extends TitleControl {
         }
     }
     getHeight() {
-        return {
-            total: NoTabsTitleControl.HEIGHT,
-            offset: 0
-        };
+        return this.tabHeight;
     }
     layout(dimensions) {
         this.breadcrumbsControl?.layout(undefined);
-        return ( new Dimension(dimensions.container.width, this.getHeight().total));
+        return ( new Dimension(dimensions.container.width, this.getHeight()));
     }
 }
 
-export { NoTabsTitleControl };
+export { SingleEditorTabsControl };

package/vscode/src/vs/workbench/browser/parts/views/checkbox.js

@@ -50,6 +50,7 @@ class TreeItemCheckbox extends Disposable {
             this.setHover(node.checkbox);
             this.setAccessibilityInformation(node.checkbox);
             this.toggle.domNode.classList.add(TreeItemCheckbox.checkboxClass);
+            this.toggle.domNode.tabIndex = 1;
             dom.append(this.checkboxContainer, this.toggle.domNode);
             this.registerListener(node);
         }

package/vscode/src/vs/workbench/browser/parts/views/treeView.js

@@ -98,7 +98,7 @@ let TreeViewPane = class TreeViewPane extends ViewPane {
         this.renderTreeView(container);
     }
     shouldShowWelcome() {
-        return ((this.treeView.dataProvider === undefined) || !!this.treeView.dataProvider.isTreeEmpty) && (this.treeView.message === undefined);
+        return ((this.treeView.dataProvider === undefined) || !!this.treeView.dataProvider.isTreeEmpty) && ((this.treeView.message === undefined) || (this.treeView.message === ''));
     }
     layoutBody(height, width) {
         super.layoutBody(height, width);
@@ -807,7 +807,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
                 this.focus(true, item);
                 this.tree.setFocus([item]);
             }
-            else {
+            else if (this.tree.getFocus().length === 0) {
                 this.tree.setFocus([]);
             }
         }
@@ -1090,10 +1090,7 @@ let TreeRenderer = class TreeRenderer extends Disposable {
             }
         }
         templateData.actionBar.context = { $treeViewId: this.treeViewId, $treeItemHandle: node.handle };
-        const menuActions = this.menus.getResourceActions(node);
-        if (menuActions.menu) {
-            templateData.elementDisposable.add(menuActions.menu);
-        }
+        const menuActions = this.menus.getResourceActions(node, templateData.elementDisposable);
         templateData.actionBar.push(menuActions.actions, { icon: true, label: false });
         if (this._actionRunner) {
             templateData.actionBar.actionRunner = this._actionRunner;
@@ -1329,16 +1326,15 @@ class MultipleSelectionActionRunner extends ActionRunner {
         await action.run(context, selectionHandleArgs);
     }
 }
-let TreeMenus = class TreeMenus extends Disposable {
+let TreeMenus = class TreeMenus {
     constructor(id, menuService) {
-        super();
         this.id = id;
         this.menuService = menuService;
         this._onDidChange = ( new Emitter());
         this.onDidChange = this._onDidChange.event;
     }
-    getResourceActions(element) {
-        const actions = this.getActions(MenuId.ViewItemContext, element, true);
+    getResourceActions(element, disposableStore) {
+        const actions = this.getActions(MenuId.ViewItemContext, element, disposableStore);
         return { menu: actions.menu, actions: actions.primary };
     }
     getResourceContextActions(element) {
@@ -1347,7 +1343,7 @@ let TreeMenus = class TreeMenus extends Disposable {
     setContextKeyService(service) {
         this.contextKeyService = service;
     }
-    getActions(menuId, element, listen = false) {
+    getActions(menuId, element, listen) {
         if (!this.contextKeyService) {
             return { primary: [], secondary: [] };
         }
@@ -1361,7 +1357,8 @@ let TreeMenus = class TreeMenus extends Disposable {
         const result = { primary, secondary, menu };
         createAndFillInContextMenuActions(menu, { shouldForwardArgs: true }, result, 'inline');
         if (listen) {
-            this._register(menu.onDidChange(() => this._onDidChange.fire(element)));
+            listen.add(menu.onDidChange(() => this._onDidChange.fire(element)));
+            listen.add(menu);
         }
         else {
             menu.dispose();
@@ -1370,7 +1367,6 @@ let TreeMenus = class TreeMenus extends Disposable {
     }
     dispose() {
         this.contextKeyService = undefined;
-        super.dispose();
     }
 };
 TreeMenus = ( __decorate([
@@ -1580,6 +1576,7 @@ let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
             this.dragCancellationToken?.cancel();
         }
     }
+    dispose() { }
 };
 CustomTreeViewDragAndDrop = ( __decorate([
     ( __param(1, ILabelService)),

package/vscode/src/vs/workbench/common/editor/filteredEditorGroupModel.js

@@ -0,0 +1,109 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+
+class FilteredEditorGroupModel extends Disposable {
+    constructor(model) {
+        super();
+        this.model = model;
+        this._onDidModelChange = this._register(( new Emitter()));
+        this.onDidModelChange = this._onDidModelChange.event;
+        this._register(this.model.onDidModelChange(e => {
+            const candidateOrIndex = e.editorIndex ?? e.editor;
+            if (candidateOrIndex !== undefined) {
+                if (!this.filter(candidateOrIndex)) {
+                    return;
+                }
+            }
+            this._onDidModelChange.fire(e);
+        }));
+    }
+    get id() { return this.model.id; }
+    get isLocked() { return this.model.isLocked; }
+    get stickyCount() { return this.model.stickyCount; }
+    get activeEditor() { return this.model.activeEditor && this.filter(this.model.activeEditor) ? this.model.activeEditor : null; }
+    get previewEditor() { return this.model.previewEditor && this.filter(this.model.previewEditor) ? this.model.previewEditor : null; }
+    isPinned(editorOrIndex) { return this.model.isPinned(editorOrIndex); }
+    isSticky(editorOrIndex) { return this.model.isSticky(editorOrIndex); }
+    isActive(editor) { return this.model.isActive(editor); }
+    isFirst(editor) {
+        return this.model.isFirst(editor, this.getEditors(1 ));
+    }
+    isLast(editor) {
+        return this.model.isLast(editor, this.getEditors(1 ));
+    }
+    getEditors(order, options) {
+        const editors = this.model.getEditors(order, options);
+        return editors.filter(e => this.filter(e));
+    }
+    findEditor(candidate, options) {
+        const result = this.model.findEditor(candidate, options);
+        if (!result) {
+            return undefined;
+        }
+        return this.filter(result[1]) ? result : undefined;
+    }
+}
+class StickyEditorGroupModel extends FilteredEditorGroupModel {
+    get count() { return this.model.stickyCount; }
+    getEditors(order, options) {
+        if (options?.excludeSticky) {
+            return [];
+        }
+        if (order === 1 ) {
+            return this.model.getEditors(1 ).slice(0, this.model.stickyCount);
+        }
+        return super.getEditors(order, options);
+    }
+    isSticky(editorOrIndex) {
+        return true;
+    }
+    getEditorByIndex(index) {
+        return index < this.count ? this.model.getEditorByIndex(index) : undefined;
+    }
+    indexOf(editor, editors, options) {
+        const editorIndex = this.model.indexOf(editor, editors, options);
+        if (editorIndex < 0 || editorIndex >= this.model.stickyCount) {
+            return -1;
+        }
+        return editorIndex;
+    }
+    contains(candidate, options) {
+        const editorIndex = this.model.indexOf(candidate, undefined, options);
+        return editorIndex >= 0 && editorIndex < this.model.stickyCount;
+    }
+    filter(candidateOrIndex) {
+        return this.model.isSticky(candidateOrIndex);
+    }
+}
+class UnstickyEditorGroupModel extends FilteredEditorGroupModel {
+    get count() { return this.model.count - this.model.stickyCount; }
+    get stickyCount() { return 0; }
+    isSticky(editorOrIndex) {
+        return false;
+    }
+    getEditors(order, options) {
+        if (order === 1 ) {
+            return this.model.getEditors(1 ).slice(this.model.stickyCount);
+        }
+        return super.getEditors(order, options);
+    }
+    getEditorByIndex(index) {
+        return index >= 0 ? this.model.getEditorByIndex(index + this.model.stickyCount) : undefined;
+    }
+    indexOf(editor, editors, options) {
+        const editorIndex = this.model.indexOf(editor, editors, options);
+        if (editorIndex < this.model.stickyCount || editorIndex >= this.model.count) {
+            return -1;
+        }
+        return editorIndex - this.model.stickyCount;
+    }
+    contains(candidate, options) {
+        const editorIndex = this.model.indexOf(candidate, undefined, options);
+        return editorIndex >= this.model.stickyCount && editorIndex < this.model.count;
+    }
+    filter(candidateOrIndex) {
+        return !this.model.isSticky(candidateOrIndex);
+    }
+}
+
+export { StickyEditorGroupModel, UnstickyEditorGroupModel };

package/vscode/src/vs/workbench/contrib/customEditor/common/customEditorModelManager.js

@@ -1,4 +1,4 @@
-import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
+import { createSingleCallFunction } from 'monaco-editor/esm/vs/base/common/functional.js';
 
 class CustomEditorModelManager {
     constructor() {
@@ -29,7 +29,7 @@ class CustomEditorModelManager {
         return entry.model.then(model => {
             return {
                 object: model,
-                dispose: once(() => {
+                dispose: createSingleCallFunction(() => {
                     if (--entry.counter <= 0) {
                         entry.model.then(x => x.dispose());
                         this._references.delete(key);

package/vscode/src/vs/workbench/contrib/files/browser/editors/fileEditorInput.js

@@ -278,7 +278,7 @@ let FileEditorInput = FileEditorInput_1 = class FileEditorInput extends Abstract
             untypedInput.languageId = this.getLanguageId();
             untypedInput.contents = (() => {
                 const model = this.textFileService.files.get(this.resource);
-                if (model?.isDirty()) {
+                if (model?.isDirty() && !model.textEditorModel.isTooLargeForHeapOperation()) {
                     return model.textEditorModel.getValue();
                 }
                 return undefined;

package/vscode/src/vs/workbench/contrib/remote/browser/tunnelView.js

@@ -22,7 +22,7 @@ import { TunnelType, TUNNEL_VIEW_ID, TunnelEditId, IRemoteExplorerService } from
 import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
 import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
 import { InputBox } from 'monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.js';
-import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
+import { createSingleCallFunction } from 'monaco-editor/esm/vs/base/common/functional.js';
 import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
@@ -385,7 +385,7 @@ let ActionBarRenderer = class ActionBarRenderer extends Disposable {
         inputBox.value = value;
         inputBox.focus();
         inputBox.select({ start: 0, end: editableData.startingValue ? editableData.startingValue.length : 0 });
-        const done = once(async (success, finishEditing) => {
+        const done = createSingleCallFunction(async (success, finishEditing) => {
             dispose(toDispose);
             if (this.inputDone) {
                 this.inputDone = undefined;
@@ -1320,7 +1320,7 @@ var ChangeLocalPortAction;
     ChangeLocalPortAction.LABEL = ( (nls.localize('remote.tunnel.changeLocalPort', "Change Local Address Port")));
     function validateInput(tunnelService, value, canElevate) {
         if (!value.match(/^[0-9]+$/)) {
-            return { content: invalidPortString, severity: Severity.Error };
+            return { content: ( (nls.localize('remote.tunnelsView.portShouldBeNumber', "Local port should be a number."))), severity: Severity.Error };
         }
         else if (Number(value) >= maxPortNumber) {
             return { content: invalidPortNumberString, severity: Severity.Error };

package/vscode/src/vs/workbench/contrib/webview/browser/themeing.js

@@ -3,7 +3,7 @@ import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { EDITOR_FONT_DEFAULTS } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import * as colors from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import * as colorRegistry from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
 import { ColorScheme } from 'monaco-editor/esm/vs/platform/theme/common/theme.js';
 import { IWorkbenchThemeService } from 'vscode/vscode/vs/workbench/services/themes/common/workbenchThemeService';
 import { DEFAULT_FONT_FAMILY } from 'vscode/vscode/vs/workbench/browser/style';
@@ -36,7 +36,7 @@ let WebviewThemeDataProvider = class WebviewThemeDataProvider extends Disposable
             const editorFontWeight = configuration.fontWeight || EDITOR_FONT_DEFAULTS.fontWeight;
             const editorFontSize = configuration.fontSize || EDITOR_FONT_DEFAULTS.fontSize;
             const theme = this._themeService.getColorTheme();
-            const exportedColors = colors.getColorRegistry().getColors().reduce((colors, entry) => {
+            const exportedColors = colorRegistry.getColorRegistry().getColors().reduce((colors, entry) => {
                 const color = theme.getColor(entry.id);
                 if (color) {
                     colors['vscode-' + entry.id.replace('.', '-')] = ( color.toString());

package/vscode/src/vs/workbench/contrib/webview/browser/webviewElement.js

@@ -22,7 +22,7 @@ import { IRemoteAuthorityResolverService } from 'vscode/vscode/vs/platform/remot
 import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
 import { ITunnelService } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
 import { WebviewPortMappingManager } from '../../../../platform/webview/common/webviewPortMapping.js';
-import { parentOriginHash } from 'vscode/vscode/vs/workbench/browser/iframe';
+import { parentOriginHash } from 'monaco-editor/esm/vs/base/browser/iframe.js';
 import { loadLocalResource, WebviewResourceResponse } from './resourceLoading.js';
 import { areWebviewContentOptionsEqual } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview';
 import { WebviewFindWidget } from './webviewFindWidget.js';

package/vscode/src/vs/workbench/services/history/browser/historyService.js

@@ -778,6 +778,17 @@ let HistoryService = class HistoryService extends Disposable {
         }
         return undefined;
     }
+    dispose() {
+        super.dispose();
+        for (const [, stack] of this.editorGroupScopedNavigationStacks) {
+            stack.disposable.dispose();
+        }
+        for (const [, editors] of this.editorScopedNavigationStacks) {
+            for (const [, stack] of editors) {
+                stack.disposable.dispose();
+            }
+        }
+    }
 };
 HistoryService = HistoryService_1 = ( (__decorate([
     ( (__param(0, IEditorService))),

package/vscode/src/vs/workbench/services/userDataProfile/common/userDataProfileIcons.js

@@ -0,0 +1,7 @@
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+
+const DEFAULT_ICON = registerIcon('settings-view-bar-icon', Codicon.settingsGear, ( localize('settingsViewBarIcon', "Settings icon in the view bar.")));
+
+export { DEFAULT_ICON };