@codingame/monaco-vscode-views-service-override 11.1.2 → 12.0.0

package/views.js

@@ -1,566 +0,0 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { StandaloneServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
-import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views.service';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { SidebarPart } from '@codingame/monaco-vscode-view-common-views-workbench-common/vscode/vs/workbench/browser/parts/sidebar/sidebarPart';
-export { SidebarPart } from '@codingame/monaco-vscode-view-common-views-workbench-common/vscode/vs/workbench/browser/parts/sidebar/sidebarPart';
-export { ActivityService } from 'vscode/vscode/vs/workbench/services/activity/browser/activityService';
-import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite.service';
-export { ActivitybarPart } from '@codingame/monaco-vscode-view-common-views-workbench-common/vscode/vs/workbench/browser/parts/activitybar/activitybarPart';
-import { PanelPart } from '@codingame/monaco-vscode-view-common-views-workbench-common/vscode/vs/workbench/browser/parts/panel/panelPart';
-export { PanelPart } from '@codingame/monaco-vscode-view-common-views-workbench-common/vscode/vs/workbench/browser/parts/panel/panelPart';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-export { GroupOrientation } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
-import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
-import { pathsToEditors, isResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor';
-export { EditorInputCapabilities } from 'vscode/vscode/vs/workbench/common/editor';
-import { positionToString } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
-export { Parts, Position } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
-import { ILayoutService } from 'vscode/vscode/vs/platform/layout/browser/layoutService.service';
-import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
-import { AuxiliaryBarPart } from '@codingame/monaco-vscode-view-common-views-workbench-common/vscode/vs/workbench/browser/parts/auxiliarybar/auxiliaryBarPart';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
-import { mark } from 'vscode/vscode/vs/base/common/performance';
-import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
-import { Promises } from 'vscode/vscode/vs/base/common/async';
-import { isWeb } from 'vscode/vscode/vs/base/common/platform';
-import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment.service';
-import { isTemporaryWorkspace } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
-import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
-import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.service';
-import { EditorParts } from '@codingame/monaco-vscode-view-common-views-workbench-common/vscode/vs/workbench/browser/parts/editor/editorParts';
-import { MonacoDelegateEditorGroupsService, MonacoEditorService } from './tools/editor.js';
-import getServiceOverride$2 from '@codingame/monaco-vscode-quickaccess-service-override';
-import getServiceOverride$3 from '@codingame/monaco-vscode-keybindings-service-override';
-import getServiceOverride$1 from '@codingame/monaco-vscode-view-common-service-override';
-import { onRenderWorkbench } from 'vscode/lifecycle';
-export { EditorPane, SimpleEditorInput, SimpleEditorPane, getPanelPosition, getSideBarPosition, isPartVisibile, onDidChangePanelPosition, onDidChangeSideBarPosition, registerCustomView, registerEditor, registerEditorPane, registerEditorSerializer, setPartVisibility, viewContainerRegistry, viewRegistry } from './tools/views.js';
-export { ViewContainerLocation } from 'vscode/vscode/vs/workbench/common/views';
-export { ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
-export { ConfirmResult } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
-export { RegisteredEditorPriority } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
-export { AbstractResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor/resourceEditorInput';
-export { AbstractTextResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor/textResourceEditorInput';
-export { EditorInput } from 'vscode/vscode/vs/workbench/common/editor/editorInput';
-export { SplitView } from 'vscode/vscode/vs/base/browser/ui/splitview/splitview';
-export { DomScrollableElement } from 'vscode/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
-
-function createPart(id, role, classes) {
-    const part = document.createElement(role === 'status' ? 'footer'  : 'div');
-    part.classList.add('part', 'monaco-workbench-part', ...classes);
-    part.id = id;
-    part.setAttribute('role', role);
-    if (role === 'status') {
-        part.setAttribute('aria-live', 'off');
-    }
-    return part;
-}
-function layoutPart(part) {
-    const parent = part.getContainer()?.parentNode;
-    if (parent == null) {
-        return;
-    }
-    part.layout(Math.max(part.minimumWidth, Math.min(part.maximumWidth, parent.offsetWidth)), Math.max(part.minimumHeight, Math.min(part.maximumHeight, parent.offsetHeight)), parent.offsetTop, parent.offsetLeft);
-}
-function renderPart(partContainer, part) {
-    partContainer.oncontextmenu = () => false;
-    function layout() {
-        layoutPart(part);
-    }
-    part.onDidVisibilityChange((visible) => {
-        if (visible) {
-            layout();
-        }
-    });
-    layout();
-}
-function getPart(part) {
-    return StandaloneServices.get(ILayoutService).getPart(part);
-}
-function _attachPart(part, container) {
-    container.append(part.getContainer());
-    const observer = new ResizeObserver(() => layoutPart(part));
-    observer.observe(container);
-    return {
-        dispose() {
-            return observer.disconnect();
-        }
-    };
-}
-function attachPart(part, container) {
-    const _part = getPart(part);
-    if (_part == null) {
-        throw new Error('Part not found');
-    }
-    return _attachPart(_part, container);
-}
-function onPartVisibilityChange(part, listener) {
-    const _part = getPart(part);
-    if (_part == null) {
-        throw new Error('Part not found');
-    }
-    return _part.onDidVisibilityChange(listener);
-}
-function renderActivitybarPar(container) {
-    return attachPart("workbench.parts.activitybar" , container);
-}
-function renderSidebarPart(container) {
-    return attachPart("workbench.parts.sidebar" , container);
-}
-function renderPanelPart(container) {
-    return attachPart("workbench.parts.panel" , container);
-}
-function renderAuxiliaryPart(container) {
-    return attachPart("workbench.parts.auxiliarybar" , container);
-}
-function renderEditorPart(container) {
-    return attachPart("workbench.parts.editor" , container);
-}
-function renderStatusBarPart(container) {
-    return attachPart("workbench.parts.statusbar" , container);
-}
-function isElementVisible(el) {
-    if (!el.isConnected) {
-        return false;
-    }
-    if (el.checkVisibility != null) {
-        return el.checkVisibility({
-            checkOpacity: true,
-            checkVisibilityCSS: true
-        });
-    }
-    return el.offsetHeight > 0 && el.offsetWidth > 0;
-}
-function isEditorPartVisible() {
-    const container = StandaloneServices.get(IEditorGroupsService).mainPart.getContainer();
-    return container != null && isElementVisible(container);
-}
-let MonacoEditorParts = class MonacoEditorParts extends MonacoDelegateEditorGroupsService {
-    constructor(instantiationService) {
-        super(instantiationService.createInstance(EditorParts), false, instantiationService);
-        this.restoreGroup = (...args) => {
-            return this.delegate.restoreGroup(...args);
-        };
-    }
-    getId() {
-        return 'standalone';
-    }
-    updateStyles() { }
-    registerPart(part) {
-        return this.delegate.registerPart(part);
-    }
-    bind(contextKey, group) {
-        return this.delegate.bind(contextKey, group);
-    }
-    get activePart() {
-        return this.delegate.activePart;
-    }
-};
-MonacoEditorParts = __decorate([
-    ( __param(0, IInstantiationService))
-], MonacoEditorParts);
-let transformInitializationState = (state) => state;
-onRenderWorkbench(async (accessor) => {
-    const paneCompositePartService = accessor.get(IPaneCompositePartService);
-    const viewDescriptorService = accessor.get(IViewDescriptorService);
-    const lifecycleService = accessor.get(ILifecycleService);
-    const storageService = accessor.get(IStorageService);
-    const editorGroupService = accessor.get(IEditorGroupsService);
-    const editorService = accessor.get(IEditorService);
-    const logService = accessor.get(ILogService);
-    const extensionService = accessor.get(IExtensionService);
-    const environmentService = accessor.get(IEnvironmentService);
-    const contextService = accessor.get(IWorkspaceContextService);
-    const configurationService = accessor.get(IConfigurationService);
-    const fileService = accessor.get(IFileService);
-    const workingCopyBackupService = accessor.get(IWorkingCopyBackupService);
-    const layoutService = accessor.get(ILayoutService);
-    function getInitialEditorsState() {
-        const defaultLayout = environmentService.options?.defaultLayout;
-        if (((defaultLayout?.editors != null && defaultLayout.editors.length > 0) ||
-            defaultLayout?.layout?.editors != null) &&
-            ((defaultLayout.force ?? false) || storageService.isNew(1 ))) {
-            return {
-                layout: defaultLayout.layout?.editors,
-                filesToOpenOrCreate: defaultLayout.editors?.map((editor) => {
-                    return {
-                        viewColumn: editor.viewColumn,
-                        fileUri: URI.revive(editor.uri),
-                        openOnlyIfExists: editor.openOnlyIfExists,
-                        options: editor.options
-                    };
-                })
-            };
-        }
-        const { filesToOpenOrCreate, filesToDiff, filesToMerge } = environmentService;
-        if (filesToOpenOrCreate != null || filesToDiff != null || filesToMerge != null) {
-            return { filesToOpenOrCreate, filesToDiff, filesToMerge };
-        }
-        return undefined;
-    }
-    function getDefaultLayoutViews(environmentService, storageService) {
-        const defaultLayout = environmentService.options?.defaultLayout;
-        if (defaultLayout == null) {
-            return undefined;
-        }
-        if (!(defaultLayout.force ?? false) && !storageService.isNew(1 )) {
-            return undefined;
-        }
-        const { views } = defaultLayout;
-        if (views != null && views.length > 0) {
-            return ( views.map((view) => view.id));
-        }
-        return undefined;
-    }
-    function shouldRestoreEditors(contextService, initialEditorsState) {
-        if (isTemporaryWorkspace(contextService.getWorkspace())) {
-            return false;
-        }
-        const forceRestoreEditors = configurationService.getValue('window.restoreWindows') === 'preserve';
-        return !!forceRestoreEditors || initialEditorsState === undefined;
-    }
-    async function resolveEditorsToOpen(fileService, initialEditorsState) {
-        if (initialEditorsState != null) {
-            const filesToMerge = coalesce(await pathsToEditors(initialEditorsState.filesToMerge, fileService, logService));
-            if (filesToMerge.length === 4 &&
-                isResourceEditorInput(filesToMerge[0]) &&
-                isResourceEditorInput(filesToMerge[1]) &&
-                isResourceEditorInput(filesToMerge[2]) &&
-                isResourceEditorInput(filesToMerge[3])) {
-                return [
-                    {
-                        editor: {
-                            input1: { resource: filesToMerge[0].resource },
-                            input2: { resource: filesToMerge[1].resource },
-                            base: { resource: filesToMerge[2].resource },
-                            result: { resource: filesToMerge[3].resource },
-                            options: { pinned: true }
-                        }
-                    }
-                ];
-            }
-            const filesToDiff = coalesce(await pathsToEditors(initialEditorsState.filesToDiff, fileService, logService));
-            if (filesToDiff.length === 2) {
-                return [
-                    {
-                        editor: {
-                            original: { resource: filesToDiff[0].resource },
-                            modified: { resource: filesToDiff[1].resource },
-                            options: { pinned: true }
-                        }
-                    }
-                ];
-            }
-            const filesToOpenOrCreate = [];
-            const resolvedFilesToOpenOrCreate = await pathsToEditors(initialEditorsState.filesToOpenOrCreate, fileService, logService);
-            for (let i = 0; i < resolvedFilesToOpenOrCreate.length; i++) {
-                const resolvedFileToOpenOrCreate = resolvedFilesToOpenOrCreate[i];
-                if (resolvedFileToOpenOrCreate != null) {
-                    filesToOpenOrCreate.push({
-                        editor: resolvedFileToOpenOrCreate,
-                        viewColumn: initialEditorsState.filesToOpenOrCreate?.[i].viewColumn
-                    });
-                }
-            }
-            return filesToOpenOrCreate;
-        }
-        else if (contextService.getWorkbenchState() === 1  &&
-            configurationService.getValue('workbench.startupEditor') === 'newUntitledFile') {
-            if (editorGroupService.mainPart.hasRestorableState) {
-                return [];
-            }
-            const hasBackups = await workingCopyBackupService.hasBackups();
-            if (hasBackups) {
-                return [];
-            }
-            return [
-                {
-                    editor: { resource: undefined }
-                }
-            ];
-        }
-        return [];
-    }
-    const initialEditorsState = getInitialEditorsState();
-    if (initialEditorsState != null) {
-        logService.info('Initial editor state', initialEditorsState);
-    }
-    let initialLayoutState = {
-        layout: {
-            editors: initialEditorsState?.layout
-        },
-        editor: {
-            restoreEditors: shouldRestoreEditors(contextService, initialEditorsState),
-            editorsToOpen: resolveEditorsToOpen(fileService, initialEditorsState)
-        },
-        views: {
-            defaults: getDefaultLayoutViews(environmentService, storageService),
-            containerToRestore: {}
-        }
-    };
-    function getDefaultViewContainer(location) {
-        return (viewDescriptorService.getDefaultViewContainer(location) ??
-            viewDescriptorService.getViewContainersByLocation(location)[0]);
-    }
-    function initLayoutState() {
-        if (layoutService.isVisible("workbench.parts.sidebar" )) {
-            let viewContainerToRestore;
-            if (!environmentService.isBuilt ||
-                lifecycleService.startupKind === 3  ||
-                isWeb) {
-                viewContainerToRestore = storageService.get(SidebarPart.activeViewletSettingsKey, 1 , getDefaultViewContainer(0 )?.id);
-            }
-            else {
-                viewContainerToRestore = getDefaultViewContainer(0 )?.id;
-            }
-            initialLayoutState.views.containerToRestore.sideBar = viewContainerToRestore;
-        }
-        if (layoutService.isVisible("workbench.parts.panel" )) {
-            const viewContainerToRestore = storageService.get(PanelPart.activePanelSettingsKey, 1 , getDefaultViewContainer(1 )?.id);
-            initialLayoutState.views.containerToRestore.panel = viewContainerToRestore;
-        }
-        if (layoutService.isVisible("workbench.parts.auxiliarybar" )) {
-            const viewContainerToRestore = storageService.get(AuxiliaryBarPart.activePanelSettingsKey, 1 , getDefaultViewContainer(2 )?.id);
-            initialLayoutState.views.containerToRestore.auxiliaryBar = viewContainerToRestore;
-        }
-    }
-    initLayoutState();
-    initialLayoutState = transformInitializationState(initialLayoutState);
-    if (initialLayoutState.views.containerToRestore.sideBar == null) {
-        layoutService.setPartHidden(true, "workbench.parts.sidebar" );
-    }
-    if (initialLayoutState.views.containerToRestore.panel == null) {
-        layoutService.setPartHidden(true, "workbench.parts.panel" );
-    }
-    if (initialLayoutState.views.containerToRestore.auxiliaryBar == null) {
-        layoutService.setPartHidden(true, "workbench.parts.auxiliarybar" );
-    }
-    const invisibleContainer = document.createElement('div');
-    invisibleContainer.style.display = 'none';
-    document.body.append(invisibleContainer);
-    for (const { id, role, classes, options, getPosition, onDidChangePosition } of [
-        { id: "workbench.parts.titlebar" , role: 'none', classes: ['titlebar'] },
-        { id: "workbench.parts.banner" , role: 'banner', classes: ['banner'] },
-        {
-            id: "workbench.parts.activitybar" ,
-            role: 'none',
-            classes: ['activitybar'],
-            getPosition: () => layoutService.getSideBarPosition(),
-            onDidChangePosition: layoutService.onDidChangeSideBarPosition
-        },
-        {
-            id: "workbench.parts.sidebar" ,
-            role: 'none',
-            classes: ['sidebar'],
-            getPosition: () => layoutService.getSideBarPosition(),
-            onDidChangePosition: layoutService.onDidChangeSideBarPosition
-        },
-        {
-            id: "workbench.parts.editor" ,
-            role: 'main',
-            classes: ['editor'],
-            options: { restorePreviousState: initialLayoutState.editor.restoreEditors }
-        },
-        {
-            id: "workbench.parts.panel" ,
-            role: 'none',
-            classes: ['panel', 'basepanel'],
-            getPosition: () => layoutService.getPanelPosition(),
-            onDidChangePosition: layoutService.onDidChangePanelPosition
-        },
-        {
-            id: "workbench.parts.auxiliarybar" ,
-            role: 'none',
-            classes: ['auxiliarybar', 'basepanel'],
-            getPosition: () => layoutService.getSideBarPosition() === 0  ? 1  : 0 ,
-            onDidChangePosition: layoutService.onDidChangeSideBarPosition
-        },
-        { id: "workbench.parts.statusbar" , role: 'status', classes: ['statusbar'] }
-    ]) {
-        const part = layoutService.getPart(id);
-        if (part != null) {
-            const partContainer = createPart(id, role, classes);
-            part.create(partContainer, options);
-            renderPart(partContainer, part);
-            part.layout(9999, 9999, 0, 0);
-            invisibleContainer.append(partContainer);
-            if (getPosition != null) {
-                let position = getPosition();
-                part.element.classList.add(positionToString(position));
-                onDidChangePosition?.(() => {
-                    part.element.classList.remove(positionToString(position));
-                    position = getPosition();
-                    part.element.classList.add(positionToString(position));
-                });
-            }
-        }
-    }
-    const layoutReadyPromises = [];
-    const layoutRestoredPromises = [];
-    layoutReadyPromises.push((async () => {
-        mark('code/willRestoreEditors');
-        await editorGroupService.mainPart.whenReady;
-        mark('code/restoreEditors/editorGroupsReady');
-        if (initialLayoutState.layout?.editors != null) {
-            editorGroupService.applyLayout(initialLayoutState.layout.editors);
-        }
-        const editors = await initialLayoutState.editor.editorsToOpen;
-        mark('code/restoreEditors/editorsToOpenResolved');
-        let openEditorsPromise;
-        if (editors.length > 0) {
-            const editorGroupsInVisualOrder = editorGroupService.getGroups(2 );
-            const mapEditorsToGroup = new Map();
-            for (const editor of editors) {
-                const group = editorGroupsInVisualOrder[(editor.viewColumn ?? 1) - 1];
-                let editorsByGroup = mapEditorsToGroup.get(group.id);
-                if (editorsByGroup == null) {
-                    editorsByGroup = new Set();
-                    mapEditorsToGroup.set(group.id, editorsByGroup);
-                }
-                editorsByGroup.add(editor.editor);
-            }
-            openEditorsPromise = Promise.all(( Array.from(mapEditorsToGroup).map(async ([groupId, editors]) => {
-                try {
-                    await editorService.openEditors(Array.from(editors), groupId, { validateTrust: true });
-                }
-                catch (error) {
-                    logService.error(error);
-                }
-            })));
-        }
-        layoutRestoredPromises.push(Promise.all([
-            openEditorsPromise?.finally(() => mark('code/restoreEditors/editorsOpened')),
-            editorGroupService.mainPart.whenRestored.finally(() => mark('code/restoreEditors/editorGroupsRestored'))
-        ]).finally(() => {
-            mark('code/didRestoreEditors');
-        }));
-    })());
-    const restoreDefaultViewsPromise = (async () => {
-        if (initialLayoutState.views.defaults != null && initialLayoutState.views.defaults.length > 0) {
-            mark('code/willOpenDefaultViews');
-            const locationsRestored = [];
-            const tryOpenView = (view) => {
-                const location = viewDescriptorService.getViewLocationById(view.id);
-                if (location !== null) {
-                    const container = viewDescriptorService.getViewContainerByViewId(view.id);
-                    if (container != null) {
-                        if (view.order >= (locationsRestored[location]?.order ?? 0)) {
-                            locationsRestored[location] = { id: container.id, order: view.order };
-                        }
-                        const containerModel = viewDescriptorService.getViewContainerModel(container);
-                        containerModel.setCollapsed(view.id, false);
-                        containerModel.setVisible(view.id, true);
-                        return true;
-                    }
-                }
-                return false;
-            };
-            const defaultViews = ( [...initialLayoutState.views.defaults]
-                .reverse()
-                .map((v, index) => ({ id: v, order: index })));
-            let i = defaultViews.length;
-            while (i > 0) {
-                i--;
-                if (tryOpenView(defaultViews[i])) {
-                    defaultViews.splice(i, 1);
-                }
-            }
-            if (defaultViews.length > 0) {
-                await extensionService.whenInstalledExtensionsRegistered();
-                let i = defaultViews.length;
-                while (i > 0) {
-                    i--;
-                    if (tryOpenView(defaultViews[i])) {
-                        defaultViews.splice(i, 1);
-                    }
-                }
-            }
-            if (locationsRestored[0 ] != null) {
-                initialLayoutState.views.containerToRestore.sideBar =
-                    locationsRestored[0 ].id;
-            }
-            if (locationsRestored[1 ] != null) {
-                initialLayoutState.views.containerToRestore.panel =
-                    locationsRestored[1 ].id;
-            }
-            if (locationsRestored[2 ] != null) {
-                initialLayoutState.views.containerToRestore.auxiliaryBar =
-                    locationsRestored[2 ].id;
-            }
-            mark('code/didOpenDefaultViews');
-        }
-    })();
-    layoutReadyPromises.push(restoreDefaultViewsPromise);
-    layoutReadyPromises.push((async () => {
-        await restoreDefaultViewsPromise;
-        if (initialLayoutState.views.containerToRestore.sideBar == null) {
-            return;
-        }
-        mark('code/willRestoreViewlet');
-        const viewlet = await paneCompositePartService.openPaneComposite(initialLayoutState.views.containerToRestore.sideBar, 0 );
-        if (viewlet == null) {
-            await paneCompositePartService.openPaneComposite(getDefaultViewContainer(0 )?.id, 0 );
-        }
-        mark('code/didRestoreViewlet');
-    })());
-    layoutReadyPromises.push((async () => {
-        await restoreDefaultViewsPromise;
-        if (initialLayoutState.views.containerToRestore.panel == null) {
-            return;
-        }
-        mark('code/willRestorePanel');
-        const panel = await paneCompositePartService.openPaneComposite(initialLayoutState.views.containerToRestore.panel, 1 );
-        if (panel == null) {
-            await paneCompositePartService.openPaneComposite(getDefaultViewContainer(1 )?.id, 1 );
-        }
-        mark('code/didRestorePanel');
-    })());
-    layoutReadyPromises.push((async () => {
-        await restoreDefaultViewsPromise;
-        if (initialLayoutState.views.containerToRestore.auxiliaryBar == null) {
-            return;
-        }
-        mark('code/willRestoreAuxiliaryBar');
-        const panel = await paneCompositePartService.openPaneComposite(initialLayoutState.views.containerToRestore.auxiliaryBar, 2 );
-        if (panel == null) {
-            await paneCompositePartService.openPaneComposite(getDefaultViewContainer(2 )?.id, 2 );
-        }
-        mark('code/didRestoreAuxiliaryBar');
-    })());
-    await Promises.settled(layoutReadyPromises);
-    await Promises.settled(layoutRestoredPromises);
-});
-function getServiceOverride(openEditorFallback, _webviewIframeAlternateDomains, initializationStateOrRestoreEditors) {
-    if (initializationStateOrRestoreEditors != null) {
-        transformInitializationState =
-            typeof initializationStateOrRestoreEditors === 'boolean'
-                ? (state) => ({
-                    ...state,
-                    editor: {
-                        ...state.editor,
-                        restoreEditors: initializationStateOrRestoreEditors
-                    }
-                })
-                : initializationStateOrRestoreEditors;
-    }
-    return {
-        ...getServiceOverride$1(_webviewIframeAlternateDomains),
-        ...getServiceOverride$2({
-            isKeybindingConfigurationVisible: isEditorPartVisible,
-            shouldUseGlobalPicker: isEditorPartVisible
-        }),
-        ...getServiceOverride$3({
-            shouldUseGlobalKeybindings: isEditorPartVisible
-        }),
-        [( IEditorGroupsService.toString())]: new SyncDescriptor(MonacoEditorParts, [], false),
-        [( IEditorService.toString())]: new SyncDescriptor(MonacoEditorService, [openEditorFallback, isEditorPartVisible], false)
-    };
-}
-
-export { attachPart, getServiceOverride as default, isEditorPartVisible, onPartVisibilityChange, renderActivitybarPar, renderAuxiliaryPart, renderEditorPart, renderPanelPart, renderPart, renderSidebarPart, renderStatusBarPart };