@codingame/monaco-vscode-api 1.79.0 → 1.79.1

package/dist/vscode/vs/workbench/browser/parts/editor/editorGroupView.js

@@ -0,0 +1,1219 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import './media/editorgroupview.css.js';
+import { isSerializedEditorGroupModel, EditorGroupModel, isGroupEditorCloseEvent, isGroupEditorOpenEvent } from '../../../common/editor/editorGroupModel.js';
+import { DEFAULT_EDITOR_ASSOCIATION, SideBySideEditor, EditorResourceAccessor, EditorCloseContext } from '../../../common/editor.js';
+import { ActiveEditorDirtyContext, ActiveEditorPinnedContext, ActiveEditorFirstInGroupContext, ActiveEditorLastInGroupContext, ActiveEditorStickyContext, EditorGroupEditorsCountContext, ActiveEditorGroupLockedContext } from '../../../common/contextkeys.js';
+import { SideBySideEditorInput } from '../../../common/editor/sideBySideEditorInput.js';
+import { Emitter, Relay } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { addDisposableListener, EventType, EventHelper, trackFocus, clearNode, isAncestor, Dimension, findParentWithClass } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { ProgressBar } from 'monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.js';
+import { Themable, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { contrastBorder, editorBackground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { EDITOR_GROUP_EMPTY_BACKGROUND, EDITOR_GROUP_HEADER_BORDER, EDITOR_GROUP_HEADER_TABS_BACKGROUND, EDITOR_GROUP_HEADER_NO_TABS_BACKGROUND } from '../../../common/theme.js';
+import { TabsTitleControl } from './tabsTitleControl.js';
+import { EditorPanes } from './editorPanes.js';
+import { IEditorProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { EditorProgressIndicator } from '../../../services/progress/browser/progressIndicator.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { coalesce, firstOrDefault } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { MutableDisposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { RunOnceWorker, DeferredPromise, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { EventType as EventType$1 } from 'monaco-editor/esm/vs/base/browser/touch.js';
+import { fillActiveEditorViewState } from './editor.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { NoTabsTitleControl } from './noTabsTitleControl.js';
+import { MenuId, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { StandardMouseEvent } from 'monaco-editor/esm/vs/base/browser/mouseEvent.js';
+import { createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
+import { getMimeTypes } from 'monaco-editor/esm/vs/editor/common/services/languagesAssociations.js';
+import { extname, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { EditorActivation } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
+import { IFileDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.js';
+import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { isNative, isWindows, isLinux, isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { TelemetryTrustedValue } from '../../../../platform/telemetry/common/telemetryUtils.js';
+import { defaultProgressBarStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { EditorGroupWatermark } from './editorGroupWatermark.js';
+let EditorGroupView = class EditorGroupView extends Themable {
+    static createNew(accessor, index, instantiationService) {
+        return instantiationService.createInstance(EditorGroupView, accessor, null, index);
+    }
+    static createFromSerialized(serialized, accessor, index, instantiationService) {
+        return instantiationService.createInstance(EditorGroupView, accessor, serialized, index);
+    }
+    static createCopy(copyFrom, accessor, index, instantiationService) {
+        return instantiationService.createInstance(EditorGroupView, accessor, copyFrom, index);
+    }
+    constructor(accessor, from, _index, instantiationService, contextKeyService, themeService, telemetryService, keybindingService, menuService, contextMenuService, fileDialogService, editorService, filesConfigurationService, uriIdentityService, logService) {
+        super(themeService);
+        this.accessor = accessor;
+        this._index = _index;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.telemetryService = telemetryService;
+        this.keybindingService = keybindingService;
+        this.menuService = menuService;
+        this.contextMenuService = contextMenuService;
+        this.fileDialogService = fileDialogService;
+        this.editorService = editorService;
+        this.filesConfigurationService = filesConfigurationService;
+        this.uriIdentityService = uriIdentityService;
+        this.logService = logService;
+        this._onDidFocus = this._register(( new Emitter()));
+        this.onDidFocus = this._onDidFocus.event;
+        this._onWillDispose = this._register(( new Emitter()));
+        this.onWillDispose = this._onWillDispose.event;
+        this._onDidModelChange = this._register(( new Emitter()));
+        this.onDidModelChange = this._onDidModelChange.event;
+        this._onDidActiveEditorChange = this._register(( new Emitter()));
+        this.onDidActiveEditorChange = this._onDidActiveEditorChange.event;
+        this._onDidOpenEditorFail = this._register(( new Emitter()));
+        this.onDidOpenEditorFail = this._onDidOpenEditorFail.event;
+        this._onWillCloseEditor = this._register(( new Emitter()));
+        this.onWillCloseEditor = this._onWillCloseEditor.event;
+        this._onDidCloseEditor = this._register(( new Emitter()));
+        this.onDidCloseEditor = this._onDidCloseEditor.event;
+        this._onWillMoveEditor = this._register(( new Emitter()));
+        this.onWillMoveEditor = this._onWillMoveEditor.event;
+        this._onWillOpenEditor = this._register(( new Emitter()));
+        this.onWillOpenEditor = this._onWillOpenEditor.event;
+        this.disposedEditorsWorker = this._register(( new RunOnceWorker(editors => this.handleDisposedEditors(editors), 0)));
+        this.mapEditorToPendingConfirmation = ( new Map());
+        this.containerToolBarMenuDisposable = this._register(( new MutableDisposable()));
+        this.whenRestoredPromise = ( new DeferredPromise());
+        this.whenRestored = this.whenRestoredPromise.p;
+        this._disposed = false;
+        this.element = document.createElement('div');
+        this._onDidChange = this._register(( new Relay()));
+        this.onDidChange = this._onDidChange.event;
+        if (from instanceof EditorGroupView) {
+            this.model = this._register(from.model.clone());
+        }
+        else if (isSerializedEditorGroupModel(from)) {
+            this.model = this._register(instantiationService.createInstance(EditorGroupModel, from));
+        }
+        else {
+            this.model = this._register(instantiationService.createInstance(EditorGroupModel, undefined));
+        }
+        {
+            this.scopedContextKeyService = this._register(this.contextKeyService.createScoped(this.element));
+            this.element.classList.add('editor-group-container');
+            this.registerContainerListeners();
+            this.createContainerToolbar();
+            this.createContainerContextMenu();
+            this._register(this.instantiationService.createInstance(EditorGroupWatermark, this.element));
+            this.progressBar = this._register(( new ProgressBar(this.element, defaultProgressBarStyles)));
+            this.progressBar.hide();
+            this.scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection(
+                [IContextKeyService, this.scopedContextKeyService],
+                [IEditorProgressService, this._register(( new EditorProgressIndicator(this.progressBar, this)))]
+            )));
+            this.handleGroupContextKeys();
+            this.titleContainer = document.createElement('div');
+            this.titleContainer.classList.add('title');
+            this.element.appendChild(this.titleContainer);
+            this.titleAreaControl = this.createTitleAreaControl();
+            this.editorContainer = document.createElement('div');
+            this.editorContainer.classList.add('editor-container');
+            this.element.appendChild(this.editorContainer);
+            this.editorPane = this._register(this.scopedInstantiationService.createInstance(EditorPanes, this.element, this.editorContainer, this));
+            this._onDidChange.input = this.editorPane.onDidChangeSizeConstraints;
+            this.doTrackFocus();
+            this.updateTitleContainer();
+            this.updateContainer();
+            this.updateStyles();
+        }
+        const restoreEditorsPromise = this.restoreEditors(from) ?? Promise.resolve();
+        restoreEditorsPromise.finally(() => {
+            this.whenRestoredPromise.complete();
+        });
+        this.registerListeners();
+    }
+    handleGroupContextKeys() {
+        const groupActiveEditorDirtyContext = ActiveEditorDirtyContext.bindTo(this.scopedContextKeyService);
+        const groupActiveEditorPinnedContext = ActiveEditorPinnedContext.bindTo(this.scopedContextKeyService);
+        const groupActiveEditorFirstContext = ActiveEditorFirstInGroupContext.bindTo(this.scopedContextKeyService);
+        const groupActiveEditorLastContext = ActiveEditorLastInGroupContext.bindTo(this.scopedContextKeyService);
+        const groupActiveEditorStickyContext = ActiveEditorStickyContext.bindTo(this.scopedContextKeyService);
+        const groupEditorsCountContext = EditorGroupEditorsCountContext.bindTo(this.scopedContextKeyService);
+        const groupLockedContext = ActiveEditorGroupLockedContext.bindTo(this.scopedContextKeyService);
+        const activeEditorListener = ( new MutableDisposable());
+        const observeActiveEditor = () => {
+            activeEditorListener.clear();
+            const activeEditor = this.model.activeEditor;
+            if (activeEditor) {
+                groupActiveEditorDirtyContext.set(activeEditor.isDirty() && !activeEditor.isSaving());
+                activeEditorListener.value = activeEditor.onDidChangeDirty(() => {
+                    groupActiveEditorDirtyContext.set(activeEditor.isDirty() && !activeEditor.isSaving());
+                });
+            }
+            else {
+                groupActiveEditorDirtyContext.set(false);
+            }
+        };
+        this._register(this.onDidModelChange(e => {
+            switch (e.kind) {
+                case 2 :
+                    groupLockedContext.set(this.isLocked);
+                    break;
+                case 6 :
+                case 4 :
+                case 3 :
+                case 5 :
+                    groupActiveEditorFirstContext.set(this.model.isFirst(this.model.activeEditor));
+                    groupActiveEditorLastContext.set(this.model.isLast(this.model.activeEditor));
+                    break;
+                case 9 :
+                    if (e.editor && e.editor === this.model.activeEditor) {
+                        groupActiveEditorPinnedContext.set(this.model.isPinned(this.model.activeEditor));
+                    }
+                    break;
+                case 10 :
+                    if (e.editor && e.editor === this.model.activeEditor) {
+                        groupActiveEditorStickyContext.set(this.model.isSticky(this.model.activeEditor));
+                    }
+                    break;
+            }
+            groupEditorsCountContext.set(this.count);
+        }));
+        this._register(this.onDidActiveEditorChange(() => {
+            observeActiveEditor();
+        }));
+        observeActiveEditor();
+    }
+    registerContainerListeners() {
+        this._register(addDisposableListener(this.element, EventType.DBLCLICK, e => {
+            if (this.isEmpty) {
+                EventHelper.stop(e);
+                this.editorService.openEditor({
+                    resource: undefined,
+                    options: {
+                        pinned: true,
+                        override: DEFAULT_EDITOR_ASSOCIATION.id
+                    }
+                }, this.id);
+            }
+        }));
+        this._register(addDisposableListener(this.element, EventType.AUXCLICK, e => {
+            if (this.isEmpty && e.button === 1 ) {
+                EventHelper.stop(e, true);
+                this.accessor.removeGroup(this);
+            }
+        }));
+    }
+    createContainerToolbar() {
+        const toolbarContainer = document.createElement('div');
+        toolbarContainer.classList.add('editor-group-container-toolbar');
+        this.element.appendChild(toolbarContainer);
+        const containerToolbar = this._register(( new ActionBar(toolbarContainer, {
+            ariaLabel: ( localize('ariaLabelGroupActions', "Empty editor group actions"))
+        })));
+        const containerToolbarMenu = this._register(this.menuService.createMenu(MenuId.EmptyEditorGroup, this.scopedContextKeyService));
+        const updateContainerToolbar = () => {
+            const actions = { primary: [], secondary: [] };
+            this.containerToolBarMenuDisposable.value = toDisposable(() => containerToolbar.clear());
+            createAndFillInActionBarActions(containerToolbarMenu, { arg: { groupId: this.id }, shouldForwardArgs: true }, actions, 'navigation');
+            for (const action of [...actions.primary, ...actions.secondary]) {
+                const keybinding = this.keybindingService.lookupKeybinding(action.id);
+                containerToolbar.push(action, { icon: true, label: false, keybinding: keybinding?.getLabel() });
+            }
+        };
+        updateContainerToolbar();
+        this._register(containerToolbarMenu.onDidChange(updateContainerToolbar));
+    }
+    createContainerContextMenu() {
+        this._register(addDisposableListener(this.element, EventType.CONTEXT_MENU, e => this.onShowContainerContextMenu(e)));
+        this._register(addDisposableListener(this.element, EventType$1.Contextmenu, () => this.onShowContainerContextMenu()));
+    }
+    onShowContainerContextMenu(e) {
+        if (!this.isEmpty) {
+            return;
+        }
+        let anchor = this.element;
+        if (e instanceof MouseEvent) {
+            const event = ( new StandardMouseEvent(e));
+            anchor = { x: event.posx, y: event.posy };
+        }
+        this.contextMenuService.showContextMenu({
+            menuId: MenuId.EmptyEditorGroupContext,
+            contextKeyService: this.contextKeyService,
+            getAnchor: () => anchor,
+            onHide: () => {
+                this.focus();
+            }
+        });
+    }
+    doTrackFocus() {
+        const containerFocusTracker = this._register(trackFocus(this.element));
+        this._register(containerFocusTracker.onDidFocus(() => {
+            if (this.isEmpty) {
+                this._onDidFocus.fire();
+            }
+        }));
+        const handleTitleClickOrTouch = (e) => {
+            let target;
+            if (e instanceof MouseEvent) {
+                if (e.button !== 0  || ((isMacintosh && e.ctrlKey) )) {
+                    return undefined;
+                }
+                target = e.target;
+            }
+            else {
+                target = e.initialTarget;
+            }
+            if (findParentWithClass(target, 'monaco-action-bar', this.titleContainer) ||
+                findParentWithClass(target, 'monaco-breadcrumb-item', this.titleContainer)) {
+                return;
+            }
+            setTimeout(() => {
+                this.focus();
+            });
+        };
+        this._register(addDisposableListener(this.titleContainer, EventType.MOUSE_DOWN, e => handleTitleClickOrTouch(e)));
+        this._register(addDisposableListener(this.titleContainer, EventType$1.Tap, e => handleTitleClickOrTouch(e)));
+        this._register(this.editorPane.onDidFocus(() => {
+            this._onDidFocus.fire();
+        }));
+    }
+    updateContainer() {
+        if (this.isEmpty) {
+            this.element.classList.add('empty');
+            this.element.tabIndex = 0;
+            this.element.setAttribute('aria-label', ( localize('emptyEditorGroup', "{0} (empty)", this.label)));
+        }
+        else {
+            this.element.classList.remove('empty');
+            this.element.removeAttribute('tabIndex');
+            this.element.removeAttribute('aria-label');
+        }
+        this.updateStyles();
+    }
+    updateTitleContainer() {
+        this.titleContainer.classList.toggle('tabs', this.accessor.partOptions.showTabs);
+        this.titleContainer.classList.toggle('show-file-icons', this.accessor.partOptions.showIcons);
+    }
+    createTitleAreaControl() {
+        if (this.titleAreaControl) {
+            this.titleAreaControl.dispose();
+            clearNode(this.titleContainer);
+        }
+        if (this.accessor.partOptions.showTabs) {
+            this.titleAreaControl = this.scopedInstantiationService.createInstance(TabsTitleControl, this.titleContainer, this.accessor, this);
+        }
+        else {
+            this.titleAreaControl = this.scopedInstantiationService.createInstance(NoTabsTitleControl, this.titleContainer, this.accessor, this);
+        }
+        return this.titleAreaControl;
+    }
+    restoreEditors(from) {
+        if (this.count === 0) {
+            return;
+        }
+        let options;
+        if (from instanceof EditorGroupView) {
+            options = fillActiveEditorViewState(from);
+        }
+        else {
+            options = Object.create(null);
+        }
+        const activeEditor = this.model.activeEditor;
+        if (!activeEditor) {
+            return;
+        }
+        options.pinned = this.model.isPinned(activeEditor);
+        options.sticky = this.model.isSticky(activeEditor);
+        options.preserveFocus = true;
+        const activeElement = document.activeElement;
+        return this.doShowEditor(activeEditor, { active: true, isNew: false  }, options).then(() => {
+            if (this.accessor.activeGroup === this && activeElement === document.activeElement) {
+                this.focus();
+            }
+        });
+    }
+    registerListeners() {
+        this._register(this.model.onDidModelChange(e => this.onDidGroupModelChange(e)));
+        this._register(this.accessor.onDidChangeEditorPartOptions(e => this.onDidChangeEditorPartOptions(e)));
+        this._register(this.accessor.onDidVisibilityChange(e => this.onDidVisibilityChange(e)));
+    }
+    onDidGroupModelChange(e) {
+        this._onDidModelChange.fire(e);
+        if (!e.editor) {
+            return;
+        }
+        switch (e.kind) {
+            case 3 :
+                if (isGroupEditorOpenEvent(e)) {
+                    this.onDidOpenEditor(e.editor, e.editorIndex);
+                }
+                break;
+            case 4 :
+                if (isGroupEditorCloseEvent(e)) {
+                    this.handleOnDidCloseEditor(e.editor, e.editorIndex, e.context, e.sticky);
+                }
+                break;
+            case 12 :
+                this.onWillDisposeEditor(e.editor);
+                break;
+            case 11 :
+                this.onDidChangeEditorDirty(e.editor);
+                break;
+            case 7 :
+                this.onDidChangeEditorLabel(e.editor);
+                break;
+        }
+    }
+    onDidOpenEditor(editor, editorIndex) {
+        this.telemetryService.publicLog('editorOpened', this.toEditorTelemetryDescriptor(editor));
+        this.updateContainer();
+    }
+    handleOnDidCloseEditor(editor, editorIndex, context, sticky) {
+        this._onWillCloseEditor.fire({ groupId: this.id, editor, context, index: editorIndex, sticky });
+        const editorsToClose = [editor];
+        if (editor instanceof SideBySideEditorInput) {
+            editorsToClose.push(editor.primary, editor.secondary);
+        }
+        for (const editor of editorsToClose) {
+            if (this.canDispose(editor)) {
+                editor.dispose();
+            }
+        }
+        this.telemetryService.publicLog('editorClosed', this.toEditorTelemetryDescriptor(editor));
+        this.updateContainer();
+        this._onDidCloseEditor.fire({ groupId: this.id, editor, context, index: editorIndex, sticky });
+    }
+    canDispose(editor) {
+        for (const groupView of this.accessor.groups) {
+            if (groupView instanceof EditorGroupView && groupView.model.contains(editor, {
+                strictEquals: true,
+                supportSideBySide: SideBySideEditor.ANY
+            })) {
+                return false;
+            }
+        }
+        return true;
+    }
+    toEditorTelemetryDescriptor(editor) {
+        const descriptor = editor.getTelemetryDescriptor();
+        const resource = EditorResourceAccessor.getOriginalUri(editor);
+        const path = resource ? resource.scheme === Schemas.file ? resource.fsPath : resource.path : undefined;
+        if (resource && path) {
+            let resourceExt = extname(resource);
+            const queryStringLocation = resourceExt.indexOf('?');
+            resourceExt = queryStringLocation !== -1 ? resourceExt.substr(0, queryStringLocation) : resourceExt;
+            descriptor['resource'] = { mimeType: ( new TelemetryTrustedValue(getMimeTypes(resource).join(', '))), scheme: resource.scheme, ext: resourceExt, path: hash(path) };
+            return descriptor;
+        }
+        return descriptor;
+    }
+    onWillDisposeEditor(editor) {
+        this.disposedEditorsWorker.work(editor);
+    }
+    handleDisposedEditors(editors) {
+        let activeEditor;
+        const inactiveEditors = [];
+        for (const editor of editors) {
+            if (this.model.isActive(editor)) {
+                activeEditor = editor;
+            }
+            else if (this.model.contains(editor)) {
+                inactiveEditors.push(editor);
+            }
+        }
+        for (const inactiveEditor of inactiveEditors) {
+            this.doCloseEditor(inactiveEditor, false);
+        }
+        if (activeEditor) {
+            this.doCloseEditor(activeEditor, false);
+        }
+    }
+    onDidChangeEditorPartOptions(event) {
+        this.updateTitleContainer();
+        if (event.oldPartOptions.showTabs !== event.newPartOptions.showTabs) {
+            this.createTitleAreaControl();
+            this.relayout();
+            if (this.model.activeEditor) {
+                this.titleAreaControl.openEditor(this.model.activeEditor);
+            }
+        }
+        else {
+            this.titleAreaControl.updateOptions(event.oldPartOptions, event.newPartOptions);
+        }
+        this.updateStyles();
+        if (event.oldPartOptions.enablePreview && !event.newPartOptions.enablePreview) {
+            if (this.model.previewEditor) {
+                this.pinEditor(this.model.previewEditor);
+            }
+        }
+    }
+    onDidChangeEditorDirty(editor) {
+        this.pinEditor(editor);
+        this.titleAreaControl.updateEditorDirty(editor);
+    }
+    onDidChangeEditorLabel(editor) {
+        this.titleAreaControl.updateEditorLabel(editor);
+    }
+    onDidVisibilityChange(visible) {
+        this.editorPane.setVisible(visible);
+    }
+    get index() {
+        return this._index;
+    }
+    get label() {
+        return ( localize('groupLabel', "Group {0}", this._index + 1));
+    }
+    get ariaLabel() {
+        return ( localize('groupAriaLabel', "Editor Group {0}", this._index + 1));
+    }
+    get disposed() {
+        return this._disposed;
+    }
+    get isEmpty() {
+        return this.count === 0;
+    }
+    get titleHeight() {
+        return this.titleAreaControl.getHeight();
+    }
+    notifyIndexChanged(newIndex) {
+        if (this._index !== newIndex) {
+            this._index = newIndex;
+            this.model.setIndex(newIndex);
+        }
+    }
+    setActive(isActive) {
+        this.active = isActive;
+        this.element.classList.toggle('active', isActive);
+        this.element.classList.toggle('inactive', !isActive);
+        this.titleAreaControl.setActive(isActive);
+        this.updateStyles();
+        this.model.setActive(undefined );
+    }
+    get id() {
+        return this.model.id;
+    }
+    get editors() {
+        return this.model.getEditors(1 );
+    }
+    get count() {
+        return this.model.count;
+    }
+    get stickyCount() {
+        return this.model.stickyCount;
+    }
+    get activeEditorPane() {
+        return this.editorPane ? withNullAsUndefined(this.editorPane.activeEditorPane) : undefined;
+    }
+    get activeEditor() {
+        return this.model.activeEditor;
+    }
+    get previewEditor() {
+        return this.model.previewEditor;
+    }
+    isPinned(editorOrIndex) {
+        return this.model.isPinned(editorOrIndex);
+    }
+    isSticky(editorOrIndex) {
+        return this.model.isSticky(editorOrIndex);
+    }
+    isActive(editor) {
+        return this.model.isActive(editor);
+    }
+    contains(candidate, options) {
+        return this.model.contains(candidate, options);
+    }
+    getEditors(order, options) {
+        return this.model.getEditors(order, options);
+    }
+    findEditors(resource, options) {
+        const canonicalResource = this.uriIdentityService.asCanonicalUri(resource);
+        return this.getEditors(1 ).filter(editor => {
+            if (editor.resource && isEqual(editor.resource, canonicalResource)) {
+                return true;
+            }
+            if (options?.supportSideBySide === SideBySideEditor.PRIMARY || options?.supportSideBySide === SideBySideEditor.ANY) {
+                const primaryResource = EditorResourceAccessor.getCanonicalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY });
+                if (primaryResource && isEqual(primaryResource, canonicalResource)) {
+                    return true;
+                }
+            }
+            if (options?.supportSideBySide === SideBySideEditor.SECONDARY || options?.supportSideBySide === SideBySideEditor.ANY) {
+                const secondaryResource = EditorResourceAccessor.getCanonicalUri(editor, { supportSideBySide: SideBySideEditor.SECONDARY });
+                if (secondaryResource && isEqual(secondaryResource, canonicalResource)) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    getEditorByIndex(index) {
+        return this.model.getEditorByIndex(index);
+    }
+    getIndexOfEditor(editor) {
+        return this.model.indexOf(editor);
+    }
+    isFirst(editor) {
+        return this.model.isFirst(editor);
+    }
+    isLast(editor) {
+        return this.model.isLast(editor);
+    }
+    focus() {
+        if (this.activeEditorPane) {
+            this.activeEditorPane.focus();
+        }
+        else {
+            this.element.focus();
+        }
+        this._onDidFocus.fire();
+    }
+    pinEditor(candidate = this.activeEditor || undefined) {
+        if (candidate && !this.model.isPinned(candidate)) {
+            const editor = this.model.pin(candidate);
+            if (editor) {
+                this.titleAreaControl.pinEditor(editor);
+            }
+        }
+    }
+    stickEditor(candidate = this.activeEditor || undefined) {
+        this.doStickEditor(candidate, true);
+    }
+    unstickEditor(candidate = this.activeEditor || undefined) {
+        this.doStickEditor(candidate, false);
+    }
+    doStickEditor(candidate, sticky) {
+        if (candidate && this.model.isSticky(candidate) !== sticky) {
+            const oldIndexOfEditor = this.getIndexOfEditor(candidate);
+            const editor = sticky ? this.model.stick(candidate) : this.model.unstick(candidate);
+            if (!editor) {
+                return;
+            }
+            const newIndexOfEditor = this.getIndexOfEditor(editor);
+            if (newIndexOfEditor !== oldIndexOfEditor) {
+                this.titleAreaControl.moveEditor(editor, oldIndexOfEditor, newIndexOfEditor);
+            }
+            if (sticky) {
+                this.titleAreaControl.stickEditor(editor);
+            }
+            else {
+                this.titleAreaControl.unstickEditor(editor);
+            }
+        }
+    }
+    async openEditor(editor, options) {
+        return this.doOpenEditor(editor, options, {
+            supportSideBySide: SideBySideEditor.BOTH
+        });
+    }
+    async doOpenEditor(editor, options, internalOptions) {
+        if (!editor || editor.isDisposed()) {
+            return;
+        }
+        this._onWillOpenEditor.fire({ editor, groupId: this.id });
+        const openEditorOptions = {
+            index: options ? options.index : undefined,
+            pinned: options?.sticky || !this.accessor.partOptions.enablePreview || editor.isDirty() || ((options?.pinned ?? typeof options?.index === 'number') ) || (typeof options?.index === 'number' && this.model.isSticky(options.index)),
+            sticky: options?.sticky || (typeof options?.index === 'number' && this.model.isSticky(options.index)),
+            active: this.count === 0 || !options || !options.inactive,
+            supportSideBySide: internalOptions?.supportSideBySide
+        };
+        if (options?.sticky && typeof options?.index === 'number' && !this.model.isSticky(options.index)) {
+            openEditorOptions.sticky = false;
+        }
+        if (!openEditorOptions.active && !openEditorOptions.pinned && this.model.activeEditor && !this.model.isPinned(this.model.activeEditor)) {
+            openEditorOptions.active = true;
+        }
+        let activateGroup = false;
+        let restoreGroup = false;
+        if (options?.activation === EditorActivation.ACTIVATE) {
+            activateGroup = true;
+        }
+        else if (options?.activation === EditorActivation.RESTORE) {
+            restoreGroup = true;
+        }
+        else if (options?.activation === EditorActivation.PRESERVE) {
+            activateGroup = false;
+            restoreGroup = false;
+        }
+        else if (openEditorOptions.active) {
+            activateGroup = !options || !options.preserveFocus;
+            restoreGroup = !activateGroup;
+        }
+        if (typeof openEditorOptions.index === 'number') {
+            const indexOfEditor = this.model.indexOf(editor);
+            if (indexOfEditor !== -1 && indexOfEditor !== openEditorOptions.index) {
+                this.doMoveEditorInsideGroup(editor, openEditorOptions);
+            }
+        }
+        const { editor: openedEditor, isNew } = this.model.openEditor(editor, openEditorOptions);
+        if (isNew &&
+            this.count === 1 &&
+            this.accessor.groups.length > 1
+        ) {
+            if (openedEditor.editorId && this.accessor.partOptions.autoLockGroups?.has(openedEditor.editorId)) {
+                this.lock(true);
+            }
+        }
+        const showEditorResult = this.doShowEditor(openedEditor, { active: !!openEditorOptions.active, isNew }, options, internalOptions);
+        if (activateGroup) {
+            this.accessor.activateGroup(this);
+        }
+        else if (restoreGroup) {
+            this.accessor.restoreGroup(this);
+        }
+        return showEditorResult;
+    }
+    doShowEditor(editor, context, options, internalOptions) {
+        let openEditorPromise;
+        if (context.active) {
+            openEditorPromise = (async () => {
+                const { pane, changed, cancelled, error } = await this.editorPane.openEditor(editor, options, { newInGroup: context.isNew });
+                if (cancelled) {
+                    return undefined;
+                }
+                if (changed) {
+                    this._onDidActiveEditorChange.fire({ editor });
+                }
+                if (error) {
+                    this._onDidOpenEditorFail.fire(editor);
+                }
+                if (!pane && this.activeEditor === editor) {
+                    const focusNext = !options || !options.preserveFocus;
+                    this.doCloseEditor(editor, focusNext, { fromError: true });
+                }
+                return pane;
+            })();
+        }
+        else {
+            openEditorPromise = Promise.resolve(undefined);
+        }
+        if (!internalOptions?.skipTitleUpdate) {
+            this.titleAreaControl.openEditor(editor);
+        }
+        return openEditorPromise;
+    }
+    async openEditors(editors) {
+        const editorsToOpen = coalesce(editors).filter(({ editor }) => !editor.isDisposed());
+        const firstEditor = firstOrDefault(editorsToOpen);
+        if (!firstEditor) {
+            return;
+        }
+        const openEditorsOptions = {
+            supportSideBySide: SideBySideEditor.BOTH
+        };
+        await this.doOpenEditor(firstEditor.editor, firstEditor.options, openEditorsOptions);
+        const inactiveEditors = editorsToOpen.slice(1);
+        const startingIndex = this.getIndexOfEditor(firstEditor.editor) + 1;
+        await Promises.settled(( inactiveEditors.map(({ editor, options }, index) => {
+            return this.doOpenEditor(editor, {
+                ...options,
+                inactive: true,
+                pinned: true,
+                index: startingIndex + index
+            }, {
+                ...openEditorsOptions,
+                skipTitleUpdate: true
+            });
+        })));
+        this.titleAreaControl.openEditors(( inactiveEditors.map(({ editor }) => editor)));
+        return withNullAsUndefined(this.editorPane.activeEditorPane);
+    }
+    moveEditors(editors, target) {
+        const internalOptions = {
+            skipTitleUpdate: this !== target
+        };
+        for (const { editor, options } of editors) {
+            this.moveEditor(editor, target, options, internalOptions);
+        }
+        if (internalOptions.skipTitleUpdate) {
+            const movedEditors = ( editors.map(({ editor }) => editor));
+            target.titleAreaControl.openEditors(movedEditors);
+            this.titleAreaControl.closeEditors(movedEditors);
+        }
+    }
+    moveEditor(editor, target, options, internalOptions) {
+        if (this === target) {
+            this.doMoveEditorInsideGroup(editor, options);
+        }
+        else {
+            this.doMoveOrCopyEditorAcrossGroups(editor, target, options, { ...internalOptions, keepCopy: false });
+        }
+    }
+    doMoveEditorInsideGroup(candidate, options) {
+        const moveToIndex = options ? options.index : undefined;
+        if (typeof moveToIndex !== 'number') {
+            return;
+        }
+        const currentIndex = this.model.indexOf(candidate);
+        if (currentIndex === -1 || currentIndex === moveToIndex) {
+            return;
+        }
+        const editor = this.model.getEditorByIndex(currentIndex);
+        if (!editor) {
+            return;
+        }
+        this.model.moveEditor(editor, moveToIndex);
+        this.model.pin(editor);
+        this.titleAreaControl.moveEditor(editor, currentIndex, moveToIndex);
+        this.titleAreaControl.pinEditor(editor);
+    }
+    doMoveOrCopyEditorAcrossGroups(editor, target, openOptions, internalOptions) {
+        const keepCopy = internalOptions?.keepCopy;
+        const options = fillActiveEditorViewState(this, editor, {
+            ...openOptions,
+            pinned: true,
+            sticky: !keepCopy && this.model.isSticky(editor)
+        });
+        if (!keepCopy) {
+            this._onWillMoveEditor.fire({
+                groupId: this.id,
+                editor,
+                target: target.id
+            });
+        }
+        target.doOpenEditor(keepCopy ? editor.copy() : editor, options, internalOptions);
+        if (!keepCopy) {
+            this.doCloseEditor(editor, false , { ...internalOptions, context: EditorCloseContext.MOVE });
+        }
+    }
+    copyEditors(editors, target) {
+        const internalOptions = {
+            skipTitleUpdate: this !== target
+        };
+        for (const { editor, options } of editors) {
+            this.copyEditor(editor, target, options, internalOptions);
+        }
+        if (internalOptions.skipTitleUpdate) {
+            const copiedEditors = ( editors.map(({ editor }) => editor));
+            target.titleAreaControl.openEditors(copiedEditors);
+        }
+    }
+    copyEditor(editor, target, options, internalOptions) {
+        if (this === target) {
+            this.doMoveEditorInsideGroup(editor, options);
+        }
+        else {
+            this.doMoveOrCopyEditorAcrossGroups(editor, target, options, { ...internalOptions, keepCopy: true });
+        }
+    }
+    async closeEditor(editor = this.activeEditor || undefined, options) {
+        return this.doCloseEditorWithConfirmationHandling(editor, options);
+    }
+    async doCloseEditorWithConfirmationHandling(editor = this.activeEditor || undefined, options, internalOptions) {
+        if (!editor) {
+            return false;
+        }
+        const veto = await this.handleCloseConfirmation([editor]);
+        if (veto) {
+            return false;
+        }
+        this.doCloseEditor(editor, options?.preserveFocus ? false : undefined, internalOptions);
+        return true;
+    }
+    doCloseEditor(editor, focusNext = (this.accessor.activeGroup === this), internalOptions) {
+        let index;
+        if (this.model.isActive(editor)) {
+            index = this.doCloseActiveEditor(focusNext, internalOptions);
+        }
+        else {
+            index = this.doCloseInactiveEditor(editor, internalOptions);
+        }
+        if (!internalOptions?.skipTitleUpdate) {
+            this.titleAreaControl.closeEditor(editor, index);
+        }
+    }
+    doCloseActiveEditor(focusNext = (this.accessor.activeGroup === this), internalOptions) {
+        const editorToClose = this.activeEditor;
+        const restoreFocus = this.shouldRestoreFocus(this.element);
+        const closeEmptyGroup = this.accessor.partOptions.closeEmptyGroups;
+        if (closeEmptyGroup && this.active && this.count === 1) {
+            const mostRecentlyActiveGroups = this.accessor.getGroups(1 );
+            const nextActiveGroup = mostRecentlyActiveGroups[1];
+            if (nextActiveGroup) {
+                if (restoreFocus) {
+                    nextActiveGroup.focus();
+                }
+                else {
+                    this.accessor.activateGroup(nextActiveGroup);
+                }
+            }
+        }
+        let index = undefined;
+        if (editorToClose) {
+            index = this.model.closeEditor(editorToClose, internalOptions?.context)?.editorIndex;
+        }
+        const nextActiveEditor = this.model.activeEditor;
+        if (nextActiveEditor) {
+            const preserveFocus = !focusNext;
+            let activation = undefined;
+            if (preserveFocus && this.accessor.activeGroup !== this) {
+                activation = EditorActivation.PRESERVE;
+            }
+            const options = {
+                preserveFocus,
+                activation,
+                ignoreError: internalOptions?.fromError
+            };
+            this.doOpenEditor(nextActiveEditor, options);
+        }
+        else {
+            if (editorToClose) {
+                this.editorPane.closeEditor(editorToClose);
+            }
+            if (restoreFocus && !closeEmptyGroup) {
+                this.focus();
+            }
+            this._onDidActiveEditorChange.fire({ editor: undefined });
+            if (closeEmptyGroup) {
+                this.accessor.removeGroup(this);
+            }
+        }
+        return index;
+    }
+    shouldRestoreFocus(target) {
+        const activeElement = document.activeElement;
+        if (activeElement === document.body) {
+            return true;
+        }
+        return isAncestor(activeElement, target);
+    }
+    doCloseInactiveEditor(editor, internalOptions) {
+        return this.model.closeEditor(editor, internalOptions?.context)?.editorIndex;
+    }
+    async handleCloseConfirmation(editors) {
+        if (!editors.length) {
+            return false;
+        }
+        const editor = editors.shift();
+        let handleCloseConfirmationPromise = this.mapEditorToPendingConfirmation.get(editor);
+        if (!handleCloseConfirmationPromise) {
+            handleCloseConfirmationPromise = this.doHandleCloseConfirmation(editor);
+            this.mapEditorToPendingConfirmation.set(editor, handleCloseConfirmationPromise);
+        }
+        let veto;
+        try {
+            veto = await handleCloseConfirmationPromise;
+        }
+        finally {
+            this.mapEditorToPendingConfirmation.delete(editor);
+        }
+        if (veto) {
+            return veto;
+        }
+        return this.handleCloseConfirmation(editors);
+    }
+    async doHandleCloseConfirmation(editor, options) {
+        if (!this.shouldConfirmClose(editor)) {
+            return false;
+        }
+        if (editor instanceof SideBySideEditorInput && this.model.contains(editor.primary)) {
+            return false;
+        }
+        if (( this.accessor.groups.some(groupView => {
+            if (groupView === this) {
+                return false;
+            }
+            const otherGroup = groupView;
+            if (otherGroup.contains(editor, { supportSideBySide: SideBySideEditor.BOTH })) {
+                return true;
+            }
+            if (editor instanceof SideBySideEditorInput && otherGroup.contains(editor.primary)) {
+                return true;
+            }
+            return false;
+        }))) {
+            return false;
+        }
+        let confirmation = 2 ;
+        let saveReason = 1 ;
+        let autoSave = false;
+        if (!editor.hasCapability(4 ) && !options?.skipAutoSave && !editor.closeHandler) {
+            if (this.filesConfigurationService.getAutoSaveMode() === 3 ) {
+                autoSave = true;
+                confirmation = 0 ;
+                saveReason = 3 ;
+            }
+            else if ((isNative && (isWindows || isLinux)) && this.filesConfigurationService.getAutoSaveMode() === 4 ) {
+                autoSave = true;
+                confirmation = 0 ;
+                saveReason = 4 ;
+            }
+        }
+        if (!autoSave) {
+            if (!this.activeEditor || !this.activeEditor.matches(editor)) {
+                await this.doOpenEditor(editor);
+            }
+            if (typeof editor.closeHandler?.confirm === 'function') {
+                confirmation = await editor.closeHandler.confirm([{ editor, groupId: this.id }]);
+            }
+            else {
+                let name;
+                if (editor instanceof SideBySideEditorInput) {
+                    name = editor.primary.getName();
+                }
+                else {
+                    name = editor.getName();
+                }
+                confirmation = await this.fileDialogService.showSaveConfirm([name]);
+            }
+        }
+        if (!editor.closeHandler && !this.shouldConfirmClose(editor)) {
+            return confirmation === 2  ? true : false;
+        }
+        switch (confirmation) {
+            case 0 : {
+                const result = await editor.save(this.id, { reason: saveReason });
+                if (!result && autoSave) {
+                    return this.doHandleCloseConfirmation(editor, { skipAutoSave: true });
+                }
+                return editor.isDirty();
+            }
+            case 1 :
+                try {
+                    await editor.revert(this.id);
+                    return editor.isDirty();
+                }
+                catch (error) {
+                    this.logService.error(error);
+                    await editor.revert(this.id, { soft: true });
+                    return editor.isDirty();
+                }
+            case 2 :
+                return true;
+        }
+    }
+    shouldConfirmClose(editor) {
+        if (editor.closeHandler) {
+            return editor.closeHandler.showConfirm();
+        }
+        return editor.isDirty() && !editor.isSaving();
+    }
+    async closeEditors(args, options) {
+        if (this.isEmpty) {
+            return true;
+        }
+        const editors = this.doGetEditorsToClose(args);
+        const veto = await this.handleCloseConfirmation(editors.slice(0));
+        if (veto) {
+            return false;
+        }
+        this.doCloseEditors(editors, options);
+        return true;
+    }
+    doGetEditorsToClose(args) {
+        if (Array.isArray(args)) {
+            return args;
+        }
+        const filter = args;
+        const hasDirection = typeof filter.direction === 'number';
+        let editorsToClose = this.model.getEditors(hasDirection ? 1  : 0 , filter);
+        if (filter.savedOnly) {
+            editorsToClose = editorsToClose.filter(editor => !editor.isDirty() || editor.isSaving());
+        }
+        else if (hasDirection && filter.except) {
+            editorsToClose = ((filter.direction === 0) ) ?
+                editorsToClose.slice(0, this.model.indexOf(filter.except, editorsToClose)) :
+                editorsToClose.slice(this.model.indexOf(filter.except, editorsToClose) + 1);
+        }
+        else if (filter.except) {
+            editorsToClose = editorsToClose.filter(editor => filter.except && !editor.matches(filter.except));
+        }
+        return editorsToClose;
+    }
+    doCloseEditors(editors, options) {
+        let closeActiveEditor = false;
+        for (const editor of editors) {
+            if (!this.isActive(editor)) {
+                this.doCloseInactiveEditor(editor);
+            }
+            else {
+                closeActiveEditor = true;
+            }
+        }
+        if (closeActiveEditor) {
+            this.doCloseActiveEditor(options?.preserveFocus ? false : undefined);
+        }
+        if (editors.length) {
+            this.titleAreaControl.closeEditors(editors);
+        }
+    }
+    async closeAllEditors(options) {
+        if (this.isEmpty) {
+            if (this.accessor.partOptions.closeEmptyGroups) {
+                this.accessor.removeGroup(this);
+            }
+            return true;
+        }
+        const veto = await this.handleCloseConfirmation(this.model.getEditors(0 , options));
+        if (veto) {
+            return false;
+        }
+        this.doCloseAllEditors(options);
+        return true;
+    }
+    doCloseAllEditors(options) {
+        const editorsToClose = [];
+        for (const editor of this.model.getEditors(1 , options)) {
+            if (!this.isActive(editor)) {
+                this.doCloseInactiveEditor(editor);
+            }
+            editorsToClose.push(editor);
+        }
+        if (this.activeEditor && editorsToClose.includes(this.activeEditor)) {
+            this.doCloseActiveEditor();
+        }
+        if (editorsToClose.length) {
+            this.titleAreaControl.closeEditors(editorsToClose);
+        }
+    }
+    async replaceEditors(editors) {
+        let activeReplacement;
+        const inactiveReplacements = [];
+        for (let { editor, replacement, forceReplaceDirty, options } of editors) {
+            const index = this.getIndexOfEditor(editor);
+            if (index >= 0) {
+                const isActiveEditor = this.isActive(editor);
+                if (options) {
+                    options.index = index;
+                }
+                else {
+                    options = { index };
+                }
+                options.inactive = !isActiveEditor;
+                options.pinned = options.pinned ?? true;
+                const editorToReplace = { editor, replacement, forceReplaceDirty, options };
+                if (isActiveEditor) {
+                    activeReplacement = editorToReplace;
+                }
+                else {
+                    inactiveReplacements.push(editorToReplace);
+                }
+            }
+        }
+        for (const { editor, replacement, forceReplaceDirty, options } of inactiveReplacements) {
+            await this.doOpenEditor(replacement, options);
+            if (!editor.matches(replacement)) {
+                let closed = false;
+                if (forceReplaceDirty) {
+                    this.doCloseEditor(editor, false, { context: EditorCloseContext.REPLACE });
+                    closed = true;
+                }
+                else {
+                    closed = await this.doCloseEditorWithConfirmationHandling(editor, { preserveFocus: true }, { context: EditorCloseContext.REPLACE });
+                }
+                if (!closed) {
+                    return;
+                }
+            }
+        }
+        if (activeReplacement) {
+            const openEditorResult = this.doOpenEditor(activeReplacement.replacement, activeReplacement.options);
+            if (!activeReplacement.editor.matches(activeReplacement.replacement)) {
+                if (activeReplacement.forceReplaceDirty) {
+                    this.doCloseEditor(activeReplacement.editor, false, { context: EditorCloseContext.REPLACE });
+                }
+                else {
+                    await this.doCloseEditorWithConfirmationHandling(activeReplacement.editor, { preserveFocus: true }, { context: EditorCloseContext.REPLACE });
+                }
+            }
+            await openEditorResult;
+        }
+    }
+    get isLocked() {
+        if (this.accessor.groups.length === 1) {
+            return false;
+        }
+        return this.model.isLocked;
+    }
+    lock(locked) {
+        if (this.accessor.groups.length === 1) {
+            locked = false;
+        }
+        this.model.lock(locked);
+    }
+    updateStyles() {
+        const isEmpty = this.isEmpty;
+        if (isEmpty) {
+            this.element.style.backgroundColor = this.getColor(EDITOR_GROUP_EMPTY_BACKGROUND) || '';
+        }
+        else {
+            this.element.style.backgroundColor = '';
+        }
+        const borderColor = this.getColor(EDITOR_GROUP_HEADER_BORDER) || this.getColor(contrastBorder);
+        if (!isEmpty && borderColor) {
+            this.titleContainer.classList.add('title-border-bottom');
+            this.titleContainer.style.setProperty('--title-border-bottom-color', borderColor);
+        }
+        else {
+            this.titleContainer.classList.remove('title-border-bottom');
+            this.titleContainer.style.removeProperty('--title-border-bottom-color');
+        }
+        const { showTabs } = this.accessor.partOptions;
+        this.titleContainer.style.backgroundColor = this.getColor(showTabs ? EDITOR_GROUP_HEADER_TABS_BACKGROUND : EDITOR_GROUP_HEADER_NO_TABS_BACKGROUND) || '';
+        this.editorContainer.style.backgroundColor = this.getColor(editorBackground) || '';
+    }
+    get minimumWidth() { return this.editorPane.minimumWidth; }
+    get minimumHeight() { return this.editorPane.minimumHeight; }
+    get maximumWidth() { return this.editorPane.maximumWidth; }
+    get maximumHeight() { return this.editorPane.maximumHeight; }
+    get proportionalLayout() {
+        if (!this.lastLayout) {
+            return true;
+        }
+        return !(this.lastLayout.width === this.minimumWidth || this.lastLayout.height === this.minimumHeight);
+    }
+    layout(width, height, top, left) {
+        this.lastLayout = { width, height, top, left };
+        this.element.classList.toggle('max-height-478px', height <= 478);
+        const titleAreaSize = this.titleAreaControl.layout({
+            container: ( new Dimension(width, height)),
+            available: ( new Dimension(width, height - this.editorPane.minimumHeight))
+        });
+        const editorHeight = Math.max(0, height - titleAreaSize.height);
+        this.editorContainer.style.height = `${editorHeight}px`;
+        this.editorPane.layout({ width, height: editorHeight, top: top + titleAreaSize.height, left });
+    }
+    relayout() {
+        if (this.lastLayout) {
+            const { width, height, top, left } = this.lastLayout;
+            this.layout(width, height, top, left);
+        }
+    }
+    setBoundarySashes(sashes) {
+        this.editorPane.setBoundarySashes(sashes);
+    }
+    toJSON() {
+        return this.model.serialize();
+    }
+    dispose() {
+        this._disposed = true;
+        this._onWillDispose.fire();
+        this.titleAreaControl.dispose();
+        super.dispose();
+    }
+};
+EditorGroupView = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IThemeService)),
+    ( __param(6, ITelemetryService)),
+    ( __param(7, IKeybindingService)),
+    ( __param(8, IMenuService)),
+    ( __param(9, IContextMenuService)),
+    ( __param(10, IFileDialogService)),
+    ( __param(11, IEditorService)),
+    ( __param(12, IFilesConfigurationService)),
+    ( __param(13, IUriIdentityService)),
+    ( __param(14, ILogService))
+], EditorGroupView));
+export { EditorGroupView };