@codingame/monaco-vscode-api 1.78.6-next.0 → 1.78.6

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

@@ -1,231 +0,0 @@
-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

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

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

@@ -1,94 +0,0 @@
-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/authentication/browser/authenticationService.js

@@ -1,35 +0,0 @@
-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

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

package/dist/vscode/vs/workbench/services/extensions/common/extensionStorageMigration.js

@@ -1,56 +0,0 @@
-import { getErrorMessage } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
-import { IExtensionStorageService } from '../../../../platform/extensionManagement/common/extensionStorage.js';
-import { IFileService, FileSystemProviderErrorCode } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-async function migrateExtensionStorage(fromExtensionId, toExtensionId, global, instantionService) {
-    return instantionService.invokeFunction(async (serviceAccessor) => {
-        const environmentService = serviceAccessor.get(IEnvironmentService);
-        const userDataProfilesService = serviceAccessor.get(IUserDataProfilesService);
-        const extensionStorageService = serviceAccessor.get(IExtensionStorageService);
-        const storageService = serviceAccessor.get(IStorageService);
-        const uriIdentityService = serviceAccessor.get(IUriIdentityService);
-        const fileService = serviceAccessor.get(IFileService);
-        const workspaceContextService = serviceAccessor.get(IWorkspaceContextService);
-        const logService = serviceAccessor.get(ILogService);
-        const storageMigratedKey = `extensionStorage.migrate.${fromExtensionId}-${toExtensionId}`;
-        const migrateLowerCaseStorageKey = fromExtensionId.toLowerCase() === toExtensionId.toLowerCase() ? `extension.storage.migrateFromLowerCaseKey.${fromExtensionId.toLowerCase()}` : undefined;
-        if (fromExtensionId === toExtensionId) {
-            return;
-        }
-        const getExtensionStorageLocation = (extensionId, global) => {
-            if (global) {
-                return uriIdentityService.extUri.joinPath(userDataProfilesService.defaultProfile.globalStorageHome, extensionId.toLowerCase() );
-            }
-            return uriIdentityService.extUri.joinPath(environmentService.workspaceStorageHome, workspaceContextService.getWorkspace().id, extensionId);
-        };
-        const storageScope = global ? 0  : 1 ;
-        if (!storageService.getBoolean(storageMigratedKey, storageScope, false) && !(migrateLowerCaseStorageKey && storageService.getBoolean(migrateLowerCaseStorageKey, storageScope, false))) {
-            logService.info(`Migrating ${global ? 'global' : 'workspace'} extension storage from ${fromExtensionId} to ${toExtensionId}...`);
-            const value = extensionStorageService.getExtensionState(fromExtensionId, global);
-            if (value) {
-                extensionStorageService.setExtensionState(toExtensionId, value, global);
-                extensionStorageService.setExtensionState(fromExtensionId, undefined, global);
-            }
-            const fromPath = getExtensionStorageLocation(fromExtensionId, global);
-            const toPath = getExtensionStorageLocation(toExtensionId, global);
-            if (!uriIdentityService.extUri.isEqual(fromPath, toPath)) {
-                try {
-                    await fileService.move(fromPath, toPath, true);
-                }
-                catch (error) {
-                    if (error.code !== FileSystemProviderErrorCode.FileNotFound) {
-                        logService.info(`Error while migrating ${global ? 'global' : 'workspace'} file storage from '${fromExtensionId}' to '${toExtensionId}'`, getErrorMessage(error));
-                    }
-                }
-            }
-            logService.info(`Migrated ${global ? 'global' : 'workspace'} extension storage from ${fromExtensionId} to ${toExtensionId}`);
-            storageService.store(storageMigratedKey, true, storageScope, 1 );
-        }
-    });
-}
-export { migrateExtensionStorage };

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

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

package/dist/vscode/vs/workbench/services/hover/browser/hoverService.js

@@ -1,149 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import "../../../../../../assets/hover.css";
-import { registerThemingParticipant } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { editorHoverBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
-import { IContextViewService, IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { HoverWidget } from './hoverWidget.js';
-import { toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { addDisposableListener, EventType } from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
-let HoverService = class HoverService {
-    constructor(_instantiationService, _contextViewService, contextMenuService, _keybindingService) {
-        this._instantiationService = _instantiationService;
-        this._contextViewService = _contextViewService;
-        this._keybindingService = _keybindingService;
-        contextMenuService.onDidShowContextMenu(() => this.hideHover());
-    }
-    showHover(options, focus) {
-        if (getHoverOptionsIdentity(this._currentHoverOptions) === getHoverOptionsIdentity(options)) {
-            return undefined;
-        }
-        this._currentHoverOptions = options;
-        if (options.trapFocus && document.activeElement) {
-            this._lastFocusedElementBeforeOpen = document.activeElement;
-        }
-        else {
-            this._lastFocusedElementBeforeOpen = undefined;
-        }
-        const hoverDisposables = ( (new DisposableStore()));
-        const hover = this._instantiationService.createInstance(HoverWidget, options);
-        hover.onDispose(() => {
-            this._lastFocusedElementBeforeOpen?.focus();
-            if (this._currentHoverOptions === options) {
-                this._currentHoverOptions = undefined;
-            }
-            hoverDisposables.dispose();
-        });
-        const provider = this._contextViewService;
-        provider.showContextView(( (new HoverContextViewDelegate(hover, focus))), options.container);
-        hover.onRequestLayout(() => provider.layout());
-        if ('targetElements' in options.target) {
-            for (const element of options.target.targetElements) {
-                hoverDisposables.add(addDisposableListener(element, EventType.CLICK, () => this.hideHover()));
-            }
-        }
-        else {
-            hoverDisposables.add(addDisposableListener(options.target, EventType.CLICK, () => this.hideHover()));
-        }
-        const focusedElement = document.activeElement;
-        if (focusedElement) {
-            hoverDisposables.add(addDisposableListener(focusedElement, EventType.KEY_DOWN, e => this._keyDown(e, hover, !!options.hideOnKeyDown)));
-            hoverDisposables.add(addDisposableListener(document, EventType.KEY_DOWN, e => this._keyDown(e, hover, !!options.hideOnKeyDown)));
-            hoverDisposables.add(addDisposableListener(focusedElement, EventType.KEY_UP, e => this._keyUp(e, hover)));
-            hoverDisposables.add(addDisposableListener(document, EventType.KEY_UP, e => this._keyUp(e, hover)));
-        }
-        if ('IntersectionObserver' in window) {
-            const observer = ( (new IntersectionObserver(e => this._intersectionChange(e, hover), { threshold: 0 })));
-            const firstTargetElement = 'targetElements' in options.target ? options.target.targetElements[0] : options.target;
-            observer.observe(firstTargetElement);
-            hoverDisposables.add(toDisposable(() => observer.disconnect()));
-        }
-        this._currentHover = hover;
-        return hover;
-    }
-    hideHover() {
-        if (this._currentHover?.isLocked || !this._currentHoverOptions) {
-            return;
-        }
-        this._currentHover = undefined;
-        this._currentHoverOptions = undefined;
-        this._contextViewService.hideContextView();
-    }
-    _intersectionChange(entries, hover) {
-        const entry = entries[entries.length - 1];
-        if (!entry.isIntersecting) {
-            hover.dispose();
-        }
-    }
-    _keyDown(e, hover, hideOnKeyDown) {
-        if (e.key === 'Alt') {
-            hover.isLocked = true;
-            return;
-        }
-        const event = ( (new StandardKeyboardEvent(e)));
-        const keybinding = this._keybindingService.resolveKeyboardEvent(event);
-        if (( (keybinding.getSingleModifierDispatchChords().some(value => !!value))) || this._keybindingService.softDispatch(event, event.target)) {
-            return;
-        }
-        if (hideOnKeyDown && (!this._currentHoverOptions?.trapFocus || e.key !== 'Tab')) {
-            this.hideHover();
-            this._lastFocusedElementBeforeOpen?.focus();
-        }
-    }
-    _keyUp(e, hover) {
-        if (e.key === 'Alt') {
-            hover.isLocked = false;
-            if (!hover.isMouseIn) {
-                this.hideHover();
-                this._lastFocusedElementBeforeOpen?.focus();
-            }
-        }
-    }
-};
-HoverService = ( (__decorate([
-    ( (__param(0, IInstantiationService))),
-    ( (__param(1, IContextViewService))),
-    ( (__param(2, IContextMenuService))),
-    ( (__param(3, IKeybindingService)))
-], HoverService)));
-function getHoverOptionsIdentity(options) {
-    if (options === undefined) {
-        return undefined;
-    }
-    return options?.id ?? options;
-}
-class HoverContextViewDelegate {
-    get anchorPosition() {
-        return this._hover.anchor;
-    }
-    constructor(_hover, _focus = false) {
-        this._hover = _hover;
-        this._focus = _focus;
-    }
-    render(container) {
-        this._hover.render(container);
-        if (this._focus) {
-            this._hover.focus();
-        }
-        return this._hover;
-    }
-    getAnchor() {
-        return {
-            x: this._hover.x,
-            y: this._hover.y
-        };
-    }
-    layout() {
-        this._hover.layout();
-    }
-}
-registerThemingParticipant((theme, collector) => {
-    const hoverBorder = theme.getColor(editorHoverBorder);
-    if (hoverBorder) {
-        collector.addRule(`.monaco-workbench .workbench-hover .hover-row:not(:first-child):not(:empty) { border-top: 1px solid ${( ( hoverBorder.transparent(0.5)))}; }`);
-        collector.addRule(`.monaco-workbench .workbench-hover hr { border-top: 1px solid ${( ( hoverBorder.transparent(0.5)))}; }`);
-    }
-});
-export { HoverService };