@codingame/monaco-vscode-api 36.2.7 → 37.1.0

package/vscode/src/vs/base/browser/markdownRenderer.js

@@ -1,11 +1,12 @@
 
 import { onUnexpectedError } from '../common/errors.js';
-import { escapeDoubleQuotes, parseHrefAndDimensions, removeMarkdownEscapes } from '../common/htmlContent.js';
+import { isUNC } from '../common/extpath.js';
+import { escapeDoubleQuotes, parseHrefAndDimensions, removeMarkdownEscapes, isPortableLinkTarget } from '../common/htmlContent.js';
 import { markdownEscapeEscapedIcons } from '../common/iconLabels.js';
 import { defaultGenerator } from '../common/idGenerator.js';
 import { KeyCode } from '../common/keyCodes.js';
 import { DisposableStore } from '../common/lifecycle.js';
-import { Marked, parse as parse$1, Renderer, lexer } from 'marked';
+import { Marked, parse as parse$1, Renderer, Lexer, lexer } from 'marked';
 import { parse } from '../common/marshalling.js';
 import { Schemas, FileAccess } from '../common/network.js';
 import { cloneAndChange } from '../common/objects.js';
@@ -13,7 +14,7 @@ import { basename as basename$1 } from '../common/path.js';
 import { resolvePath, dirname, basename } from '../common/resources.js';
 import { escape } from '../common/strings.js';
 import { URI } from '../common/uri.js';
-import { createElement, reset, addDisposableListener, getWindow, $, isHTMLElement } from './dom.js';
+import { createElement, reset, addDisposableListener, getWindow, isHTMLElement } from './dom.js';
 import { safeSetInnerHtml, convertTagToPlaintext, sanitizeHtml, basicMarkupHtmlTags } from './domSanitize.js';
 import { StandardKeyboardEvent } from './keyboardEvent.js';
 import { StandardMouseEvent } from './mouseEvent.js';
@@ -262,12 +263,6 @@ function rewriteRenderedLinks(markdown, options, root) {
                 }
             } catch (err) {}
             el.setAttribute("src", massageHref(markdown, href, true));
-            if (options.sanitizerConfig?.remoteImageIsAllowed) {
-                const uri = ( URI.parse(href));
-                if (uri.scheme !== Schemas.file && uri.scheme !== Schemas.data && !options.sanitizerConfig.remoteImageIsAllowed(uri)) {
-                    el.replaceWith($("", undefined, el.outerHTML));
-                }
-            }
         }
     }
     for (const el of root.querySelectorAll("a")) {
@@ -281,6 +276,9 @@ function rewriteRenderedLinks(markdown, options, root) {
                 resolvedHref = resolveWithBaseUri(( URI.from(markdown.baseUri)), href);
             }
             el.dataset.href = resolvedHref;
+            if (options.actionHandler && isPortableLinkTarget(resolvedHref)) {
+                el.setAttribute("href", resolvedHref);
+            }
         }
     }
 }
@@ -435,6 +433,24 @@ function resolveWithBaseUri(baseUri, href) {
         return ( resolvePath(dirname(baseUri), href).toString());
     }
 }
+function isLocalFileUri(uri) {
+    return uri.scheme === Schemas.file && !uri.authority && !isUNC(uri.fsPath);
+}
+function isMediaSourceAllowed(mdStrConfig, source, remoteImageIsAllowed) {
+    let uri;
+    try {
+        const baseUri = mdStrConfig.baseUri ? ( URI.from(mdStrConfig.baseUri)) : undefined;
+        const hasScheme = /^\w[\w\d+.-]*:/.test(source);
+        if (!hasScheme && baseUri?.scheme === Schemas.file && !isLocalFileUri(baseUri)) {
+            return false;
+        }
+        const href = baseUri ? resolveWithBaseUri(baseUri, source) : source;
+        uri = ( URI.parse(href));
+    } catch {
+        return false;
+    }
+    return isLocalFileUri(uri) || uri.scheme === Schemas.data || remoteImageIsAllowed(uri);
+}
 function sanitizeRenderedMarkdown(renderedMarkdown, originalMdStrConfig, options = {}) {
     const sanitizerConfig = getDomSanitizerConfig(originalMdStrConfig, options);
     return sanitizeHtml(renderedMarkdown, sanitizerConfig);
@@ -494,6 +510,7 @@ const allowedMarkdownHtmlAttributes = ( Object.freeze([
 ]));
 function getDomSanitizerConfig(mdStrConfig, options) {
     const isTrusted = mdStrConfig.isTrusted ?? false;
+    const remoteImageIsAllowed = options.remoteImageIsAllowed;
     const allowedLinkSchemes = [
         Schemas.http,
         Schemas.https,
@@ -534,6 +551,7 @@ function getDomSanitizerConfig(mdStrConfig, options) {
             ]
         },
         allowRelativeMediaPaths: !!mdStrConfig.baseUri,
+        mediaSourceIsAllowed: remoteImageIsAllowed ? source => isMediaSourceAllowed(mdStrConfig, source, remoteImageIsAllowed) : undefined,
         replaceWithPlaintext: options.replaceWithPlaintext
     };
 }
@@ -552,6 +570,10 @@ function renderAsPlaintext(str, options) {
     if (options?.useLinkFormatter) {
         renderer.link = linkFormatter;
     }
+    if (options?.omitMarkdownSyntax) {
+        renderer.listitem = parsedListItem;
+        renderer.text = parsedText;
+    }
     const html = parse$1(value, {
         async: false,
         renderer
@@ -713,6 +735,16 @@ const linkFormatter = (
     }
     return text;
 };
+const parsedListItem = function(
+    {
+        tokens
+    }
+) {
+    return this.parser.parse(tokens, true);
+};
+const parsedText = function(token) {
+    return token.tokens ? this.parser.parseInline(token.tokens) : token.text;
+};
 function mergeRawTokenText(tokens) {
     let mergedTokenText = "";
     tokens.forEach(token => {
@@ -758,11 +790,36 @@ function completeSingleLinePattern(token) {
     return undefined;
 }
 function hasLinkTextAndStartOfLinkTarget(str) {
-    return !!str.match(/(^|\s|\*|_|~)\[.*\]\(\w*/);
+    return !!str.match(/(?:^|[\s(*_~])\[.*\]\(\w*/);
 }
 function hasStartOfLinkTargetAndNoLinkText(str) {
     return !!str.match(/^[^\[]*\]\([^\)]*$/);
 }
+function completeBlockquotePattern(blockquote, links) {
+    let lastInterestingIndex = blockquote.tokens.length - 1;
+    while (lastInterestingIndex >= 0 && blockquote.tokens[lastInterestingIndex].type === "space") {
+        lastInterestingIndex--;
+    }
+    const lastToken = blockquote.tokens[lastInterestingIndex];
+    if (lastToken?.type !== "paragraph") {
+        return undefined;
+    }
+    const completedToken = completeSingleLinePattern(lastToken);
+    if (!completedToken) {
+        return undefined;
+    }
+    const completion = completedToken.raw.slice(lastToken.raw.trimEnd().length);
+    const trailingQuoteOnlyLines = blockquote.raw.match(/(?:\n[ \t]*>[ \t]*(?=\n|$))+\n?$/)?.[0] ?? "";
+    const insertionIndex = blockquote.raw.length - trailingQuoteOnlyLines.length;
+    const completedRaw = blockquote.raw.slice(0, insertionIndex) + completion + trailingQuoteOnlyLines;
+    const lexer = new Lexer();
+    lexer.tokens.links = links;
+    const completedBlockquote = lexer.lex(completedRaw)[0];
+    if (completedBlockquote.type === "blockquote") {
+        return completedBlockquote;
+    }
+    return undefined;
+}
 function completeListItemPattern(list) {
     const lastListItem = list.items[list.items.length - 1];
     const lastListSubToken = lastListItem.tokens ? lastListItem.tokens[lastListItem.tokens.length - 1] : undefined;
@@ -836,6 +893,13 @@ function fillInIncompleteTokensOnce(tokens) {
             i = lastInterestingIdx;
         }
     }
+    if (!newTokens && lastInterestingToken?.type === "blockquote") {
+        const newBlockquoteToken = completeBlockquotePattern(lastInterestingToken, tokens.links);
+        if (newBlockquoteToken) {
+            newTokens = [newBlockquoteToken, ...trailingTokens];
+            i = lastInterestingIdx;
+        }
+    }
     if (!newTokens && lastInterestingToken?.type === "paragraph") {
         const newToken = completeSingleLinePattern(lastInterestingToken);
         if (newToken) {

package/vscode/src/vs/base/browser/ui/actionbar/actionViewItems.d.ts

@@ -6,7 +6,7 @@ import { ISelectBoxOptions, ISelectBoxStyles, ISelectOptionItem, SelectBox } fro
 import { IToggleStyles } from "../toggle/toggle.js";
 import { IAction, IActionRunner } from "../../../common/actions.js";
 import { Disposable } from "../../../common/lifecycle.js";
-import type { IManagedHoverContent } from "../hover/hover.js";
+import type { IManagedHoverContent, IManagedHoverOptions } from "../hover/hover.js";
 export interface IBaseActionViewItemOptions {
     readonly draggable?: boolean;
     readonly isMenu?: boolean;
@@ -40,6 +40,7 @@ export declare class BaseActionViewItem extends Disposable implements IActionVie
     protected getClass(): string | undefined;
     protected getTooltip(): string | undefined;
     protected getHoverContents(): IManagedHoverContent | undefined;
+    protected getHoverOptions(): IManagedHoverOptions | undefined;
     protected updateTooltip(): void;
     protected updateAriaLabel(): void;
     protected updateClass(): void;

package/vscode/src/vs/base/browser/ui/actionbar/actionViewItems.js

@@ -157,6 +157,9 @@ class BaseActionViewItem extends Disposable {
     getHoverContents() {
         return this.getTooltip();
     }
+    getHoverOptions() {
+        return undefined;
+    }
     updateTooltip() {
         if (!this.element) {
             return;
@@ -166,10 +169,10 @@ class BaseActionViewItem extends Disposable {
         if (!this.customHover && title !== "") {
             const hoverDelegate = this.options.hoverDelegate ?? getDefaultHoverDelegate("element");
             this.customHover = this._store.add(
-                getBaseLayerHoverDelegate().setupManagedHover(hoverDelegate, this.element, title)
+                getBaseLayerHoverDelegate().setupManagedHover(hoverDelegate, this.element, title, this.getHoverOptions())
             );
         } else if (this.customHover) {
-            this.customHover.update(title);
+            this.customHover.update(title, this.getHoverOptions());
         }
     }
     updateAriaLabel() {

package/vscode/src/vs/base/browser/ui/animations/animations.d.ts

@@ -15,8 +15,7 @@ export declare function bounceElement(element: HTMLElement, opts: {
     duration?: number;
 }): void;
 /**
- * Confetti: small particles burst outward in a circle from the element center,
- * with an expanding ring.
+ * Confetti: colorful particles burst upward from the element center and fall.
  */
 export declare function triggerConfettiAnimation(element: HTMLElement): void;
 /**

package/vscode/src/vs/base/browser/ui/animations/animations.js

@@ -10,18 +10,14 @@ var ClickAnimation;
     ClickAnimation[ClickAnimation["RadiantLines"] = 4] = "RadiantLines";
 })(ClickAnimation || (ClickAnimation = {}));
 const confettiColors = [
-    '#007acc',
-    '#005a9e',
-    '#0098ff',
-    '#4fc3f7',
-    '#64b5f6',
-    '#42a5f5',
+    'var(--vscode-charts-red)',
+    'var(--vscode-charts-orange)',
+    'var(--vscode-charts-yellow)',
+    'var(--vscode-charts-green)',
+    'var(--vscode-charts-blue)',
+    'var(--vscode-charts-purple)',
 ];
-let activeOverlay;
 function createOverlay(element) {
-    if (activeOverlay) {
-        return undefined;
-    }
     const rect = element.getBoundingClientRect();
     const ownerDocument = getWindow(element).document;
     const overlay = $('.animation-overlay');
@@ -33,16 +29,12 @@ function createOverlay(element) {
     overlay.style.pointerEvents = 'none';
     overlay.style.overflow = 'visible';
     overlay.style.zIndex = '10000';
-    ownerDocument.body.appendChild(overlay);
-    activeOverlay = overlay;
+    (element.closest('.monaco-workbench') ?? ownerDocument.body).appendChild(overlay);
     return { overlay, cx: rect.width / 2, cy: rect.height / 2 };
 }
-function cleanupOverlay(duration) {
-    setTimeout(() => {
-        if (activeOverlay) {
-            activeOverlay.remove();
-            activeOverlay = undefined;
-        }
+function cleanupOverlay(overlay, duration) {
+    getWindow(overlay).setTimeout(() => {
+        overlay.remove();
     }, duration);
 }
 function bounceElement(element, opts) {
@@ -78,71 +70,49 @@ function bounceElement(element, opts) {
     });
 }
 function triggerConfettiAnimation(element) {
-    const result = createOverlay(element);
-    if (!result) {
-        return;
-    }
-    const { overlay, cx, cy } = result;
-    const rect = element.getBoundingClientRect();
+    const { overlay, cx, cy } = createOverlay(element);
     bounceElement(element, {
         scale: [1, 1.3, 1],
         rotate: [0, -10, 10, 0],
         duration: 350,
     });
-    const particleCount = 10;
+    const particleCount = 24;
     for (let i = 0; i < particleCount; i++) {
-        const size = 3 + (i % 3) * 1.5;
-        const angle = (i * 36 * Math.PI) / 180;
-        const distance = 35;
-        const particleOpacity = 0.6 + (i % 4) * 0.1;
-        const part = $('.animation-particle');
+        const width = 4 + (i % 3) * 1.5;
+        const height = 3 + ((i + 1) % 3);
+        const angle = (-160 + Math.random() * 140) * Math.PI / 180;
+        const distance = 30 + Math.random() * 30;
+        const peakX = Math.cos(angle) * distance;
+        const peakY = Math.sin(angle) * distance;
+        const endX = peakX * 1.4 + (Math.random() - 0.5) * 20;
+        const endY = 25 + Math.random() * 30;
+        const rotation = (Math.random() - 0.5) * 720;
+        const part = $('.animation-particle.animation-confetti-particle');
         part.style.position = 'absolute';
-        part.style.width = `${size}px`;
-        part.style.height = `${size}px`;
-        part.style.borderRadius = '50%';
+        part.style.width = `${width}px`;
+        part.style.height = `${height}px`;
+        part.style.borderRadius = i % 4 === 0 ? '50%' : '1px';
         part.style.backgroundColor = confettiColors[i % confettiColors.length];
-        part.style.left = `${cx - size / 2}px`;
-        part.style.top = `${cy - size / 2}px`;
+        part.style.left = `${cx}px`;
+        part.style.top = `${cy}px`;
         overlay.appendChild(part);
-        const tx = Math.cos(angle) * distance;
-        const ty = Math.sin(angle) * distance;
         part.animate([
-            { opacity: 0, transform: 'scale(0) translate(0, 0)' },
-            { opacity: particleOpacity, transform: `scale(1) translate(${tx * 0.5}px, ${ty * 0.5}px)`, offset: 0.3 },
-            { opacity: particleOpacity, transform: `scale(1) translate(${tx}px, ${ty}px)`, offset: 0.7 },
-            { opacity: 0, transform: `scale(0) translate(${tx}px, ${ty}px)` },
+            { opacity: 0, transform: 'translate(-50%, -50%) scale(0) rotate(0deg)' },
+            { opacity: 1, transform: `translate(calc(-50% + ${peakX * 0.35}px), calc(-50% + ${peakY * 0.55}px)) scale(1) rotate(${rotation * 0.2}deg)`, offset: 0.15 },
+            { opacity: 1, transform: `translate(calc(-50% + ${peakX}px), calc(-50% + ${peakY}px)) rotate(${rotation * 0.5}deg)`, offset: 0.45 },
+            { opacity: 0.9, transform: `translate(calc(-50% + ${endX * 0.9}px), calc(-50% + ${endY * 0.35}px)) rotate(${rotation * 0.8}deg)`, offset: 0.75 },
+            { opacity: 0, transform: `translate(calc(-50% + ${endX}px), calc(-50% + ${endY}px)) rotate(${rotation}deg)` },
         ], {
-            duration: 1100,
-            easing: 'cubic-bezier(0.4, 0, 0.2, 1)',
-            fill: 'forwards',
+            duration: 900 + Math.random() * 400,
+            delay: Math.random() * 100,
+            easing: 'cubic-bezier(0.2, 0.7, 0.3, 1)',
+            fill: 'both',
         });
     }
-    const ring = $('.animation-particle');
-    ring.style.position = 'absolute';
-    ring.style.left = '0';
-    ring.style.top = '0';
-    ring.style.width = `${rect.width}px`;
-    ring.style.height = `${rect.height}px`;
-    ring.style.borderRadius = '50%';
-    ring.style.border = '2px solid var(--vscode-focusBorder, #007acc)';
-    ring.style.boxSizing = 'border-box';
-    overlay.appendChild(ring);
-    ring.animate([
-        { transform: 'scale(1)', opacity: 1 },
-        { transform: 'scale(2)', opacity: 0 },
-    ], {
-        duration: 800,
-        easing: 'cubic-bezier(0.4, 0, 0.2, 1)',
-        fill: 'forwards',
-    });
-    cleanupOverlay(2000);
+    cleanupOverlay(overlay, 2000);
 }
 function triggerFloatingIconsAnimation(element, icon) {
-    const result = createOverlay(element);
-    if (!result) {
-        return;
-    }
-    const { overlay, cx, cy } = result;
+    const { overlay, cx, cy } = createOverlay(element);
     const rect = element.getBoundingClientRect();
     bounceElement(element, {
         translateY: [0, -6, 0],
@@ -194,14 +164,10 @@ function triggerFloatingIconsAnimation(element, icon) {
         easing: 'cubic-bezier(0.4, 0, 0.2, 1)',
         fill: 'forwards',
     });
-    cleanupOverlay(2000);
+    cleanupOverlay(overlay, 2000);
 }
 function triggerPulseWaveAnimation(element) {
-    const result = createOverlay(element);
-    if (!result) {
-        return;
-    }
-    const { overlay, cx, cy } = result;
+    const { overlay, cx, cy } = createOverlay(element);
     const rect = element.getBoundingClientRect();
     bounceElement(element, {
         scale: [1, 1.1, 1],
@@ -274,14 +240,10 @@ function triggerPulseWaveAnimation(element) {
         easing: 'cubic-bezier(0.4, 0, 0.2, 1)',
         fill: 'forwards',
     });
-    cleanupOverlay(2000);
+    cleanupOverlay(overlay, 2000);
 }
 function triggerRadiantLinesAnimation(element) {
-    const result = createOverlay(element);
-    if (!result) {
-        return;
-    }
-    const { overlay, cx, cy } = result;
+    const { overlay, cx, cy } = createOverlay(element);
     bounceElement(element, {
         scale: [1, 1.15, 1],
         duration: 350,
@@ -349,7 +311,7 @@ function triggerRadiantLinesAnimation(element) {
             fill: 'forwards',
         });
     }
-    cleanupOverlay(2000);
+    cleanupOverlay(overlay, 2000);
 }
 function triggerClickAnimation(element, animation, icon) {
     switch (animation) {

package/vscode/src/vs/base/browser/ui/breadcrumbs/breadcrumbsWidget.d.ts

@@ -21,6 +21,7 @@ export interface IBreadcrumbsItemEvent {
     payload: unknown;
 }
 export declare class BreadcrumbsWidget {
+    private readonly _measure;
     private readonly _disposables;
     private readonly _domNode;
     private readonly _scrollable;
@@ -39,8 +40,9 @@ export declare class BreadcrumbsWidget {
     private _selectedItemIdx;
     private _pendingDimLayout;
     private _pendingLayout;
+    private readonly _pendingReveal;
     private _dimension;
-    constructor(container: HTMLElement, horizontalScrollbarSize: number, horizontalScrollbarVisibility: ScrollbarVisibility | undefined, separatorIcon: ThemeIcon, styles: IBreadcrumbsWidgetStyles);
+    constructor(container: HTMLElement, horizontalScrollbarSize: number, horizontalScrollbarVisibility: ScrollbarVisibility | undefined, separatorIcon: ThemeIcon, styles: IBreadcrumbsWidgetStyles, _measure?: typeof dom.measure);
     setHorizontalScrollbarSize(size: number): void;
     setHorizontalScrollbarVisibility(visibility: ScrollbarVisibility): void;
     dispose(): void;
@@ -59,6 +61,7 @@ export declare class BreadcrumbsWidget {
     reveal(item: BreadcrumbsItem): void;
     revealLast(): void;
     private _reveal;
+    private _revealNode;
     getSelection(): BreadcrumbsItem;
     setSelection(item: BreadcrumbsItem | undefined, payload?: any): void;
     private _select;

package/vscode/src/vs/base/browser/ui/breadcrumbs/breadcrumbsWidget.js

@@ -1,12 +1,12 @@
 
 import { registerCss } from '../../../../../../../css.js';
-import { createElement, addStandardDisposableListener, trackFocus, Dimension, modify, getWindow, measure, isAncestorOfActiveElement, clearNode, $ } from '../../dom.js';
+import { measure, createElement, addStandardDisposableListener, trackFocus, Dimension, modify, getWindow, isAncestorOfActiveElement, clearNode, $ } from '../../dom.js';
 import { createStyleSheet } from '../../domStylesheets.js';
 import { DomScrollableElement } from '../scrollbar/scrollableElement.js';
 import { commonPrefixLength } from '../../../common/arrays.js';
 import { ThemeIcon } from '../../../common/themables.js';
 import { Emitter } from '../../../common/event.js';
-import { DisposableStore, dispose } from '../../../common/lifecycle.js';
+import { DisposableStore, MutableDisposable, dispose } from '../../../common/lifecycle.js';
 import { ScrollbarVisibility } from '../../../common/scrollable.js';
 import * as breadcrumbsWidget from './breadcrumbsWidget.css';
 
@@ -18,8 +18,10 @@ class BreadcrumbsWidget {
         horizontalScrollbarSize,
         horizontalScrollbarVisibility = ScrollbarVisibility.Auto,
         separatorIcon,
-        styles
+        styles,
+        _measure = measure
     ) {
+        this._measure = _measure;
         this._disposables = ( new DisposableStore());
         this._onDidSelectItem = ( new Emitter());
         this._onDidFocusItem = ( new Emitter());
@@ -33,6 +35,7 @@ class BreadcrumbsWidget {
         this._enabled = true;
         this._focusedItemIdx = -1;
         this._selectedItemIdx = -1;
+        this._pendingReveal = this._disposables.add(( new MutableDisposable()));
         this._domNode = createElement("div");
         this._domNode.className = "monaco-breadcrumbs";
         this._domNode.tabIndex = 0;
@@ -191,6 +194,7 @@ class BreadcrumbsWidget {
         this._reveal(this._items.length - 1, false);
     }
     _reveal(nth, minimal) {
+        this._pendingReveal.clear();
         if (nth < 0 || nth >= this._nodes.length) {
             return;
         }
@@ -198,16 +202,28 @@ class BreadcrumbsWidget {
         if (!node) {
             return;
         }
+        if (!minimal) {
+            this._pendingReveal.value = this._measure(getWindow(this._domNode), () => {
+                if (this._nodes[nth] === node) {
+                    this._revealNode(node, false);
+                }
+            });
+            return;
+        }
+        this._revealNode(node, true);
+    }
+    _revealNode(node, minimal) {
         const {
             width
         } = this._scrollable.getScrollDimensions();
         const {
             scrollLeft
         } = this._scrollable.getScrollPosition();
-        if (!minimal || node.offsetLeft > scrollLeft + width || node.offsetLeft < scrollLeft) {
+        const nodeOffsetLeft = node.offsetLeft;
+        if (!minimal || nodeOffsetLeft > scrollLeft + width || nodeOffsetLeft < scrollLeft) {
             this._scrollable.setRevealOnScroll(false);
             this._scrollable.setScrollPosition({
-                scrollLeft: node.offsetLeft
+                scrollLeft: nodeOffsetLeft
             });
             this._scrollable.setRevealOnScroll(true);
         }

package/vscode/src/vs/base/browser/ui/contextview/contextview.d.ts

@@ -32,11 +32,27 @@ export interface IDelegate {
     canRelayout?: boolean;
     onDOMEvent?(e: Event, activeElement: HTMLElement): void;
     onHide?(data?: unknown): void;
+    closeAnimation?: IContextViewCloseAnimation;
     /**
      * context views with higher layers are rendered higher in z-index order
      */
     layer?: number;
 }
+export interface IContextViewCloseAnimation {
+    readonly className: string;
+    readonly duration: number;
+    readonly requiredAncestorClasses?: readonly string[];
+}
+export declare const CONTEXT_VIEW_MENU_MOTION_CLASS = "context-view-menu-motion";
+export declare const CONTEXT_VIEW_MENU_MOTION_CLOSING_CLASS = "context-view-menu-motion-closing";
+export declare const CONTEXT_VIEW_MENU_MOTION_CLOSE_ANIMATION_DURATION = 150;
+export declare const CONTEXT_VIEW_MENU_MOTION_ANCESTOR_CLASSES: readonly [
+    "modern-ui",
+    "monaco-enable-motion"
+];
+export declare const CONTEXT_VIEW_CLOSE_ANIMATION_DURATION_VARIABLE = "--vscode-context-view-close-animation-duration";
+export declare const CONTEXT_VIEW_MENU_MOTION_SHADOW_VARIABLE = "--vscode-context-view-menu-motion-shadow";
+export declare const contextViewMenuCloseAnimation: IContextViewCloseAnimation;
 export interface IContextViewProvider {
     showContextView(delegate: IDelegate, container?: HTMLElement): void;
     hideContextView(): void;
@@ -53,6 +69,7 @@ export declare class ContextView extends Disposable {
     private delegate;
     private toDisposeOnClean;
     private toDisposeOnSetContainer;
+    private hidingContextView;
     private shadowRoot;
     private shadowRootHostElement;
     constructor(container: HTMLElement, domPosition: ContextViewDOMPosition);
@@ -61,8 +78,11 @@ export declare class ContextView extends Disposable {
     getViewElement(): HTMLElement;
     layout(): void;
     private doLayout;
-    hide(data?: unknown): void;
+    hide(data?: unknown, skipAnimation?: boolean): void;
     private isVisible;
+    private completeHideAnimation;
+    private prepareMenuCloseAnimation;
+    private hasRequiredAncestorClasses;
     private onDOMEvent;
     dispose(): void;
 }