@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/vscode/vs/workbench/contrib/webviewView/browser/webviewViewPane.js

@@ -0,0 +1,231 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Dimension, EventType, addDisposableListener, findParentWithClass } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { MutableDisposable, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+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 { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ViewPane } from '../../../browser/parts/views/viewPane.js';
+import { Memento } from '../../../common/memento.js';
+import { IViewDescriptorService, IViewsService } from '../../../common/views.js';
+import { ExtensionKeyedWebviewOriginStore, IWebviewService } from '../../webview/browser/webview.js';
+import { WebviewWindowDragMonitor } from '../../webview/browser/webviewWindowDragMonitor.js';
+import { IWebviewViewService } from './webviewViewService.js';
+import { IActivityService, NumberBadge } from '../../../services/activity/common/activity.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+const storageKeys = {
+    webviewState: 'webviewState',
+};
+let WebviewViewPane = class WebviewViewPane extends ViewPane {
+    static getOriginStore(storageService) {
+        this._originStore ??= ( new ExtensionKeyedWebviewOriginStore('webviewViews.origins', storageService));
+        return this._originStore;
+    }
+    constructor(options, configurationService, contextKeyService, contextMenuService, instantiationService, keybindingService, openerService, telemetryService, themeService, viewDescriptorService, activityService, extensionService, progressService, storageService, viewService, webviewService, webviewViewService) {
+        super({ ...options, titleMenuId: MenuId.ViewTitle }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.activityService = activityService;
+        this.extensionService = extensionService;
+        this.progressService = progressService;
+        this.storageService = storageService;
+        this.viewService = viewService;
+        this.webviewService = webviewService;
+        this.webviewViewService = webviewViewService;
+        this._webview = this._register(( new MutableDisposable()));
+        this._webviewDisposables = this._register(( new DisposableStore()));
+        this._activated = false;
+        this._onDidChangeVisibility = this._register(( new Emitter()));
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this._onDispose = this._register(( new Emitter()));
+        this.onDispose = this._onDispose.event;
+        this.extensionId = options.fromExtensionId;
+        this.defaultTitle = this.title;
+        this.memento = ( new Memento(`webviewView.${this.id}`, storageService));
+        this.viewState = this.memento.getMemento(1 , 1 );
+        this._register(this.onDidChangeBodyVisibility(() => this.updateTreeVisibility()));
+        this._register(this.webviewViewService.onNewResolverRegistered(e => {
+            if (e.viewType === this.id) {
+                this.updateTreeVisibility();
+            }
+        }));
+        this.updateTreeVisibility();
+    }
+    dispose() {
+        this._onDispose.fire();
+        clearTimeout(this._repositionTimeout);
+        super.dispose();
+    }
+    focus() {
+        super.focus();
+        this._webview.value?.focus();
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        this._container = container;
+        this._rootContainer = undefined;
+        if (!this._resizeObserver) {
+            this._resizeObserver = ( new ResizeObserver(() => {
+                setTimeout(() => {
+                    this.layoutWebview();
+                }, 0);
+            }));
+            this._register(toDisposable(() => {
+                this._resizeObserver.disconnect();
+            }));
+            this._resizeObserver.observe(container);
+        }
+    }
+    saveState() {
+        if (this._webview.value) {
+            this.viewState[storageKeys.webviewState] = this._webview.value.state;
+        }
+        this.memento.saveMemento();
+        super.saveState();
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this.layoutWebview(( new Dimension(width, height)));
+    }
+    updateTreeVisibility() {
+        if (this.isBodyVisible()) {
+            this.activate();
+            this._webview.value?.claim(this, undefined);
+        }
+        else {
+            this._webview.value?.release(this);
+        }
+    }
+    activate() {
+        if (this._activated) {
+            return;
+        }
+        this._activated = true;
+        const origin = this.extensionId ? WebviewViewPane.getOriginStore(this.storageService).getOrigin(this.id, this.extensionId) : undefined;
+        const webview = this.webviewService.createWebviewOverlay({
+            origin,
+            providedViewType: this.id,
+            title: this.title,
+            options: { purpose: "webviewView"  },
+            contentOptions: {},
+            extension: this.extensionId ? { id: this.extensionId } : undefined
+        });
+        webview.state = this.viewState[storageKeys.webviewState];
+        this._webview.value = webview;
+        if (this._container) {
+            this.layoutWebview();
+        }
+        this._webviewDisposables.add(toDisposable(() => {
+            this._webview.value?.release(this);
+        }));
+        this._webviewDisposables.add(webview.onDidUpdateState(() => {
+            this.viewState[storageKeys.webviewState] = webview.state;
+        }));
+        for (const event of [EventType.DRAG, EventType.DRAG_END, EventType.DRAG_ENTER, EventType.DRAG_LEAVE, EventType.DRAG_START]) {
+            this._webviewDisposables.add(addDisposableListener(this._webview.value.container, event, e => {
+                e.preventDefault();
+                e.stopImmediatePropagation();
+                this.dropTargetElement.dispatchEvent(( new DragEvent(e.type, e)));
+            }));
+        }
+        this._webviewDisposables.add(( new WebviewWindowDragMonitor(() => this._webview.value)));
+        const source = this._webviewDisposables.add(( new CancellationTokenSource()));
+        this.withProgress(async () => {
+            await this.extensionService.activateByEvent(`onView:${this.id}`);
+            const self = this;
+            const webviewView = {
+                webview,
+                onDidChangeVisibility: this.onDidChangeBodyVisibility,
+                onDispose: this.onDispose,
+                get title() { return self.setTitle; },
+                set title(value) { self.updateTitle(value); },
+                get description() { return self.titleDescription; },
+                set description(value) { self.updateTitleDescription(value); },
+                get badge() { return self.badge; },
+                set badge(badge) { self.updateBadge(badge); },
+                dispose: () => {
+                    this._activated = false;
+                    this._webview.clear();
+                    this._webviewDisposables.clear();
+                },
+                show: (preserveFocus) => {
+                    this.viewService.openView(this.id, !preserveFocus);
+                }
+            };
+            await this.webviewViewService.resolve(this.id, webviewView, source.token);
+        });
+    }
+    updateTitle(value) {
+        this.setTitle = value;
+        super.updateTitle(typeof value === 'string' ? value : this.defaultTitle);
+    }
+    updateBadge(badge) {
+        if (this.badge?.value === badge?.value &&
+            this.badge?.tooltip === badge?.tooltip) {
+            return;
+        }
+        if (this.activity) {
+            this.activity.dispose();
+            this.activity = undefined;
+        }
+        this.badge = badge;
+        if (badge) {
+            const activity = {
+                badge: ( new NumberBadge(badge.value, () => badge.tooltip)),
+                priority: 150
+            };
+            this.activityService.showViewActivity(this.id, activity);
+        }
+    }
+    async withProgress(task) {
+        return this.progressService.withProgress({ location: this.id, delay: 500 }, task);
+    }
+    onDidScrollRoot() {
+        this.layoutWebview();
+    }
+    doLayoutWebview(dimension) {
+        const webviewEntry = this._webview.value;
+        if (!this._container || !webviewEntry) {
+            return;
+        }
+        if (!this._rootContainer || !this._rootContainer.isConnected) {
+            this._rootContainer = this.findRootContainer(this._container);
+        }
+        webviewEntry.layoutWebviewOverElement(this._container, dimension, this._rootContainer);
+    }
+    layoutWebview(dimension) {
+        this.doLayoutWebview(dimension);
+        clearTimeout(this._repositionTimeout);
+        this._repositionTimeout = setTimeout(() => this.doLayoutWebview(dimension), 200);
+    }
+    findRootContainer(container) {
+        return withNullAsUndefined(findParentWithClass(container, 'monaco-scrollable-element'));
+    }
+};
+WebviewViewPane = ( __decorate([
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IKeybindingService)),
+    ( __param(6, IOpenerService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, IThemeService)),
+    ( __param(9, IViewDescriptorService)),
+    ( __param(10, IActivityService)),
+    ( __param(11, IExtensionService)),
+    ( __param(12, IProgressService)),
+    ( __param(13, IStorageService)),
+    ( __param(14, IViewsService)),
+    ( __param(15, IWebviewService)),
+    ( __param(16, IWebviewViewService))
+], WebviewViewPane));
+export { WebviewViewPane };

package/dist/vscode/vs/workbench/contrib/webviewView/browser/webviewViewService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IWebviewViewService = ( createDecorator('webviewViewService'));
+export { IWebviewViewService };

package/dist/vscode/vs/workbench/services/actions/common/menusExtensionPoint.js

@@ -3,10 +3,11 @@ import { isFalsyOrWhitespace } from 'monaco-editor/esm/vs/base/common/strings.js
 import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
 import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
 import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { MenuRegistry, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { MenuId, MenuRegistry } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { index } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { isProposedApiEnabled } from '../../extensions/common/extensions.js';
 const apiMenus = [
     {
         key: 'commandPalette',
@@ -826,4 +827,181 @@ commandsExtensionPoint.setHandler(extensions => {
         }
     }
 });
+const _submenus = ( new Map());
+const submenusExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'submenus',
+    jsonSchema: schema.submenusContribution
+}));
+submenusExtensionPoint.setHandler(extensions => {
+    _submenus.clear();
+    for (const extension of extensions) {
+        const { value, collector } = extension;
+        for (const [, submenuInfo] of Object.entries(value)) {
+            if (!schema.isValidSubmenu(submenuInfo, collector)) {
+                continue;
+            }
+            if (!submenuInfo.id) {
+                collector.warn(( localize(
+                    'submenuId.invalid.id',
+                    "`{0}` is not a valid submenu identifier",
+                    submenuInfo.id
+                )));
+                continue;
+            }
+            if (( _submenus.has(submenuInfo.id))) {
+                collector.info(( localize(
+                    'submenuId.duplicate.id',
+                    "The `{0}` submenu was already previously registered.",
+                    submenuInfo.id
+                )));
+                continue;
+            }
+            if (!submenuInfo.label) {
+                collector.warn(( localize(
+                    'submenuId.invalid.label',
+                    "`{0}` is not a valid submenu label",
+                    submenuInfo.label
+                )));
+                continue;
+            }
+            let absoluteIcon;
+            if (submenuInfo.icon) {
+                if (typeof submenuInfo.icon === 'string') {
+                    absoluteIcon = ThemeIcon.fromString(submenuInfo.icon) || { dark: resources.joinPath(extension.description.extensionLocation, submenuInfo.icon) };
+                }
+                else {
+                    absoluteIcon = {
+                        dark: resources.joinPath(extension.description.extensionLocation, submenuInfo.icon.dark),
+                        light: resources.joinPath(extension.description.extensionLocation, submenuInfo.icon.light)
+                    };
+                }
+            }
+            const item = {
+                id: MenuId.for(`api:${submenuInfo.id}`),
+                label: submenuInfo.label,
+                icon: absoluteIcon
+            };
+            _submenus.set(submenuInfo.id, item);
+        }
+    }
+});
+const _apiMenusByKey = ( new Map(( apiMenus.map(menu => ([menu.key, menu])))));
+const _menuRegistrations = ( new DisposableStore());
+const _submenuMenuItems = ( new Map());
+const menusExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'menus',
+    jsonSchema: schema.menusContribution,
+    deps: [submenusExtensionPoint]
+}));
+menusExtensionPoint.setHandler(extensions => {
+    _menuRegistrations.clear();
+    _submenuMenuItems.clear();
+    for (const extension of extensions) {
+        const { value, collector } = extension;
+        for (const entry of Object.entries(value)) {
+            if (!schema.isValidItems(entry[1], collector)) {
+                continue;
+            }
+            let menu = _apiMenusByKey.get(entry[0]);
+            if (!menu) {
+                const submenu = _submenus.get(entry[0]);
+                if (submenu) {
+                    menu = {
+                        key: entry[0],
+                        id: submenu.id,
+                        description: ''
+                    };
+                }
+            }
+            if (!menu) {
+                continue;
+            }
+            if (menu.proposed && !isProposedApiEnabled(extension.description, menu.proposed)) {
+                collector.error(( localize(
+                    'proposedAPI.invalid',
+                    "{0} is a proposed menu identifier. It requires 'package.json#enabledApiProposals: [\"{1}\"]' and is only available when running out of dev or with the following command line switch: --enable-proposed-api {2}",
+                    entry[0],
+                    menu.proposed,
+                    extension.description.identifier.value
+                )));
+                continue;
+            }
+            for (const menuItem of entry[1]) {
+                let item;
+                if (schema.isMenuItem(menuItem)) {
+                    const command = MenuRegistry.getCommand(menuItem.command);
+                    const alt = menuItem.alt && MenuRegistry.getCommand(menuItem.alt) || undefined;
+                    if (!command) {
+                        collector.error(( localize(
+                            'missing.command',
+                            "Menu item references a command `{0}` which is not defined in the 'commands' section.",
+                            menuItem.command
+                        )));
+                        continue;
+                    }
+                    if (menuItem.alt && !alt) {
+                        collector.warn(( localize(
+                            'missing.altCommand',
+                            "Menu item references an alt-command `{0}` which is not defined in the 'commands' section.",
+                            menuItem.alt
+                        )));
+                    }
+                    if (menuItem.command === menuItem.alt) {
+                        collector.info(( localize(
+                            'dupe.command',
+                            "Menu item references the same command as default and alt-command"
+                        )));
+                    }
+                    item = { command, alt, group: undefined, order: undefined, when: undefined };
+                }
+                else {
+                    if (menu.supportsSubmenus === false) {
+                        collector.error(( localize(
+                            'unsupported.submenureference',
+                            "Menu item references a submenu for a menu which doesn't have submenu support."
+                        )));
+                        continue;
+                    }
+                    const submenu = _submenus.get(menuItem.submenu);
+                    if (!submenu) {
+                        collector.error(( localize(
+                            'missing.submenu',
+                            "Menu item references a submenu `{0}` which is not defined in the 'submenus' section.",
+                            menuItem.submenu
+                        )));
+                        continue;
+                    }
+                    let submenuRegistrations = _submenuMenuItems.get(menu.id.id);
+                    if (!submenuRegistrations) {
+                        submenuRegistrations = ( new Set());
+                        _submenuMenuItems.set(menu.id.id, submenuRegistrations);
+                    }
+                    if (( submenuRegistrations.has(submenu.id.id))) {
+                        collector.warn(( localize(
+                            'submenuItem.duplicate',
+                            "The `{0}` submenu was already contributed to the `{1}` menu.",
+                            menuItem.submenu,
+                            entry[0]
+                        )));
+                        continue;
+                    }
+                    submenuRegistrations.add(submenu.id.id);
+                    item = { submenu: submenu.id, icon: submenu.icon, title: submenu.label, group: undefined, order: undefined, when: undefined };
+                }
+                if (menuItem.group) {
+                    const idx = menuItem.group.lastIndexOf('@');
+                    if (idx > 0) {
+                        item.group = menuItem.group.substr(0, idx);
+                        item.order = Number(menuItem.group.substr(idx + 1)) || undefined;
+                    }
+                    else {
+                        item.group = menuItem.group;
+                    }
+                }
+                item.when = ContextKeyExpr.deserialize(menuItem.when);
+                _menuRegistrations.add(MenuRegistry.appendMenuItem(menu.id, item));
+            }
+        }
+    }
+});
 export { commandsExtensionPoint };

package/dist/vscode/vs/workbench/services/activity/browser/activityService.js

@@ -0,0 +1,94 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { IActivityService } from '../common/activity.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { ACCOUNTS_ACTIVITY_ID, GLOBAL_ACTIVITY_ID } from '../../../common/activity.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IPaneCompositePartService } from '../../panecomposite/browser/panecomposite.js';
+let ViewContainerActivityByView = class ViewContainerActivityByView extends Disposable {
+    constructor(viewId, viewDescriptorService, activityService) {
+        super();
+        this.viewId = viewId;
+        this.viewDescriptorService = viewDescriptorService;
+        this.activityService = activityService;
+        this.activity = undefined;
+        this.activityDisposable = Disposable.None;
+        this._register(Event.filter(this.viewDescriptorService.onDidChangeContainer, e => ( e.views.some(view => view.id === viewId)))(() => this.update()));
+        this._register(Event.filter(this.viewDescriptorService.onDidChangeLocation, e => ( e.views.some(view => view.id === viewId)))(() => this.update()));
+    }
+    setActivity(activity) {
+        this.activity = activity;
+        this.update();
+    }
+    clearActivity() {
+        this.activity = undefined;
+        this.update();
+    }
+    update() {
+        this.activityDisposable.dispose();
+        const container = this.viewDescriptorService.getViewContainerByViewId(this.viewId);
+        if (container && this.activity) {
+            this.activityDisposable = this.activityService.showViewContainerActivity(container.id, this.activity);
+        }
+    }
+    dispose() {
+        this.activityDisposable.dispose();
+    }
+};
+ViewContainerActivityByView = ( __decorate([
+    ( __param(1, IViewDescriptorService)),
+    ( __param(2, IActivityService))
+], ViewContainerActivityByView));
+let ActivityService = class ActivityService {
+    constructor(paneCompositeService, viewDescriptorService, instantiationService) {
+        this.paneCompositeService = paneCompositeService;
+        this.viewDescriptorService = viewDescriptorService;
+        this.instantiationService = instantiationService;
+        this.viewActivities = ( new Map());
+    }
+    showViewContainerActivity(viewContainerId, { badge, clazz, priority }) {
+        const viewContainer = this.viewDescriptorService.getViewContainerById(viewContainerId);
+        if (viewContainer) {
+            const location = this.viewDescriptorService.getViewContainerLocation(viewContainer);
+            if (location !== null) {
+                return this.paneCompositeService.showActivity(viewContainer.id, location, badge, clazz, priority);
+            }
+        }
+        return Disposable.None;
+    }
+    showViewActivity(viewId, activity) {
+        let maybeItem = this.viewActivities.get(viewId);
+        if (maybeItem) {
+            maybeItem.id++;
+        }
+        else {
+            maybeItem = {
+                id: 1,
+                activity: this.instantiationService.createInstance(ViewContainerActivityByView, viewId)
+            };
+            this.viewActivities.set(viewId, maybeItem);
+        }
+        const id = maybeItem.id;
+        maybeItem.activity.setActivity(activity);
+        const item = maybeItem;
+        return toDisposable(() => {
+            if (item.id === id) {
+                item.activity.dispose();
+                this.viewActivities.delete(viewId);
+            }
+        });
+    }
+    showAccountsActivity({ badge, clazz, priority }) {
+        return this.paneCompositeService.showActivity(ACCOUNTS_ACTIVITY_ID, 0 , badge, clazz, priority);
+    }
+    showGlobalActivity({ badge, clazz, priority }) {
+        return this.paneCompositeService.showActivity(GLOBAL_ACTIVITY_ID, 0 , badge, clazz, priority);
+    }
+};
+ActivityService = ( __decorate([
+    ( __param(0, IPaneCompositePartService)),
+    ( __param(1, IViewDescriptorService)),
+    ( __param(2, IInstantiationService))
+], ActivityService));
+export { ActivityService };

package/dist/vscode/vs/workbench/services/activity/common/activity.js

@@ -19,4 +19,18 @@ class NumberBadge extends BaseBadge {
         return this.descriptorFn(this.number);
     }
 }
-export { IActivityService, NumberBadge };
+class TextBadge extends BaseBadge {
+    constructor(text, descriptorFn) {
+        super(descriptorFn);
+        this.text = text;
+    }
+}
+class IconBadge extends BaseBadge {
+    constructor(icon, descriptorFn) {
+        super(descriptorFn);
+        this.icon = icon;
+    }
+}
+class ProgressBadge extends BaseBadge {
+}
+export { IActivityService, IconBadge, NumberBadge, ProgressBadge, TextBadge };

package/dist/vscode/vs/workbench/services/authentication/browser/authenticationService.js

@@ -0,0 +1,35 @@
+import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { MenuRegistry, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IBrowserWorkbenchEnvironmentService } from '../../environment/browser/environmentService.js';
+async function getCurrentAuthenticationSessionInfo(credentialsService, productService) {
+    const authenticationSessionValue = await credentialsService.getPassword(`${productService.urlProtocol}.login`, 'account');
+    if (authenticationSessionValue) {
+        try {
+            const authenticationSessionInfo = JSON.parse(authenticationSessionValue);
+            if (authenticationSessionInfo
+                && isString(authenticationSessionInfo.id)
+                && isString(authenticationSessionInfo.accessToken)
+                && isString(authenticationSessionInfo.providerId)) {
+                return authenticationSessionInfo;
+            }
+        }
+        catch (e) {
+        }
+    }
+    return undefined;
+}
+CommandsRegistry.registerCommand('workbench.getCodeExchangeProxyEndpoints', function (accessor, _) {
+    const environmentService = accessor.get(IBrowserWorkbenchEnvironmentService);
+    return environmentService.options?.codeExchangeProxyEndpoints;
+});
+MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
+    command: {
+        id: 'noAuthenticationProviders',
+        title: ( nls.localize('authentication.Placeholder', "No accounts requested yet...")),
+        precondition: ContextKeyExpr.false()
+    },
+});
+export { getCurrentAuthenticationSessionInfo };

package/dist/vscode/vs/workbench/services/authentication/common/authentication.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IAuthenticationService = ( createDecorator('IAuthenticationService'));
+export { IAuthenticationService };

package/dist/vscode/vs/workbench/services/configuration/browser/configuration.js

@@ -179,7 +179,7 @@ class FileServiceBasedConfiguration extends Disposable {
                 catch (error) {
                     this.logService.trace(`Error while resolving configuration file '${( ( resource.toString()))}': ${errors.getErrorMessage(error)}`);
                     if (error.fileOperationResult !== 1
-                        && error.fileOperationResult !== 10 ) {
+                        && error.fileOperationResult !== 9 ) {
                         this.logService.error(error);
                     }
                 }

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

@@ -1,4 +1,4 @@
-import * as paths from 'monaco-editor/esm/vs/base/common/path.js';
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
 import * as process from 'monaco-editor/esm/vs/base/common/process.js';
 import * as types from 'monaco-editor/esm/vs/base/common/types.js';
 import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
@@ -141,7 +141,7 @@ class AbstractVariableResolverService {
                     return normalizeDriveLetter(folderPath);
                 }
             }
-            throw new VariableError(variableKind, localize('canNotResolveFolderForFile', "Variable {0}: can not find workspace folder of '{1}'.", match, paths.basename(filePath)));
+            throw new VariableError(variableKind, localize('canNotResolveFolderForFile', "Variable {0}: can not find workspace folder of '{1}'.", match, path.basename(filePath)));
         };
         const getFolderUri = (variableKind) => {
             if (argument) {
@@ -205,7 +205,7 @@ class AbstractVariableResolverService {
                         return ((folderUri || argument) ? normalizeDriveLetter(this.fsPath(getFolderUri(VariableKind.Cwd))) : process.cwd());
                     case 'workspaceRootFolderName':
                     case 'workspaceFolderBasename':
-                        return normalizeDriveLetter(paths.basename(this.fsPath(getFolderUri(VariableKind.WorkspaceFolderBasename))));
+                        return normalizeDriveLetter(path.basename(this.fsPath(getFolderUri(VariableKind.WorkspaceFolderBasename))));
                     case 'userHome': {
                         if (environment.userHome) {
                             return environment.userHome;
@@ -232,29 +232,29 @@ class AbstractVariableResolverService {
                         return getFolderPathForFile(VariableKind.FileWorkspaceFolder);
                     case 'relativeFile':
                         if (folderUri || argument) {
-                            return paths.relative(this.fsPath(getFolderUri(VariableKind.RelativeFile)), getFilePath(VariableKind.RelativeFile));
+                            return path.relative(this.fsPath(getFolderUri(VariableKind.RelativeFile)), getFilePath(VariableKind.RelativeFile));
                         }
                         return getFilePath(VariableKind.RelativeFile);
                     case 'relativeFileDirname': {
-                        const dirname = paths.dirname(getFilePath(VariableKind.RelativeFileDirname));
+                        const dirname = path.dirname(getFilePath(VariableKind.RelativeFileDirname));
                         if (folderUri || argument) {
-                            const relative = paths.relative(this.fsPath(getFolderUri(VariableKind.RelativeFileDirname)), dirname);
+                            const relative = path.relative(this.fsPath(getFolderUri(VariableKind.RelativeFileDirname)), dirname);
                             return relative.length === 0 ? '.' : relative;
                         }
                         return dirname;
                     }
                     case 'fileDirname':
-                        return paths.dirname(getFilePath(VariableKind.FileDirname));
+                        return path.dirname(getFilePath(VariableKind.FileDirname));
                     case 'fileExtname':
-                        return paths.extname(getFilePath(VariableKind.FileExtname));
+                        return path.extname(getFilePath(VariableKind.FileExtname));
                     case 'fileBasename':
-                        return paths.basename(getFilePath(VariableKind.FileBasename));
+                        return path.basename(getFilePath(VariableKind.FileBasename));
                     case 'fileBasenameNoExtension': {
-                        const basename = paths.basename(getFilePath(VariableKind.FileBasenameNoExtension));
-                        return (basename.slice(0, basename.length - paths.extname(basename).length));
+                        const basename = path.basename(getFilePath(VariableKind.FileBasenameNoExtension));
+                        return (basename.slice(0, basename.length - path.extname(basename).length));
                     }
                     case 'fileDirnameBasename':
-                        return paths.basename(paths.dirname(getFilePath(VariableKind.FileDirnameBasename)));
+                        return path.basename(path.dirname(getFilePath(VariableKind.FileDirnameBasename)));
                     case 'execPath': {
                         const ep = this._context.getExecPath();
                         if (ep) {
@@ -270,7 +270,7 @@ class AbstractVariableResolverService {
                         return match;
                     }
                     case 'pathSeparator':
-                        return paths.sep;
+                        return path.sep;
                     default:
                         try {
                             const key = argument ? `${variable}:${argument}` : variable;