@codingame/monaco-vscode-api 4.5.1 → 5.0.0

package/vscode/src/vs/editor/contrib/hover/browser/contentHover.js

@@ -1,838 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { addStandardDisposableListener, Dimension, append, trackFocus, getClientArea, getDomNodePagePosition, getTotalHeight, getTotalWidth, $ as $$1 } from '../../../../base/browser/dom.js';
-import { HoverWidget, getHoverAccessibleViewHint, HoverAction } from '../../../../base/browser/ui/hover/hoverWidget.js';
-import { coalesce } from '../../../../base/common/arrays.js';
-import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
-import { Position } from '../../../common/core/position.js';
-import { Range } from '../../../common/core/range.js';
-import { ModelDecorationOptions } from '../../../common/model/textModel.js';
-import { TokenizationRegistry } from '../../../common/languages.js';
-import { HoverOperation } from './hoverOperation.js';
-import { HoverParticipantRegistry, HoverRangeAnchor } from './hoverTypes.js';
-import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
-import { AsyncIterableObject } from '../../../../base/common/async.js';
-import { EditorContextKeys } from '../../../common/editorContextKeys.js';
-import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
-import { ResizableContentWidget } from './resizableContentWidget.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
-import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.service.js';
-var ContentHoverController_1, ContentHoverWidget_1;
-const $ = $$1;
-let ContentHoverController = class ContentHoverController extends Disposable {
-    static { ContentHoverController_1 = this; }
-    constructor(_editor, _instantiationService, _keybindingService) {
-        super();
-        this._editor = _editor;
-        this._instantiationService = _instantiationService;
-        this._keybindingService = _keybindingService;
-        this._currentResult = null;
-        this._widget = this._register(this._instantiationService.createInstance(ContentHoverWidget, this._editor));
-        this._participants = [];
-        for (const participant of HoverParticipantRegistry.getAll()) {
-            this._participants.push(this._instantiationService.createInstance(participant, this._editor));
-        }
-        this._participants.sort((p1, p2) => p1.hoverOrdinal - p2.hoverOrdinal);
-        this._computer = ( new ContentHoverComputer(this._editor, this._participants));
-        this._hoverOperation = this._register(( new HoverOperation(this._editor, this._computer)));
-        this._register(this._hoverOperation.onResult((result) => {
-            if (!this._computer.anchor) {
-                return;
-            }
-            const messages = (result.hasLoadingMessage ? this._addLoadingMessage(result.value) : result.value);
-            this._withResult(( new HoverResult(this._computer.anchor, messages, result.isComplete)));
-        }));
-        this._register(addStandardDisposableListener(this._widget.getDomNode(), 'keydown', (e) => {
-            if (e.equals(9 )) {
-                this.hide();
-            }
-        }));
-        this._register(TokenizationRegistry.onDidChange(() => {
-            if (this._widget.position && this._currentResult) {
-                this._setCurrentResult(this._currentResult);
-            }
-        }));
-    }
-    _startShowingOrUpdateHover(anchor, mode, source, focus, mouseEvent) {
-        if (!this._widget.position || !this._currentResult) {
-            if (anchor) {
-                this._startHoverOperationIfNecessary(anchor, mode, source, focus, false);
-                return true;
-            }
-            return false;
-        }
-        const isHoverSticky = this._editor.getOption(60 ).sticky;
-        const isGettingCloser = (isHoverSticky
-            && mouseEvent
-            && this._widget.isMouseGettingCloser(mouseEvent.event.posx, mouseEvent.event.posy));
-        if (isGettingCloser) {
-            if (anchor) {
-                this._startHoverOperationIfNecessary(anchor, mode, source, focus, true);
-            }
-            return true;
-        }
-        if (!anchor) {
-            this._setCurrentResult(null);
-            return false;
-        }
-        if (anchor && this._currentResult.anchor.equals(anchor)) {
-            return true;
-        }
-        if (!anchor.canAdoptVisibleHover(this._currentResult.anchor, this._widget.position)) {
-            this._setCurrentResult(null);
-            this._startHoverOperationIfNecessary(anchor, mode, source, focus, false);
-            return true;
-        }
-        this._setCurrentResult(this._currentResult.filter(anchor));
-        this._startHoverOperationIfNecessary(anchor, mode, source, focus, false);
-        return true;
-    }
-    _startHoverOperationIfNecessary(anchor, mode, source, focus, insistOnKeepingHoverVisible) {
-        if (this._computer.anchor && this._computer.anchor.equals(anchor)) {
-            return;
-        }
-        this._hoverOperation.cancel();
-        this._computer.anchor = anchor;
-        this._computer.shouldFocus = focus;
-        this._computer.source = source;
-        this._computer.insistOnKeepingHoverVisible = insistOnKeepingHoverVisible;
-        this._hoverOperation.start(mode);
-    }
-    _setCurrentResult(hoverResult) {
-        if (this._currentResult === hoverResult) {
-            return;
-        }
-        if (hoverResult && hoverResult.messages.length === 0) {
-            hoverResult = null;
-        }
-        this._currentResult = hoverResult;
-        if (this._currentResult) {
-            this._renderMessages(this._currentResult.anchor, this._currentResult.messages);
-        }
-        else {
-            this._widget.hide();
-        }
-    }
-    _addLoadingMessage(result) {
-        if (this._computer.anchor) {
-            for (const participant of this._participants) {
-                if (participant.createLoadingMessage) {
-                    const loadingMessage = participant.createLoadingMessage(this._computer.anchor);
-                    if (loadingMessage) {
-                        return result.slice(0).concat([loadingMessage]);
-                    }
-                }
-            }
-        }
-        return result;
-    }
-    _withResult(hoverResult) {
-        if (this._widget.position && this._currentResult && this._currentResult.isComplete) {
-            if (!hoverResult.isComplete) {
-                return;
-            }
-            if (this._computer.insistOnKeepingHoverVisible && hoverResult.messages.length === 0) {
-                return;
-            }
-        }
-        this._setCurrentResult(hoverResult);
-    }
-    _renderMessages(anchor, messages) {
-        const { showAtPosition, showAtSecondaryPosition, highlightRange } = ContentHoverController_1.computeHoverRanges(this._editor, anchor.range, messages);
-        const disposables = ( new DisposableStore());
-        const statusBar = disposables.add(( new EditorHoverStatusBar(this._keybindingService)));
-        const fragment = document.createDocumentFragment();
-        let colorPicker = null;
-        const context = {
-            fragment,
-            statusBar,
-            setColorPicker: (widget) => colorPicker = widget,
-            onContentsChanged: () => this._widget.onContentsChanged(),
-            setMinimumDimensions: (dimensions) => this._widget.setMinimumDimensions(dimensions),
-            hide: () => this.hide()
-        };
-        for (const participant of this._participants) {
-            const hoverParts = messages.filter(msg => msg.owner === participant);
-            if (hoverParts.length > 0) {
-                disposables.add(participant.renderHoverParts(context, hoverParts));
-            }
-        }
-        const isBeforeContent = ( messages.some(m => m.isBeforeContent));
-        if (statusBar.hasContent) {
-            fragment.appendChild(statusBar.hoverElement);
-        }
-        if (fragment.hasChildNodes()) {
-            if (highlightRange) {
-                const highlightDecoration = this._editor.createDecorationsCollection();
-                highlightDecoration.set([{
-                        range: highlightRange,
-                        options: ContentHoverController_1._DECORATION_OPTIONS
-                    }]);
-                disposables.add(toDisposable(() => {
-                    highlightDecoration.clear();
-                }));
-            }
-            this._widget.showAt(fragment, ( new ContentHoverVisibleData(
-                anchor.initialMousePosX,
-                anchor.initialMousePosY,
-                colorPicker,
-                showAtPosition,
-                showAtSecondaryPosition,
-                this._editor.getOption(60 ).above,
-                this._computer.shouldFocus,
-                this._computer.source,
-                isBeforeContent,
-                disposables
-            )));
-        }
-        else {
-            disposables.dispose();
-        }
-    }
-    static { this._DECORATION_OPTIONS = ModelDecorationOptions.register({
-        description: 'content-hover-highlight',
-        className: 'hoverHighlight'
-    }); }
-    static computeHoverRanges(editor, anchorRange, messages) {
-        let startColumnBoundary = 1;
-        if (editor.hasModel()) {
-            const viewModel = editor._getViewModel();
-            const coordinatesConverter = viewModel.coordinatesConverter;
-            const anchorViewRange = coordinatesConverter.convertModelRangeToViewRange(anchorRange);
-            const anchorViewRangeStart = ( new Position(
-                anchorViewRange.startLineNumber,
-                viewModel.getLineMinColumn(anchorViewRange.startLineNumber)
-            ));
-            startColumnBoundary = coordinatesConverter.convertViewPositionToModelPosition(anchorViewRangeStart).column;
-        }
-        const anchorLineNumber = anchorRange.startLineNumber;
-        let renderStartColumn = anchorRange.startColumn;
-        let highlightRange = messages[0].range;
-        let forceShowAtRange = null;
-        for (const msg of messages) {
-            highlightRange = Range.plusRange(highlightRange, msg.range);
-            if (msg.range.startLineNumber === anchorLineNumber && msg.range.endLineNumber === anchorLineNumber) {
-                renderStartColumn = Math.max(Math.min(renderStartColumn, msg.range.startColumn), startColumnBoundary);
-            }
-            if (msg.forceShowAtRange) {
-                forceShowAtRange = msg.range;
-            }
-        }
-        const showAtPosition = forceShowAtRange ? forceShowAtRange.getStartPosition() : ( new Position(anchorLineNumber, anchorRange.startColumn));
-        const showAtSecondaryPosition = forceShowAtRange ? forceShowAtRange.getStartPosition() : ( new Position(anchorLineNumber, renderStartColumn));
-        return {
-            showAtPosition,
-            showAtSecondaryPosition,
-            highlightRange
-        };
-    }
-    showsOrWillShow(mouseEvent) {
-        if (this._widget.isResizing) {
-            return true;
-        }
-        const anchorCandidates = [];
-        for (const participant of this._participants) {
-            if (participant.suggestHoverAnchor) {
-                const anchor = participant.suggestHoverAnchor(mouseEvent);
-                if (anchor) {
-                    anchorCandidates.push(anchor);
-                }
-            }
-        }
-        const target = mouseEvent.target;
-        if (target.type === 6 ) {
-            anchorCandidates.push(( new HoverRangeAnchor(0, target.range, mouseEvent.event.posx, mouseEvent.event.posy)));
-        }
-        if (target.type === 7 ) {
-            const epsilon = this._editor.getOption(50 ).typicalHalfwidthCharacterWidth / 2;
-            if (!target.detail.isAfterLines
-                && typeof target.detail.horizontalDistanceToText === 'number'
-                && target.detail.horizontalDistanceToText < epsilon) {
-                anchorCandidates.push(( new HoverRangeAnchor(0, target.range, mouseEvent.event.posx, mouseEvent.event.posy)));
-            }
-        }
-        if (anchorCandidates.length === 0) {
-            return this._startShowingOrUpdateHover(null, 0 , 0 , false, mouseEvent);
-        }
-        anchorCandidates.sort((a, b) => b.priority - a.priority);
-        return this._startShowingOrUpdateHover(anchorCandidates[0], 0 , 0 , false, mouseEvent);
-    }
-    startShowingAtRange(range, mode, source, focus) {
-        this._startShowingOrUpdateHover(( new HoverRangeAnchor(0, range, undefined, undefined)), mode, source, focus, null);
-    }
-    getWidgetContent() {
-        const node = this._widget.getDomNode();
-        if (!node.textContent) {
-            return undefined;
-        }
-        return node.textContent;
-    }
-    containsNode(node) {
-        return (node ? this._widget.getDomNode().contains(node) : false);
-    }
-    focus() {
-        this._widget.focus();
-    }
-    scrollUp() {
-        this._widget.scrollUp();
-    }
-    scrollDown() {
-        this._widget.scrollDown();
-    }
-    scrollLeft() {
-        this._widget.scrollLeft();
-    }
-    scrollRight() {
-        this._widget.scrollRight();
-    }
-    pageUp() {
-        this._widget.pageUp();
-    }
-    pageDown() {
-        this._widget.pageDown();
-    }
-    goToTop() {
-        this._widget.goToTop();
-    }
-    goToBottom() {
-        this._widget.goToBottom();
-    }
-    hide() {
-        this._computer.anchor = null;
-        this._hoverOperation.cancel();
-        this._setCurrentResult(null);
-    }
-    get isColorPickerVisible() {
-        return this._widget.isColorPickerVisible;
-    }
-    get isVisibleFromKeyboard() {
-        return this._widget.isVisibleFromKeyboard;
-    }
-    get isVisible() {
-        return this._widget.isVisible;
-    }
-    get isFocused() {
-        return this._widget.isFocused;
-    }
-    get isResizing() {
-        return this._widget.isResizing;
-    }
-    get widget() {
-        return this._widget;
-    }
-};
-ContentHoverController = ContentHoverController_1 = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IKeybindingService))
-], ContentHoverController));
-class HoverResult {
-    constructor(anchor, messages, isComplete) {
-        this.anchor = anchor;
-        this.messages = messages;
-        this.isComplete = isComplete;
-    }
-    filter(anchor) {
-        const filteredMessages = this.messages.filter((m) => m.isValidForHoverAnchor(anchor));
-        if (filteredMessages.length === this.messages.length) {
-            return this;
-        }
-        return ( new FilteredHoverResult(this, this.anchor, filteredMessages, this.isComplete));
-    }
-}
-class FilteredHoverResult extends HoverResult {
-    constructor(original, anchor, messages, isComplete) {
-        super(anchor, messages, isComplete);
-        this.original = original;
-    }
-    filter(anchor) {
-        return this.original.filter(anchor);
-    }
-}
-class ContentHoverVisibleData {
-    constructor(initialMousePosX, initialMousePosY, colorPicker, showAtPosition, showAtSecondaryPosition, preferAbove, stoleFocus, source, isBeforeContent, disposables) {
-        this.initialMousePosX = initialMousePosX;
-        this.initialMousePosY = initialMousePosY;
-        this.colorPicker = colorPicker;
-        this.showAtPosition = showAtPosition;
-        this.showAtSecondaryPosition = showAtSecondaryPosition;
-        this.preferAbove = preferAbove;
-        this.stoleFocus = stoleFocus;
-        this.source = source;
-        this.isBeforeContent = isBeforeContent;
-        this.disposables = disposables;
-        this.closestMouseDistance = undefined;
-    }
-}
-const HORIZONTAL_SCROLLING_BY = 30;
-const SCROLLBAR_WIDTH = 10;
-const CONTAINER_HEIGHT_PADDING = 6;
-let ContentHoverWidget = class ContentHoverWidget extends ResizableContentWidget {
-    static { ContentHoverWidget_1 = this; }
-    static { this.ID = 'editor.contrib.resizableContentHoverWidget'; }
-    static { this._lastDimensions = new Dimension(0, 0); }
-    get isColorPickerVisible() {
-        return Boolean(this._visibleData?.colorPicker);
-    }
-    get isVisibleFromKeyboard() {
-        return (this._visibleData?.source === 1) ;
-    }
-    get isVisible() {
-        return this._hoverVisibleKey.get() ?? false;
-    }
-    get isFocused() {
-        return this._hoverFocusedKey.get() ?? false;
-    }
-    constructor(editor, contextKeyService, _configurationService, _accessibilityService, _keybindingService) {
-        const minimumHeight = editor.getOption(67 ) + 8;
-        const minimumWidth = 150;
-        const minimumSize = new Dimension(minimumWidth, minimumHeight);
-        super(editor, minimumSize);
-        this._configurationService = _configurationService;
-        this._accessibilityService = _accessibilityService;
-        this._keybindingService = _keybindingService;
-        this._hover = this._register(( new HoverWidget()));
-        this._minimumSize = minimumSize;
-        this._hoverVisibleKey = EditorContextKeys.hoverVisible.bindTo(contextKeyService);
-        this._hoverFocusedKey = EditorContextKeys.hoverFocused.bindTo(contextKeyService);
-        append(this._resizableNode.domNode, this._hover.containerDomNode);
-        this._resizableNode.domNode.style.zIndex = '50';
-        this._register(this._editor.onDidLayoutChange(() => {
-            if (this.isVisible) {
-                this._updateMaxDimensions();
-            }
-        }));
-        this._register(this._editor.onDidChangeConfiguration((e) => {
-            if (e.hasChanged(50 )) {
-                this._updateFont();
-            }
-        }));
-        const focusTracker = this._register(trackFocus(this._resizableNode.domNode));
-        this._register(focusTracker.onDidFocus(() => {
-            this._hoverFocusedKey.set(true);
-        }));
-        this._register(focusTracker.onDidBlur(() => {
-            this._hoverFocusedKey.set(false);
-        }));
-        this._setHoverData(undefined);
-        this._editor.addContentWidget(this);
-    }
-    dispose() {
-        super.dispose();
-        this._visibleData?.disposables.dispose();
-        this._editor.removeContentWidget(this);
-    }
-    getId() {
-        return ContentHoverWidget_1.ID;
-    }
-    static _applyDimensions(container, width, height) {
-        const transformedWidth = typeof width === 'number' ? `${width}px` : width;
-        const transformedHeight = typeof height === 'number' ? `${height}px` : height;
-        container.style.width = transformedWidth;
-        container.style.height = transformedHeight;
-    }
-    _setContentsDomNodeDimensions(width, height) {
-        const contentsDomNode = this._hover.contentsDomNode;
-        return ContentHoverWidget_1._applyDimensions(contentsDomNode, width, height);
-    }
-    _setContainerDomNodeDimensions(width, height) {
-        const containerDomNode = this._hover.containerDomNode;
-        return ContentHoverWidget_1._applyDimensions(containerDomNode, width, height);
-    }
-    _setHoverWidgetDimensions(width, height) {
-        this._setContentsDomNodeDimensions(width, height);
-        this._setContainerDomNodeDimensions(width, height);
-        this._layoutContentWidget();
-    }
-    static _applyMaxDimensions(container, width, height) {
-        const transformedWidth = typeof width === 'number' ? `${width}px` : width;
-        const transformedHeight = typeof height === 'number' ? `${height}px` : height;
-        container.style.maxWidth = transformedWidth;
-        container.style.maxHeight = transformedHeight;
-    }
-    _setHoverWidgetMaxDimensions(width, height) {
-        ContentHoverWidget_1._applyMaxDimensions(this._hover.contentsDomNode, width, height);
-        ContentHoverWidget_1._applyMaxDimensions(this._hover.containerDomNode, width, height);
-        this._hover.containerDomNode.style.setProperty('--vscode-hover-maxWidth', typeof width === 'number' ? `${width}px` : width);
-        this._layoutContentWidget();
-    }
-    _hasHorizontalScrollbar() {
-        const scrollDimensions = this._hover.scrollbar.getScrollDimensions();
-        const hasHorizontalScrollbar = scrollDimensions.scrollWidth > scrollDimensions.width;
-        return hasHorizontalScrollbar;
-    }
-    _adjustContentsBottomPadding() {
-        const contentsDomNode = this._hover.contentsDomNode;
-        const extraBottomPadding = `${this._hover.scrollbar.options.horizontalScrollbarSize}px`;
-        if (contentsDomNode.style.paddingBottom !== extraBottomPadding) {
-            contentsDomNode.style.paddingBottom = extraBottomPadding;
-        }
-    }
-    _setAdjustedHoverWidgetDimensions(size) {
-        this._setHoverWidgetMaxDimensions('none', 'none');
-        const width = size.width;
-        const height = size.height;
-        this._setHoverWidgetDimensions(width, height);
-        if (this._hasHorizontalScrollbar()) {
-            this._adjustContentsBottomPadding();
-            this._setContentsDomNodeDimensions(width, height - SCROLLBAR_WIDTH);
-        }
-    }
-    _updateResizableNodeMaxDimensions() {
-        const maxRenderingWidth = this._findMaximumRenderingWidth() ?? Infinity;
-        const maxRenderingHeight = this._findMaximumRenderingHeight() ?? Infinity;
-        this._resizableNode.maxSize = new Dimension(maxRenderingWidth, maxRenderingHeight);
-        this._setHoverWidgetMaxDimensions(maxRenderingWidth, maxRenderingHeight);
-    }
-    _resize(size) {
-        ContentHoverWidget_1._lastDimensions = new Dimension(size.width, size.height);
-        this._setAdjustedHoverWidgetDimensions(size);
-        this._resizableNode.layout(size.height, size.width);
-        this._updateResizableNodeMaxDimensions();
-        this._hover.scrollbar.scanDomNode();
-        this._editor.layoutContentWidget(this);
-        this._visibleData?.colorPicker?.layout();
-    }
-    _findAvailableSpaceVertically() {
-        const position = this._visibleData?.showAtPosition;
-        if (!position) {
-            return;
-        }
-        return this._positionPreference === 1  ?
-            this._availableVerticalSpaceAbove(position)
-            : this._availableVerticalSpaceBelow(position);
-    }
-    _findMaximumRenderingHeight() {
-        const availableSpace = this._findAvailableSpaceVertically();
-        if (!availableSpace) {
-            return;
-        }
-        let maximumHeight = CONTAINER_HEIGHT_PADDING;
-        Array.from(this._hover.contentsDomNode.children).forEach((hoverPart) => {
-            maximumHeight += hoverPart.clientHeight;
-        });
-        if (this._hasHorizontalScrollbar()) {
-            maximumHeight += SCROLLBAR_WIDTH;
-        }
-        return Math.min(availableSpace, maximumHeight);
-    }
-    _isHoverTextOverflowing() {
-        this._hover.containerDomNode.style.setProperty('--vscode-hover-whiteSpace', 'nowrap');
-        this._hover.containerDomNode.style.setProperty('--vscode-hover-sourceWhiteSpace', 'nowrap');
-        const overflowing = ( Array.from(this._hover.contentsDomNode.children).some((hoverElement) => {
-            return hoverElement.scrollWidth > hoverElement.clientWidth;
-        }));
-        this._hover.containerDomNode.style.removeProperty('--vscode-hover-whiteSpace');
-        this._hover.containerDomNode.style.removeProperty('--vscode-hover-sourceWhiteSpace');
-        return overflowing;
-    }
-    _findMaximumRenderingWidth() {
-        if (!this._editor || !this._editor.hasModel()) {
-            return;
-        }
-        const overflowing = this._isHoverTextOverflowing();
-        const initialWidth = ((typeof this._contentWidth === 'undefined' ? 0 : this._contentWidth - 2)
-        );
-        if (overflowing || this._hover.containerDomNode.clientWidth < initialWidth) {
-            const bodyBoxWidth = getClientArea(this._hover.containerDomNode.ownerDocument.body).width;
-            const horizontalPadding = 14;
-            return bodyBoxWidth - horizontalPadding;
-        }
-        else {
-            return this._hover.containerDomNode.clientWidth + 2;
-        }
-    }
-    isMouseGettingCloser(posx, posy) {
-        if (!this._visibleData) {
-            return false;
-        }
-        if (typeof this._visibleData.initialMousePosX === 'undefined'
-            || typeof this._visibleData.initialMousePosY === 'undefined') {
-            this._visibleData.initialMousePosX = posx;
-            this._visibleData.initialMousePosY = posy;
-            return false;
-        }
-        const widgetRect = getDomNodePagePosition(this.getDomNode());
-        if (typeof this._visibleData.closestMouseDistance === 'undefined') {
-            this._visibleData.closestMouseDistance = computeDistanceFromPointToRectangle(this._visibleData.initialMousePosX, this._visibleData.initialMousePosY, widgetRect.left, widgetRect.top, widgetRect.width, widgetRect.height);
-        }
-        const distance = computeDistanceFromPointToRectangle(posx, posy, widgetRect.left, widgetRect.top, widgetRect.width, widgetRect.height);
-        if (distance > this._visibleData.closestMouseDistance + 4 ) {
-            return false;
-        }
-        this._visibleData.closestMouseDistance = Math.min(this._visibleData.closestMouseDistance, distance);
-        return true;
-    }
-    _setHoverData(hoverData) {
-        this._visibleData?.disposables.dispose();
-        this._visibleData = hoverData;
-        this._hoverVisibleKey.set(!!hoverData);
-        this._hover.containerDomNode.classList.toggle('hidden', !hoverData);
-    }
-    _updateFont() {
-        const { fontSize, lineHeight } = this._editor.getOption(50 );
-        const contentsDomNode = this._hover.contentsDomNode;
-        contentsDomNode.style.fontSize = `${fontSize}px`;
-        contentsDomNode.style.lineHeight = `${lineHeight / fontSize}`;
-        const codeClasses = Array.prototype.slice.call(this._hover.contentsDomNode.getElementsByClassName('code'));
-        codeClasses.forEach(node => this._editor.applyFontInfo(node));
-    }
-    _updateContent(node) {
-        const contentsDomNode = this._hover.contentsDomNode;
-        contentsDomNode.style.paddingBottom = '';
-        contentsDomNode.textContent = '';
-        contentsDomNode.appendChild(node);
-    }
-    _layoutContentWidget() {
-        this._editor.layoutContentWidget(this);
-        this._hover.onContentsChanged();
-    }
-    _updateMaxDimensions() {
-        const height = Math.max(this._editor.getLayoutInfo().height / 4, 250, ContentHoverWidget_1._lastDimensions.height);
-        const width = Math.max(this._editor.getLayoutInfo().width * 0.66, 500, ContentHoverWidget_1._lastDimensions.width);
-        this._setHoverWidgetMaxDimensions(width, height);
-    }
-    _render(node, hoverData) {
-        this._setHoverData(hoverData);
-        this._updateFont();
-        this._updateContent(node);
-        this._updateMaxDimensions();
-        this.onContentsChanged();
-        this._editor.render();
-    }
-    getPosition() {
-        if (!this._visibleData) {
-            return null;
-        }
-        return {
-            position: this._visibleData.showAtPosition,
-            secondaryPosition: this._visibleData.showAtSecondaryPosition,
-            positionAffinity: this._visibleData.isBeforeContent ? 3  : undefined,
-            preference: [this._positionPreference ?? 1 ]
-        };
-    }
-    showAt(node, hoverData) {
-        if (!this._editor || !this._editor.hasModel()) {
-            return;
-        }
-        this._render(node, hoverData);
-        const widgetHeight = getTotalHeight(this._hover.containerDomNode);
-        const widgetPosition = hoverData.showAtPosition;
-        this._positionPreference = this._findPositionPreference(widgetHeight, widgetPosition) ?? 1 ;
-        this.onContentsChanged();
-        if (hoverData.stoleFocus) {
-            this._hover.containerDomNode.focus();
-        }
-        hoverData.colorPicker?.layout();
-        const hoverFocused = this._hover.containerDomNode.ownerDocument.activeElement === this._hover.containerDomNode;
-        const accessibleViewHint = hoverFocused && getHoverAccessibleViewHint(this._configurationService.getValue('accessibility.verbosity.hover') === true && this._accessibilityService.isScreenReaderOptimized(), this._keybindingService.lookupKeybinding('editor.action.accessibleView')?.getAriaLabel() ?? '');
-        if (accessibleViewHint) {
-            this._hover.contentsDomNode.ariaLabel = this._hover.contentsDomNode.textContent + ', ' + accessibleViewHint;
-        }
-    }
-    hide() {
-        if (!this._visibleData) {
-            return;
-        }
-        const stoleFocus = this._visibleData.stoleFocus || this._hoverFocusedKey.get();
-        this._setHoverData(undefined);
-        this._resizableNode.maxSize = new Dimension(Infinity, Infinity);
-        this._resizableNode.clearSashHoverState();
-        this._hoverFocusedKey.set(false);
-        this._editor.layoutContentWidget(this);
-        if (stoleFocus) {
-            this._editor.focus();
-        }
-    }
-    _removeConstraintsRenderNormally() {
-        const layoutInfo = this._editor.getLayoutInfo();
-        this._resizableNode.layout(layoutInfo.height, layoutInfo.width);
-        this._setHoverWidgetDimensions('auto', 'auto');
-    }
-    _adjustHoverHeightForScrollbar(height) {
-        const containerDomNode = this._hover.containerDomNode;
-        const contentsDomNode = this._hover.contentsDomNode;
-        const maxRenderingHeight = this._findMaximumRenderingHeight() ?? Infinity;
-        this._setContainerDomNodeDimensions(getTotalWidth(containerDomNode), Math.min(maxRenderingHeight, height));
-        this._setContentsDomNodeDimensions(getTotalWidth(contentsDomNode), Math.min(maxRenderingHeight, height - SCROLLBAR_WIDTH));
-    }
-    setMinimumDimensions(dimensions) {
-        this._minimumSize = new Dimension(Math.max(this._minimumSize.width, dimensions.width), Math.max(this._minimumSize.height, dimensions.height));
-        this._updateMinimumWidth();
-    }
-    _updateMinimumWidth() {
-        const width = (typeof this._contentWidth === 'undefined'
-            ? this._minimumSize.width
-            : Math.min(this._contentWidth, this._minimumSize.width));
-        this._resizableNode.minSize = new Dimension(width, this._minimumSize.height);
-    }
-    onContentsChanged() {
-        this._removeConstraintsRenderNormally();
-        const containerDomNode = this._hover.containerDomNode;
-        let height = getTotalHeight(containerDomNode);
-        let width = getTotalWidth(containerDomNode);
-        this._resizableNode.layout(height, width);
-        this._setHoverWidgetDimensions(width, height);
-        height = getTotalHeight(containerDomNode);
-        width = getTotalWidth(containerDomNode);
-        this._contentWidth = width;
-        this._updateMinimumWidth();
-        this._resizableNode.layout(height, width);
-        if (this._hasHorizontalScrollbar()) {
-            this._adjustContentsBottomPadding();
-            this._adjustHoverHeightForScrollbar(height);
-        }
-        if (this._visibleData?.showAtPosition) {
-            const widgetHeight = getTotalHeight(this._hover.containerDomNode);
-            this._positionPreference = this._findPositionPreference(widgetHeight, this._visibleData.showAtPosition);
-        }
-        this._layoutContentWidget();
-    }
-    focus() {
-        this._hover.containerDomNode.focus();
-    }
-    scrollUp() {
-        const scrollTop = this._hover.scrollbar.getScrollPosition().scrollTop;
-        const fontInfo = this._editor.getOption(50 );
-        this._hover.scrollbar.setScrollPosition({ scrollTop: scrollTop - fontInfo.lineHeight });
-    }
-    scrollDown() {
-        const scrollTop = this._hover.scrollbar.getScrollPosition().scrollTop;
-        const fontInfo = this._editor.getOption(50 );
-        this._hover.scrollbar.setScrollPosition({ scrollTop: scrollTop + fontInfo.lineHeight });
-    }
-    scrollLeft() {
-        const scrollLeft = this._hover.scrollbar.getScrollPosition().scrollLeft;
-        this._hover.scrollbar.setScrollPosition({ scrollLeft: scrollLeft - HORIZONTAL_SCROLLING_BY });
-    }
-    scrollRight() {
-        const scrollLeft = this._hover.scrollbar.getScrollPosition().scrollLeft;
-        this._hover.scrollbar.setScrollPosition({ scrollLeft: scrollLeft + HORIZONTAL_SCROLLING_BY });
-    }
-    pageUp() {
-        const scrollTop = this._hover.scrollbar.getScrollPosition().scrollTop;
-        const scrollHeight = this._hover.scrollbar.getScrollDimensions().height;
-        this._hover.scrollbar.setScrollPosition({ scrollTop: scrollTop - scrollHeight });
-    }
-    pageDown() {
-        const scrollTop = this._hover.scrollbar.getScrollPosition().scrollTop;
-        const scrollHeight = this._hover.scrollbar.getScrollDimensions().height;
-        this._hover.scrollbar.setScrollPosition({ scrollTop: scrollTop + scrollHeight });
-    }
-    goToTop() {
-        this._hover.scrollbar.setScrollPosition({ scrollTop: 0 });
-    }
-    goToBottom() {
-        this._hover.scrollbar.setScrollPosition({ scrollTop: this._hover.scrollbar.getScrollDimensions().scrollHeight });
-    }
-};
-ContentHoverWidget = ContentHoverWidget_1 = ( __decorate([
-    ( __param(1, IContextKeyService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IAccessibilityService)),
-    ( __param(4, IKeybindingService))
-], ContentHoverWidget));
-let EditorHoverStatusBar = class EditorHoverStatusBar extends Disposable {
-    get hasContent() {
-        return this._hasContent;
-    }
-    constructor(_keybindingService) {
-        super();
-        this._keybindingService = _keybindingService;
-        this._hasContent = false;
-        this.hoverElement = $('div.hover-row.status-bar');
-        this.actionsElement = append(this.hoverElement, $('div.actions'));
-    }
-    addAction(actionOptions) {
-        const keybinding = this._keybindingService.lookupKeybinding(actionOptions.commandId);
-        const keybindingLabel = keybinding ? keybinding.getLabel() : null;
-        this._hasContent = true;
-        return this._register(HoverAction.render(this.actionsElement, actionOptions, keybindingLabel));
-    }
-    append(element) {
-        const result = append(this.actionsElement, element);
-        this._hasContent = true;
-        return result;
-    }
-};
-EditorHoverStatusBar = ( __decorate([
-    ( __param(0, IKeybindingService))
-], EditorHoverStatusBar));
-class ContentHoverComputer {
-    get anchor() { return this._anchor; }
-    set anchor(value) { this._anchor = value; }
-    get shouldFocus() { return this._shouldFocus; }
-    set shouldFocus(value) { this._shouldFocus = value; }
-    get source() { return this._source; }
-    set source(value) { this._source = value; }
-    get insistOnKeepingHoverVisible() { return this._insistOnKeepingHoverVisible; }
-    set insistOnKeepingHoverVisible(value) { this._insistOnKeepingHoverVisible = value; }
-    constructor(_editor, _participants) {
-        this._editor = _editor;
-        this._participants = _participants;
-        this._anchor = null;
-        this._shouldFocus = false;
-        this._source = 0 ;
-        this._insistOnKeepingHoverVisible = false;
-    }
-    static _getLineDecorations(editor, anchor) {
-        if (anchor.type !== 1  && !anchor.supportsMarkerHover) {
-            return [];
-        }
-        const model = editor.getModel();
-        const lineNumber = anchor.range.startLineNumber;
-        if (lineNumber > model.getLineCount()) {
-            return [];
-        }
-        const maxColumn = model.getLineMaxColumn(lineNumber);
-        return editor.getLineDecorations(lineNumber).filter((d) => {
-            if (d.options.isWholeLine) {
-                return true;
-            }
-            const startColumn = (d.range.startLineNumber === lineNumber) ? d.range.startColumn : 1;
-            const endColumn = (d.range.endLineNumber === lineNumber) ? d.range.endColumn : maxColumn;
-            if (d.options.showIfCollapsed) {
-                if (startColumn > anchor.range.startColumn + 1 || anchor.range.endColumn - 1 > endColumn) {
-                    return false;
-                }
-            }
-            else {
-                if (startColumn > anchor.range.startColumn || anchor.range.endColumn > endColumn) {
-                    return false;
-                }
-            }
-            return true;
-        });
-    }
-    computeAsync(token) {
-        const anchor = this._anchor;
-        if (!this._editor.hasModel() || !anchor) {
-            return AsyncIterableObject.EMPTY;
-        }
-        const lineDecorations = ContentHoverComputer._getLineDecorations(this._editor, anchor);
-        return AsyncIterableObject.merge(( this._participants.map((participant) => {
-            if (!participant.computeAsync) {
-                return AsyncIterableObject.EMPTY;
-            }
-            return participant.computeAsync(anchor, lineDecorations, token);
-        })));
-    }
-    computeSync() {
-        if (!this._editor.hasModel() || !this._anchor) {
-            return [];
-        }
-        const lineDecorations = ContentHoverComputer._getLineDecorations(this._editor, this._anchor);
-        let result = [];
-        for (const participant of this._participants) {
-            result = result.concat(participant.computeSync(this._anchor, lineDecorations));
-        }
-        return coalesce(result);
-    }
-}
-function computeDistanceFromPointToRectangle(pointX, pointY, left, top, width, height) {
-    const x = (left + width / 2);
-    const y = (top + height / 2);
-    const dx = Math.max(Math.abs(pointX - x) - width / 2, 0);
-    const dy = Math.max(Math.abs(pointY - y) - height / 2, 0);
-    return Math.sqrt(dx * dx + dy * dy);
-}
-export { ContentHoverController, ContentHoverWidget, EditorHoverStatusBar };