@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

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

@@ -0,0 +1,245 @@
+import './media/notabstitlecontrol.css.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { TitleControl } from './titleControl.js';
+import { ResourceLabel } from '../../labels.js';
+import { TAB_ACTIVE_FOREGROUND, TAB_UNFOCUSED_ACTIVE_FOREGROUND } from '../../../common/theme.js';
+import { Gesture, EventType as EventType$1 } from 'monaco-editor/esm/vs/base/browser/touch.js';
+import { addDisposableListener, EventType, EventHelper, isAncestor, Dimension } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { CLOSE_EDITOR_COMMAND_ID, UNLOCK_GROUP_COMMAND_ID } from './editorCommands.js';
+import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
+import { assertIsDefined, withNullAsUndefined, assertAllDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+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';
+class NoTabsTitleControl extends TitleControl {
+    constructor() {
+        super(...arguments);
+        this.activeLabel = Object.create(null);
+    }
+    create(parent) {
+        const titleContainer = this.titleContainer = parent;
+        titleContainer.draggable = true;
+        this.registerContainerListeners(titleContainer);
+        this._register(Gesture.addTarget(titleContainer));
+        const labelContainer = document.createElement('div');
+        labelContainer.classList.add('label-container');
+        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 });
+        titleContainer.classList.toggle('breadcrumbs', Boolean(this.breadcrumbsControl));
+        this._register(toDisposable(() => titleContainer.classList.remove('breadcrumbs')));
+        const actionsContainer = document.createElement('div');
+        actionsContainer.classList.add('title-actions');
+        titleContainer.appendChild(actionsContainer);
+        this.createEditorActionsToolBar(actionsContainer);
+    }
+    registerContainerListeners(titleContainer) {
+        this.enableGroupDragging(titleContainer);
+        this._register(addDisposableListener(titleContainer, EventType.DBLCLICK, e => this.onTitleDoubleClick(e)));
+        this._register(addDisposableListener(titleContainer, EventType.AUXCLICK, e => this.onTitleAuxClick(e)));
+        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);
+                }
+            }));
+        }
+    }
+    onTitleLabelClick(e) {
+        EventHelper.stop(e, false);
+        setTimeout(() => this.quickInputService.quickAccess.show());
+    }
+    onTitleDoubleClick(e) {
+        EventHelper.stop(e);
+        this.group.pinEditor();
+    }
+    onTitleAuxClick(e) {
+        if (e.button === 1  && this.group.activeEditor) {
+            EventHelper.stop(e, true );
+            this.group.closeEditor(this.group.activeEditor);
+        }
+    }
+    onTitleTap(e) {
+        const target = e.initialTarget;
+        if (!(target instanceof HTMLElement) || !this.editorLabel || !isAncestor(target, this.editorLabel.element)) {
+            return;
+        }
+        setTimeout(() => this.quickInputService.quickAccess.show(), 50);
+    }
+    openEditor(editor) {
+        this.doHandleOpenEditor();
+    }
+    openEditors(editors) {
+        this.doHandleOpenEditor();
+    }
+    doHandleOpenEditor() {
+        const activeEditorChanged = this.ifActiveEditorChanged(() => this.redraw());
+        if (!activeEditorChanged) {
+            this.ifActiveEditorPropertiesChanged(() => this.redraw());
+        }
+    }
+    beforeCloseEditor(editor) {
+    }
+    closeEditor(editor) {
+        this.ifActiveEditorChanged(() => this.redraw());
+    }
+    closeEditors(editors) {
+        this.ifActiveEditorChanged(() => this.redraw());
+    }
+    moveEditor(editor, fromIndex, targetIndex) {
+        this.ifActiveEditorChanged(() => this.redraw());
+    }
+    pinEditor(editor) {
+        this.ifEditorIsActive(editor, () => this.redraw());
+    }
+    stickEditor(editor) {
+    }
+    unstickEditor(editor) {
+    }
+    setActive(isActive) {
+        this.redraw();
+    }
+    updateEditorLabel(editor) {
+        this.ifEditorIsActive(editor, () => this.redraw());
+    }
+    updateEditorDirty(editor) {
+        this.ifEditorIsActive(editor, () => {
+            const titleContainer = assertIsDefined(this.titleContainer);
+            if (editor.isDirty() && !editor.isSaving()) {
+                titleContainer.classList.add('dirty');
+            }
+            else {
+                titleContainer.classList.remove('dirty');
+            }
+        });
+    }
+    updateOptions(oldOptions, newOptions) {
+        if (oldOptions.labelFormat !== newOptions.labelFormat || !equals(oldOptions.decorations, newOptions.decorations)) {
+            this.redraw();
+        }
+    }
+    updateStyles() {
+        this.redraw();
+    }
+    handleBreadcrumbsEnablementChange() {
+        const titleContainer = assertIsDefined(this.titleContainer);
+        titleContainer.classList.toggle('breadcrumbs', Boolean(this.breadcrumbsControl));
+        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))
+        ) {
+            fn();
+            return true;
+        }
+        return false;
+    }
+    ifActiveEditorPropertiesChanged(fn) {
+        if (!this.activeLabel.editor || !this.group.activeEditor) {
+            return;
+        }
+        if (this.activeLabel.pinned !== this.group.isPinned(this.group.activeEditor)) {
+            fn();
+        }
+    }
+    ifEditorIsActive(editor, fn) {
+        if (this.group.isActive(editor)) {
+            fn();
+        }
+    }
+    redraw() {
+        const editor = withNullAsUndefined(this.group.activeEditor);
+        const options = this.accessor.partOptions;
+        const isEditorPinned = editor ? this.group.isPinned(editor) : false;
+        const isGroupActive = this.accessor.activeGroup === this.group;
+        this.activeLabel = { editor, pinned: isEditorPinned };
+        if (this.breadcrumbsControl) {
+            if (isGroupActive) {
+                this.breadcrumbsControl.update();
+                this.breadcrumbsControl.domNode.classList.toggle('preview', !isEditorPinned);
+            }
+            else {
+                this.breadcrumbsControl.hide();
+            }
+        }
+        const [titleContainer, editorLabel] = assertAllDefined(this.titleContainer, this.editorLabel);
+        if (!editor) {
+            titleContainer.classList.remove('dirty');
+            editorLabel.clear();
+            this.clearEditorActionsToolbar();
+        }
+        else {
+            this.updateEditorDirty(editor);
+            const { labelFormat } = this.accessor.partOptions;
+            let description;
+            if (this.breadcrumbsControl && !this.breadcrumbsControl.isHidden()) {
+                description = '';
+            }
+            else if (labelFormat === 'default' && !isGroupActive) {
+                description = '';
+            }
+            else {
+                description = editor.getDescription(this.getVerbosity(labelFormat)) || '';
+            }
+            let title = editor.getTitle(2 );
+            if (description === title) {
+                title = '';
+            }
+            editorLabel.setResource({
+                resource: EditorResourceAccessor.getOriginalUri(editor, { supportSideBySide: SideBySideEditor.BOTH }),
+                name: editor.getName(),
+                description
+            }, {
+                title,
+                italic: !isEditorPinned,
+                extraClasses: ['no-tabs', 'title-label'].concat(editor.getLabelExtraClasses()),
+                fileDecorations: {
+                    colors: Boolean(options.decorations?.colors),
+                    badges: Boolean(options.decorations?.badges)
+                },
+            });
+            if (isGroupActive) {
+                titleContainer.style.color = this.getColor(TAB_ACTIVE_FOREGROUND) || '';
+            }
+            else {
+                titleContainer.style.color = this.getColor(TAB_UNFOCUSED_ACTIVE_FOREGROUND) || '';
+            }
+            this.updateEditorActionsToolbar();
+        }
+    }
+    getVerbosity(style) {
+        switch (style) {
+            case 'short': return 0 ;
+            case 'long': return 2 ;
+            default: return 1 ;
+        }
+    }
+    prepareEditorActions(editorActions) {
+        const isGroupActive = this.accessor.activeGroup === this.group;
+        if (isGroupActive) {
+            return editorActions;
+        }
+        else {
+            return {
+                primary: editorActions.primary.filter(action => action.id === CLOSE_EDITOR_COMMAND_ID || action.id === UNLOCK_GROUP_COMMAND_ID),
+                secondary: editorActions.secondary
+            };
+        }
+    }
+    getHeight() {
+        return {
+            total: NoTabsTitleControl.HEIGHT,
+            offset: 0
+        };
+    }
+    layout(dimensions) {
+        this.breadcrumbsControl?.layout(undefined);
+        return ( new Dimension(dimensions.container.width, this.getHeight().total));
+    }
+}
+NoTabsTitleControl.HEIGHT = 35;
+export { NoTabsTitleControl };

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

@@ -0,0 +1,387 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import './media/sidebysideeditor.css.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Dimension, $, multibyteAwareBtoa, clearNode } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { SIDE_BY_SIDE_EDITOR_ID, SideBySideEditor as SideBySideEditor$1, EditorExtensions, isEditorPaneWithSelection } from '../../../common/editor.js';
+import { SideBySideEditorInput } from '../../../common/editor/sideBySideEditorInput.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { SplitView, Sizing } from 'monaco-editor/esm/vs/base/browser/ui/splitview/splitview.js';
+import { Emitter, Relay, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { DEFAULT_EDITOR_MIN_DIMENSIONS } from './editor.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { SIDE_BY_SIDE_EDITOR_VERTICAL_BORDER, SIDE_BY_SIDE_EDITOR_HORIZONTAL_BORDER } from '../../../common/theme.js';
+import { AbstractEditorWithViewState } from './editorWithViewState.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+function isSideBySideEditorViewState(thing) {
+    const candidate = thing;
+    return typeof candidate?.primary === 'object' && typeof candidate.secondary === 'object';
+}
+let SideBySideEditor = class SideBySideEditor extends AbstractEditorWithViewState {
+    get minimumPrimaryWidth() { return this.primaryEditorPane ? this.primaryEditorPane.minimumWidth : 0; }
+    get maximumPrimaryWidth() { return this.primaryEditorPane ? this.primaryEditorPane.maximumWidth : Number.POSITIVE_INFINITY; }
+    get minimumPrimaryHeight() { return this.primaryEditorPane ? this.primaryEditorPane.minimumHeight : 0; }
+    get maximumPrimaryHeight() { return this.primaryEditorPane ? this.primaryEditorPane.maximumHeight : Number.POSITIVE_INFINITY; }
+    get minimumSecondaryWidth() { return this.secondaryEditorPane ? this.secondaryEditorPane.minimumWidth : 0; }
+    get maximumSecondaryWidth() { return this.secondaryEditorPane ? this.secondaryEditorPane.maximumWidth : Number.POSITIVE_INFINITY; }
+    get minimumSecondaryHeight() { return this.secondaryEditorPane ? this.secondaryEditorPane.minimumHeight : 0; }
+    get maximumSecondaryHeight() { return this.secondaryEditorPane ? this.secondaryEditorPane.maximumHeight : Number.POSITIVE_INFINITY; }
+    set minimumWidth(value) { }
+    set maximumWidth(value) { }
+    set minimumHeight(value) { }
+    set maximumHeight(value) { }
+    get minimumWidth() { return this.minimumPrimaryWidth + this.minimumSecondaryWidth; }
+    get maximumWidth() { return this.maximumPrimaryWidth + this.maximumSecondaryWidth; }
+    get minimumHeight() { return this.minimumPrimaryHeight + this.minimumSecondaryHeight; }
+    get maximumHeight() { return this.maximumPrimaryHeight + this.maximumSecondaryHeight; }
+    constructor(telemetryService, instantiationService, themeService, storageService, configurationService, textResourceConfigurationService, editorService, editorGroupService) {
+        super(SideBySideEditor.ID, SideBySideEditor.VIEW_STATE_PREFERENCE_KEY, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService);
+        this.configurationService = configurationService;
+        this.onDidCreateEditors = this._register(( (new Emitter())));
+        this._onDidChangeSizeConstraints = this._register(( (new Relay())));
+        this.onDidChangeSizeConstraints = Event.any(this.onDidCreateEditors.event, this._onDidChangeSizeConstraints.event);
+        this._onDidChangeSelection = this._register(( (new Emitter())));
+        this.onDidChangeSelection = this._onDidChangeSelection.event;
+        this.primaryEditorPane = undefined;
+        this.secondaryEditorPane = undefined;
+        this.splitviewDisposables = this._register(( (new DisposableStore())));
+        this.editorDisposables = this._register(( (new DisposableStore())));
+        this.orientation = this.configurationService.getValue(SideBySideEditor.SIDE_BY_SIDE_LAYOUT_SETTING) === 'vertical' ? 0  : 1 ;
+        this.dimension = ( (new Dimension(0, 0)));
+        this.lastFocusedSide = undefined;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e)));
+    }
+    onConfigurationUpdated(event) {
+        if (event.affectsConfiguration(SideBySideEditor.SIDE_BY_SIDE_LAYOUT_SETTING)) {
+            this.orientation = this.configurationService.getValue(SideBySideEditor.SIDE_BY_SIDE_LAYOUT_SETTING) === 'vertical' ? 0  : 1 ;
+            if (this.splitview) {
+                this.recreateSplitview();
+            }
+        }
+    }
+    recreateSplitview() {
+        const container = assertIsDefined(this.getContainer());
+        const ratio = this.getSplitViewRatio();
+        if (this.splitview) {
+            container.removeChild(this.splitview.el);
+            this.splitviewDisposables.clear();
+        }
+        this.createSplitView(container, ratio);
+        this.layout(this.dimension);
+    }
+    getSplitViewRatio() {
+        let ratio = undefined;
+        if (this.splitview) {
+            const leftViewSize = this.splitview.getViewSize(0);
+            const rightViewSize = this.splitview.getViewSize(1);
+            if (Math.abs(leftViewSize - rightViewSize) > 1) {
+                const totalSize = this.splitview.orientation === 1  ? this.dimension.width : this.dimension.height;
+                ratio = leftViewSize / totalSize;
+            }
+        }
+        return ratio;
+    }
+    createEditor(parent) {
+        parent.classList.add('side-by-side-editor');
+        this.secondaryEditorContainer = $('.side-by-side-editor-container.editor-instance');
+        this.primaryEditorContainer = $('.side-by-side-editor-container.editor-instance');
+        this.createSplitView(parent);
+    }
+    createSplitView(parent, ratio) {
+        this.splitview = this.splitviewDisposables.add(( (new SplitView(parent, { orientation: this.orientation }))));
+        this.splitviewDisposables.add(this.splitview.onDidSashReset(() => this.splitview?.distributeViewSizes()));
+        if (this.orientation === 1 ) {
+            this.splitview.orthogonalEndSash = this._boundarySashes?.bottom;
+        }
+        else {
+            this.splitview.orthogonalStartSash = this._boundarySashes?.left;
+            this.splitview.orthogonalEndSash = this._boundarySashes?.right;
+        }
+        let leftSizing = Sizing.Distribute;
+        let rightSizing = Sizing.Distribute;
+        if (ratio) {
+            const totalSize = this.splitview.orientation === 1  ? this.dimension.width : this.dimension.height;
+            leftSizing = Math.round(totalSize * ratio);
+            rightSizing = totalSize - leftSizing;
+            this.splitview.layout(this.orientation === 1  ? this.dimension.width : this.dimension.height);
+        }
+        const secondaryEditorContainer = assertIsDefined(this.secondaryEditorContainer);
+        this.splitview.addView({
+            element: secondaryEditorContainer,
+            layout: size => this.layoutPane(this.secondaryEditorPane, size),
+            minimumSize: this.orientation === 1  ? DEFAULT_EDITOR_MIN_DIMENSIONS.width : DEFAULT_EDITOR_MIN_DIMENSIONS.height,
+            maximumSize: Number.POSITIVE_INFINITY,
+            onDidChange: Event.None
+        }, leftSizing);
+        const primaryEditorContainer = assertIsDefined(this.primaryEditorContainer);
+        this.splitview.addView({
+            element: primaryEditorContainer,
+            layout: size => this.layoutPane(this.primaryEditorPane, size),
+            minimumSize: this.orientation === 1  ? DEFAULT_EDITOR_MIN_DIMENSIONS.width : DEFAULT_EDITOR_MIN_DIMENSIONS.height,
+            maximumSize: Number.POSITIVE_INFINITY,
+            onDidChange: Event.None
+        }, rightSizing);
+        this.updateStyles();
+    }
+    getTitle() {
+        if (this.input) {
+            return this.input.getName();
+        }
+        return (
+             (localize('sideBySideEditor', "Side by Side Editor"))
+        );
+    }
+    async setInput(input, options, context, token) {
+        const oldInput = this.input;
+        await super.setInput(input, options, context, token);
+        if (!oldInput || !input.matches(oldInput)) {
+            if (oldInput) {
+                this.disposeEditors();
+            }
+            this.createEditors(input);
+        }
+        const { primary, secondary, viewState } = this.loadViewState(input, options, context);
+        this.lastFocusedSide = viewState?.focus;
+        if (typeof viewState?.ratio === 'number' && this.splitview) {
+            const totalSize = this.splitview.orientation === 1  ? this.dimension.width : this.dimension.height;
+            this.splitview.resizeView(0, Math.round(totalSize * viewState.ratio));
+        }
+        else {
+            this.splitview?.distributeViewSizes();
+        }
+        await Promise.all([
+            this.secondaryEditorPane?.setInput(input.secondary, secondary, context, token),
+            this.primaryEditorPane?.setInput(input.primary, primary, context, token)
+        ]);
+        if (typeof options?.target === 'number') {
+            this.lastFocusedSide = options.target;
+        }
+    }
+    loadViewState(input, options, context) {
+        const viewState = isSideBySideEditorViewState(options?.viewState) ? options?.viewState : this.loadEditorViewState(input, context);
+        let primaryOptions = Object.create(null);
+        let secondaryOptions = undefined;
+        if (options?.target === SideBySideEditor$1.SECONDARY) {
+            secondaryOptions = { ...options };
+        }
+        else {
+            primaryOptions = { ...options };
+        }
+        primaryOptions.viewState = viewState?.primary;
+        if (viewState?.secondary) {
+            if (!secondaryOptions) {
+                secondaryOptions = { viewState: viewState.secondary };
+            }
+            else {
+                secondaryOptions.viewState = viewState?.secondary;
+            }
+        }
+        return { primary: primaryOptions, secondary: secondaryOptions, viewState };
+    }
+    createEditors(newInput) {
+        this.secondaryEditorPane = this.doCreateEditor(newInput.secondary, assertIsDefined(this.secondaryEditorContainer));
+        this.primaryEditorPane = this.doCreateEditor(newInput.primary, assertIsDefined(this.primaryEditorContainer));
+        this.layout(this.dimension);
+        this._onDidChangeSizeConstraints.input = Event.any(( (Event.map(this.secondaryEditorPane.onDidChangeSizeConstraints, () => undefined))), ( (Event.map(this.primaryEditorPane.onDidChangeSizeConstraints, () => undefined))));
+        this.onDidCreateEditors.fire(undefined);
+        this.editorDisposables.add(this.primaryEditorPane.onDidFocus(() => this.onDidFocusChange(SideBySideEditor$1.PRIMARY)));
+        this.editorDisposables.add(this.secondaryEditorPane.onDidFocus(() => this.onDidFocusChange(SideBySideEditor$1.SECONDARY)));
+    }
+    doCreateEditor(editorInput, container) {
+        const editorPaneDescriptor = ( (Registry.as(EditorExtensions.EditorPane))).getEditorPane(editorInput);
+        if (!editorPaneDescriptor) {
+            throw new Error('No editor pane descriptor for editor found');
+        }
+        const editorPane = editorPaneDescriptor.instantiate(this.instantiationService);
+        editorPane.create(container);
+        editorPane.setVisible(this.isVisible(), this.group);
+        if (isEditorPaneWithSelection(editorPane)) {
+            this.editorDisposables.add(editorPane.onDidChangeSelection(e => this._onDidChangeSelection.fire(e)));
+        }
+        this.editorDisposables.add(editorPane);
+        return editorPane;
+    }
+    onDidFocusChange(side) {
+        this.lastFocusedSide = side;
+        this._onDidChangeControl.fire();
+    }
+    getSelection() {
+        const lastFocusedEditorPane = this.getLastFocusedEditorPane();
+        if (isEditorPaneWithSelection(lastFocusedEditorPane)) {
+            const selection = lastFocusedEditorPane.getSelection();
+            if (selection) {
+                return (
+                     (new SideBySideAwareEditorPaneSelection(
+                        selection,
+                        lastFocusedEditorPane === this.primaryEditorPane ? SideBySideEditor$1.PRIMARY : SideBySideEditor$1.SECONDARY
+                    ))
+                );
+            }
+        }
+        return undefined;
+    }
+    setOptions(options) {
+        super.setOptions(options);
+        if (typeof options?.target === 'number') {
+            this.lastFocusedSide = options.target;
+        }
+        this.getLastFocusedEditorPane()?.setOptions(options);
+    }
+    setEditorVisible(visible, group) {
+        this.primaryEditorPane?.setVisible(visible, group);
+        this.secondaryEditorPane?.setVisible(visible, group);
+        super.setEditorVisible(visible, group);
+    }
+    clearInput() {
+        super.clearInput();
+        this.primaryEditorPane?.clearInput();
+        this.secondaryEditorPane?.clearInput();
+        this.disposeEditors();
+    }
+    focus() {
+        this.getLastFocusedEditorPane()?.focus();
+    }
+    getLastFocusedEditorPane() {
+        if (this.lastFocusedSide === SideBySideEditor$1.SECONDARY) {
+            return this.secondaryEditorPane;
+        }
+        return this.primaryEditorPane;
+    }
+    layout(dimension) {
+        this.dimension = dimension;
+        const splitview = assertIsDefined(this.splitview);
+        splitview.layout(this.orientation === 1  ? dimension.width : dimension.height);
+    }
+    setBoundarySashes(sashes) {
+        this._boundarySashes = sashes;
+        if (this.splitview) {
+            this.splitview.orthogonalEndSash = sashes.bottom;
+        }
+    }
+    layoutPane(pane, size) {
+        pane?.layout(this.orientation === 1  ? ( (new Dimension(size, this.dimension.height))) : ( (new Dimension(this.dimension.width, size))));
+    }
+    getControl() {
+        return this.getLastFocusedEditorPane()?.getControl();
+    }
+    getPrimaryEditorPane() {
+        return this.primaryEditorPane;
+    }
+    getSecondaryEditorPane() {
+        return this.secondaryEditorPane;
+    }
+    tracksEditorViewState(input) {
+        return input instanceof SideBySideEditorInput;
+    }
+    computeEditorViewState(resource) {
+        if (!this.input || !isEqual(resource, this.toEditorViewStateResource(this.input))) {
+            return;
+        }
+        const primarViewState = this.primaryEditorPane?.getViewState();
+        const secondaryViewState = this.secondaryEditorPane?.getViewState();
+        if (!primarViewState || !secondaryViewState) {
+            return;
+        }
+        return {
+            primary: primarViewState,
+            secondary: secondaryViewState,
+            focus: this.lastFocusedSide,
+            ratio: this.getSplitViewRatio()
+        };
+    }
+    toEditorViewStateResource(input) {
+        let primary;
+        let secondary;
+        if (input instanceof SideBySideEditorInput) {
+            primary = input.primary.resource;
+            secondary = input.secondary.resource;
+        }
+        if (!secondary || !primary) {
+            return undefined;
+        }
+        return (
+             (URI.from({ scheme: 'sideBySide', path: `${multibyteAwareBtoa(( ( secondary.toString())))}${multibyteAwareBtoa(( ( primary.toString())))}` }))
+        );
+    }
+    updateStyles() {
+        super.updateStyles();
+        if (this.primaryEditorContainer) {
+            if (this.orientation === 1 ) {
+                this.primaryEditorContainer.style.borderLeftWidth = '1px';
+                this.primaryEditorContainer.style.borderLeftStyle = 'solid';
+                this.primaryEditorContainer.style.borderLeftColor = this.getColor(SIDE_BY_SIDE_EDITOR_VERTICAL_BORDER) ?? '';
+                this.primaryEditorContainer.style.borderTopWidth = '0';
+            }
+            else {
+                this.primaryEditorContainer.style.borderTopWidth = '1px';
+                this.primaryEditorContainer.style.borderTopStyle = 'solid';
+                this.primaryEditorContainer.style.borderTopColor = this.getColor(SIDE_BY_SIDE_EDITOR_HORIZONTAL_BORDER) ?? '';
+                this.primaryEditorContainer.style.borderLeftWidth = '0';
+            }
+        }
+    }
+    dispose() {
+        this.disposeEditors();
+        super.dispose();
+    }
+    disposeEditors() {
+        this.editorDisposables.clear();
+        this.secondaryEditorPane = undefined;
+        this.primaryEditorPane = undefined;
+        this.lastFocusedSide = undefined;
+        if (this.secondaryEditorContainer) {
+            clearNode(this.secondaryEditorContainer);
+        }
+        if (this.primaryEditorContainer) {
+            clearNode(this.primaryEditorContainer);
+        }
+    }
+};
+SideBySideEditor.ID = SIDE_BY_SIDE_EDITOR_ID;
+SideBySideEditor.SIDE_BY_SIDE_LAYOUT_SETTING = 'workbench.editor.splitInGroupLayout';
+SideBySideEditor.VIEW_STATE_PREFERENCE_KEY = 'sideBySideEditorViewState';
+SideBySideEditor = ( (__decorate([
+    ( (__param(0, ITelemetryService))),
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, IThemeService))),
+    ( (__param(3, IStorageService))),
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, ITextResourceConfigurationService))),
+    ( (__param(6, IEditorService))),
+    ( (__param(7, IEditorGroupsService)))
+], SideBySideEditor)));
+class SideBySideAwareEditorPaneSelection {
+    constructor(selection, side) {
+        this.selection = selection;
+        this.side = side;
+    }
+    compare(other) {
+        if (!(other instanceof SideBySideAwareEditorPaneSelection)) {
+            return 3 ;
+        }
+        if (this.side !== other.side) {
+            return 3 ;
+        }
+        return this.selection.compare(other.selection);
+    }
+    restore(options) {
+        const sideBySideEditorOptions = {
+            ...options,
+            target: this.side
+        };
+        return this.selection.restore(sideBySideEditorOptions);
+    }
+}
+export { SideBySideEditor };