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

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

@@ -1,162 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import './media/hover.css.js';
-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';
-import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
-let HoverService = class HoverService {
-    constructor(_instantiationService, _contextViewService, contextMenuService, _keybindingService, _accessibilityService) {
-        this._instantiationService = _instantiationService;
-        this._contextViewService = _contextViewService;
-        this._keybindingService = _keybindingService;
-        this._accessibilityService = _accessibilityService;
-        contextMenuService.onDidShowContextMenu(() => this.hideHover());
-    }
-    showHover(options, focus, skipLastFocusedUpdate) {
-        if (getHoverOptionsIdentity(this._currentHoverOptions) === getHoverOptionsIdentity(options)) {
-            return undefined;
-        }
-        this._currentHoverOptions = options;
-        this._lastHoverOptions = options;
-        const trapFocus = options.trapFocus || this._accessibilityService.isScreenReaderOptimized();
-        if (!skipLastFocusedUpdate) {
-            if (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();
-        }
-    }
-    showAndFocusLastHover() {
-        if (!this._lastHoverOptions) {
-            return;
-        }
-        this.showHover(this._lastHoverOptions, true, true);
-    }
-    _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).kind !== 0 ) {
-            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))),
-    ( (__param(4, IAccessibilityService)))
-], 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 };

package/vscode/src/vs/workbench/services/hover/browser/hoverWidget.js

@@ -1,523 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { EDITOR_FONT_DEFAULTS } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
-import { HoverWidget as HoverWidget$1, HoverAction, getHoverAccessibleViewHint } from 'monaco-editor/esm/vs/base/browser/ui/hover/hoverWidget.js';
-import { Widget } from 'monaco-editor/esm/vs/base/browser/ui/widget.js';
-import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { openLinkFromMarkdown, MarkdownRenderer } from 'monaco-editor/esm/vs/editor/contrib/markdownRenderer/browser/markdownRenderer.js';
-import { isMarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
-import { status } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
-const $ = dom.$;
-let HoverWidget = class HoverWidget extends Widget {
-    get isDisposed() { return this._isDisposed; }
-    get isMouseIn() { return this._lockMouseTracker.isMouseIn; }
-    get domNode() { return this._hover.containerDomNode; }
-    get onDispose() { return this._onDispose.event; }
-    get onRequestLayout() { return this._onRequestLayout.event; }
-    get anchor() { return this._hoverPosition === 2  ? 0  : 1 ; }
-    get x() { return this._x; }
-    get y() { return this._y; }
-    get isLocked() { return this._isLocked; }
-    set isLocked(value) {
-        if (this._isLocked === value) {
-            return;
-        }
-        this._isLocked = value;
-        this._hoverContainer.classList.toggle('locked', this._isLocked);
-    }
-    constructor(options, _keybindingService, _configurationService, _openerService, _instantiationService, _accessibilityService) {
-        super();
-        this._keybindingService = _keybindingService;
-        this._configurationService = _configurationService;
-        this._openerService = _openerService;
-        this._instantiationService = _instantiationService;
-        this._accessibilityService = _accessibilityService;
-        this._messageListeners = ( new DisposableStore());
-        this._isDisposed = false;
-        this._forcePosition = false;
-        this._x = 0;
-        this._y = 0;
-        this._isLocked = false;
-        this._enableFocusTraps = false;
-        this._addedFocusTrap = false;
-        this._onDispose = this._register(( new Emitter()));
-        this._onRequestLayout = this._register(( new Emitter()));
-        this._linkHandler = options.linkHandler || (url => {
-            return openLinkFromMarkdown(this._openerService, url, isMarkdownString(options.content) ? options.content.isTrusted : undefined);
-        });
-        this._target = 'targetElements' in options.target ? options.target : ( new ElementHoverTarget(options.target));
-        this._hoverPointer = options.showPointer ? $('div.workbench-hover-pointer') : undefined;
-        this._hover = this._register(( new HoverWidget$1()));
-        this._hover.containerDomNode.classList.add('workbench-hover', 'fadeIn');
-        if (options.compact) {
-            this._hover.containerDomNode.classList.add('workbench-hover', 'compact');
-        }
-        if (options.skipFadeInAnimation) {
-            this._hover.containerDomNode.classList.add('skip-fade-in');
-        }
-        if (options.additionalClasses) {
-            this._hover.containerDomNode.classList.add(...options.additionalClasses);
-        }
-        if (options.forcePosition) {
-            this._forcePosition = true;
-        }
-        if (options.trapFocus) {
-            this._enableFocusTraps = true;
-        }
-        this._hoverPosition = options.hoverPosition ?? 3 ;
-        this.onmousedown(this._hover.containerDomNode, e => e.stopPropagation());
-        this.onkeydown(this._hover.containerDomNode, e => {
-            if (e.equals(9 )) {
-                this.dispose();
-            }
-        });
-        this._register(dom.addDisposableListener(window, 'blur', () => this.dispose()));
-        const rowElement = $('div.hover-row.markdown-hover');
-        const contentsElement = $('div.hover-contents');
-        if (typeof options.content === 'string') {
-            contentsElement.textContent = options.content;
-            contentsElement.style.whiteSpace = 'pre-wrap';
-        }
-        else if (options.content instanceof HTMLElement) {
-            contentsElement.appendChild(options.content);
-            contentsElement.classList.add('html-hover-contents');
-        }
-        else {
-            const markdown = options.content;
-            const mdRenderer = this._instantiationService.createInstance(MarkdownRenderer, { codeBlockFontFamily: this._configurationService.getValue('editor').fontFamily || EDITOR_FONT_DEFAULTS.fontFamily });
-            const { element } = mdRenderer.render(markdown, {
-                actionHandler: {
-                    callback: (content) => this._linkHandler(content),
-                    disposables: this._messageListeners
-                },
-                asyncRenderCallback: () => {
-                    contentsElement.classList.add('code-hover-contents');
-                    this.layout();
-                    this._onRequestLayout.fire();
-                }
-            });
-            contentsElement.appendChild(element);
-        }
-        rowElement.appendChild(contentsElement);
-        this._hover.contentsDomNode.appendChild(rowElement);
-        if (options.actions && options.actions.length > 0) {
-            const statusBarElement = $('div.hover-row.status-bar');
-            const actionsElement = $('div.actions');
-            options.actions.forEach(action => {
-                const keybinding = this._keybindingService.lookupKeybinding(action.commandId);
-                const keybindingLabel = keybinding ? keybinding.getLabel() : null;
-                HoverAction.render(actionsElement, {
-                    label: action.label,
-                    commandId: action.commandId,
-                    run: e => {
-                        action.run(e);
-                        this.dispose();
-                    },
-                    iconClass: action.iconClass
-                }, keybindingLabel);
-            });
-            statusBarElement.appendChild(actionsElement);
-            this._hover.containerDomNode.appendChild(statusBarElement);
-        }
-        this._hoverContainer = $('div.workbench-hover-container');
-        if (this._hoverPointer) {
-            this._hoverContainer.appendChild(this._hoverPointer);
-        }
-        this._hoverContainer.appendChild(this._hover.containerDomNode);
-        let hideOnHover;
-        if (options.actions && options.actions.length > 0) {
-            hideOnHover = false;
-        }
-        else {
-            if (options.hideOnHover === undefined) {
-                hideOnHover = typeof options.content === 'string' ||
-                    isMarkdownString(options.content) && !options.content.value.includes('](') && !options.content.value.includes('</a>');
-            }
-            else {
-                hideOnHover = options.hideOnHover;
-            }
-        }
-        if (hideOnHover && options.showHoverHint) {
-            const statusBarElement = $('div.hover-row.status-bar');
-            const infoElement = $('div.info');
-            infoElement.textContent = ( localize('hoverhint', 'Hold {0} key to mouse over', isMacintosh ? 'Option' : 'Alt'));
-            statusBarElement.appendChild(infoElement);
-            this._hover.containerDomNode.appendChild(statusBarElement);
-        }
-        const mouseTrackerTargets = [...this._target.targetElements];
-        if (!hideOnHover) {
-            mouseTrackerTargets.push(this._hoverContainer);
-        }
-        const mouseTracker = this._register(( new CompositeMouseTracker(mouseTrackerTargets)));
-        this._register(mouseTracker.onMouseOut(() => {
-            if (!this._isLocked) {
-                this.dispose();
-            }
-        }));
-        if (hideOnHover) {
-            const mouseTracker2Targets = [...this._target.targetElements, this._hoverContainer];
-            this._lockMouseTracker = this._register(( new CompositeMouseTracker(mouseTracker2Targets)));
-            this._register(this._lockMouseTracker.onMouseOut(() => {
-                if (!this._isLocked) {
-                    this.dispose();
-                }
-            }));
-        }
-        else {
-            this._lockMouseTracker = mouseTracker;
-        }
-    }
-    addFocusTrap() {
-        if (!this._enableFocusTraps || this._addedFocusTrap) {
-            return;
-        }
-        this._addedFocusTrap = true;
-        const firstContainerFocusElement = this._hover.containerDomNode;
-        const lastContainerFocusElement = this.findLastFocusableChild(this._hover.containerDomNode);
-        if (lastContainerFocusElement) {
-            const beforeContainerFocusElement = dom.prepend(this._hoverContainer, $('div'));
-            const afterContainerFocusElement = dom.append(this._hoverContainer, $('div'));
-            beforeContainerFocusElement.tabIndex = 0;
-            afterContainerFocusElement.tabIndex = 0;
-            this._register(dom.addDisposableListener(afterContainerFocusElement, 'focus', (e) => {
-                firstContainerFocusElement.focus();
-                e.preventDefault();
-            }));
-            this._register(dom.addDisposableListener(beforeContainerFocusElement, 'focus', (e) => {
-                lastContainerFocusElement.focus();
-                e.preventDefault();
-            }));
-        }
-    }
-    findLastFocusableChild(root) {
-        if (root.hasChildNodes()) {
-            for (let i = 0; i < root.childNodes.length; i++) {
-                const node = root.childNodes.item(root.childNodes.length - i - 1);
-                if (node.nodeType === node.ELEMENT_NODE) {
-                    const parsedNode = node;
-                    if (typeof parsedNode.tabIndex === 'number' && parsedNode.tabIndex >= 0) {
-                        return parsedNode;
-                    }
-                }
-                const recursivelyFoundElement = this.findLastFocusableChild(node);
-                if (recursivelyFoundElement) {
-                    return recursivelyFoundElement;
-                }
-            }
-        }
-        return undefined;
-    }
-    render(container) {
-        container.appendChild(this._hoverContainer);
-        const accessibleViewHint = getHoverAccessibleViewHint(this._configurationService.getValue('accessibility.verbosity.hover') === true && this._accessibilityService.isScreenReaderOptimized(), this._keybindingService.lookupKeybinding('editor.action.accessibleView')?.getAriaLabel());
-        if (accessibleViewHint) {
-            status(accessibleViewHint);
-        }
-        this.layout();
-        this.addFocusTrap();
-    }
-    layout() {
-        this._hover.containerDomNode.classList.remove('right-aligned');
-        this._hover.contentsDomNode.style.maxHeight = '';
-        const getZoomAccountedBoundingClientRect = (e) => {
-            const zoom = dom.getDomNodeZoomLevel(e);
-            const boundingRect = e.getBoundingClientRect();
-            return {
-                top: boundingRect.top * zoom,
-                bottom: boundingRect.bottom * zoom,
-                right: boundingRect.right * zoom,
-                left: boundingRect.left * zoom,
-            };
-        };
-        const targetBounds = ( this._target.targetElements.map(e => getZoomAccountedBoundingClientRect(e)));
-        const top = Math.min(...( targetBounds.map(e => e.top)));
-        const right = Math.max(...( targetBounds.map(e => e.right)));
-        const bottom = Math.max(...( targetBounds.map(e => e.bottom)));
-        const left = Math.min(...( targetBounds.map(e => e.left)));
-        const width = right - left;
-        const height = bottom - top;
-        const targetRect = {
-            top, right, bottom, left, width, height,
-            center: {
-                x: left + (width / 2),
-                y: top + (height / 2)
-            }
-        };
-        this.adjustHorizontalHoverPosition(targetRect);
-        this.adjustVerticalHoverPosition(targetRect);
-        this.adjustHoverMaxHeight(targetRect);
-        this._hoverContainer.style.padding = '';
-        this._hoverContainer.style.margin = '';
-        if (this._hoverPointer) {
-            switch (this._hoverPosition) {
-                case 1 :
-                    targetRect.left += 3 ;
-                    targetRect.right += 3 ;
-                    this._hoverContainer.style.paddingLeft = `${3 }px`;
-                    this._hoverContainer.style.marginLeft = `${-3 }px`;
-                    break;
-                case 0 :
-                    targetRect.left -= 3 ;
-                    targetRect.right -= 3 ;
-                    this._hoverContainer.style.paddingRight = `${3 }px`;
-                    this._hoverContainer.style.marginRight = `${-3 }px`;
-                    break;
-                case 2 :
-                    targetRect.top += 3 ;
-                    targetRect.bottom += 3 ;
-                    this._hoverContainer.style.paddingTop = `${3 }px`;
-                    this._hoverContainer.style.marginTop = `${-3 }px`;
-                    break;
-                case 3 :
-                    targetRect.top -= 3 ;
-                    targetRect.bottom -= 3 ;
-                    this._hoverContainer.style.paddingBottom = `${3 }px`;
-                    this._hoverContainer.style.marginBottom = `${-3 }px`;
-                    break;
-            }
-            targetRect.center.x = targetRect.left + (width / 2);
-            targetRect.center.y = targetRect.top + (height / 2);
-        }
-        this.computeXCordinate(targetRect);
-        this.computeYCordinate(targetRect);
-        if (this._hoverPointer) {
-            this._hoverPointer.classList.remove('top');
-            this._hoverPointer.classList.remove('left');
-            this._hoverPointer.classList.remove('right');
-            this._hoverPointer.classList.remove('bottom');
-            this.setHoverPointerPosition(targetRect);
-        }
-        this._hover.onContentsChanged();
-    }
-    computeXCordinate(target) {
-        const hoverWidth = this._hover.containerDomNode.clientWidth + 2 ;
-        if (this._target.x !== undefined) {
-            this._x = this._target.x;
-        }
-        else if (this._hoverPosition === 1 ) {
-            this._x = target.right;
-        }
-        else if (this._hoverPosition === 0 ) {
-            this._x = target.left - hoverWidth;
-        }
-        else {
-            if (this._hoverPointer) {
-                this._x = target.center.x - (this._hover.containerDomNode.clientWidth / 2);
-            }
-            else {
-                this._x = target.left;
-            }
-            if (this._x + hoverWidth >= document.documentElement.clientWidth) {
-                this._hover.containerDomNode.classList.add('right-aligned');
-                this._x = Math.max(document.documentElement.clientWidth - hoverWidth - 2 , document.documentElement.clientLeft);
-            }
-        }
-        if (this._x < document.documentElement.clientLeft) {
-            this._x = target.left + 2 ;
-        }
-    }
-    computeYCordinate(target) {
-        if (this._target.y !== undefined) {
-            this._y = this._target.y;
-        }
-        else if (this._hoverPosition === 3 ) {
-            this._y = target.top;
-        }
-        else if (this._hoverPosition === 2 ) {
-            this._y = target.bottom - 2;
-        }
-        else {
-            if (this._hoverPointer) {
-                this._y = target.center.y + (this._hover.containerDomNode.clientHeight / 2);
-            }
-            else {
-                this._y = target.bottom;
-            }
-        }
-        if (this._y > window.innerHeight) {
-            this._y = target.bottom;
-        }
-    }
-    adjustHorizontalHoverPosition(target) {
-        if (this._target.x !== undefined) {
-            return;
-        }
-        if (this._forcePosition) {
-            const padding = (this._hoverPointer ? 3  : 0) + 2 ;
-            if (this._hoverPosition === 1 ) {
-                this._hover.containerDomNode.style.maxWidth = `${document.documentElement.clientWidth - target.right - padding}px`;
-            }
-            else if (this._hoverPosition === 0 ) {
-                this._hover.containerDomNode.style.maxWidth = `${target.left - padding}px`;
-            }
-            return;
-        }
-        if (this._hoverPosition === 1 ) {
-            const roomOnRight = document.documentElement.clientWidth - target.right;
-            if (roomOnRight < this._hover.containerDomNode.clientWidth) {
-                const roomOnLeft = target.left;
-                if (roomOnLeft >= this._hover.containerDomNode.clientWidth) {
-                    this._hoverPosition = 0 ;
-                }
-                else {
-                    this._hoverPosition = 2 ;
-                }
-            }
-        }
-        else if (this._hoverPosition === 0 ) {
-            const roomOnLeft = target.left;
-            if (roomOnLeft < this._hover.containerDomNode.clientWidth) {
-                const roomOnRight = document.documentElement.clientWidth - target.right;
-                if (roomOnRight >= this._hover.containerDomNode.clientWidth) {
-                    this._hoverPosition = 1 ;
-                }
-                else {
-                    this._hoverPosition = 2 ;
-                }
-            }
-            if (target.left - this._hover.containerDomNode.clientWidth <= document.documentElement.clientLeft) {
-                this._hoverPosition = 1 ;
-            }
-        }
-    }
-    adjustVerticalHoverPosition(target) {
-        if (this._target.y !== undefined || this._forcePosition) {
-            return;
-        }
-        if (this._hoverPosition === 3 ) {
-            if (target.top - this._hover.containerDomNode.clientHeight < 0) {
-                this._hoverPosition = 2 ;
-            }
-        }
-        else if (this._hoverPosition === 2 ) {
-            if (target.bottom + this._hover.containerDomNode.clientHeight > window.innerHeight) {
-                this._hoverPosition = 3 ;
-            }
-        }
-    }
-    adjustHoverMaxHeight(target) {
-        let maxHeight = window.innerHeight / 2;
-        if (this._forcePosition) {
-            const padding = (this._hoverPointer ? 3  : 0) + 2 ;
-            if (this._hoverPosition === 3 ) {
-                maxHeight = Math.min(maxHeight, target.top - padding);
-            }
-            else if (this._hoverPosition === 2 ) {
-                maxHeight = Math.min(maxHeight, window.innerHeight - target.bottom - padding);
-            }
-        }
-        this._hover.containerDomNode.style.maxHeight = `${maxHeight}px`;
-        if (this._hover.contentsDomNode.clientHeight < this._hover.contentsDomNode.scrollHeight) {
-            const extraRightPadding = `${this._hover.scrollbar.options.verticalScrollbarSize}px`;
-            if (this._hover.contentsDomNode.style.paddingRight !== extraRightPadding) {
-                this._hover.contentsDomNode.style.paddingRight = extraRightPadding;
-            }
-        }
-    }
-    setHoverPointerPosition(target) {
-        if (!this._hoverPointer) {
-            return;
-        }
-        switch (this._hoverPosition) {
-            case 0 :
-            case 1 : {
-                this._hoverPointer.classList.add(this._hoverPosition === 0  ? 'right' : 'left');
-                const hoverHeight = this._hover.containerDomNode.clientHeight;
-                if (hoverHeight > target.height) {
-                    this._hoverPointer.style.top = `${target.center.y - (this._y - hoverHeight) - 3 }px`;
-                }
-                else {
-                    this._hoverPointer.style.top = `${Math.round((hoverHeight / 2)) - 3 }px`;
-                }
-                break;
-            }
-            case 3 :
-            case 2 : {
-                this._hoverPointer.classList.add(this._hoverPosition === 3  ? 'bottom' : 'top');
-                const hoverWidth = this._hover.containerDomNode.clientWidth;
-                let pointerLeftPosition = Math.round((hoverWidth / 2)) - 3 ;
-                const pointerX = this._x + pointerLeftPosition;
-                if (pointerX < target.left || pointerX > target.right) {
-                    pointerLeftPosition = target.center.x - this._x - 3 ;
-                }
-                this._hoverPointer.style.left = `${pointerLeftPosition}px`;
-                break;
-            }
-        }
-    }
-    focus() {
-        this._hover.containerDomNode.focus();
-    }
-    hide() {
-        this.dispose();
-    }
-    dispose() {
-        if (!this._isDisposed) {
-            this._onDispose.fire();
-            this._hoverContainer.remove();
-            this._messageListeners.dispose();
-            this._target.dispose();
-            super.dispose();
-        }
-        this._isDisposed = true;
-    }
-};
-HoverWidget = ( __decorate([
-    ( __param(1, IKeybindingService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IOpenerService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IAccessibilityService))
-], HoverWidget));
-class CompositeMouseTracker extends Widget {
-    get onMouseOut() { return this._onMouseOut.event; }
-    get isMouseIn() { return this._isMouseIn; }
-    constructor(_elements) {
-        super();
-        this._elements = _elements;
-        this._isMouseIn = true;
-        this._onMouseOut = this._register(( new Emitter()));
-        this._elements.forEach(n => this.onmouseover(n, () => this._onTargetMouseOver()));
-        this._elements.forEach(n => this.onmouseleave(n, () => this._onTargetMouseLeave()));
-    }
-    _onTargetMouseOver() {
-        this._isMouseIn = true;
-        this._clearEvaluateMouseStateTimeout();
-    }
-    _onTargetMouseLeave() {
-        this._isMouseIn = false;
-        this._evaluateMouseState();
-    }
-    _evaluateMouseState() {
-        this._clearEvaluateMouseStateTimeout();
-        this._mouseTimeout = window.setTimeout(() => this._fireIfMouseOutside(), 0);
-    }
-    _clearEvaluateMouseStateTimeout() {
-        if (this._mouseTimeout) {
-            clearTimeout(this._mouseTimeout);
-            this._mouseTimeout = undefined;
-        }
-    }
-    _fireIfMouseOutside() {
-        if (!this._isMouseIn) {
-            this._onMouseOut.fire();
-        }
-    }
-}
-class ElementHoverTarget {
-    constructor(_element) {
-        this._element = _element;
-        this.targetElements = [this._element];
-    }
-    dispose() {
-    }
-}
-export { HoverWidget };