monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/contextkeys.js

@@ -0,0 +1,21 @@
+import { isMacintosh, isLinux, isWindows, isWeb, isIOS, isMobile } from '../../../base/common/platform.js';
+import { localize } from '../../../nls.js';
+import { RawContextKey } from './contextkey.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+new RawContextKey('isMac', isMacintosh, localize(1684, "Whether the operating system is macOS"));
+new RawContextKey('isLinux', isLinux, localize(1685, "Whether the operating system is Linux"));
+const IsWindowsContext = new RawContextKey('isWindows', isWindows, localize(1686, "Whether the operating system is Windows"));
+const IsWebContext = new RawContextKey('isWeb', isWeb, localize(1687, "Whether the platform is a web browser"));
+new RawContextKey('isMacNative', isMacintosh && !isWeb, localize(1688, "Whether the operating system is macOS on a non-browser platform"));
+new RawContextKey('isIOS', isIOS, localize(1689, "Whether the operating system is iOS"));
+new RawContextKey('isMobile', isMobile, localize(1690, "Whether the platform is a mobile web browser"));
+new RawContextKey('isDevelopment', false, true);
+new RawContextKey('productQualityType', '', localize(1691, "Quality type of VS Code"));
+const InputFocusedContextKey = 'inputFocus';
+const InputFocusedContext = new RawContextKey(InputFocusedContextKey, false, localize(1692, "Whether keyboard focus is inside an input box"));
+
+export { InputFocusedContext, InputFocusedContextKey, IsWebContext, IsWindowsContext };

package/dist/workers/contextmenu.js

@@ -0,0 +1,334 @@
+import { getShadowRoot, getDomNodePagePosition } from '../../../../base/browser/dom.js';
+import { ActionViewItem } from '../../../../base/browser/ui/actionbar/actionViewItems.js';
+import { SubmenuAction, Separator } from '../../../../base/common/actions.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { isIOS } from '../../../../base/common/platform.js';
+import { registerEditorContribution, registerEditorAction, EditorAction } from '../../../browser/editorExtensions.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { localize, localize2 } from '../../../../nls.js';
+import { SubmenuItemAction, IMenuService } from '../../../../platform/actions/common/actions.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IContextMenuService, IContextViewService } from '../../../../platform/contextview/browser/contextView.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { isStandaloneEditorWorkspace, IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var ContextMenuController_1;
+let ContextMenuController = class ContextMenuController {
+    static { ContextMenuController_1 = this; }
+    static { this.ID = 'editor.contrib.contextmenu'; }
+    static get(editor) {
+        return editor.getContribution(ContextMenuController_1.ID);
+    }
+    constructor(editor, _contextMenuService, _contextViewService, _contextKeyService, _keybindingService, _menuService, _configurationService, _workspaceContextService) {
+        this._contextMenuService = _contextMenuService;
+        this._contextViewService = _contextViewService;
+        this._contextKeyService = _contextKeyService;
+        this._keybindingService = _keybindingService;
+        this._menuService = _menuService;
+        this._configurationService = _configurationService;
+        this._workspaceContextService = _workspaceContextService;
+        this._toDispose = new DisposableStore();
+        this._contextMenuIsBeingShownCount = 0;
+        this._editor = editor;
+        this._toDispose.add(this._editor.onContextMenu((e) => this._onContextMenu(e)));
+        this._toDispose.add(this._editor.onMouseWheel((e) => {
+            if (this._contextMenuIsBeingShownCount > 0) {
+                const view = this._contextViewService.getContextViewElement();
+                const target = e.srcElement;
+                // Event triggers on shadow root host first
+                // Check if the context view is under this host before hiding it #103169
+                if (!(target.shadowRoot && getShadowRoot(view) === target.shadowRoot)) {
+                    this._contextViewService.hideContextView();
+                }
+            }
+        }));
+        this._toDispose.add(this._editor.onKeyDown((e) => {
+            if (!this._editor.getOption(30 /* EditorOption.contextmenu */)) {
+                return; // Context menu is turned off through configuration
+            }
+            if (e.keyCode === 58 /* KeyCode.ContextMenu */) {
+                // Chrome is funny like that
+                e.preventDefault();
+                e.stopPropagation();
+                this.showContextMenu();
+            }
+        }));
+    }
+    _onContextMenu(e) {
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        if (!this._editor.getOption(30 /* EditorOption.contextmenu */)) {
+            this._editor.focus();
+            // Ensure the cursor is at the position of the mouse click
+            if (e.target.position && !this._editor.getSelection().containsPosition(e.target.position)) {
+                this._editor.setPosition(e.target.position);
+            }
+            return; // Context menu is turned off through configuration
+        }
+        if (e.target.type === 12 /* MouseTargetType.OVERLAY_WIDGET */) {
+            return; // allow native menu on widgets to support right click on input field for example in find
+        }
+        if (e.target.type === 6 /* MouseTargetType.CONTENT_TEXT */ && e.target.detail.injectedText) {
+            return; // allow native menu on injected text
+        }
+        e.event.preventDefault();
+        e.event.stopPropagation();
+        if (e.target.type === 11 /* MouseTargetType.SCROLLBAR */) {
+            return this._showScrollbarContextMenu(e.event);
+        }
+        if (e.target.type !== 6 /* MouseTargetType.CONTENT_TEXT */ && e.target.type !== 7 /* MouseTargetType.CONTENT_EMPTY */ && e.target.type !== 1 /* MouseTargetType.TEXTAREA */) {
+            return; // only support mouse click into text or native context menu key for now
+        }
+        // Ensure the editor gets focus if it hasn't, so the right events are being sent to other contributions
+        this._editor.focus();
+        // Ensure the cursor is at the position of the mouse click
+        if (e.target.position) {
+            let hasSelectionAtPosition = false;
+            for (const selection of this._editor.getSelections()) {
+                if (selection.containsPosition(e.target.position)) {
+                    hasSelectionAtPosition = true;
+                    break;
+                }
+            }
+            if (!hasSelectionAtPosition) {
+                this._editor.setPosition(e.target.position);
+            }
+        }
+        // Unless the user triggerd the context menu through Shift+F10, use the mouse position as menu position
+        let anchor = null;
+        if (e.target.type !== 1 /* MouseTargetType.TEXTAREA */) {
+            anchor = e.event;
+        }
+        // Show the context menu
+        this.showContextMenu(anchor);
+    }
+    showContextMenu(anchor) {
+        if (!this._editor.getOption(30 /* EditorOption.contextmenu */)) {
+            return; // Context menu is turned off through configuration
+        }
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        // Find actions available for menu
+        const menuActions = this._getMenuActions(this._editor.getModel(), this._editor.contextMenuId);
+        // Show menu if we have actions to show
+        if (menuActions.length > 0) {
+            this._doShowContextMenu(menuActions, anchor);
+        }
+    }
+    _getMenuActions(model, menuId) {
+        const result = [];
+        // get menu groups
+        const groups = this._menuService.getMenuActions(menuId, this._contextKeyService, { arg: model.uri });
+        // translate them into other actions
+        for (const group of groups) {
+            const [, actions] = group;
+            let addedItems = 0;
+            for (const action of actions) {
+                if (action instanceof SubmenuItemAction) {
+                    const subActions = this._getMenuActions(model, action.item.submenu);
+                    if (subActions.length > 0) {
+                        result.push(new SubmenuAction(action.id, action.label, subActions));
+                        addedItems++;
+                    }
+                }
+                else {
+                    result.push(action);
+                    addedItems++;
+                }
+            }
+            if (addedItems) {
+                result.push(new Separator());
+            }
+        }
+        if (result.length) {
+            result.pop(); // remove last separator
+        }
+        return result;
+    }
+    _doShowContextMenu(actions, event = null) {
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        let anchor = event;
+        if (!anchor) {
+            // Ensure selection is visible
+            this._editor.revealPosition(this._editor.getPosition(), 1 /* ScrollType.Immediate */);
+            this._editor.render();
+            const cursorCoords = this._editor.getScrolledVisiblePosition(this._editor.getPosition());
+            // Translate to absolute editor position
+            const editorCoords = getDomNodePagePosition(this._editor.getDomNode());
+            const posx = editorCoords.left + cursorCoords.left;
+            const posy = editorCoords.top + cursorCoords.top + cursorCoords.height;
+            anchor = { x: posx, y: posy };
+        }
+        const useShadowDOM = this._editor.getOption(144 /* EditorOption.useShadowDOM */) && !isIOS; // Do not use shadow dom on IOS #122035
+        // Show menu
+        this._contextMenuIsBeingShownCount++;
+        this._contextMenuService.showContextMenu({
+            domForShadowRoot: useShadowDOM ? this._editor.getOverflowWidgetsDomNode() ?? this._editor.getDomNode() : undefined,
+            getAnchor: () => anchor,
+            getActions: () => actions,
+            getActionViewItem: (action) => {
+                const keybinding = this._keybindingFor(action);
+                if (keybinding) {
+                    return new ActionViewItem(action, action, { label: true, keybinding: keybinding.getLabel(), isMenu: true });
+                }
+                const customAction = action;
+                if (typeof customAction.getActionViewItem === 'function') {
+                    return customAction.getActionViewItem();
+                }
+                return new ActionViewItem(action, action, { icon: true, label: true, isMenu: true });
+            },
+            getKeyBinding: (action) => {
+                return this._keybindingFor(action);
+            },
+            onHide: (wasCancelled) => {
+                this._contextMenuIsBeingShownCount--;
+            }
+        });
+    }
+    _showScrollbarContextMenu(anchor) {
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        if (isStandaloneEditorWorkspace(this._workspaceContextService.getWorkspace())) {
+            // can't update the configuration properly in the standalone editor
+            return;
+        }
+        const minimapOptions = this._editor.getOption(81 /* EditorOption.minimap */);
+        let lastId = 0;
+        const createAction = (opts) => {
+            return {
+                id: `menu-action-${++lastId}`,
+                label: opts.label,
+                tooltip: '',
+                class: undefined,
+                enabled: (typeof opts.enabled === 'undefined' ? true : opts.enabled),
+                checked: opts.checked,
+                run: opts.run
+            };
+        };
+        const createSubmenuAction = (label, actions) => {
+            return new SubmenuAction(`menu-action-${++lastId}`, label, actions, undefined);
+        };
+        const createEnumAction = (label, enabled, configName, configuredValue, options) => {
+            if (!enabled) {
+                return createAction({ label, enabled, run: () => { } });
+            }
+            const createRunner = (value) => {
+                return () => {
+                    this._configurationService.updateValue(configName, value);
+                };
+            };
+            const actions = [];
+            for (const option of options) {
+                actions.push(createAction({
+                    label: option.label,
+                    checked: configuredValue === option.value,
+                    run: createRunner(option.value)
+                }));
+            }
+            return createSubmenuAction(label, actions);
+        };
+        const actions = [];
+        actions.push(createAction({
+            label: localize(901, "Minimap"),
+            checked: minimapOptions.enabled,
+            run: () => {
+                this._configurationService.updateValue(`editor.minimap.enabled`, !minimapOptions.enabled);
+            }
+        }));
+        actions.push(new Separator());
+        actions.push(createAction({
+            label: localize(902, "Render Characters"),
+            enabled: minimapOptions.enabled,
+            checked: minimapOptions.renderCharacters,
+            run: () => {
+                this._configurationService.updateValue(`editor.minimap.renderCharacters`, !minimapOptions.renderCharacters);
+            }
+        }));
+        actions.push(createEnumAction(localize(903, "Vertical size"), minimapOptions.enabled, 'editor.minimap.size', minimapOptions.size, [{
+                label: localize(904, "Proportional"),
+                value: 'proportional'
+            }, {
+                label: localize(905, "Fill"),
+                value: 'fill'
+            }, {
+                label: localize(906, "Fit"),
+                value: 'fit'
+            }]));
+        actions.push(createEnumAction(localize(907, "Slider"), minimapOptions.enabled, 'editor.minimap.showSlider', minimapOptions.showSlider, [{
+                label: localize(908, "Mouse Over"),
+                value: 'mouseover'
+            }, {
+                label: localize(909, "Always"),
+                value: 'always'
+            }]));
+        const useShadowDOM = this._editor.getOption(144 /* EditorOption.useShadowDOM */) && !isIOS; // Do not use shadow dom on IOS #122035
+        this._contextMenuIsBeingShownCount++;
+        this._contextMenuService.showContextMenu({
+            domForShadowRoot: useShadowDOM ? this._editor.getDomNode() : undefined,
+            getAnchor: () => anchor,
+            getActions: () => actions,
+            onHide: (wasCancelled) => {
+                this._contextMenuIsBeingShownCount--;
+                this._editor.focus();
+            }
+        });
+    }
+    _keybindingFor(action) {
+        return this._keybindingService.lookupKeybinding(action.id);
+    }
+    dispose() {
+        if (this._contextMenuIsBeingShownCount > 0) {
+            this._contextViewService.hideContextView();
+        }
+        this._toDispose.dispose();
+    }
+};
+ContextMenuController = ContextMenuController_1 = __decorate([
+    __param(1, IContextMenuService),
+    __param(2, IContextViewService),
+    __param(3, IContextKeyService),
+    __param(4, IKeybindingService),
+    __param(5, IMenuService),
+    __param(6, IConfigurationService),
+    __param(7, IWorkspaceContextService)
+], ContextMenuController);
+class ShowContextMenu extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.showContextMenu',
+            label: localize2(910, "Show Editor Context Menu"),
+            precondition: undefined,
+            kbOpts: {
+                kbExpr: EditorContextKeys.textInputFocus,
+                primary: 1024 /* KeyMod.Shift */ | 68 /* KeyCode.F10 */,
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            }
+        });
+    }
+    run(accessor, editor) {
+        ContextMenuController.get(editor)?.showContextMenu();
+    }
+}
+registerEditorContribution(ContextMenuController.ID, ContextMenuController, 2 /* EditorContributionInstantiation.BeforeFirstInteraction */);
+registerEditorAction(ShowContextMenu);
+
+export { ContextMenuController };

package/dist/workers/contextview.js

@@ -0,0 +1,298 @@
+import { BrowserFeatures } from '../../canIUse.js';
+import { $, hide, addStandardDisposableListener, clearNode, show, isHTMLElement, getDomNodePagePosition, getDomNodeZoomLevel, getTotalWidth, getTotalHeight, getActiveWindow, getWindow, isAncestor } from '../../dom.js';
+import { Disposable, toDisposable, DisposableStore } from '../../../common/lifecycle.js';
+import { isIOS } from '../../../common/platform.js';
+import { Range } from '../../../common/range.js';
+import './contextview.css';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function isAnchor(obj) {
+    const anchor = obj;
+    return !!anchor && typeof anchor.x === 'number' && typeof anchor.y === 'number';
+}
+var LayoutAnchorMode;
+(function (LayoutAnchorMode) {
+    LayoutAnchorMode[LayoutAnchorMode["AVOID"] = 0] = "AVOID";
+    LayoutAnchorMode[LayoutAnchorMode["ALIGN"] = 1] = "ALIGN";
+})(LayoutAnchorMode || (LayoutAnchorMode = {}));
+/**
+ * Lays out a one dimensional view next to an anchor in a viewport.
+ *
+ * @returns The view offset within the viewport.
+ */
+function layout(viewportSize, viewSize, anchor) {
+    const layoutAfterAnchorBoundary = anchor.mode === LayoutAnchorMode.ALIGN ? anchor.offset : anchor.offset + anchor.size;
+    const layoutBeforeAnchorBoundary = anchor.mode === LayoutAnchorMode.ALIGN ? anchor.offset + anchor.size : anchor.offset;
+    if (anchor.position === 0 /* LayoutAnchorPosition.Before */) {
+        if (viewSize <= viewportSize - layoutAfterAnchorBoundary) {
+            return layoutAfterAnchorBoundary; // happy case, lay it out after the anchor
+        }
+        if (viewSize <= layoutBeforeAnchorBoundary) {
+            return layoutBeforeAnchorBoundary - viewSize; // ok case, lay it out before the anchor
+        }
+        return Math.max(viewportSize - viewSize, 0); // sad case, lay it over the anchor
+    }
+    else {
+        if (viewSize <= layoutBeforeAnchorBoundary) {
+            return layoutBeforeAnchorBoundary - viewSize; // happy case, lay it out before the anchor
+        }
+        if (viewSize <= viewportSize - layoutAfterAnchorBoundary) {
+            return layoutAfterAnchorBoundary; // ok case, lay it out after the anchor
+        }
+        return 0; // sad case, lay it over the anchor
+    }
+}
+class ContextView extends Disposable {
+    static { this.BUBBLE_UP_EVENTS = ['click', 'keydown', 'focus', 'blur']; }
+    static { this.BUBBLE_DOWN_EVENTS = ['click']; }
+    constructor(container, domPosition) {
+        super();
+        this.container = null;
+        this.useFixedPosition = false;
+        this.useShadowDOM = false;
+        this.delegate = null;
+        this.toDisposeOnClean = Disposable.None;
+        this.toDisposeOnSetContainer = Disposable.None;
+        this.shadowRoot = null;
+        this.shadowRootHostElement = null;
+        this.view = $('.context-view');
+        hide(this.view);
+        this.setContainer(container, domPosition);
+        this._register(toDisposable(() => this.setContainer(null, 1 /* ContextViewDOMPosition.ABSOLUTE */)));
+    }
+    setContainer(container, domPosition) {
+        this.useFixedPosition = domPosition !== 1 /* ContextViewDOMPosition.ABSOLUTE */;
+        const usedShadowDOM = this.useShadowDOM;
+        this.useShadowDOM = domPosition === 3 /* ContextViewDOMPosition.FIXED_SHADOW */;
+        if (container === this.container && usedShadowDOM === this.useShadowDOM) {
+            return; // container is the same and no shadow DOM usage has changed
+        }
+        if (this.container) {
+            this.toDisposeOnSetContainer.dispose();
+            this.view.remove();
+            if (this.shadowRoot) {
+                this.shadowRoot = null;
+                this.shadowRootHostElement?.remove();
+                this.shadowRootHostElement = null;
+            }
+            this.container = null;
+        }
+        if (container) {
+            this.container = container;
+            if (this.useShadowDOM) {
+                this.shadowRootHostElement = $('.shadow-root-host');
+                this.container.appendChild(this.shadowRootHostElement);
+                this.shadowRoot = this.shadowRootHostElement.attachShadow({ mode: 'open' });
+                const style = document.createElement('style');
+                style.textContent = SHADOW_ROOT_CSS;
+                this.shadowRoot.appendChild(style);
+                this.shadowRoot.appendChild(this.view);
+                this.shadowRoot.appendChild($('slot'));
+            }
+            else {
+                this.container.appendChild(this.view);
+            }
+            const toDisposeOnSetContainer = new DisposableStore();
+            ContextView.BUBBLE_UP_EVENTS.forEach(event => {
+                toDisposeOnSetContainer.add(addStandardDisposableListener(this.container, event, e => {
+                    this.onDOMEvent(e, false);
+                }));
+            });
+            ContextView.BUBBLE_DOWN_EVENTS.forEach(event => {
+                toDisposeOnSetContainer.add(addStandardDisposableListener(this.container, event, e => {
+                    this.onDOMEvent(e, true);
+                }, true));
+            });
+            this.toDisposeOnSetContainer = toDisposeOnSetContainer;
+        }
+    }
+    show(delegate) {
+        if (this.isVisible()) {
+            this.hide();
+        }
+        // Show static box
+        clearNode(this.view);
+        this.view.className = 'context-view monaco-component';
+        this.view.style.top = '0px';
+        this.view.style.left = '0px';
+        this.view.style.zIndex = `${2575 + (delegate.layer ?? 0)}`;
+        this.view.style.position = this.useFixedPosition ? 'fixed' : 'absolute';
+        show(this.view);
+        // Render content
+        this.toDisposeOnClean = delegate.render(this.view) || Disposable.None;
+        // Set active delegate
+        this.delegate = delegate;
+        // Layout
+        this.doLayout();
+        // Focus
+        this.delegate.focus?.();
+    }
+    getViewElement() {
+        return this.view;
+    }
+    layout() {
+        if (!this.isVisible()) {
+            return;
+        }
+        if (this.delegate.canRelayout === false && !(isIOS && BrowserFeatures.pointerEvents)) {
+            this.hide();
+            return;
+        }
+        this.delegate?.layout?.();
+        this.doLayout();
+    }
+    doLayout() {
+        // Check that we still have a delegate - this.delegate.layout may have hidden
+        if (!this.isVisible()) {
+            return;
+        }
+        // Get anchor
+        const anchor = this.delegate.getAnchor();
+        // Compute around
+        let around;
+        // Get the element's position and size (to anchor the view)
+        if (isHTMLElement(anchor)) {
+            const elementPosition = getDomNodePagePosition(anchor);
+            // In areas where zoom is applied to the element or its ancestors, we need to adjust the size of the element
+            // e.g. The title bar has counter zoom behavior meaning it applies the inverse of zoom level.
+            // Window Zoom Level: 1.5, Title Bar Zoom: 1/1.5, Size Multiplier: 1.5
+            const zoom = getDomNodeZoomLevel(anchor);
+            around = {
+                top: elementPosition.top * zoom,
+                left: elementPosition.left * zoom,
+                width: elementPosition.width * zoom,
+                height: elementPosition.height * zoom
+            };
+        }
+        else if (isAnchor(anchor)) {
+            around = {
+                top: anchor.y,
+                left: anchor.x,
+                width: anchor.width || 1,
+                height: anchor.height || 2
+            };
+        }
+        else {
+            around = {
+                top: anchor.posy,
+                left: anchor.posx,
+                // We are about to position the context view where the mouse
+                // cursor is. To prevent the view being exactly under the mouse
+                // when showing and thus potentially triggering an action within,
+                // we treat the mouse location like a small sized block element.
+                width: 2,
+                height: 2
+            };
+        }
+        const viewSizeWidth = getTotalWidth(this.view);
+        const viewSizeHeight = getTotalHeight(this.view);
+        const anchorPosition = this.delegate.anchorPosition ?? 0 /* AnchorPosition.BELOW */;
+        const anchorAlignment = this.delegate.anchorAlignment ?? 0 /* AnchorAlignment.LEFT */;
+        const anchorAxisAlignment = this.delegate.anchorAxisAlignment ?? 0 /* AnchorAxisAlignment.VERTICAL */;
+        let top;
+        let left;
+        const activeWindow = getActiveWindow();
+        if (anchorAxisAlignment === 0 /* AnchorAxisAlignment.VERTICAL */) {
+            const verticalAnchor = { offset: around.top - activeWindow.pageYOffset, size: around.height, position: anchorPosition === 0 /* AnchorPosition.BELOW */ ? 0 /* LayoutAnchorPosition.Before */ : 1 /* LayoutAnchorPosition.After */ };
+            const horizontalAnchor = { offset: around.left, size: around.width, position: anchorAlignment === 0 /* AnchorAlignment.LEFT */ ? 0 /* LayoutAnchorPosition.Before */ : 1 /* LayoutAnchorPosition.After */, mode: LayoutAnchorMode.ALIGN };
+            top = layout(activeWindow.innerHeight, viewSizeHeight, verticalAnchor) + activeWindow.pageYOffset;
+            // if view intersects vertically with anchor,  we must avoid the anchor
+            if (Range.intersects({ start: top, end: top + viewSizeHeight }, { start: verticalAnchor.offset, end: verticalAnchor.offset + verticalAnchor.size })) {
+                horizontalAnchor.mode = LayoutAnchorMode.AVOID;
+            }
+            left = layout(activeWindow.innerWidth, viewSizeWidth, horizontalAnchor);
+        }
+        else {
+            const horizontalAnchor = { offset: around.left, size: around.width, position: anchorAlignment === 0 /* AnchorAlignment.LEFT */ ? 0 /* LayoutAnchorPosition.Before */ : 1 /* LayoutAnchorPosition.After */ };
+            const verticalAnchor = { offset: around.top, size: around.height, position: anchorPosition === 0 /* AnchorPosition.BELOW */ ? 0 /* LayoutAnchorPosition.Before */ : 1 /* LayoutAnchorPosition.After */, mode: LayoutAnchorMode.ALIGN };
+            left = layout(activeWindow.innerWidth, viewSizeWidth, horizontalAnchor);
+            // if view intersects horizontally with anchor, we must avoid the anchor
+            if (Range.intersects({ start: left, end: left + viewSizeWidth }, { start: horizontalAnchor.offset, end: horizontalAnchor.offset + horizontalAnchor.size })) {
+                verticalAnchor.mode = LayoutAnchorMode.AVOID;
+            }
+            top = layout(activeWindow.innerHeight, viewSizeHeight, verticalAnchor) + activeWindow.pageYOffset;
+        }
+        this.view.classList.remove('top', 'bottom', 'left', 'right');
+        this.view.classList.add(anchorPosition === 0 /* AnchorPosition.BELOW */ ? 'bottom' : 'top');
+        this.view.classList.add(anchorAlignment === 0 /* AnchorAlignment.LEFT */ ? 'left' : 'right');
+        this.view.classList.toggle('fixed', this.useFixedPosition);
+        const containerPosition = getDomNodePagePosition(this.container);
+        // Account for container scroll when positioning the context view
+        const containerScrollTop = this.container.scrollTop || 0;
+        const containerScrollLeft = this.container.scrollLeft || 0;
+        this.view.style.top = `${top - (this.useFixedPosition ? getDomNodePagePosition(this.view).top : containerPosition.top) + containerScrollTop}px`;
+        this.view.style.left = `${left - (this.useFixedPosition ? getDomNodePagePosition(this.view).left : containerPosition.left) + containerScrollLeft}px`;
+        this.view.style.width = 'initial';
+    }
+    hide(data) {
+        const delegate = this.delegate;
+        this.delegate = null;
+        if (delegate?.onHide) {
+            delegate.onHide(data);
+        }
+        this.toDisposeOnClean.dispose();
+        hide(this.view);
+    }
+    isVisible() {
+        return !!this.delegate;
+    }
+    onDOMEvent(e, onCapture) {
+        if (this.delegate) {
+            if (this.delegate.onDOMEvent) {
+                this.delegate.onDOMEvent(e, getWindow(e).document.activeElement);
+            }
+            else if (onCapture && !isAncestor(e.target, this.container)) {
+                this.hide();
+            }
+        }
+    }
+    dispose() {
+        this.hide();
+        super.dispose();
+    }
+}
+const SHADOW_ROOT_CSS = /* css */ `
+	:host {
+		all: initial; /* 1st rule so subsequent properties are reset. */
+	}
+
+	.codicon[class*='codicon-'] {
+		font: normal normal normal 16px/1 codicon;
+		display: inline-block;
+		text-decoration: none;
+		text-rendering: auto;
+		text-align: center;
+		-webkit-font-smoothing: antialiased;
+		-moz-osx-font-smoothing: grayscale;
+		user-select: none;
+		-webkit-user-select: none;
+		-ms-user-select: none;
+	}
+
+	:host {
+		font-family: -apple-system, BlinkMacSystemFont, "Segoe WPC", "Segoe UI", "HelveticaNeue-Light", system-ui, "Ubuntu", "Droid Sans", sans-serif;
+	}
+
+	:host-context(.mac) { font-family: -apple-system, BlinkMacSystemFont, sans-serif; }
+	:host-context(.mac:lang(zh-Hans)) { font-family: -apple-system, BlinkMacSystemFont, "PingFang SC", "Hiragino Sans GB", sans-serif; }
+	:host-context(.mac:lang(zh-Hant)) { font-family: -apple-system, BlinkMacSystemFont, "PingFang TC", sans-serif; }
+	:host-context(.mac:lang(ja)) { font-family: -apple-system, BlinkMacSystemFont, "Hiragino Kaku Gothic Pro", sans-serif; }
+	:host-context(.mac:lang(ko)) { font-family: -apple-system, BlinkMacSystemFont, "Apple SD Gothic Neo", "Nanum Gothic", "AppleGothic", sans-serif; }
+
+	:host-context(.windows) { font-family: "Segoe WPC", "Segoe UI", sans-serif; }
+	:host-context(.windows:lang(zh-Hans)) { font-family: "Segoe WPC", "Segoe UI", "Microsoft YaHei", sans-serif; }
+	:host-context(.windows:lang(zh-Hant)) { font-family: "Segoe WPC", "Segoe UI", "Microsoft Jhenghei", sans-serif; }
+	:host-context(.windows:lang(ja)) { font-family: "Segoe WPC", "Segoe UI", "Yu Gothic UI", "Meiryo UI", sans-serif; }
+	:host-context(.windows:lang(ko)) { font-family: "Segoe WPC", "Segoe UI", "Malgun Gothic", "Dotom", sans-serif; }
+
+	:host-context(.linux) { font-family: system-ui, "Ubuntu", "Droid Sans", sans-serif; }
+	:host-context(.linux:lang(zh-Hans)) { font-family: system-ui, "Ubuntu", "Droid Sans", "Source Han Sans SC", "Source Han Sans CN", "Source Han Sans", sans-serif; }
+	:host-context(.linux:lang(zh-Hant)) { font-family: system-ui, "Ubuntu", "Droid Sans", "Source Han Sans TC", "Source Han Sans TW", "Source Han Sans", sans-serif; }
+	:host-context(.linux:lang(ja)) { font-family: system-ui, "Ubuntu", "Droid Sans", "Source Han Sans J", "Source Han Sans JP", "Source Han Sans", sans-serif; }
+	:host-context(.linux:lang(ko)) { font-family: system-ui, "Ubuntu", "Droid Sans", "Source Han Sans K", "Source Han Sans JR", "Source Han Sans", "UnDotum", "FBaekmuk Gulim", sans-serif; }
+`;
+
+export { ContextView, LayoutAnchorMode, isAnchor, layout };