@codingame/monaco-vscode-api 1.79.0 → 1.79.1

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

@@ -0,0 +1,137 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isMacintosh, isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { h, append, $, clearNode } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IContextKeyService, ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+const showCommands = { text: ( nls.localize('watermark.showCommands', "Show All Commands")), id: 'workbench.action.showCommands' };
+const quickAccess = { text: ( nls.localize('watermark.quickAccess', "Go to File")), id: 'workbench.action.quickOpen' };
+const openFileNonMacOnly = { text: ( nls.localize('watermark.openFile', "Open File")), id: 'workbench.action.files.openFile', mac: false };
+const openFolderNonMacOnly = { text: ( nls.localize('watermark.openFolder', "Open Folder")), id: 'workbench.action.files.openFolder', mac: false };
+const openFileOrFolderMacOnly = { text: ( nls.localize('watermark.openFileFolder', "Open File or Folder")), id: 'workbench.action.files.openFileFolder', mac: true };
+const openRecent = { text: ( nls.localize('watermark.openRecent', "Open Recent")), id: 'workbench.action.openRecent' };
+const newUntitledFile = { text: ( nls.localize('watermark.newUntitledFile', "New Untitled Text File")), id: 'workbench.action.files.newUntitledFile' };
+const newUntitledFileMacOnly = Object.assign({ mac: true }, newUntitledFile);
+const findInFiles = { text: ( nls.localize('watermark.findInFiles', "Find in Files")), id: 'workbench.action.findInFiles' };
+const toggleTerminal = { text: ( nls.localize(
+    { key: 'watermark.toggleTerminal', comment: ['toggle is a verb here'] },
+    "Toggle Terminal"
+)), id: 'workbench.action.terminal.toggleTerminal', when: ( ContextKeyExpr.equals('terminalProcessSupported', true)) };
+const startDebugging = { text: ( nls.localize('watermark.startDebugging', "Start Debugging")), id: 'workbench.action.debug.start', when: ( ContextKeyExpr.equals('terminalProcessSupported', true)) };
+const toggleFullscreen = { text: ( nls.localize(
+    { key: 'watermark.toggleFullscreen', comment: ['toggle is a verb here'] },
+    "Toggle Full Screen"
+)), id: 'workbench.action.toggleFullScreen', when: ( ( ContextKeyExpr.equals('terminalProcessSupported', true)).negate()) };
+const showSettings = { text: ( nls.localize('watermark.showSettings', "Show Settings")), id: 'workbench.action.openSettings', when: ( ( ContextKeyExpr.equals('terminalProcessSupported', true)).negate()) };
+const noFolderEntries = [
+    showCommands,
+    openFileNonMacOnly,
+    openFolderNonMacOnly,
+    openFileOrFolderMacOnly,
+    openRecent,
+    newUntitledFileMacOnly
+];
+const folderEntries = [
+    showCommands,
+    quickAccess,
+    findInFiles,
+    startDebugging,
+    toggleTerminal,
+    toggleFullscreen,
+    showSettings
+];
+let EditorGroupWatermark = class EditorGroupWatermark extends Disposable {
+    constructor(container, lifecycleService, keybindingService, contextService, contextKeyService, configurationService, telemetryService) {
+        super();
+        this.lifecycleService = lifecycleService;
+        this.keybindingService = keybindingService;
+        this.contextService = contextService;
+        this.contextKeyService = contextKeyService;
+        this.configurationService = configurationService;
+        this.telemetryService = telemetryService;
+        this.transientDisposables = this._register(( new DisposableStore()));
+        const elements = h('.editor-group-watermark', [
+            h('.letterpress'),
+            h('.shortcuts@shortcuts'),
+        ]);
+        append(container, elements.root);
+        this.shortcuts = elements.shortcuts;
+        this.workbenchState = contextService.getWorkbenchState();
+        this.enabled = this.configurationService.getValue('workbench.tips.enabled');
+        this.registerListeners();
+        if (this.enabled) {
+            this.render();
+        }
+    }
+    registerListeners() {
+        this.lifecycleService.onDidShutdown(() => this.dispose());
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('workbench.tips.enabled')) {
+                const enabled = this.configurationService.getValue('workbench.tips.enabled');
+                if (enabled === this.enabled) {
+                    return;
+                }
+                this.enabled = enabled;
+                if (this.enabled) {
+                    this.render();
+                }
+                else {
+                    this.clear();
+                }
+            }
+        }));
+        this._register(this.contextService.onDidChangeWorkbenchState(workbenchState => {
+            if (!this.enabled || this.workbenchState === workbenchState) {
+                return;
+            }
+            this.workbenchState = workbenchState;
+            this.render();
+        }));
+        const allEntriesWhenClauses = ( [...noFolderEntries, ...folderEntries].filter(entry => entry.when !== undefined).map(entry => entry.when));
+        const allKeys = ( new Set());
+        allEntriesWhenClauses.forEach(when => ( when.keys()).forEach(key => allKeys.add(key)));
+        this._register(this.contextKeyService.onDidChangeContext(e => {
+            if (e.affectsSome(allKeys)) {
+                this.render();
+            }
+        }));
+    }
+    render() {
+        this.clear();
+        const box = append(this.shortcuts, $('.watermark-box'));
+        const folder = this.workbenchState !== 1 ;
+        (folder ? folderEntries : noFolderEntries)
+            .filter(entry => !('when' in entry) || this.contextKeyService.contextMatchesRules(entry.when))
+            .filter(entry => !('mac' in entry) || entry.mac === (isMacintosh && !isWeb))
+            .filter(entry => !!CommandsRegistry.getCommand(entry.id));
+        const update = () => {
+            clearNode(box);
+        };
+        update();
+        this.transientDisposables.add(this.keybindingService.onDidUpdateKeybindings(update));
+        this.telemetryService.publicLog('watermark:open');
+    }
+    clear() {
+        clearNode(this.shortcuts);
+        this.transientDisposables.clear();
+    }
+    dispose() {
+        super.dispose();
+        this.clear();
+    }
+};
+EditorGroupWatermark = ( __decorate([
+    ( __param(1, ILifecycleService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IWorkspaceContextService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, ITelemetryService))
+], EditorGroupWatermark));
+export { EditorGroupWatermark };

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

@@ -0,0 +1,242 @@
+import { Composite } from '../../composite.js';
+import { isEditorInput } from '../../../common/editor.js';
+import { LRUCache } from 'monaco-editor/esm/vs/base/common/map.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { isEmptyObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { DEFAULT_EDITOR_MIN_DIMENSIONS, DEFAULT_EDITOR_MAX_DIMENSIONS } from './editor.js';
+import { isEqual, joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { indexOfPath } from 'monaco-editor/esm/vs/base/common/extpath.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class EditorPane extends Composite {
+    get minimumWidth() { return DEFAULT_EDITOR_MIN_DIMENSIONS.width; }
+    get maximumWidth() { return DEFAULT_EDITOR_MAX_DIMENSIONS.width; }
+    get minimumHeight() { return DEFAULT_EDITOR_MIN_DIMENSIONS.height; }
+    get maximumHeight() { return DEFAULT_EDITOR_MAX_DIMENSIONS.height; }
+    get input() { return this._input; }
+    get options() { return this._options; }
+    get group() { return this._group; }
+    get scopedContextKeyService() { return undefined; }
+    constructor(id, telemetryService, themeService, storageService) {
+        super(id, telemetryService, themeService, storageService);
+        this.onDidChangeSizeConstraints = Event.None;
+        this._onDidChangeControl = this._register(( new Emitter()));
+        this.onDidChangeControl = this._onDidChangeControl.event;
+    }
+    create(parent) {
+        super.create(parent);
+        this.createEditor(parent);
+    }
+    async setInput(input, options, context, token) {
+        this._input = input;
+        this._options = options;
+    }
+    clearInput() {
+        this._input = undefined;
+        this._options = undefined;
+    }
+    setOptions(options) {
+        this._options = options;
+    }
+    setVisible(visible, group) {
+        super.setVisible(visible);
+        this.setEditorVisible(visible, group);
+    }
+    setEditorVisible(visible, group) {
+        this._group = group;
+    }
+    setBoundarySashes(_sashes) {
+    }
+    getEditorMemento(editorGroupService, configurationService, key, limit = 10) {
+        const mementoKey = `${this.getId()}${key}`;
+        let editorMemento = EditorPane.EDITOR_MEMENTOS.get(mementoKey);
+        if (!editorMemento) {
+            editorMemento = this._register(( new EditorMemento(
+                this.getId(),
+                key,
+                this.getMemento(1 , 1 ),
+                limit,
+                editorGroupService,
+                configurationService
+            )));
+            EditorPane.EDITOR_MEMENTOS.set(mementoKey, editorMemento);
+        }
+        return editorMemento;
+    }
+    getViewState() {
+        return undefined;
+    }
+    saveState() {
+        for (const [, editorMemento] of EditorPane.EDITOR_MEMENTOS) {
+            if (editorMemento.id === this.getId()) {
+                editorMemento.saveState();
+            }
+        }
+        super.saveState();
+    }
+    dispose() {
+        this._input = undefined;
+        this._options = undefined;
+        super.dispose();
+    }
+}
+EditorPane.EDITOR_MEMENTOS = ( new Map());
+class EditorMemento extends Disposable {
+    constructor(id, key, memento, limit, editorGroupService, configurationService) {
+        super();
+        this.id = id;
+        this.key = key;
+        this.memento = memento;
+        this.limit = limit;
+        this.editorGroupService = editorGroupService;
+        this.configurationService = configurationService;
+        this.cleanedUp = false;
+        this.shareEditorState = false;
+        this.updateConfiguration(undefined);
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.configurationService.onDidChangeConfiguration(e => this.updateConfiguration(e)));
+    }
+    updateConfiguration(e) {
+        if (!e || e.affectsConfiguration(undefined, 'workbench.editor.sharedViewState')) {
+            this.shareEditorState = this.configurationService.getValue(undefined, 'workbench.editor.sharedViewState') === true;
+        }
+    }
+    saveEditorState(group, resourceOrEditor, state) {
+        const resource = this.doGetResource(resourceOrEditor);
+        if (!resource || !group) {
+            return;
+        }
+        const cache = this.doLoad();
+        let mementosForResource = cache.get(( resource.toString()));
+        if (!mementosForResource) {
+            mementosForResource = Object.create(null);
+            cache.set(( resource.toString()), mementosForResource);
+        }
+        mementosForResource[group.id] = state;
+        if (this.shareEditorState) {
+            mementosForResource[EditorMemento.SHARED_EDITOR_STATE] = state;
+        }
+        if (isEditorInput(resourceOrEditor)) {
+            this.clearEditorStateOnDispose(resource, resourceOrEditor);
+        }
+    }
+    loadEditorState(group, resourceOrEditor) {
+        const resource = this.doGetResource(resourceOrEditor);
+        if (!resource || !group) {
+            return;
+        }
+        const cache = this.doLoad();
+        const mementosForResource = cache.get(( resource.toString()));
+        if (mementosForResource) {
+            const mementoForResourceAndGroup = mementosForResource[group.id];
+            if (mementoForResourceAndGroup) {
+                return mementoForResourceAndGroup;
+            }
+            if (this.shareEditorState) {
+                return mementosForResource[EditorMemento.SHARED_EDITOR_STATE];
+            }
+        }
+        return undefined;
+    }
+    clearEditorState(resourceOrEditor, group) {
+        if (isEditorInput(resourceOrEditor)) {
+            this.editorDisposables?.delete(resourceOrEditor);
+        }
+        const resource = this.doGetResource(resourceOrEditor);
+        if (resource) {
+            const cache = this.doLoad();
+            if (group) {
+                const mementosForResource = cache.get(( resource.toString()));
+                if (mementosForResource) {
+                    delete mementosForResource[group.id];
+                    if (isEmptyObject(mementosForResource)) {
+                        cache.delete(( resource.toString()));
+                    }
+                }
+            }
+            else {
+                cache.delete(( resource.toString()));
+            }
+        }
+    }
+    clearEditorStateOnDispose(resource, editor) {
+        if (!this.editorDisposables) {
+            this.editorDisposables = ( new Map());
+        }
+        if (!( this.editorDisposables.has(editor))) {
+            this.editorDisposables.set(editor, Event.once(editor.onWillDispose)(() => {
+                this.clearEditorState(resource);
+                this.editorDisposables?.delete(editor);
+            }));
+        }
+    }
+    moveEditorState(source, target, comparer) {
+        const cache = this.doLoad();
+        const cacheKeys = [...( cache.keys())];
+        for (const cacheKey of cacheKeys) {
+            const resource = ( URI.parse(cacheKey));
+            if (!comparer.isEqualOrParent(resource, source)) {
+                continue;
+            }
+            let targetResource;
+            if (isEqual(source, resource)) {
+                targetResource = target;
+            }
+            else {
+                const index = indexOfPath(resource.path, source.path);
+                targetResource = joinPath(target, resource.path.substr(index + source.path.length + 1));
+            }
+            const value = cache.get(cacheKey, 0 );
+            if (value) {
+                cache.delete(cacheKey);
+                cache.set(( targetResource.toString()), value);
+            }
+        }
+    }
+    doGetResource(resourceOrEditor) {
+        if (isEditorInput(resourceOrEditor)) {
+            return resourceOrEditor.resource;
+        }
+        return resourceOrEditor;
+    }
+    doLoad() {
+        if (!this.cache) {
+            this.cache = ( new LRUCache(this.limit));
+            const rawEditorMemento = this.memento[this.key];
+            if (Array.isArray(rawEditorMemento)) {
+                this.cache.fromJSON(rawEditorMemento);
+            }
+        }
+        return this.cache;
+    }
+    saveState() {
+        const cache = this.doLoad();
+        if (!this.cleanedUp) {
+            this.cleanUp();
+            this.cleanedUp = true;
+        }
+        this.memento[this.key] = cache.toJSON();
+    }
+    cleanUp() {
+        const cache = this.doLoad();
+        const entries = [...cache.entries()];
+        for (const [resource, mapGroupToMementos] of entries) {
+            for (const group of ( Object.keys(mapGroupToMementos))) {
+                const groupId = Number(group);
+                if (groupId === EditorMemento.SHARED_EDITOR_STATE && this.shareEditorState) {
+                    continue;
+                }
+                if (!this.editorGroupService.getGroup(groupId)) {
+                    delete mapGroupToMementos[groupId];
+                    if (isEmptyObject(mapGroupToMementos)) {
+                        cache.delete(resource);
+                    }
+                }
+            }
+        }
+    }
+}
+EditorMemento.SHARED_EDITOR_STATE = -1;
+export { EditorMemento, EditorPane };

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

@@ -0,0 +1,297 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { EditorExtensions, isEditorOpenError } from '../../../common/editor.js';
+import { isAncestor, show, Dimension, hide } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { LongRunningOperation, IEditorProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { DEFAULT_EDITOR_MIN_DIMENSIONS, DEFAULT_EDITOR_MAX_DIMENSIONS } from './editor.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IWorkspaceTrustManagementService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { ErrorPlaceholderEditor, WorkspaceTrustRequiredPlaceholderEditor } from './editorPlaceholder.js';
+import { EditorOpenSource } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+let EditorPanes = class EditorPanes extends Disposable {
+    get minimumWidth() { return this._activeEditorPane?.minimumWidth ?? DEFAULT_EDITOR_MIN_DIMENSIONS.width; }
+    get minimumHeight() { return this._activeEditorPane?.minimumHeight ?? DEFAULT_EDITOR_MIN_DIMENSIONS.height; }
+    get maximumWidth() { return this._activeEditorPane?.maximumWidth ?? DEFAULT_EDITOR_MAX_DIMENSIONS.width; }
+    get maximumHeight() { return this._activeEditorPane?.maximumHeight ?? DEFAULT_EDITOR_MAX_DIMENSIONS.height; }
+    get activeEditorPane() { return this._activeEditorPane; }
+    constructor(editorGroupParent, editorPanesParent, groupView, layoutService, instantiationService, editorProgressService, workspaceTrustService, logService, dialogService) {
+        super();
+        this.editorGroupParent = editorGroupParent;
+        this.editorPanesParent = editorPanesParent;
+        this.groupView = groupView;
+        this.layoutService = layoutService;
+        this.instantiationService = instantiationService;
+        this.editorProgressService = editorProgressService;
+        this.workspaceTrustService = workspaceTrustService;
+        this.logService = logService;
+        this.dialogService = dialogService;
+        this._onDidFocus = this._register(( new Emitter()));
+        this.onDidFocus = this._onDidFocus.event;
+        this._onDidChangeSizeConstraints = this._register(( new Emitter()));
+        this.onDidChangeSizeConstraints = this._onDidChangeSizeConstraints.event;
+        this._activeEditorPane = null;
+        this.editorPanes = [];
+        this.activeEditorPaneDisposables = this._register(( new DisposableStore()));
+        this.editorOperation = this._register(( new LongRunningOperation(this.editorProgressService)));
+        this.editorPanesRegistry = ( Registry.as(EditorExtensions.EditorPane));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.workspaceTrustService.onDidChangeTrust(() => this.onDidChangeWorkspaceTrust()));
+    }
+    onDidChangeWorkspaceTrust() {
+        const editor = this._activeEditorPane?.input;
+        const options = this._activeEditorPane?.options;
+        if (editor?.hasCapability(16 )) {
+            this.groupView.openEditor(editor, options);
+        }
+    }
+    async openEditor(editor, options, context = Object.create(null)) {
+        try {
+            return await this.doOpenEditor(this.getEditorPaneDescriptor(editor), editor, options, context);
+        }
+        catch (error) {
+            if (options?.ignoreError) {
+                return { error };
+            }
+            return this.doShowError(error, editor, options, context);
+        }
+    }
+    async doShowError(error, editor, options, context) {
+        this.logService.error(error);
+        let errorHandled = false;
+        if (options?.source === EditorOpenSource.USER && (!isEditorOpenError(error) || error.allowDialog)) {
+            errorHandled = await this.doShowErrorDialog(error, editor);
+        }
+        if (errorHandled) {
+            return { error };
+        }
+        const editorPlaceholderOptions = { ...options };
+        if (!isCancellationError(error)) {
+            editorPlaceholderOptions.error = error;
+        }
+        return {
+            ...(await this.doOpenEditor(ErrorPlaceholderEditor.DESCRIPTOR, editor, editorPlaceholderOptions, context)),
+            error
+        };
+    }
+    async doShowErrorDialog(error, editor) {
+        let severity = Severity.Error;
+        let message = undefined;
+        let detail = toErrorMessage(error);
+        let errorActions = undefined;
+        if (isEditorOpenError(error)) {
+            errorActions = error.actions;
+            severity = error.forceSeverity ?? Severity.Error;
+            if (error.forceMessage) {
+                message = error.message;
+                detail = undefined;
+            }
+        }
+        if (!message) {
+            message = ( localize('editorOpenErrorDialog', "Unable to open '{0}'", editor.getName()));
+        }
+        const buttons = [];
+        if (errorActions && errorActions.length > 0) {
+            for (const errorAction of errorActions) {
+                buttons.push({
+                    label: errorAction.label,
+                    run: () => errorAction
+                });
+            }
+        }
+        else {
+            buttons.push({
+                label: ( localize({ key: 'ok', comment: ['&& denotes a mnemonic'] }, "&&OK")),
+                run: () => undefined
+            });
+        }
+        let cancelButton = undefined;
+        if (buttons.length === 1) {
+            cancelButton = {
+                run: () => {
+                    errorHandled = true;
+                    return undefined;
+                }
+            };
+        }
+        let errorHandled = false;
+        const { result } = await this.dialogService.prompt({
+            type: severity,
+            message,
+            detail,
+            buttons,
+            cancelButton
+        });
+        if (result) {
+            const errorActionResult = result.run();
+            if (errorActionResult instanceof Promise) {
+                errorActionResult.catch(error => this.dialogService.error(toErrorMessage(error)));
+            }
+            errorHandled = true;
+        }
+        return errorHandled;
+    }
+    async doOpenEditor(descriptor, editor, options, context = Object.create(null)) {
+        const pane = this.doShowEditorPane(descriptor);
+        const activeElement = document.activeElement;
+        const { changed, cancelled } = await this.doSetInput(pane, editor, options, context);
+        const focus = !options || !options.preserveFocus;
+        if (!cancelled && focus && this.shouldRestoreFocus(activeElement)) {
+            pane.focus();
+        }
+        return { pane, changed, cancelled };
+    }
+    shouldRestoreFocus(expectedActiveElement) {
+        if (!this.layoutService.isRestored()) {
+            return true;
+        }
+        if (!expectedActiveElement) {
+            return true;
+        }
+        const activeElement = document.activeElement;
+        if (!activeElement || activeElement === document.body) {
+            return true;
+        }
+        const same = expectedActiveElement === activeElement;
+        if (same) {
+            return true;
+        }
+        if (activeElement.tagName !== 'INPUT' && activeElement.tagName !== 'TEXTAREA') {
+            return true;
+        }
+        if (isAncestor(activeElement, this.editorGroupParent)) {
+            return true;
+        }
+        return false;
+    }
+    getEditorPaneDescriptor(editor) {
+        if (editor.hasCapability(16 ) && !this.workspaceTrustService.isWorkspaceTrusted()) {
+            return WorkspaceTrustRequiredPlaceholderEditor.DESCRIPTOR;
+        }
+        return assertIsDefined(this.editorPanesRegistry.getEditorPane(editor));
+    }
+    doShowEditorPane(descriptor) {
+        if (this._activeEditorPane && descriptor.describes(this._activeEditorPane)) {
+            return this._activeEditorPane;
+        }
+        this.doHideActiveEditorPane();
+        const editorPane = this.doCreateEditorPane(descriptor);
+        this.doSetActiveEditorPane(editorPane);
+        const container = assertIsDefined(editorPane.getContainer());
+        this.editorPanesParent.appendChild(container);
+        show(container);
+        editorPane.setVisible(true, this.groupView);
+        if (this.pagePosition) {
+            editorPane.layout(( new Dimension(this.pagePosition.width, this.pagePosition.height)), { top: this.pagePosition.top, left: this.pagePosition.left });
+        }
+        if (this.boundarySashes) {
+            editorPane.setBoundarySashes(this.boundarySashes);
+        }
+        return editorPane;
+    }
+    doCreateEditorPane(descriptor) {
+        const editorPane = this.doInstantiateEditorPane(descriptor);
+        if (!editorPane.getContainer()) {
+            const editorPaneContainer = document.createElement('div');
+            editorPaneContainer.classList.add('editor-instance');
+            editorPane.create(editorPaneContainer);
+        }
+        return editorPane;
+    }
+    doInstantiateEditorPane(descriptor) {
+        const existingEditorPane = this.editorPanes.find(editorPane => descriptor.describes(editorPane));
+        if (existingEditorPane) {
+            return existingEditorPane;
+        }
+        const editorPane = this._register(descriptor.instantiate(this.instantiationService));
+        this.editorPanes.push(editorPane);
+        return editorPane;
+    }
+    doSetActiveEditorPane(editorPane) {
+        this._activeEditorPane = editorPane;
+        this.activeEditorPaneDisposables.clear();
+        if (editorPane) {
+            this.activeEditorPaneDisposables.add(editorPane.onDidChangeSizeConstraints(e => this._onDidChangeSizeConstraints.fire(e)));
+            this.activeEditorPaneDisposables.add(editorPane.onDidFocus(() => this._onDidFocus.fire()));
+        }
+        this._onDidChangeSizeConstraints.fire(undefined);
+    }
+    async doSetInput(editorPane, editor, options, context) {
+        const inputMatches = editorPane.input?.matches(editor);
+        if (inputMatches && !options?.forceReload) {
+            editorPane.setOptions(options);
+            return { changed: false, cancelled: false };
+        }
+        const operation = this.editorOperation.start(this.layoutService.isRestored() ? 800 : 3200);
+        let cancelled = false;
+        try {
+            editorPane.clearInput();
+            await editorPane.setInput(editor, options, context, operation.token);
+            if (!operation.isCurrent()) {
+                cancelled = true;
+            }
+        }
+        catch (error) {
+            if (!operation.isCurrent()) {
+                cancelled = true;
+            }
+            else {
+                throw error;
+            }
+        }
+        finally {
+            operation.stop();
+        }
+        return { changed: !inputMatches, cancelled };
+    }
+    doHideActiveEditorPane() {
+        if (!this._activeEditorPane) {
+            return;
+        }
+        this.editorOperation.stop();
+        this._activeEditorPane.clearInput();
+        this._activeEditorPane.setVisible(false, this.groupView);
+        const editorPaneContainer = this._activeEditorPane.getContainer();
+        if (editorPaneContainer) {
+            this.editorPanesParent.removeChild(editorPaneContainer);
+            hide(editorPaneContainer);
+        }
+        this.doSetActiveEditorPane(null);
+    }
+    closeEditor(editor) {
+        if (this._activeEditorPane?.input && editor.matches(this._activeEditorPane.input)) {
+            this.doHideActiveEditorPane();
+        }
+    }
+    setVisible(visible) {
+        this._activeEditorPane?.setVisible(visible, this.groupView);
+    }
+    layout(pagePosition) {
+        this.pagePosition = pagePosition;
+        this._activeEditorPane?.layout(( new Dimension(pagePosition.width, pagePosition.height)), pagePosition);
+    }
+    setBoundarySashes(sashes) {
+        this.boundarySashes = sashes;
+        this._activeEditorPane?.setBoundarySashes(sashes);
+    }
+};
+EditorPanes = ( __decorate([
+    ( __param(3, IWorkbenchLayoutService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IEditorProgressService)),
+    ( __param(6, IWorkspaceTrustManagementService)),
+    ( __param(7, ILogService)),
+    ( __param(8, IDialogService))
+], EditorPanes));
+export { EditorPanes };