@codingame/monaco-vscode-api 1.83.15 → 1.85.0-next.0

package/vscode/src/vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService.js

@@ -0,0 +1,273 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { getWindowId, registerWindow, getActiveWindow, createMetaElement, copyAttributes, cloneGlobalStylesheets, sharedMutationObserver, trackAttributes, addDisposableListener, EventType, getClientArea, position, size, EventHelper, ModifierKeyEmitter, isGlobalStylesheet } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { mainWindow, ensureCodeWindow } from 'monaco-editor/esm/vs/base/browser/window.js';
+import { Disposable, toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IWorkbenchLayoutService } from '../../layout/browser/layoutService.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { WindowMinimumSize } from '../../../../platform/window/common/window.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { BaseWindow } from '../../../browser/window.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+var BrowserAuxiliaryWindowService_1;
+const IAuxiliaryWindowService = ( createDecorator('auxiliaryWindowService'));
+let AuxiliaryWindow = class AuxiliaryWindow extends BaseWindow {
+    constructor(window, container, configurationService) {
+        super(window);
+        this.window = window;
+        this.container = container;
+        this.configurationService = configurationService;
+        this._onDidLayout = this._register(( new Emitter()));
+        this.onDidLayout = this._onDidLayout.event;
+        this._onWillClose = this._register(( new Emitter()));
+        this.onWillClose = this._onWillClose.event;
+        this._onWillDispose = this._register(( new Emitter()));
+        this.onWillDispose = this._onWillDispose.event;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(addDisposableListener(this.window, EventType.BEFORE_UNLOAD, (e) => this.onBeforeUnload(e)));
+        this._register(addDisposableListener(this.window, EventType.UNLOAD, () => this._onWillClose.fire()));
+        this._register(addDisposableListener(this.window, 'unhandledrejection', e => {
+            onUnexpectedError(e.reason);
+            e.preventDefault();
+        }));
+        this._register(addDisposableListener(this.window, EventType.RESIZE, () => {
+            const dimension = getClientArea(this.window.document.body, this.container);
+            position(this.container, 0, 0, 0, 0, 'relative');
+            size(this.container, dimension.width, dimension.height);
+            this._onDidLayout.fire(dimension);
+        }));
+        this._register(addDisposableListener(this.container, EventType.SCROLL, () => this.container.scrollTop = 0));
+        if (isWeb) {
+            this._register(addDisposableListener(this.container, EventType.DROP, e => EventHelper.stop(e, true)));
+            this._register(addDisposableListener(this.container, EventType.WHEEL, e => e.preventDefault(), { passive: false }));
+            this._register(addDisposableListener(this.container, EventType.CONTEXT_MENU, e => EventHelper.stop(e, true)));
+        }
+        else {
+            this._register(addDisposableListener(this.window.document.body, EventType.DRAG_OVER, (e) => EventHelper.stop(e)));
+            this._register(addDisposableListener(this.window.document.body, EventType.DROP, (e) => EventHelper.stop(e)));
+        }
+    }
+    onBeforeUnload(e) {
+        const confirmBeforeCloseSetting = this.configurationService.getValue('window.confirmBeforeClose');
+        const confirmBeforeClose = confirmBeforeCloseSetting === 'always' || (confirmBeforeCloseSetting === 'keyboardOnly' && ModifierKeyEmitter.getInstance().isModifierPressed);
+        if (confirmBeforeClose) {
+            this.confirmBeforeClose(e);
+        }
+    }
+    confirmBeforeClose(e) {
+        e.preventDefault();
+        e.returnValue = ( localizeWithPath(
+            'vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService',
+            'lifecycleVeto',
+            "Changes that you made may not be saved. Please check press 'Cancel' and try again."
+        ));
+    }
+    layout() {
+        this._onDidLayout.fire(getClientArea(this.window.document.body, this.container));
+    }
+    dispose() {
+        if (this._store.isDisposed) {
+            return;
+        }
+        this._onWillDispose.fire();
+        super.dispose();
+    }
+};
+AuxiliaryWindow = ( __decorate([
+    ( __param(2, IConfigurationService))
+], AuxiliaryWindow));
+let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends Disposable {
+    static { BrowserAuxiliaryWindowService_1 = this; }
+    static { this.DEFAULT_SIZE = { width: 800, height: 600 }; }
+    static { this.WINDOW_IDS = getWindowId(mainWindow) + 1; }
+    constructor(layoutService, dialogService, configurationService, telemetryService) {
+        super();
+        this.layoutService = layoutService;
+        this.dialogService = dialogService;
+        this.configurationService = configurationService;
+        this.telemetryService = telemetryService;
+        this._onDidOpenAuxiliaryWindow = this._register(( new Emitter()));
+        this.onDidOpenAuxiliaryWindow = this._onDidOpenAuxiliaryWindow.event;
+        this.windows = ( new Map());
+    }
+    async open(options) {
+        mark('code/auxiliaryWindow/willOpen');
+        const targetWindow = await this.openWindow(options);
+        if (!targetWindow) {
+            throw new Error(localizeWithPath('vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService', 'unableToOpenWindowError', "Unable to open a new window."));
+        }
+        const resolvedWindowId = await this.resolveWindowId(targetWindow);
+        ensureCodeWindow(targetWindow, resolvedWindowId);
+        const containerDisposables = ( new DisposableStore());
+        const container = this.createContainer(targetWindow, containerDisposables);
+        const auxiliaryWindow = this.createAuxiliaryWindow(targetWindow, container);
+        const registryDisposables = ( new DisposableStore());
+        this.windows.set(targetWindow.vscodeWindowId, auxiliaryWindow);
+        registryDisposables.add(toDisposable(() => this.windows.delete(targetWindow.vscodeWindowId)));
+        const eventDisposables = ( new DisposableStore());
+        Event.once(auxiliaryWindow.onWillDispose)(() => {
+            targetWindow.close();
+            containerDisposables.dispose();
+            registryDisposables.dispose();
+            eventDisposables.dispose();
+        });
+        registryDisposables.add(registerWindow(targetWindow));
+        this._onDidOpenAuxiliaryWindow.fire({ window: auxiliaryWindow, disposables: eventDisposables });
+        mark('code/auxiliaryWindow/didOpen');
+        this.telemetryService.publicLog2('auxiliaryWindowOpen', { bounds: !!options?.bounds });
+        return auxiliaryWindow;
+    }
+    createAuxiliaryWindow(targetWindow, container) {
+        return ( new AuxiliaryWindow(targetWindow, container, this.configurationService));
+    }
+    async openWindow(options) {
+        const activeWindow = getActiveWindow();
+        const activeWindowBounds = {
+            x: activeWindow.screenX,
+            y: activeWindow.screenY,
+            width: activeWindow.outerWidth,
+            height: activeWindow.outerHeight
+        };
+        const width = Math.max(options?.bounds?.width ?? BrowserAuxiliaryWindowService_1.DEFAULT_SIZE.width, WindowMinimumSize.WIDTH);
+        const height = Math.max(options?.bounds?.height ?? BrowserAuxiliaryWindowService_1.DEFAULT_SIZE.height, WindowMinimumSize.HEIGHT);
+        let newWindowBounds = {
+            x: options?.bounds?.x ?? (activeWindowBounds.x + activeWindowBounds.width / 2 - width / 2),
+            y: options?.bounds?.y ?? (activeWindowBounds.y + activeWindowBounds.height / 2 - height / 2),
+            width,
+            height
+        };
+        if (newWindowBounds.x === activeWindowBounds.x && newWindowBounds.y === activeWindowBounds.y) {
+            newWindowBounds = {
+                ...newWindowBounds,
+                x: newWindowBounds.x + 30,
+                y: newWindowBounds.y + 30
+            };
+        }
+        const auxiliaryWindow = mainWindow.open('about:blank', undefined, `popup=yes,left=${newWindowBounds.x},top=${newWindowBounds.y},width=${newWindowBounds.width},height=${newWindowBounds.height}`);
+        if (!auxiliaryWindow && isWeb) {
+            return (await this.dialogService.prompt({
+                type: Severity.Warning,
+                message: ( localizeWithPath(
+                    'vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService',
+                    'unableToOpenWindow',
+                    "The browser interrupted the opening of a new window. Press 'Retry' to try again."
+                )),
+                detail: ( localizeWithPath(
+                    'vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService',
+                    'unableToOpenWindowDetail',
+                    "To avoid this problem in the future, please ensure to allow popups for this website."
+                )),
+                buttons: [
+                    {
+                        label: ( localizeWithPath(
+                            'vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService',
+                            { key: 'retry', comment: ['&& denotes a mnemonic'] },
+                            "&&Retry"
+                        )),
+                        run: () => this.openWindow(options)
+                    }
+                ],
+                cancelButton: true
+            })).result;
+        }
+        return auxiliaryWindow?.window;
+    }
+    async resolveWindowId(auxiliaryWindow) {
+        return BrowserAuxiliaryWindowService_1.WINDOW_IDS++;
+    }
+    createContainer(auxiliaryWindow, disposables) {
+        this.patchMethods(auxiliaryWindow);
+        this.applyMeta(auxiliaryWindow);
+        this.applyCSS(auxiliaryWindow, disposables);
+        return this.applyHTML(auxiliaryWindow, disposables);
+    }
+    patchMethods(auxiliaryWindow) {
+        auxiliaryWindow.document.createElement = function () {
+            throw new Error('Not allowed to create elements in child window JavaScript context. Always use the main window so that "xyz instanceof HTMLElement" continues to work.');
+        };
+    }
+    applyMeta(auxiliaryWindow) {
+        const metaCharset = createMetaElement(auxiliaryWindow.document.head);
+        metaCharset.setAttribute('charset', 'utf-8');
+        const originalCSPMetaTag = mainWindow.document.querySelector('meta[http-equiv="Content-Security-Policy"]');
+        if (originalCSPMetaTag) {
+            const csp = createMetaElement(auxiliaryWindow.document.head);
+            copyAttributes(originalCSPMetaTag, csp);
+            const content = csp.getAttribute('content');
+            if (content) {
+                csp.setAttribute('content', content.replace(/(script-src[^\;]*)/, `script-src 'none'`));
+            }
+        }
+    }
+    applyCSS(auxiliaryWindow, disposables) {
+        mark('code/auxiliaryWindow/willApplyCSS');
+        const mapOriginalToClone = ( new Map());
+        function cloneNode(originalNode) {
+            if (isGlobalStylesheet(originalNode)) {
+                return;
+            }
+            const clonedNode = auxiliaryWindow.document.head.appendChild(originalNode.cloneNode(true));
+            mapOriginalToClone.set(originalNode, clonedNode);
+        }
+        for (const originalNode of mainWindow.document.head.querySelectorAll('link[rel="stylesheet"], style')) {
+            cloneNode(originalNode);
+        }
+        disposables.add(cloneGlobalStylesheets(auxiliaryWindow));
+        disposables.add(sharedMutationObserver.observe(mainWindow.document.head, disposables, { childList: true, subtree: true })(mutations => {
+            for (const mutation of mutations) {
+                if (mutation.type !== 'childList' ||
+                    mutation.target.nodeName.toLowerCase() === 'title' ||
+                    mutation.target.nodeName.toLowerCase() === 'script' ||
+                    mutation.target.nodeName.toLowerCase() === 'meta'
+                ) {
+                    continue;
+                }
+                for (const node of mutation.addedNodes) {
+                    if (node instanceof HTMLElement && (node.tagName.toLowerCase() === 'style' || node.tagName.toLowerCase() === 'link')) {
+                        cloneNode(node);
+                    }
+                    else if (node.nodeType === Node.TEXT_NODE && node.parentNode) {
+                        const clonedNode = mapOriginalToClone.get(node.parentNode);
+                        if (clonedNode) {
+                            clonedNode.textContent = node.textContent;
+                        }
+                    }
+                }
+                for (const node of mutation.removedNodes) {
+                    const clonedNode = mapOriginalToClone.get(node);
+                    if (clonedNode) {
+                        clonedNode.parentNode?.removeChild(clonedNode);
+                        mapOriginalToClone.delete(node);
+                    }
+                }
+            }
+        }));
+        mark('code/auxiliaryWindow/didApplyCSS');
+    }
+    applyHTML(auxiliaryWindow, disposables) {
+        mark('code/auxiliaryWindow/willApplyHTML');
+        const container = document.createElement('div');
+        auxiliaryWindow.document.body.append(container);
+        disposables.add(trackAttributes(mainWindow.document.documentElement, auxiliaryWindow.document.documentElement));
+        disposables.add(trackAttributes(mainWindow.document.body, auxiliaryWindow.document.body));
+        disposables.add(trackAttributes(this.layoutService.mainContainer, container, ['class']));
+        mark('code/auxiliaryWindow/didApplyHTML');
+        return container;
+    }
+};
+BrowserAuxiliaryWindowService = BrowserAuxiliaryWindowService_1 = ( __decorate([
+    ( __param(0, IWorkbenchLayoutService)),
+    ( __param(1, IDialogService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, ITelemetryService))
+], BrowserAuxiliaryWindowService));
+export { AuxiliaryWindow, BrowserAuxiliaryWindowService, IAuxiliaryWindowService };

package/vscode/src/vs/workbench/services/configurationResolver/common/configurationResolver.js

@@ -16,6 +16,7 @@ var VariableKind;
     VariableKind["SelectedText"] = "selectedText";
     VariableKind["File"] = "file";
     VariableKind["FileWorkspaceFolder"] = "fileWorkspaceFolder";
+    VariableKind["FileWorkspaceFolderBasename"] = "fileWorkspaceFolderBasename";
     VariableKind["RelativeFile"] = "relativeFile";
     VariableKind["RelativeFileDirname"] = "relativeFileDirname";
     VariableKind["FileDirname"] = "fileDirname";

package/vscode/src/vs/workbench/services/configurationResolver/common/variableResolver.js

@@ -232,6 +232,8 @@ class AbstractVariableResolverService {
                         return getFilePath(VariableKind.File);
                     case 'fileWorkspaceFolder':
                         return getFolderPathForFile(VariableKind.FileWorkspaceFolder);
+                    case 'fileWorkspaceFolderBasename':
+                        return path.basename(getFolderPathForFile(VariableKind.FileWorkspaceFolderBasename));
                     case 'relativeFile':
                         if (folderUri || argument) {
                             return path.relative(this.fsPath(getFolderUri(VariableKind.RelativeFile)), getFilePath(VariableKind.RelativeFile));

package/vscode/src/vs/workbench/services/decorations/browser/decorationsService.js

@@ -122,13 +122,12 @@ class DecorationRule {
 class DecorationStyles {
     constructor(_themeService) {
         this._themeService = _themeService;
-        this._styleElement = createStyleSheet();
-        this._decorationRules = ( new Map());
         this._dispoables = ( new DisposableStore());
+        this._styleElement = createStyleSheet(undefined, undefined, this._dispoables);
+        this._decorationRules = ( new Map());
     }
     dispose() {
         this._dispoables.dispose();
-        this._styleElement.remove();
     }
     asDecoration(data, onlyChildren) {
         data.sort((a, b) => (b.weight || 0) - (a.weight || 0));

package/vscode/src/vs/workbench/services/editor/browser/editorService.d.ts

@@ -5,10 +5,10 @@ import { EditorInput } from '../../../common/editor/editorInput.js';
 import { IFileService } from '../../../../platform/files/common/files.js';
 import { Event } from '../../../../base/common/event.js';
 import { URI } from '../../../../base/common/uri.js';
-import { IEditorGroupsService, ICloseEditorOptions, IEditorGroup, IEditorReplacement } from '../common/editorGroupsService.js';
-import { IEditorsChangeEvent, PreferredGroup, IOpenEditorsOptions, IUntypedEditorReplacement, ISaveEditorsOptions, ISaveEditorsResult, ISaveAllEditorsOptions, IRevertAllEditorsOptions } from '../common/editorService.js';
+import { IEditorGroupsContainer, IEditorGroupsService, ICloseEditorOptions, IEditorGroup, IEditorReplacement } from '../common/editorGroupsService.js';
+import { IEditorsChangeEvent, IEditorService, PreferredGroup, IOpenEditorsOptions, IUntypedEditorReplacement, ISaveEditorsOptions, ISaveEditorsResult, ISaveAllEditorsOptions, IRevertAllEditorsOptions } from '../common/editorService.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { ICodeEditor, IDiffEditor } from '../../../../editor/browser/editorBrowser.js';
 import { EditorServiceImpl } from '../../../browser/parts/editor/editor.js';
 import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
@@ -42,7 +42,9 @@ declare class EditorService extends Disposable implements EditorServiceImpl {
     readonly onDidOpenEditorFail: Event<IEditorIdentifier>;
     private readonly _onDidMostRecentlyActiveEditorsChange;
     readonly onDidMostRecentlyActiveEditorsChange: Event<void>;
-    constructor(editorGroupService: IEditorGroupsService, instantiationService: IInstantiationService, fileService: IFileService, configurationService: IConfigurationService, contextService: IWorkspaceContextService, uriIdentityService: IUriIdentityService, editorResolverService: IEditorResolverService, workspaceTrustRequestService: IWorkspaceTrustRequestService, hostService: IHostService, textEditorService: ITextEditorService);
+    private readonly editorGroupsContainer;
+    constructor(editorGroupsContainer: IEditorGroupsContainer | undefined, editorGroupService: IEditorGroupsService, instantiationService: IInstantiationService, fileService: IFileService, configurationService: IConfigurationService, contextService: IWorkspaceContextService, uriIdentityService: IUriIdentityService, editorResolverService: IEditorResolverService, workspaceTrustRequestService: IWorkspaceTrustRequestService, hostService: IHostService, textEditorService: ITextEditorService);
+    createScoped(editorGroupsContainer: IEditorGroupsContainer | 'main', disposables: DisposableStore): IEditorService;
     private registerListeners;
     private lastActiveEditor;
     private onEditorGroupsReady;
@@ -66,7 +68,7 @@ declare class EditorService extends Disposable implements EditorServiceImpl {
     get editors(): EditorInput[];
     getEditors(order: EditorsOrder, options?: {
         excludeSticky?: boolean;
-    }): readonly IEditorIdentifier[];
+    }): IEditorIdentifier[];
     get activeEditor(): EditorInput | undefined;
     get visibleEditorPanes(): IVisibleEditorPane[];
     get visibleTextEditorControls(): Array<ICodeEditor | IDiffEditor>;

package/vscode/src/vs/workbench/services/editor/browser/editorService.js

@@ -26,8 +26,9 @@ import { IWorkspaceTrustRequestService } from 'monaco-editor/esm/vs/platform/wor
 import { IHostService } from '../../host/browser/host.js';
 import { findGroup } from '../common/editorGroupFinder.js';
 import { ITextEditorService } from '../../textfile/common/textEditorService.js';
-let EditorService = class EditorService extends Disposable {
-    constructor(editorGroupService, instantiationService, fileService, configurationService, contextService, uriIdentityService, editorResolverService, workspaceTrustRequestService, hostService, textEditorService) {
+var EditorService_1;
+let EditorService = EditorService_1 = class EditorService extends Disposable {
+    constructor(editorGroupsContainer, editorGroupService, instantiationService, fileService, configurationService, contextService, uriIdentityService, editorResolverService, workspaceTrustRequestService, hostService, textEditorService) {
         super();
         this.editorGroupService = editorGroupService;
         this.instantiationService = instantiationService;
@@ -54,14 +55,35 @@ let EditorService = class EditorService extends Disposable {
         this.lastActiveEditor = undefined;
         this.activeOutOfWorkspaceWatchers = ( new ResourceMap());
         this.closeOnFileDelete = false;
-        this.editorsObserver = this._register(this.instantiationService.createInstance(EditorsObserver));
+        this.editorGroupsContainer = editorGroupsContainer ?? editorGroupService;
+        this.editorsObserver = this._register(this.instantiationService.createInstance(EditorsObserver, this.editorGroupsContainer));
         this.onConfigurationUpdated();
         this.registerListeners();
     }
+    createScoped(editorGroupsContainer, disposables) {
+        return disposables.add(( new EditorService_1(
+            editorGroupsContainer === 'main' ? this.editorGroupService.mainPart : editorGroupsContainer,
+            this.editorGroupService,
+            this.instantiationService,
+            this.fileService,
+            this.configurationService,
+            this.contextService,
+            this.uriIdentityService,
+            this.editorResolverService,
+            this.workspaceTrustRequestService,
+            this.hostService,
+            this.textEditorService
+        )));
+    }
     registerListeners() {
-        this.editorGroupService.whenReady.then(() => this.onEditorGroupsReady());
-        this._register(this.editorGroupService.onDidChangeActiveGroup(group => this.handleActiveEditorChange(group)));
-        this._register(this.editorGroupService.onDidAddGroup(group => this.registerGroupListeners(group)));
+        if (this.editorGroupsContainer === this.editorGroupService.mainPart || this.editorGroupsContainer === this.editorGroupService) {
+            this.editorGroupService.mainPart.whenReady.then(() => this.onEditorGroupsReady());
+        }
+        else {
+            this.onEditorGroupsReady();
+        }
+        this._register(this.editorGroupsContainer.onDidChangeActiveGroup(group => this.handleActiveEditorChange(group)));
+        this._register(this.editorGroupsContainer.onDidAddGroup(group => this.registerGroupListeners(group)));
         this._register(this.editorsObserver.onDidMostRecentlyActiveEditorsChange(() => this._onDidMostRecentlyActiveEditorsChange.fire()));
         this._register(this.onDidVisibleEditorsChange(() => this.handleVisibleEditorsChange()));
         this._register(this.fileService.onDidRunOperation(e => this.onDidRunFileOperation(e)));
@@ -69,7 +91,7 @@ let EditorService = class EditorService extends Disposable {
         this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e)));
     }
     onEditorGroupsReady() {
-        for (const group of this.editorGroupService.groups) {
+        for (const group of this.editorGroupsContainer.groups) {
             this.registerGroupListeners(group);
         }
         if (this.activeEditor) {
@@ -78,7 +100,7 @@ let EditorService = class EditorService extends Disposable {
         }
     }
     handleActiveEditorChange(group) {
-        if (group !== this.editorGroupService.activeGroup) {
+        if (group !== this.editorGroupsContainer.activeGroup) {
             return;
         }
         if (!this.lastActiveEditor && !group.activeEditor) {
@@ -87,7 +109,7 @@ let EditorService = class EditorService extends Disposable {
         this.doHandleActiveEditorChangeEvent();
     }
     doHandleActiveEditorChangeEvent() {
-        const activeGroup = this.editorGroupService.activeGroup;
+        const activeGroup = this.editorGroupsContainer.activeGroup;
         this.lastActiveEditor = activeGroup.activeEditor ?? undefined;
         this._onDidActiveEditorChange.fire();
     }
@@ -150,7 +172,7 @@ let EditorService = class EditorService extends Disposable {
         }
     }
     async handleMovedFile(source, target) {
-        for (const group of this.editorGroupService.groups) {
+        for (const group of this.editorGroupsContainer.groups) {
             const replacements = [];
             for (const editor of group.editors) {
                 const resource = editor.resource;
@@ -272,7 +294,7 @@ let EditorService = class EditorService extends Disposable {
         return editors;
     }
     get activeEditorPane() {
-        return this.editorGroupService.activeGroup?.activeEditorPane;
+        return this.editorGroupsContainer.activeGroup?.activeEditorPane;
     }
     get activeTextEditorControl() {
         const activeEditorPane = this.activeEditorPane;
@@ -308,12 +330,12 @@ let EditorService = class EditorService extends Disposable {
         switch (order) {
             case 0 :
                 if (options?.excludeSticky) {
-                    return this.editorsObserver.editors.filter(({ groupId, editor }) => !this.editorGroupService.getGroup(groupId)?.isSticky(editor));
+                    return this.editorsObserver.editors.filter(({ groupId, editor }) => !this.editorGroupsContainer.getGroup(groupId)?.isSticky(editor));
                 }
                 return this.editorsObserver.editors;
             case 1 : {
                 const editors = [];
-                for (const group of this.editorGroupService.getGroups(2 )) {
+                for (const group of this.editorGroupsContainer.getGroups(2 )) {
                     editors.push(...( group.getEditors(1 , options).map(editor => ({ editor, groupId: group.id }))));
                 }
                 return editors;
@@ -321,11 +343,11 @@ let EditorService = class EditorService extends Disposable {
         }
     }
     get activeEditor() {
-        const activeGroup = this.editorGroupService.activeGroup;
+        const activeGroup = this.editorGroupsContainer.activeGroup;
         return activeGroup ? activeGroup.activeEditor ?? undefined : undefined;
     }
     get visibleEditorPanes() {
-        return coalesce(( this.editorGroupService.groups.map(group => group.activeEditorPane)));
+        return coalesce(( this.editorGroupsContainer.groups.map(group => group.activeEditorPane)));
     }
     get visibleTextEditorControls() {
         const visibleTextEditorControls = [];
@@ -338,7 +360,7 @@ let EditorService = class EditorService extends Disposable {
         return visibleTextEditorControls;
     }
     get visibleEditors() {
-        return coalesce(( this.editorGroupService.groups.map(group => group.activeEditor)));
+        return coalesce(( this.editorGroupsContainer.groups.map(group => group.activeEditor)));
     }
     async openEditor(editor, optionsOrPreferredGroup, preferredGroup) {
         let typedEditor = undefined;
@@ -487,7 +509,7 @@ let EditorService = class EditorService extends Disposable {
         });
     }
     isVisible(editor) {
-        for (const group of this.editorGroupService.groups) {
+        for (const group of this.editorGroupsContainer.groups) {
             if (group.activeEditor?.matches(editor)) {
                 return true;
             }
@@ -495,13 +517,13 @@ let EditorService = class EditorService extends Disposable {
         return false;
     }
     async closeEditor({ editor, groupId }, options) {
-        const group = this.editorGroupService.getGroup(groupId);
+        const group = this.editorGroupsContainer.getGroup(groupId);
         await group?.closeEditor(editor, options);
     }
     async closeEditors(editors, options) {
         const mapGroupToEditors = ( new Map());
         for (const { editor, groupId } of editors) {
-            const group = this.editorGroupService.getGroup(groupId);
+            const group = this.editorGroupsContainer.getGroup(groupId);
             if (!group) {
                 continue;
             }
@@ -528,7 +550,7 @@ let EditorService = class EditorService extends Disposable {
             }
         }
         if (!isUndefined(arg2)) {
-            const targetGroup = typeof arg2 === 'number' ? this.editorGroupService.getGroup(arg2) : arg2;
+            const targetGroup = typeof arg2 === 'number' ? this.editorGroupsContainer.getGroup(arg2) : arg2;
             if (URI.isUri(arg1)) {
                 if (!targetGroup) {
                     return [];
@@ -550,7 +572,7 @@ let EditorService = class EditorService extends Disposable {
         }
         else {
             const result = [];
-            for (const group of this.editorGroupService.getGroups(1 )) {
+            for (const group of this.editorGroupsContainer.getGroups(1 )) {
                 const editors = [];
                 if (URI.isUri(arg1)) {
                     editors.push(...this.findEditors(arg1, options, group));
@@ -567,7 +589,7 @@ let EditorService = class EditorService extends Disposable {
         }
     }
     async replaceEditors(replacements, group) {
-        const targetGroup = typeof group === 'number' ? this.editorGroupService.getGroup(group) : group;
+        const targetGroup = typeof group === 'number' ? this.editorGroupsContainer.getGroup(group) : group;
         const typedReplacements = [];
         for (const replacement of replacements) {
             let typedReplacement = undefined;
@@ -619,7 +641,7 @@ let EditorService = class EditorService extends Disposable {
         }
         const saveResults = await Promises.settled(( editorsToSaveParallel.map(({ groupId, editor }) => {
             if (options?.reason === 1 ) {
-                this.editorGroupService.getGroup(groupId)?.pinEditor(editor);
+                this.editorGroupsContainer.getGroup(groupId)?.pinEditor(editor);
             }
             return editor.save(groupId, options);
         })));
@@ -638,7 +660,7 @@ let EditorService = class EditorService extends Disposable {
                 break;
             }
             if (!editor.matches(result)) {
-                const targetGroups = editor.hasCapability(4 ) ? ( this.editorGroupService.groups.map(group => group.id) ) : [groupId];
+                const targetGroups = editor.hasCapability(4 ) ? ( this.editorGroupsContainer.groups.map(group => group.id) ) : [groupId];
                 for (const targetGroup of targetGroups) {
                     if (result instanceof EditorInput) {
                         await this.replaceEditors([{ editor, replacement: result, options: editorOptions }], targetGroup);
@@ -663,7 +685,7 @@ let EditorService = class EditorService extends Disposable {
         }
         const uniqueEditors = this.getUniqueEditors(editors);
         await Promises.settled(( uniqueEditors.map(async ({ groupId, editor }) => {
-            this.editorGroupService.getGroup(groupId)?.pinEditor(editor);
+            this.editorGroupsContainer.getGroup(groupId)?.pinEditor(editor);
             return editor.revert(groupId, options);
         })));
         return !( uniqueEditors.some(({ editor }) => editor.isDirty()));
@@ -673,7 +695,7 @@ let EditorService = class EditorService extends Disposable {
     }
     getAllModifiedEditors(options) {
         const editors = [];
-        for (const group of this.editorGroupService.getGroups(1 )) {
+        for (const group of this.editorGroupsContainer.getGroups(1 )) {
             for (const editor of group.getEditors(0 )) {
                 if (!editor.isModified()) {
                     continue;
@@ -709,16 +731,16 @@ let EditorService = class EditorService extends Disposable {
         this.activeOutOfWorkspaceWatchers.clear();
     }
 };
-EditorService = ( __decorate([
-    ( __param(0, IEditorGroupsService)),
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IFileService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IWorkspaceContextService)),
-    ( __param(5, IUriIdentityService)),
-    ( __param(6, IEditorResolverService)),
-    ( __param(7, IWorkspaceTrustRequestService)),
-    ( __param(8, IHostService)),
-    ( __param(9, ITextEditorService))
+EditorService = EditorService_1 = ( __decorate([
+    ( __param(1, IEditorGroupsService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IWorkspaceContextService)),
+    ( __param(6, IUriIdentityService)),
+    ( __param(7, IEditorResolverService)),
+    ( __param(8, IWorkspaceTrustRequestService)),
+    ( __param(9, IHostService)),
+    ( __param(10, ITextEditorService))
 ], EditorService));
 export { EditorService };