@codingame/monaco-vscode-api 1.82.3 → 1.82.4-next.1

package/vscode/src/vs/workbench/browser/contextkeys.js

@@ -0,0 +1,249 @@
+import { __decorate, __param } from '../../../../../external/tslib/tslib.es6.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { setConstant, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IsMacContext, IsLinuxContext, IsWindowsContext, IsWebContext, IsMacNativeContext, IsIOSContext, IsMobileContext, IsDevelopmentContext, ProductQualityContext, InputFocusedContext } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.js';
+import { RemoteNameContext, VirtualWorkspaceContext, TemporaryWorkspaceContext, HasWebFileSystemAccess, EmbedderIdentifierContext, ActiveEditorContext, ActiveEditorReadonlyContext, ActiveEditorCanToggleReadonlyContext, ActiveEditorCanRevertContext, ActiveEditorCanSplitInGroupContext, ActiveEditorAvailableEditorIdsContext, EditorsVisibleContext, TextCompareEditorVisibleContext, TextCompareEditorActiveContext, SideBySideEditorActiveContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupIndexContext, ActiveEditorGroupLastContext, ActiveEditorGroupLockedContext, MultipleEditorGroupsContext, DirtyWorkingCopiesContext, WorkbenchStateContext, WorkspaceFolderCountContext, OpenFolderWorkspaceSupportContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, SplitEditorsVertically, IsFullscreenContext, InEditorZenModeContext, IsCenteredLayoutContext, EditorAreaVisibleContext, EditorTabsVisibleContext, SideBarVisibleContext, PanelPositionContext, PanelVisibleContext, PanelMaximizedContext, PanelAlignmentContext, AuxiliaryBarVisibleContext, applyAvailableEditorIds } from '../common/contextkeys.js';
+import { TEXT_DIFF_EDITOR_ID, SIDE_BY_SIDE_EDITOR_ID, EditorResourceAccessor, SideBySideEditor } from '../common/editor.js';
+import { addDisposableListener, EventType, trackFocus } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { preferredSideBySideGroupDirection, IEditorGroupsService } from '../services/editor/common/editorGroupsService.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IWorkbenchEnvironmentService } from '../services/environment/common/environmentService.js';
+import { IEditorService } from '../services/editor/common/editorService.js';
+import { isTemporaryWorkspace, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { positionToString, IWorkbenchLayoutService } from '../services/layout/browser/layoutService.js';
+import { getRemoteName } from 'monaco-editor/esm/vs/platform/remote/common/remoteHosts.js';
+import { getVirtualWorkspaceScheme } from '../../platform/workspace/common/virtualWorkspace.js';
+import { IWorkingCopyService } from '../services/workingCopy/common/workingCopyService.js';
+import { isNative } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IEditorResolverService } from '../services/editor/common/editorResolverService.js';
+import { IPaneCompositePartService } from '../services/panecomposite/browser/panecomposite.js';
+import { WebFileSystemAccess } from 'monaco-editor/esm/vs/platform/files/browser/webFileSystemAccess.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+let WorkbenchContextKeysHandler = class WorkbenchContextKeysHandler extends Disposable {
+    constructor(contextKeyService, contextService, configurationService, environmentService, productService, editorService, editorResolverService, editorGroupService, layoutService, paneCompositeService, workingCopyService, fileService) {
+        super();
+        this.contextKeyService = contextKeyService;
+        this.contextService = contextService;
+        this.configurationService = configurationService;
+        this.environmentService = environmentService;
+        this.productService = productService;
+        this.editorService = editorService;
+        this.editorResolverService = editorResolverService;
+        this.editorGroupService = editorGroupService;
+        this.layoutService = layoutService;
+        this.paneCompositeService = paneCompositeService;
+        this.workingCopyService = workingCopyService;
+        this.fileService = fileService;
+        IsMacContext.bindTo(this.contextKeyService);
+        IsLinuxContext.bindTo(this.contextKeyService);
+        IsWindowsContext.bindTo(this.contextKeyService);
+        IsWebContext.bindTo(this.contextKeyService);
+        IsMacNativeContext.bindTo(this.contextKeyService);
+        IsIOSContext.bindTo(this.contextKeyService);
+        IsMobileContext.bindTo(this.contextKeyService);
+        RemoteNameContext.bindTo(this.contextKeyService).set(getRemoteName(this.environmentService.remoteAuthority) || '');
+        this.virtualWorkspaceContext = VirtualWorkspaceContext.bindTo(this.contextKeyService);
+        this.temporaryWorkspaceContext = TemporaryWorkspaceContext.bindTo(this.contextKeyService);
+        this.updateWorkspaceContextKeys();
+        HasWebFileSystemAccess.bindTo(this.contextKeyService).set(WebFileSystemAccess.supported(window));
+        const isDevelopment = !this.environmentService.isBuilt || this.environmentService.isExtensionDevelopment;
+        IsDevelopmentContext.bindTo(this.contextKeyService).set(isDevelopment);
+        setConstant(IsDevelopmentContext.key, isDevelopment);
+        ProductQualityContext.bindTo(this.contextKeyService).set(this.productService.quality || '');
+        EmbedderIdentifierContext.bindTo(this.contextKeyService).set(productService.embedderIdentifier);
+        this.activeEditorContext = ActiveEditorContext.bindTo(this.contextKeyService);
+        this.activeEditorIsReadonly = ActiveEditorReadonlyContext.bindTo(this.contextKeyService);
+        this.activeEditorCanToggleReadonly = ActiveEditorCanToggleReadonlyContext.bindTo(this.contextKeyService);
+        this.activeEditorCanRevert = ActiveEditorCanRevertContext.bindTo(this.contextKeyService);
+        this.activeEditorCanSplitInGroup = ActiveEditorCanSplitInGroupContext.bindTo(this.contextKeyService);
+        this.activeEditorAvailableEditorIds = ActiveEditorAvailableEditorIdsContext.bindTo(this.contextKeyService);
+        this.editorsVisibleContext = EditorsVisibleContext.bindTo(this.contextKeyService);
+        this.textCompareEditorVisibleContext = TextCompareEditorVisibleContext.bindTo(this.contextKeyService);
+        this.textCompareEditorActiveContext = TextCompareEditorActiveContext.bindTo(this.contextKeyService);
+        this.sideBySideEditorActiveContext = SideBySideEditorActiveContext.bindTo(this.contextKeyService);
+        this.activeEditorGroupEmpty = ActiveEditorGroupEmptyContext.bindTo(this.contextKeyService);
+        this.activeEditorGroupIndex = ActiveEditorGroupIndexContext.bindTo(this.contextKeyService);
+        this.activeEditorGroupLast = ActiveEditorGroupLastContext.bindTo(this.contextKeyService);
+        this.activeEditorGroupLocked = ActiveEditorGroupLockedContext.bindTo(this.contextKeyService);
+        this.multipleEditorGroupsContext = MultipleEditorGroupsContext.bindTo(this.contextKeyService);
+        this.dirtyWorkingCopiesContext = DirtyWorkingCopiesContext.bindTo(this.contextKeyService);
+        this.dirtyWorkingCopiesContext.set(this.workingCopyService.hasDirty);
+        this.inputFocusedContext = InputFocusedContext.bindTo(this.contextKeyService);
+        this.workbenchStateContext = WorkbenchStateContext.bindTo(this.contextKeyService);
+        this.updateWorkbenchStateContextKey();
+        this.workspaceFolderCountContext = WorkspaceFolderCountContext.bindTo(this.contextKeyService);
+        this.updateWorkspaceFolderCountContextKey();
+        this.openFolderWorkspaceSupportContext = OpenFolderWorkspaceSupportContext.bindTo(this.contextKeyService);
+        this.openFolderWorkspaceSupportContext.set(isNative || typeof this.environmentService.remoteAuthority === 'string');
+        this.emptyWorkspaceSupportContext = EmptyWorkspaceSupportContext.bindTo(this.contextKeyService);
+        this.emptyWorkspaceSupportContext.set(isNative || typeof this.environmentService.remoteAuthority === 'string');
+        this.enterMultiRootWorkspaceSupportContext = EnterMultiRootWorkspaceSupportContext.bindTo(this.contextKeyService);
+        this.enterMultiRootWorkspaceSupportContext.set(isNative || typeof this.environmentService.remoteAuthority === 'string');
+        this.splitEditorsVerticallyContext = SplitEditorsVertically.bindTo(this.contextKeyService);
+        this.updateSplitEditorsVerticallyContext();
+        this.isFullscreenContext = IsFullscreenContext.bindTo(this.contextKeyService);
+        this.inZenModeContext = InEditorZenModeContext.bindTo(this.contextKeyService);
+        this.isCenteredLayoutContext = IsCenteredLayoutContext.bindTo(this.contextKeyService);
+        this.editorAreaVisibleContext = EditorAreaVisibleContext.bindTo(this.contextKeyService);
+        this.editorTabsVisibleContext = EditorTabsVisibleContext.bindTo(this.contextKeyService);
+        this.sideBarVisibleContext = SideBarVisibleContext.bindTo(this.contextKeyService);
+        this.panelPositionContext = PanelPositionContext.bindTo(this.contextKeyService);
+        this.panelPositionContext.set(positionToString(this.layoutService.getPanelPosition()));
+        this.panelVisibleContext = PanelVisibleContext.bindTo(this.contextKeyService);
+        this.panelVisibleContext.set(this.layoutService.isVisible("workbench.parts.panel" ));
+        this.panelMaximizedContext = PanelMaximizedContext.bindTo(this.contextKeyService);
+        this.panelMaximizedContext.set(this.layoutService.isPanelMaximized());
+        this.panelAlignmentContext = PanelAlignmentContext.bindTo(this.contextKeyService);
+        this.panelAlignmentContext.set(this.layoutService.getPanelAlignment());
+        this.auxiliaryBarVisibleContext = AuxiliaryBarVisibleContext.bindTo(this.contextKeyService);
+        this.auxiliaryBarVisibleContext.set(this.layoutService.isVisible("workbench.parts.auxiliarybar" ));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this.editorGroupService.whenReady.then(() => {
+            this.updateEditorAreaContextKeys();
+            this.updateEditorContextKeys();
+        });
+        this._register(this.editorService.onDidActiveEditorChange(() => this.updateEditorContextKeys()));
+        this._register(this.editorService.onDidVisibleEditorsChange(() => this.updateEditorContextKeys()));
+        this._register(this.editorGroupService.onDidAddGroup(() => this.updateEditorContextKeys()));
+        this._register(this.editorGroupService.onDidRemoveGroup(() => this.updateEditorContextKeys()));
+        this._register(this.editorGroupService.onDidChangeGroupIndex(() => this.updateEditorContextKeys()));
+        this._register(this.editorGroupService.onDidChangeActiveGroup(() => this.updateEditorGroupContextKeys()));
+        this._register(this.editorGroupService.onDidChangeGroupLocked(() => this.updateEditorGroupContextKeys()));
+        this._register(this.editorGroupService.onDidChangeEditorPartOptions(() => this.updateEditorAreaContextKeys()));
+        this._register(addDisposableListener(window, EventType.FOCUS_IN, () => this.updateInputContextKeys(), true));
+        this._register(this.contextService.onDidChangeWorkbenchState(() => this.updateWorkbenchStateContextKey()));
+        this._register(this.contextService.onDidChangeWorkspaceFolders(() => {
+            this.updateWorkspaceFolderCountContextKey();
+            this.updateWorkspaceContextKeys();
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('workbench.editor.openSideBySideDirection')) {
+                this.updateSplitEditorsVerticallyContext();
+            }
+        }));
+        this._register(this.layoutService.onDidChangeZenMode(enabled => this.inZenModeContext.set(enabled)));
+        this._register(this.layoutService.onDidChangeFullscreen(fullscreen => this.isFullscreenContext.set(fullscreen)));
+        this._register(this.layoutService.onDidChangeCenteredLayout(centered => this.isCenteredLayoutContext.set(centered)));
+        this._register(this.layoutService.onDidChangePanelPosition(position => this.panelPositionContext.set(position)));
+        this._register(this.layoutService.onDidChangePanelAlignment(alignment => this.panelAlignmentContext.set(alignment)));
+        this._register(this.paneCompositeService.onDidPaneCompositeClose(() => this.updateSideBarContextKeys()));
+        this._register(this.paneCompositeService.onDidPaneCompositeOpen(() => this.updateSideBarContextKeys()));
+        this._register(this.layoutService.onDidChangePartVisibility(() => {
+            this.editorAreaVisibleContext.set(this.layoutService.isVisible("workbench.parts.editor" ));
+            this.panelVisibleContext.set(this.layoutService.isVisible("workbench.parts.panel" ));
+            this.panelMaximizedContext.set(this.layoutService.isPanelMaximized());
+            this.auxiliaryBarVisibleContext.set(this.layoutService.isVisible("workbench.parts.auxiliarybar" ));
+        }));
+        this._register(this.workingCopyService.onDidChangeDirty(workingCopy => this.dirtyWorkingCopiesContext.set(workingCopy.isDirty() || this.workingCopyService.hasDirty)));
+    }
+    updateEditorAreaContextKeys() {
+        this.editorTabsVisibleContext.set(!!this.editorGroupService.partOptions.showTabs);
+    }
+    updateEditorContextKeys() {
+        const activeEditorPane = this.editorService.activeEditorPane;
+        const visibleEditorPanes = this.editorService.visibleEditorPanes;
+        this.textCompareEditorActiveContext.set(activeEditorPane?.getId() === TEXT_DIFF_EDITOR_ID);
+        this.textCompareEditorVisibleContext.set(( visibleEditorPanes.some(editorPane => editorPane.getId() === TEXT_DIFF_EDITOR_ID)));
+        this.sideBySideEditorActiveContext.set(activeEditorPane?.getId() === SIDE_BY_SIDE_EDITOR_ID);
+        if (visibleEditorPanes.length > 0) {
+            this.editorsVisibleContext.set(true);
+        }
+        else {
+            this.editorsVisibleContext.reset();
+        }
+        if (!this.editorService.activeEditor) {
+            this.activeEditorGroupEmpty.set(true);
+        }
+        else {
+            this.activeEditorGroupEmpty.reset();
+        }
+        this.updateEditorGroupContextKeys();
+        if (activeEditorPane) {
+            this.activeEditorContext.set(activeEditorPane.getId());
+            this.activeEditorCanRevert.set(!activeEditorPane.input.hasCapability(4 ));
+            this.activeEditorCanSplitInGroup.set(activeEditorPane.input.hasCapability(32 ));
+            applyAvailableEditorIds(this.activeEditorAvailableEditorIds, activeEditorPane.input, this.editorResolverService);
+            this.activeEditorIsReadonly.set(!!activeEditorPane.input.isReadonly());
+            const primaryEditorResource = EditorResourceAccessor.getOriginalUri(activeEditorPane.input, { supportSideBySide: SideBySideEditor.PRIMARY });
+            this.activeEditorCanToggleReadonly.set(!!primaryEditorResource && this.fileService.hasProvider(primaryEditorResource) && !this.fileService.hasCapability(primaryEditorResource, 2048 ));
+        }
+        else {
+            this.activeEditorContext.reset();
+            this.activeEditorIsReadonly.reset();
+            this.activeEditorCanToggleReadonly.reset();
+            this.activeEditorCanRevert.reset();
+            this.activeEditorCanSplitInGroup.reset();
+            this.activeEditorAvailableEditorIds.reset();
+        }
+    }
+    updateEditorGroupContextKeys() {
+        const groupCount = this.editorGroupService.count;
+        if (groupCount > 1) {
+            this.multipleEditorGroupsContext.set(true);
+        }
+        else {
+            this.multipleEditorGroupsContext.reset();
+        }
+        const activeGroup = this.editorGroupService.activeGroup;
+        this.activeEditorGroupIndex.set(activeGroup.index + 1);
+        this.activeEditorGroupLast.set(activeGroup.index === groupCount - 1);
+        this.activeEditorGroupLocked.set(activeGroup.isLocked);
+    }
+    updateInputContextKeys() {
+        function activeElementIsInput() {
+            return !!document.activeElement && (document.activeElement.tagName === 'INPUT' || document.activeElement.tagName === 'TEXTAREA');
+        }
+        const isInputFocused = activeElementIsInput();
+        this.inputFocusedContext.set(isInputFocused);
+        if (isInputFocused) {
+            const tracker = trackFocus(document.activeElement);
+            Event.once(tracker.onDidBlur)(() => {
+                this.inputFocusedContext.set(activeElementIsInput());
+                tracker.dispose();
+            });
+        }
+    }
+    updateWorkbenchStateContextKey() {
+        this.workbenchStateContext.set(this.getWorkbenchStateString());
+    }
+    updateWorkspaceFolderCountContextKey() {
+        this.workspaceFolderCountContext.set(this.contextService.getWorkspace().folders.length);
+    }
+    updateSplitEditorsVerticallyContext() {
+        const direction = preferredSideBySideGroupDirection(this.configurationService);
+        this.splitEditorsVerticallyContext.set(direction === 1 );
+    }
+    getWorkbenchStateString() {
+        switch (this.contextService.getWorkbenchState()) {
+            case 1 : return 'empty';
+            case 2 : return 'folder';
+            case 3 : return 'workspace';
+        }
+    }
+    updateSideBarContextKeys() {
+        this.sideBarVisibleContext.set(this.layoutService.isVisible("workbench.parts.sidebar" ));
+    }
+    updateWorkspaceContextKeys() {
+        this.virtualWorkspaceContext.set(getVirtualWorkspaceScheme(this.contextService.getWorkspace()) || '');
+        this.temporaryWorkspaceContext.set(isTemporaryWorkspace(this.contextService.getWorkspace()));
+    }
+};
+WorkbenchContextKeysHandler = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IWorkbenchEnvironmentService)),
+    ( __param(4, IProductService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, IEditorResolverService)),
+    ( __param(7, IEditorGroupsService)),
+    ( __param(8, IWorkbenchLayoutService)),
+    ( __param(9, IPaneCompositePartService)),
+    ( __param(10, IWorkingCopyService)),
+    ( __param(11, IFileService))
+], WorkbenchContextKeysHandler));
+export { WorkbenchContextKeysHandler };

package/vscode/src/vs/workbench/browser/parts/banner/bannerPart.d.ts

@@ -0,0 +1,45 @@
+import { Event } from '../../../../base/common/event.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { Part } from '../../part.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { IBannerService, IBannerItem } from '../../../services/banner/browser/bannerService.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+
+declare class BannerPart extends Part implements IBannerService {
+    private readonly contextKeyService;
+    private readonly instantiationService;
+    readonly _serviceBrand: undefined;
+    readonly height: number;
+    readonly minimumWidth: number;
+    readonly maximumWidth: number;
+    get minimumHeight(): number;
+    get maximumHeight(): number;
+    private _onDidChangeSize;
+    get onDidChange(): Event<{
+        width: number;
+        height: number;
+    } | undefined>;
+    private item;
+    private readonly markdownRenderer;
+    private visible;
+    private actionBar;
+    private messageActionsContainer;
+    private focusedActionIndex;
+    constructor(themeService: IThemeService, layoutService: IWorkbenchLayoutService, storageService: IStorageService, contextKeyService: IContextKeyService, instantiationService: IInstantiationService);
+    protected createContentArea(parent: HTMLElement): HTMLElement;
+    private close;
+    private focusActionLink;
+    private getAriaLabel;
+    private getBannerMessage;
+    private setVisibility;
+    focus(): void;
+    focusNextAction(): void;
+    focusPreviousAction(): void;
+    hide(id: string): void;
+    show(item: IBannerItem): void;
+    toJSON(): object;
+}
+
+export { BannerPart };

package/vscode/src/vs/workbench/browser/parts/titlebar/commandCenterControl.js

@@ -14,7 +14,7 @@ import { MenuId, MenuItemAction } from 'monaco-editor/esm/vs/platform/actions/co
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
 import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
-import * as colorRegistry from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import * as colors from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
 import { TITLE_BAR_ACTIVE_FOREGROUND, MENUBAR_SELECTION_FOREGROUND, TITLE_BAR_INACTIVE_FOREGROUND, MENUBAR_SELECTION_BACKGROUND } from '../../../common/theme.js';
 let CommandCenterControl = class CommandCenterControl {
     constructor(windowTitle, hoverDelegate, instantiationService, quickInputService, keybindingService) {
@@ -109,25 +109,25 @@ CommandCenterControl = ( __decorate([
     ( __param(3, IQuickInputService)),
     ( __param(4, IKeybindingService))
 ], CommandCenterControl));
-colorRegistry.registerColor('commandCenter.foreground', { dark: TITLE_BAR_ACTIVE_FOREGROUND, hcDark: TITLE_BAR_ACTIVE_FOREGROUND, light: TITLE_BAR_ACTIVE_FOREGROUND, hcLight: TITLE_BAR_ACTIVE_FOREGROUND }, ( localize('commandCenter-foreground', "Foreground color of the command center")), false);
-colorRegistry.registerColor('commandCenter.activeForeground', { dark: MENUBAR_SELECTION_FOREGROUND, hcDark: MENUBAR_SELECTION_FOREGROUND, light: MENUBAR_SELECTION_FOREGROUND, hcLight: MENUBAR_SELECTION_FOREGROUND }, ( localize(
+colors.registerColor('commandCenter.foreground', { dark: TITLE_BAR_ACTIVE_FOREGROUND, hcDark: TITLE_BAR_ACTIVE_FOREGROUND, light: TITLE_BAR_ACTIVE_FOREGROUND, hcLight: TITLE_BAR_ACTIVE_FOREGROUND }, ( localize('commandCenter-foreground', "Foreground color of the command center")), false);
+colors.registerColor('commandCenter.activeForeground', { dark: MENUBAR_SELECTION_FOREGROUND, hcDark: MENUBAR_SELECTION_FOREGROUND, light: MENUBAR_SELECTION_FOREGROUND, hcLight: MENUBAR_SELECTION_FOREGROUND }, ( localize(
     'commandCenter-activeForeground',
     "Active foreground color of the command center"
 )), false);
-colorRegistry.registerColor('commandCenter.inactiveForeground', { dark: TITLE_BAR_INACTIVE_FOREGROUND, hcDark: TITLE_BAR_INACTIVE_FOREGROUND, light: TITLE_BAR_INACTIVE_FOREGROUND, hcLight: TITLE_BAR_INACTIVE_FOREGROUND }, ( localize(
+colors.registerColor('commandCenter.inactiveForeground', { dark: TITLE_BAR_INACTIVE_FOREGROUND, hcDark: TITLE_BAR_INACTIVE_FOREGROUND, light: TITLE_BAR_INACTIVE_FOREGROUND, hcLight: TITLE_BAR_INACTIVE_FOREGROUND }, ( localize(
     'commandCenter-inactiveForeground',
     "Foreground color of the command center when the window is inactive"
 )), false);
-colorRegistry.registerColor('commandCenter.background', {
+colors.registerColor('commandCenter.background', {
     dark: ( Color.white.transparent(0.05)), hcDark: null, light: ( Color.black.transparent(0.05)), hcLight: null
 }, ( localize('commandCenter-background', "Background color of the command center")), false);
-colorRegistry.registerColor('commandCenter.activeBackground', { dark: ( Color.white.transparent(0.08)), hcDark: MENUBAR_SELECTION_BACKGROUND, light: ( Color.black.transparent(0.08)), hcLight: MENUBAR_SELECTION_BACKGROUND }, ( localize(
+colors.registerColor('commandCenter.activeBackground', { dark: ( Color.white.transparent(0.08)), hcDark: MENUBAR_SELECTION_BACKGROUND, light: ( Color.black.transparent(0.08)), hcLight: MENUBAR_SELECTION_BACKGROUND }, ( localize(
     'commandCenter-activeBackground',
     "Active background color of the command center"
 )), false);
-colorRegistry.registerColor('commandCenter.border', { dark: ( colorRegistry.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .20)), hcDark: ( colorRegistry.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .60)), light: ( colorRegistry.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .20)), hcLight: ( colorRegistry.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .60)) }, ( localize('commandCenter-border', "Border color of the command center")), false);
-colorRegistry.registerColor('commandCenter.activeBorder', { dark: ( colorRegistry.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .30)), hcDark: TITLE_BAR_ACTIVE_FOREGROUND, light: ( colorRegistry.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .30)), hcLight: TITLE_BAR_ACTIVE_FOREGROUND }, ( localize('commandCenter-activeBorder', "Active border color of the command center")), false);
-colorRegistry.registerColor('commandCenter.inactiveBorder', { dark: ( colorRegistry.transparent(TITLE_BAR_INACTIVE_FOREGROUND, .25)), hcDark: ( colorRegistry.transparent(TITLE_BAR_INACTIVE_FOREGROUND, .25)), light: ( colorRegistry.transparent(TITLE_BAR_INACTIVE_FOREGROUND, .25)), hcLight: ( colorRegistry.transparent(TITLE_BAR_INACTIVE_FOREGROUND, .25)) }, ( localize(
+colors.registerColor('commandCenter.border', { dark: ( colors.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .20)), hcDark: ( colors.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .60)), light: ( colors.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .20)), hcLight: ( colors.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .60)) }, ( localize('commandCenter-border', "Border color of the command center")), false);
+colors.registerColor('commandCenter.activeBorder', { dark: ( colors.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .30)), hcDark: TITLE_BAR_ACTIVE_FOREGROUND, light: ( colors.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .30)), hcLight: TITLE_BAR_ACTIVE_FOREGROUND }, ( localize('commandCenter-activeBorder', "Active border color of the command center")), false);
+colors.registerColor('commandCenter.inactiveBorder', { dark: ( colors.transparent(TITLE_BAR_INACTIVE_FOREGROUND, .25)), hcDark: ( colors.transparent(TITLE_BAR_INACTIVE_FOREGROUND, .25)), light: ( colors.transparent(TITLE_BAR_INACTIVE_FOREGROUND, .25)), hcLight: ( colors.transparent(TITLE_BAR_INACTIVE_FOREGROUND, .25)) }, ( localize(
     'commandCenter-inactiveBorder',
     "Border color of the command center when the window is inactive"
 )), false);

package/vscode/src/vs/workbench/browser/parts/titlebar/menubarControl.d.ts

@@ -0,0 +1,115 @@
+import { IMenuService, IMenu } from '../../../../platform/actions/common/actions.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { Separator, IAction } from '../../../../base/common/actions.js';
+import { Dimension } from '../../../../base/browser/dom.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { Event } from '../../../../base/common/event.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { IWorkspacesService, IRecentlyOpened } from '../../../../platform/workspaces/common/workspaces.js';
+import { RunOnceScheduler } from '../../../../base/common/async.js';
+import { URI } from '../../../../base/common/uri.js';
+import { ILabelService } from '../../../../platform/label/common/label.js';
+import { IUpdateService } from '../../../../platform/update/common/update.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { IHostService } from '../../../services/host/browser/host.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+
+type IOpenRecentAction = IAction & {
+    uri: URI;
+    remoteAuthority?: string;
+};
+declare abstract class MenubarControl extends Disposable {
+    protected readonly menuService: IMenuService;
+    protected readonly workspacesService: IWorkspacesService;
+    protected readonly contextKeyService: IContextKeyService;
+    protected readonly keybindingService: IKeybindingService;
+    protected readonly configurationService: IConfigurationService;
+    protected readonly labelService: ILabelService;
+    protected readonly updateService: IUpdateService;
+    protected readonly storageService: IStorageService;
+    protected readonly notificationService: INotificationService;
+    protected readonly preferencesService: IPreferencesService;
+    protected readonly environmentService: IWorkbenchEnvironmentService;
+    protected readonly accessibilityService: IAccessibilityService;
+    protected readonly hostService: IHostService;
+    protected readonly commandService: ICommandService;
+    protected keys: string[];
+    protected mainMenu: IMenu;
+    protected menus: {
+        [index: string]: IMenu | undefined;
+    };
+    protected topLevelTitles: {
+        [menu: string]: string;
+    };
+    protected mainMenuDisposables: DisposableStore;
+    protected recentlyOpened: IRecentlyOpened;
+    protected menuUpdater: RunOnceScheduler;
+    protected static readonly MAX_MENU_RECENT_ENTRIES = 10;
+    constructor(menuService: IMenuService, workspacesService: IWorkspacesService, contextKeyService: IContextKeyService, keybindingService: IKeybindingService, configurationService: IConfigurationService, labelService: ILabelService, updateService: IUpdateService, storageService: IStorageService, notificationService: INotificationService, preferencesService: IPreferencesService, environmentService: IWorkbenchEnvironmentService, accessibilityService: IAccessibilityService, hostService: IHostService, commandService: ICommandService);
+    protected abstract doUpdateMenubar(firstTime: boolean): void;
+    protected registerListeners(): void;
+    protected setupMainMenu(): void;
+    protected updateMenubar(): void;
+    protected calculateActionLabel(action: {
+        id: string;
+        label: string;
+    }): string;
+    protected onUpdateStateChange(): void;
+    protected onUpdateKeybindings(): void;
+    protected getOpenRecentActions(): (Separator | IOpenRecentAction)[];
+    protected onDidChangeWindowFocus(hasFocus: boolean): void;
+    private onConfigurationUpdated;
+    private get menubarHidden();
+    protected onDidChangeRecentlyOpened(): void;
+    private createOpenRecentMenuAction;
+    private notifyUserOfCustomMenubarAccessibility;
+}
+declare class CustomMenubarControl extends MenubarControl {
+    private readonly layoutService;
+    private readonly telemetryService;
+    private menubar;
+    private container;
+    private alwaysOnMnemonics;
+    private focusInsideMenubar;
+    private pendingFirstTimeUpdate;
+    private visible;
+    private actionRunner;
+    private readonly webNavigationMenu;
+    private readonly _onVisibilityChange;
+    private readonly _onFocusStateChange;
+    constructor(menuService: IMenuService, workspacesService: IWorkspacesService, contextKeyService: IContextKeyService, keybindingService: IKeybindingService, configurationService: IConfigurationService, labelService: ILabelService, updateService: IUpdateService, storageService: IStorageService, notificationService: INotificationService, preferencesService: IPreferencesService, environmentService: IWorkbenchEnvironmentService, accessibilityService: IAccessibilityService, layoutService: IWorkbenchLayoutService, telemetryService: ITelemetryService, hostService: IHostService, commandService: ICommandService);
+    protected doUpdateMenubar(firstTime: boolean): void;
+    private registerActions;
+    private getUpdateAction;
+    private get currentMenubarVisibility();
+    private get currentDisableMenuBarAltFocus();
+    private insertActionsBefore;
+    private get currentEnableMenuBarMnemonics();
+    private get currentCompactMenuMode();
+    private onDidVisibilityChange;
+    private toActionsArray;
+    private reinstallDisposables;
+    private setupCustomMenubar;
+    private getWebNavigationActions;
+    private getMenuBarOptions;
+    protected onDidChangeWindowFocus(hasFocus: boolean): void;
+    protected onUpdateStateChange(): void;
+    protected onDidChangeRecentlyOpened(): void;
+    protected onUpdateKeybindings(): void;
+    protected registerListeners(): void;
+    get onVisibilityChange(): Event<boolean>;
+    get onFocusStateChange(): Event<boolean>;
+    getMenubarItemsDimensions(): Dimension;
+    create(parent: HTMLElement): HTMLElement;
+    layout(dimension: Dimension): void;
+    toggleFocus(): void;
+}
+
+export { CustomMenubarControl, type IOpenRecentAction, MenubarControl };

package/vscode/src/vs/workbench/browser/parts/titlebar/titlebarPart.d.ts

@@ -0,0 +1,77 @@
+import { Part } from '../../part.js';
+import { ITitleService, ITitleProperties } from '../../../services/title/common/titleService.js';
+import { MenuBarVisibility } from '../../../../platform/window/common/window.js';
+import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
+import { IConfigurationService, IConfigurationChangeEvent } from '../../../../platform/configuration/common/configuration.js';
+import { IBrowserWorkbenchEnvironmentService } from '../../../services/environment/browser/environmentService.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { Dimension } from '../../../../base/browser/dom.js';
+import { CustomMenubarControl } from './menubarControl.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { Event } from '../../../../base/common/event.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IHostService } from '../../../services/host/browser/host.js';
+import { IHoverService } from '../../../services/hover/browser/hover.js';
+
+declare class TitlebarPart extends Part implements ITitleService {
+    private readonly contextMenuService;
+    protected readonly configurationService: IConfigurationService;
+    protected readonly environmentService: IBrowserWorkbenchEnvironmentService;
+    protected readonly instantiationService: IInstantiationService;
+    private readonly contextKeyService;
+    private readonly hostService;
+    private static readonly configCommandCenter;
+    readonly _serviceBrand: undefined;
+    readonly minimumWidth: number;
+    readonly maximumWidth: number;
+    get minimumHeight(): number;
+    get maximumHeight(): number;
+    private _onMenubarVisibilityChange;
+    readonly onMenubarVisibilityChange: Event<boolean>;
+    private readonly _onDidChangeCommandCenterVisibility;
+    readonly onDidChangeCommandCenterVisibility: Event<void>;
+    protected rootContainer: HTMLElement;
+    protected primaryWindowControls: HTMLElement | undefined;
+    protected dragRegion: HTMLElement | undefined;
+    protected title: HTMLElement;
+    private leftContent;
+    private centerContent;
+    private rightContent;
+    protected customMenubar: CustomMenubarControl | undefined;
+    protected appIcon: HTMLElement | undefined;
+    private appIconBadge;
+    protected menubar?: HTMLElement;
+    protected layoutControls: HTMLElement | undefined;
+    private layoutToolbar;
+    protected lastLayoutDimensions: Dimension | undefined;
+    private hoverDelegate;
+    private readonly titleDisposables;
+    private titleBarStyle;
+    private isInactive;
+    private readonly windowTitle;
+    constructor(contextMenuService: IContextMenuService, configurationService: IConfigurationService, environmentService: IBrowserWorkbenchEnvironmentService, instantiationService: IInstantiationService, themeService: IThemeService, storageService: IStorageService, layoutService: IWorkbenchLayoutService, contextKeyService: IContextKeyService, hostService: IHostService, hoverService: IHoverService);
+    updateProperties(properties: ITitleProperties): void;
+    get isCommandCenterVisible(): boolean;
+    private registerListeners;
+    private onBlur;
+    private onFocus;
+    protected onConfigurationChanged(event: IConfigurationChangeEvent): void;
+    protected onMenubarVisibilityChanged(visible: boolean): void;
+    private uninstallMenubar;
+    protected installMenubar(): void;
+    private updateTitle;
+    protected createContentArea(parent: HTMLElement): HTMLElement;
+    updateStyles(): void;
+    protected onContextMenu(e: MouseEvent, menuId: MenuId): void;
+    protected get currentMenubarVisibility(): MenuBarVisibility;
+    private get layoutControlEnabled();
+    protected get useCounterZoom(): boolean;
+    updateLayout(dimension: Dimension): void;
+    layout(width: number, height: number): void;
+    toJSON(): object;
+}
+
+export { TitlebarPart };

package/vscode/src/vs/workbench/common/contextkeys.js

@@ -29,8 +29,16 @@ const VirtualWorkspaceContext = ( new RawContextKey('virtualWorkspace', '', ( lo
     'virtualWorkspace',
     "The scheme of the current workspace is from a virtual file system or an empty string."
 ))));
+const TemporaryWorkspaceContext = ( new RawContextKey('temporaryWorkspace', false, ( localize(
+    'temporaryWorkspace',
+    "The scheme of the current workspace is from a temporary file system."
+))));
 const IsFullscreenContext = ( new RawContextKey('isFullscreen', false, ( localize('isFullscreen', "Whether the window is in fullscreen mode"))));
 const HasWebFileSystemAccess = ( new RawContextKey('hasWebFileSystemAccess', false, true));
+const EmbedderIdentifierContext = ( new RawContextKey('embedderIdentifier', undefined, ( localize(
+    'embedderIdentifier',
+    'The identifier of the embedder according to the product service, if one is defined'
+))));
 const ActiveEditorDirtyContext = ( new RawContextKey('activeEditorIsDirty', false, ( localize('activeEditorIsDirty', "Whether the active editor has unsaved changes"))));
 const ActiveEditorPinnedContext = ( new RawContextKey('activeEditorIsNotPreview', false, ( localize(
     'activeEditorIsNotPreview',
@@ -45,10 +53,12 @@ const ActiveEditorLastInGroupContext = ( new RawContextKey('activeEditorIsLastIn
     "Whether the active editor is the last one in its group"
 ))));
 const ActiveEditorStickyContext = ( new RawContextKey('activeEditorIsPinned', false, ( localize('activeEditorIsPinned', "Whether the active editor is pinned"))));
+const ActiveEditorReadonlyContext = ( new RawContextKey('activeEditorIsReadonly', false, ( localize('activeEditorIsReadonly', "Whether the active editor is read-only"))));
 const ActiveEditorCanToggleReadonlyContext = ( new RawContextKey('activeEditorCanToggleReadonly', true, ( localize(
     'activeEditorCanToggleReadonly',
     "Whether the active editor can toggle between being read-only or writeable"
 ))));
+const ActiveEditorCanRevertContext = ( new RawContextKey('activeEditorCanRevert', false, ( localize('activeEditorCanRevert', "Whether the active editor can revert"))));
 const ActiveEditorCanSplitInGroupContext = ( new RawContextKey('activeEditorCanSplitInGroup', true));
 const ActiveEditorContext = ( new RawContextKey('activeEditor', null, { type: 'string', description: ( localize('activeEditor', "The identifier of the active editor")) }));
 const ActiveEditorAvailableEditorIdsContext = ( new RawContextKey('activeEditorAvailableEditorIds', '', ( localize(
@@ -60,10 +70,18 @@ const TextCompareEditorActiveContext = ( new RawContextKey('textCompareEditorAct
 const SideBySideEditorActiveContext = ( new RawContextKey('sideBySideEditorActive', false, ( localize('sideBySideEditorActive', "Whether a side by side editor is active"))));
 const EditorGroupEditorsCountContext = ( new RawContextKey('groupEditorsCount', 0, ( localize('groupEditorsCount', "The number of opened editor groups"))));
 const ActiveEditorGroupEmptyContext = ( new RawContextKey('activeEditorGroupEmpty', false, ( localize('activeEditorGroupEmpty', "Whether the active editor group is empty"))));
+const ActiveEditorGroupIndexContext = ( new RawContextKey('activeEditorGroupIndex', 0, ( localize('activeEditorGroupIndex', "The index of the active editor group"))));
+const ActiveEditorGroupLastContext = ( new RawContextKey('activeEditorGroupLast', false, ( localize(
+    'activeEditorGroupLast',
+    "Whether the active editor group is the last group"
+))));
 const ActiveEditorGroupLockedContext = ( new RawContextKey('activeEditorGroupLocked', false, ( localize('activeEditorGroupLocked', "Whether the active editor group is locked"))));
 const MultipleEditorGroupsContext = ( new RawContextKey('multipleEditorGroups', false, ( localize('multipleEditorGroups', "Whether there are multiple editor groups opened"))));
+const EditorsVisibleContext = ( new RawContextKey('editorIsOpen', false, ( localize('editorIsOpen', "Whether an editor is open"))));
 const InEditorZenModeContext = ( new RawContextKey('inZenMode', false, ( localize('inZenMode', "Whether Zen mode is enabled"))));
 const IsCenteredLayoutContext = ( new RawContextKey('isCenteredLayout', false, ( localize('isCenteredLayout', "Whether centered layout is enabled"))));
+const SplitEditorsVertically = ( new RawContextKey('splitEditorsVertically', false, ( localize('splitEditorsVertically', "Whether editors split vertically"))));
+const EditorAreaVisibleContext = ( new RawContextKey('editorAreaVisible', true, ( localize('editorAreaVisible', "Whether the editor area is visible"))));
 const EditorTabsVisibleContext = ( new RawContextKey('editorTabsVisible', true, ( localize('editorTabsVisible', "Whether editor tabs are visible"))));
 const SideBarVisibleContext = ( new RawContextKey('sideBarVisible', false, ( localize('sideBarVisible', "Whether the sidebar is visible"))));
 const SidebarFocusContext = ( new RawContextKey('sideBarFocus', false, ( localize('sideBarFocus', "Whether the sidebar has keyboard focus"))));
@@ -84,6 +102,7 @@ const PanelAlignmentContext = ( new RawContextKey('panelAlignment', 'center', (
     "The alignment of the panel, either 'center', 'left', 'right' or 'justify'"
 ))));
 const PanelVisibleContext = ( new RawContextKey('panelVisible', false, ( localize('panelVisible', "Whether the panel is visible"))));
+const PanelMaximizedContext = ( new RawContextKey('panelMaximized', false, ( localize('panelMaximized', "Whether the panel is maximized"))));
 const FocusedViewContext = ( new RawContextKey('focusedView', '', ( localize('focusedView', "The identifier of the view that has keyboard focus"))));
 function getVisbileViewContextKey(viewId) { return `view.${viewId}.visible`; }
 function getEnabledViewContainerContextKey(viewContainerId) { return `viewContainer.${viewContainerId}.enabled`; }
@@ -221,4 +240,4 @@ function applyAvailableEditorIds(contextKey, editor, editorResolverService) {
         contextKey.set(editors.join(','));
     }
 }
-export { ActiveAuxiliaryContext, ActiveEditorAvailableEditorIdsContext, ActiveEditorCanSplitInGroupContext, ActiveEditorCanToggleReadonlyContext, ActiveEditorContext, ActiveEditorDirtyContext, ActiveEditorFirstInGroupContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupLockedContext, ActiveEditorLastInGroupContext, ActiveEditorPinnedContext, ActiveEditorStickyContext, ActivePanelContext, ActiveViewletContext, AuxiliaryBarFocusContext, AuxiliaryBarVisibleContext, BannerFocused, DirtyWorkingCopiesContext, EditorGroupEditorsCountContext, EditorTabsVisibleContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, FocusedViewContext, HasWebFileSystemAccess, InEditorZenModeContext, IsCenteredLayoutContext, IsFullscreenContext, MultipleEditorGroupsContext, NotificationFocusedContext, NotificationsCenterVisibleContext, NotificationsToastsVisibleContext, OpenFolderWorkspaceSupportContext, PanelAlignmentContext, PanelFocusContext, PanelPositionContext, PanelVisibleContext, RemoteNameContext, ResourceContextKey, SideBarVisibleContext, SideBySideEditorActiveContext, SidebarFocusContext, StatusBarFocused, TextCompareEditorActiveContext, TextCompareEditorVisibleContext, VirtualWorkspaceContext, WorkbenchStateContext, WorkspaceFolderCountContext, applyAvailableEditorIds, getEnabledViewContainerContextKey, getVisbileViewContextKey };
+export { ActiveAuxiliaryContext, ActiveEditorAvailableEditorIdsContext, ActiveEditorCanRevertContext, ActiveEditorCanSplitInGroupContext, ActiveEditorCanToggleReadonlyContext, ActiveEditorContext, ActiveEditorDirtyContext, ActiveEditorFirstInGroupContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupIndexContext, ActiveEditorGroupLastContext, ActiveEditorGroupLockedContext, ActiveEditorLastInGroupContext, ActiveEditorPinnedContext, ActiveEditorReadonlyContext, ActiveEditorStickyContext, ActivePanelContext, ActiveViewletContext, AuxiliaryBarFocusContext, AuxiliaryBarVisibleContext, BannerFocused, DirtyWorkingCopiesContext, EditorAreaVisibleContext, EditorGroupEditorsCountContext, EditorTabsVisibleContext, EditorsVisibleContext, EmbedderIdentifierContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, FocusedViewContext, HasWebFileSystemAccess, InEditorZenModeContext, IsCenteredLayoutContext, IsFullscreenContext, MultipleEditorGroupsContext, NotificationFocusedContext, NotificationsCenterVisibleContext, NotificationsToastsVisibleContext, OpenFolderWorkspaceSupportContext, PanelAlignmentContext, PanelFocusContext, PanelMaximizedContext, PanelPositionContext, PanelVisibleContext, RemoteNameContext, ResourceContextKey, SideBarVisibleContext, SideBySideEditorActiveContext, SidebarFocusContext, SplitEditorsVertically, StatusBarFocused, TemporaryWorkspaceContext, TextCompareEditorActiveContext, TextCompareEditorVisibleContext, VirtualWorkspaceContext, WorkbenchStateContext, WorkspaceFolderCountContext, applyAvailableEditorIds, getEnabledViewContainerContextKey, getVisbileViewContextKey };

package/vscode/src/vs/workbench/contrib/webview/browser/themeing.js

@@ -3,7 +3,7 @@ import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { EDITOR_FONT_DEFAULTS } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import * as colorRegistry from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import * as colors from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
 import { ColorScheme } from 'monaco-editor/esm/vs/platform/theme/common/theme.js';
 import { IWorkbenchThemeService } from '../../../services/themes/common/workbenchThemeService.js';
 import { DEFAULT_FONT_FAMILY } from '../../../browser/style.js';
@@ -35,7 +35,7 @@ let WebviewThemeDataProvider = class WebviewThemeDataProvider extends Disposable
             const editorFontWeight = configuration.fontWeight || EDITOR_FONT_DEFAULTS.fontWeight;
             const editorFontSize = configuration.fontSize || EDITOR_FONT_DEFAULTS.fontSize;
             const theme = this._themeService.getColorTheme();
-            const exportedColors = colorRegistry.getColorRegistry().getColors().reduce((colors, entry) => {
+            const exportedColors = colors.getColorRegistry().getColors().reduce((colors, entry) => {
                 const color = theme.getColor(entry.id);
                 if (color) {
                     colors['vscode-' + entry.id.replace('.', '-')] = ( color.toString());