@angular/material 10.0.0-rc.3 → 10.1.0

package/esm2015/menu/menu-trigger.js

@@ -35,448 +35,445 @@ export const MENU_PANEL_TOP_PADDING = 8;
 const passiveEventListenerOptions = normalizePassiveListenerOptions({ passive: true });
 // TODO(andrewseguin): Remove the kebab versions in favor of camelCased attribute selectors
 /** Directive applied to an element that should trigger a `mat-menu`. */
-let MatMenuTrigger = /** @class */ (() => {
-    class MatMenuTrigger {
-        constructor(_overlay, _element, _viewContainerRef, scrollStrategy, _parentMenu, _menuItemInstance, _dir, 
-        // TODO(crisbeto): make the _focusMonitor required when doing breaking changes.
-        // @breaking-change 8.0.0
-        _focusMonitor) {
-            this._overlay = _overlay;
-            this._element = _element;
-            this._viewContainerRef = _viewContainerRef;
-            this._parentMenu = _parentMenu;
-            this._menuItemInstance = _menuItemInstance;
-            this._dir = _dir;
-            this._focusMonitor = _focusMonitor;
-            this._overlayRef = null;
-            this._menuOpen = false;
-            this._closingActionsSubscription = Subscription.EMPTY;
-            this._hoverSubscription = Subscription.EMPTY;
-            this._menuCloseSubscription = Subscription.EMPTY;
-            /**
-             * Handles touch start events on the trigger.
-             * Needs to be an arrow function so we can easily use addEventListener and removeEventListener.
-             */
-            this._handleTouchStart = () => this._openedBy = 'touch';
-            // Tracking input type is necessary so it's possible to only auto-focus
-            // the first item of the list when the menu is opened via the keyboard
-            this._openedBy = null;
-            /**
-             * Whether focus should be restored when the menu is closed.
-             * Note that disabling this option can have accessibility implications
-             * and it's up to you to manage focus, if you decide to turn it off.
-             */
-            this.restoreFocus = true;
-            /** Event emitted when the associated menu is opened. */
-            this.menuOpened = new EventEmitter();
-            /**
-             * Event emitted when the associated menu is opened.
-             * @deprecated Switch to `menuOpened` instead
-             * @breaking-change 8.0.0
-             */
-            // tslint:disable-next-line:no-output-on-prefix
-            this.onMenuOpen = this.menuOpened;
-            /** Event emitted when the associated menu is closed. */
-            this.menuClosed = new EventEmitter();
-            /**
-             * Event emitted when the associated menu is closed.
-             * @deprecated Switch to `menuClosed` instead
-             * @breaking-change 8.0.0
-             */
-            // tslint:disable-next-line:no-output-on-prefix
-            this.onMenuClose = this.menuClosed;
-            _element.nativeElement.addEventListener('touchstart', this._handleTouchStart, passiveEventListenerOptions);
-            if (_menuItemInstance) {
-                _menuItemInstance._triggersSubmenu = this.triggersSubmenu();
-            }
-            this._scrollStrategy = scrollStrategy;
-        }
+export class MatMenuTrigger {
+    constructor(_overlay, _element, _viewContainerRef, scrollStrategy, _parentMenu, _menuItemInstance, _dir, 
+    // TODO(crisbeto): make the _focusMonitor required when doing breaking changes.
+    // @breaking-change 8.0.0
+    _focusMonitor) {
+        this._overlay = _overlay;
+        this._element = _element;
+        this._viewContainerRef = _viewContainerRef;
+        this._parentMenu = _parentMenu;
+        this._menuItemInstance = _menuItemInstance;
+        this._dir = _dir;
+        this._focusMonitor = _focusMonitor;
+        this._overlayRef = null;
+        this._menuOpen = false;
+        this._closingActionsSubscription = Subscription.EMPTY;
+        this._hoverSubscription = Subscription.EMPTY;
+        this._menuCloseSubscription = Subscription.EMPTY;
+        /**
+         * Handles touch start events on the trigger.
+         * Needs to be an arrow function so we can easily use addEventListener and removeEventListener.
+         */
+        this._handleTouchStart = () => this._openedBy = 'touch';
+        // Tracking input type is necessary so it's possible to only auto-focus
+        // the first item of the list when the menu is opened via the keyboard
+        this._openedBy = null;
+        /**
+         * Whether focus should be restored when the menu is closed.
+         * Note that disabling this option can have accessibility implications
+         * and it's up to you to manage focus, if you decide to turn it off.
+         */
+        this.restoreFocus = true;
+        /** Event emitted when the associated menu is opened. */
+        this.menuOpened = new EventEmitter();
         /**
-         * @deprecated
+         * Event emitted when the associated menu is opened.
+         * @deprecated Switch to `menuOpened` instead
          * @breaking-change 8.0.0
          */
-        get _deprecatedMatMenuTriggerFor() { return this.menu; }
-        set _deprecatedMatMenuTriggerFor(v) {
-            this.menu = v;
-        }
-        /** References the menu instance that the trigger is associated with. */
-        get menu() { return this._menu; }
-        set menu(menu) {
-            if (menu === this._menu) {
-                return;
-            }
-            this._menu = menu;
-            this._menuCloseSubscription.unsubscribe();
-            if (menu) {
-                this._menuCloseSubscription = menu.close.asObservable().subscribe(reason => {
-                    this._destroyMenu();
-                    // If a click closed the menu, we should close the entire chain of nested menus.
-                    if ((reason === 'click' || reason === 'tab') && this._parentMenu) {
-                        this._parentMenu.closed.emit(reason);
-                    }
-                });
-            }
+        // tslint:disable-next-line:no-output-on-prefix
+        this.onMenuOpen = this.menuOpened;
+        /** Event emitted when the associated menu is closed. */
+        this.menuClosed = new EventEmitter();
+        /**
+         * Event emitted when the associated menu is closed.
+         * @deprecated Switch to `menuClosed` instead
+         * @breaking-change 8.0.0
+         */
+        // tslint:disable-next-line:no-output-on-prefix
+        this.onMenuClose = this.menuClosed;
+        _element.nativeElement.addEventListener('touchstart', this._handleTouchStart, passiveEventListenerOptions);
+        if (_menuItemInstance) {
+            _menuItemInstance._triggersSubmenu = this.triggersSubmenu();
         }
-        ngAfterContentInit() {
-            this._checkMenu();
-            this._handleHover();
+        this._scrollStrategy = scrollStrategy;
+    }
+    /**
+     * @deprecated
+     * @breaking-change 8.0.0
+     */
+    get _deprecatedMatMenuTriggerFor() { return this.menu; }
+    set _deprecatedMatMenuTriggerFor(v) {
+        this.menu = v;
+    }
+    /** References the menu instance that the trigger is associated with. */
+    get menu() { return this._menu; }
+    set menu(menu) {
+        if (menu === this._menu) {
+            return;
         }
-        ngOnDestroy() {
-            if (this._overlayRef) {
-                this._overlayRef.dispose();
-                this._overlayRef = null;
-            }
-            this._element.nativeElement.removeEventListener('touchstart', this._handleTouchStart, passiveEventListenerOptions);
-            this._menuCloseSubscription.unsubscribe();
-            this._closingActionsSubscription.unsubscribe();
-            this._hoverSubscription.unsubscribe();
+        this._menu = menu;
+        this._menuCloseSubscription.unsubscribe();
+        if (menu) {
+            this._menuCloseSubscription = menu.close.asObservable().subscribe(reason => {
+                this._destroyMenu();
+                // If a click closed the menu, we should close the entire chain of nested menus.
+                if ((reason === 'click' || reason === 'tab') && this._parentMenu) {
+                    this._parentMenu.closed.emit(reason);
+                }
+            });
         }
-        /** Whether the menu is open. */
-        get menuOpen() {
-            return this._menuOpen;
+    }
+    ngAfterContentInit() {
+        this._checkMenu();
+        this._handleHover();
+    }
+    ngOnDestroy() {
+        if (this._overlayRef) {
+            this._overlayRef.dispose();
+            this._overlayRef = null;
         }
-        /** The text direction of the containing app. */
-        get dir() {
-            return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';
+        this._element.nativeElement.removeEventListener('touchstart', this._handleTouchStart, passiveEventListenerOptions);
+        this._menuCloseSubscription.unsubscribe();
+        this._closingActionsSubscription.unsubscribe();
+        this._hoverSubscription.unsubscribe();
+    }
+    /** Whether the menu is open. */
+    get menuOpen() {
+        return this._menuOpen;
+    }
+    /** The text direction of the containing app. */
+    get dir() {
+        return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';
+    }
+    /** Whether the menu triggers a sub-menu or a top-level one. */
+    triggersSubmenu() {
+        return !!(this._menuItemInstance && this._parentMenu);
+    }
+    /** Toggles the menu between the open and closed states. */
+    toggleMenu() {
+        return this._menuOpen ? this.closeMenu() : this.openMenu();
+    }
+    /** Opens the menu. */
+    openMenu() {
+        if (this._menuOpen) {
+            return;
         }
-        /** Whether the menu triggers a sub-menu or a top-level one. */
-        triggersSubmenu() {
-            return !!(this._menuItemInstance && this._parentMenu);
+        this._checkMenu();
+        const overlayRef = this._createOverlay();
+        const overlayConfig = overlayRef.getConfig();
+        this._setPosition(overlayConfig.positionStrategy);
+        overlayConfig.hasBackdrop = this.menu.hasBackdrop == null ? !this.triggersSubmenu() :
+            this.menu.hasBackdrop;
+        overlayRef.attach(this._getPortal());
+        if (this.menu.lazyContent) {
+            this.menu.lazyContent.attach(this.menuData);
         }
-        /** Toggles the menu between the open and closed states. */
-        toggleMenu() {
-            return this._menuOpen ? this.closeMenu() : this.openMenu();
+        this._closingActionsSubscription = this._menuClosingActions().subscribe(() => this.closeMenu());
+        this._initMenu();
+        if (this.menu instanceof MatMenu) {
+            this.menu._startAnimation();
         }
-        /** Opens the menu. */
-        openMenu() {
-            if (this._menuOpen) {
-                return;
-            }
-            this._checkMenu();
-            const overlayRef = this._createOverlay();
-            const overlayConfig = overlayRef.getConfig();
-            this._setPosition(overlayConfig.positionStrategy);
-            overlayConfig.hasBackdrop = this.menu.hasBackdrop == null ? !this.triggersSubmenu() :
-                this.menu.hasBackdrop;
-            overlayRef.attach(this._getPortal());
-            if (this.menu.lazyContent) {
-                this.menu.lazyContent.attach(this.menuData);
-            }
-            this._closingActionsSubscription = this._menuClosingActions().subscribe(() => this.closeMenu());
-            this._initMenu();
-            if (this.menu instanceof MatMenu) {
-                this.menu._startAnimation();
-            }
+    }
+    /** Closes the menu. */
+    closeMenu() {
+        this.menu.close.emit();
+    }
+    /**
+     * Focuses the menu trigger.
+     * @param origin Source of the menu trigger's focus.
+     */
+    focus(origin = 'program', options) {
+        if (this._focusMonitor) {
+            this._focusMonitor.focusVia(this._element, origin, options);
         }
-        /** Closes the menu. */
-        closeMenu() {
-            this.menu.close.emit();
+        else {
+            this._element.nativeElement.focus(options);
         }
-        /**
-         * Focuses the menu trigger.
-         * @param origin Source of the menu trigger's focus.
-         */
-        focus(origin = 'program', options) {
-            if (this._focusMonitor) {
-                this._focusMonitor.focusVia(this._element, origin, options);
-            }
-            else {
-                this._element.nativeElement.focus(options);
-            }
+    }
+    /** Closes the menu and does the necessary cleanup. */
+    _destroyMenu() {
+        if (!this._overlayRef || !this.menuOpen) {
+            return;
         }
-        /** Closes the menu and does the necessary cleanup. */
-        _destroyMenu() {
-            if (!this._overlayRef || !this.menuOpen) {
-                return;
-            }
-            const menu = this.menu;
-            this._closingActionsSubscription.unsubscribe();
-            this._overlayRef.detach();
-            this._restoreFocus();
-            if (menu instanceof MatMenu) {
-                menu._resetAnimation();
-                if (menu.lazyContent) {
-                    // Wait for the exit animation to finish before detaching the content.
-                    menu._animationDone
-                        .pipe(filter(event => event.toState === 'void'), take(1), 
-                    // Interrupt if the content got re-attached.
-                    takeUntil(menu.lazyContent._attached))
-                        .subscribe({
-                        next: () => menu.lazyContent.detach(),
-                        // No matter whether the content got re-attached, reset the menu.
-                        complete: () => this._setIsMenuOpen(false)
-                    });
-                }
-                else {
-                    this._setIsMenuOpen(false);
-                }
+        const menu = this.menu;
+        this._closingActionsSubscription.unsubscribe();
+        this._overlayRef.detach();
+        this._restoreFocus();
+        if (menu instanceof MatMenu) {
+            menu._resetAnimation();
+            if (menu.lazyContent) {
+                // Wait for the exit animation to finish before detaching the content.
+                menu._animationDone
+                    .pipe(filter(event => event.toState === 'void'), take(1), 
+                // Interrupt if the content got re-attached.
+                takeUntil(menu.lazyContent._attached))
+                    .subscribe({
+                    next: () => menu.lazyContent.detach(),
+                    // No matter whether the content got re-attached, reset the menu.
+                    complete: () => this._setIsMenuOpen(false)
+                });
             }
             else {
                 this._setIsMenuOpen(false);
-                if (menu.lazyContent) {
-                    menu.lazyContent.detach();
-                }
             }
         }
-        /**
-         * This method sets the menu state to open and focuses the first item if
-         * the menu was opened via the keyboard.
-         */
-        _initMenu() {
-            this.menu.parentMenu = this.triggersSubmenu() ? this._parentMenu : undefined;
-            this.menu.direction = this.dir;
-            this._setMenuElevation();
-            this._setIsMenuOpen(true);
-            this.menu.focusFirstItem(this._openedBy || 'program');
-        }
-        /** Updates the menu elevation based on the amount of parent menus that it has. */
-        _setMenuElevation() {
-            if (this.menu.setElevation) {
-                let depth = 0;
-                let parentMenu = this.menu.parentMenu;
-                while (parentMenu) {
-                    depth++;
-                    parentMenu = parentMenu.parentMenu;
-                }
-                this.menu.setElevation(depth);
+        else {
+            this._setIsMenuOpen(false);
+            if (menu.lazyContent) {
+                menu.lazyContent.detach();
             }
         }
-        /** Restores focus to the element that was focused before the menu was open. */
-        _restoreFocus() {
-            // We should reset focus if the user is navigating using a keyboard or
-            // if we have a top-level trigger which might cause focus to be lost
-            // when clicking on the backdrop.
-            if (this.restoreFocus) {
-                if (!this._openedBy) {
-                    // Note that the focus style will show up both for `program` and
-                    // `keyboard` so we don't have to specify which one it is.
-                    this.focus();
-                }
-                else if (!this.triggersSubmenu()) {
-                    this.focus(this._openedBy);
-                }
+    }
+    /**
+     * This method sets the menu state to open and focuses the first item if
+     * the menu was opened via the keyboard.
+     */
+    _initMenu() {
+        this.menu.parentMenu = this.triggersSubmenu() ? this._parentMenu : undefined;
+        this.menu.direction = this.dir;
+        this._setMenuElevation();
+        this._setIsMenuOpen(true);
+        this.menu.focusFirstItem(this._openedBy || 'program');
+    }
+    /** Updates the menu elevation based on the amount of parent menus that it has. */
+    _setMenuElevation() {
+        if (this.menu.setElevation) {
+            let depth = 0;
+            let parentMenu = this.menu.parentMenu;
+            while (parentMenu) {
+                depth++;
+                parentMenu = parentMenu.parentMenu;
             }
-            this._openedBy = null;
+            this.menu.setElevation(depth);
         }
-        // set state rather than toggle to support triggers sharing a menu
-        _setIsMenuOpen(isOpen) {
-            this._menuOpen = isOpen;
-            this._menuOpen ? this.menuOpened.emit() : this.menuClosed.emit();
-            if (this.triggersSubmenu()) {
-                this._menuItemInstance._highlighted = isOpen;
+    }
+    /** Restores focus to the element that was focused before the menu was open. */
+    _restoreFocus() {
+        // We should reset focus if the user is navigating using a keyboard or
+        // if we have a top-level trigger which might cause focus to be lost
+        // when clicking on the backdrop.
+        if (this.restoreFocus) {
+            if (!this._openedBy) {
+                // Note that the focus style will show up both for `program` and
+                // `keyboard` so we don't have to specify which one it is.
+                this.focus();
             }
-        }
-        /**
-         * This method checks that a valid instance of MatMenu has been passed into
-         * matMenuTriggerFor. If not, an exception is thrown.
-         */
-        _checkMenu() {
-            if (!this.menu) {
-                throwMatMenuMissingError();
+            else if (!this.triggersSubmenu()) {
+                this.focus(this._openedBy);
             }
         }
-        /**
-         * This method creates the overlay from the provided menu's template and saves its
-         * OverlayRef so that it can be attached to the DOM when openMenu is called.
-         */
-        _createOverlay() {
-            if (!this._overlayRef) {
-                const config = this._getOverlayConfig();
-                this._subscribeToPositions(config.positionStrategy);
-                this._overlayRef = this._overlay.create(config);
-                // Consume the `keydownEvents` in order to prevent them from going to another overlay.
-                // Ideally we'd also have our keyboard event logic in here, however doing so will
-                // break anybody that may have implemented the `MatMenuPanel` themselves.
-                this._overlayRef.keydownEvents().subscribe();
-            }
-            return this._overlayRef;
+        this._openedBy = null;
+    }
+    // set state rather than toggle to support triggers sharing a menu
+    _setIsMenuOpen(isOpen) {
+        this._menuOpen = isOpen;
+        this._menuOpen ? this.menuOpened.emit() : this.menuClosed.emit();
+        if (this.triggersSubmenu()) {
+            this._menuItemInstance._highlighted = isOpen;
         }
-        /**
-         * This method builds the configuration object needed to create the overlay, the OverlayState.
-         * @returns OverlayConfig
-         */
-        _getOverlayConfig() {
-            return new OverlayConfig({
-                positionStrategy: this._overlay.position()
-                    .flexibleConnectedTo(this._element)
-                    .withLockedPosition()
-                    .withTransformOriginOn('.mat-menu-panel, .mat-mdc-menu-panel'),
-                backdropClass: this.menu.backdropClass || 'cdk-overlay-transparent-backdrop',
-                scrollStrategy: this._scrollStrategy(),
-                direction: this._dir
+    }
+    /**
+     * This method checks that a valid instance of MatMenu has been passed into
+     * matMenuTriggerFor. If not, an exception is thrown.
+     */
+    _checkMenu() {
+        if (!this.menu) {
+            throwMatMenuMissingError();
+        }
+    }
+    /**
+     * This method creates the overlay from the provided menu's template and saves its
+     * OverlayRef so that it can be attached to the DOM when openMenu is called.
+     */
+    _createOverlay() {
+        if (!this._overlayRef) {
+            const config = this._getOverlayConfig();
+            this._subscribeToPositions(config.positionStrategy);
+            this._overlayRef = this._overlay.create(config);
+            // Consume the `keydownEvents` in order to prevent them from going to another overlay.
+            // Ideally we'd also have our keyboard event logic in here, however doing so will
+            // break anybody that may have implemented the `MatMenuPanel` themselves.
+            this._overlayRef.keydownEvents().subscribe();
+        }
+        return this._overlayRef;
+    }
+    /**
+     * This method builds the configuration object needed to create the overlay, the OverlayState.
+     * @returns OverlayConfig
+     */
+    _getOverlayConfig() {
+        return new OverlayConfig({
+            positionStrategy: this._overlay.position()
+                .flexibleConnectedTo(this._element)
+                .withLockedPosition()
+                .withTransformOriginOn('.mat-menu-panel, .mat-mdc-menu-panel'),
+            backdropClass: this.menu.backdropClass || 'cdk-overlay-transparent-backdrop',
+            panelClass: this.menu.overlayPanelClass,
+            scrollStrategy: this._scrollStrategy(),
+            direction: this._dir
+        });
+    }
+    /**
+     * Listens to changes in the position of the overlay and sets the correct classes
+     * on the menu based on the new position. This ensures the animation origin is always
+     * correct, even if a fallback position is used for the overlay.
+     */
+    _subscribeToPositions(position) {
+        if (this.menu.setPositionClasses) {
+            position.positionChanges.subscribe(change => {
+                const posX = change.connectionPair.overlayX === 'start' ? 'after' : 'before';
+                const posY = change.connectionPair.overlayY === 'top' ? 'below' : 'above';
+                this.menu.setPositionClasses(posX, posY);
             });
         }
-        /**
-         * Listens to changes in the position of the overlay and sets the correct classes
-         * on the menu based on the new position. This ensures the animation origin is always
-         * correct, even if a fallback position is used for the overlay.
-         */
-        _subscribeToPositions(position) {
-            if (this.menu.setPositionClasses) {
-                position.positionChanges.subscribe(change => {
-                    const posX = change.connectionPair.overlayX === 'start' ? 'after' : 'before';
-                    const posY = change.connectionPair.overlayY === 'top' ? 'below' : 'above';
-                    this.menu.setPositionClasses(posX, posY);
-                });
-            }
+    }
+    /**
+     * Sets the appropriate positions on a position strategy
+     * so the overlay connects with the trigger correctly.
+     * @param positionStrategy Strategy whose position to update.
+     */
+    _setPosition(positionStrategy) {
+        let [originX, originFallbackX] = this.menu.xPosition === 'before' ? ['end', 'start'] : ['start', 'end'];
+        let [overlayY, overlayFallbackY] = this.menu.yPosition === 'above' ? ['bottom', 'top'] : ['top', 'bottom'];
+        let [originY, originFallbackY] = [overlayY, overlayFallbackY];
+        let [overlayX, overlayFallbackX] = [originX, originFallbackX];
+        let offsetY = 0;
+        if (this.triggersSubmenu()) {
+            // When the menu is a sub-menu, it should always align itself
+            // to the edges of the trigger, instead of overlapping it.
+            overlayFallbackX = originX = this.menu.xPosition === 'before' ? 'start' : 'end';
+            originFallbackX = overlayX = originX === 'end' ? 'start' : 'end';
+            offsetY = overlayY === 'bottom' ? MENU_PANEL_TOP_PADDING : -MENU_PANEL_TOP_PADDING;
         }
-        /**
-         * Sets the appropriate positions on a position strategy
-         * so the overlay connects with the trigger correctly.
-         * @param positionStrategy Strategy whose position to update.
-         */
-        _setPosition(positionStrategy) {
-            let [originX, originFallbackX] = this.menu.xPosition === 'before' ? ['end', 'start'] : ['start', 'end'];
-            let [overlayY, overlayFallbackY] = this.menu.yPosition === 'above' ? ['bottom', 'top'] : ['top', 'bottom'];
-            let [originY, originFallbackY] = [overlayY, overlayFallbackY];
-            let [overlayX, overlayFallbackX] = [originX, originFallbackX];
-            let offsetY = 0;
-            if (this.triggersSubmenu()) {
-                // When the menu is a sub-menu, it should always align itself
-                // to the edges of the trigger, instead of overlapping it.
-                overlayFallbackX = originX = this.menu.xPosition === 'before' ? 'start' : 'end';
-                originFallbackX = overlayX = originX === 'end' ? 'start' : 'end';
-                offsetY = overlayY === 'bottom' ? MENU_PANEL_TOP_PADDING : -MENU_PANEL_TOP_PADDING;
+        else if (!this.menu.overlapTrigger) {
+            originY = overlayY === 'top' ? 'bottom' : 'top';
+            originFallbackY = overlayFallbackY === 'top' ? 'bottom' : 'top';
+        }
+        positionStrategy.withPositions([
+            { originX, originY, overlayX, overlayY, offsetY },
+            { originX: originFallbackX, originY, overlayX: overlayFallbackX, overlayY, offsetY },
+            {
+                originX,
+                originY: originFallbackY,
+                overlayX,
+                overlayY: overlayFallbackY,
+                offsetY: -offsetY
+            },
+            {
+                originX: originFallbackX,
+                originY: originFallbackY,
+                overlayX: overlayFallbackX,
+                overlayY: overlayFallbackY,
+                offsetY: -offsetY
             }
-            else if (!this.menu.overlapTrigger) {
-                originY = overlayY === 'top' ? 'bottom' : 'top';
-                originFallbackY = overlayFallbackY === 'top' ? 'bottom' : 'top';
+        ]);
+    }
+    /** Returns a stream that emits whenever an action that should close the menu occurs. */
+    _menuClosingActions() {
+        const backdrop = this._overlayRef.backdropClick();
+        const detachments = this._overlayRef.detachments();
+        const parentClose = this._parentMenu ? this._parentMenu.closed : observableOf();
+        const hover = this._parentMenu ? this._parentMenu._hovered().pipe(filter(active => active !== this._menuItemInstance), filter(() => this._menuOpen)) : observableOf();
+        return merge(backdrop, parentClose, hover, detachments);
+    }
+    /** Handles mouse presses on the trigger. */
+    _handleMousedown(event) {
+        if (!isFakeMousedownFromScreenReader(event)) {
+            // Since right or middle button clicks won't trigger the `click` event,
+            // we shouldn't consider the menu as opened by mouse in those cases.
+            this._openedBy = event.button === 0 ? 'mouse' : null;
+            // Since clicking on the trigger won't close the menu if it opens a sub-menu,
+            // we should prevent focus from moving onto it via click to avoid the
+            // highlight from lingering on the menu item.
+            if (this.triggersSubmenu()) {
+                event.preventDefault();
             }
-            positionStrategy.withPositions([
-                { originX, originY, overlayX, overlayY, offsetY },
-                { originX: originFallbackX, originY, overlayX: overlayFallbackX, overlayY, offsetY },
-                {
-                    originX,
-                    originY: originFallbackY,
-                    overlayX,
-                    overlayY: overlayFallbackY,
-                    offsetY: -offsetY
-                },
-                {
-                    originX: originFallbackX,
-                    originY: originFallbackY,
-                    overlayX: overlayFallbackX,
-                    overlayY: overlayFallbackY,
-                    offsetY: -offsetY
-                }
-            ]);
         }
-        /** Returns a stream that emits whenever an action that should close the menu occurs. */
-        _menuClosingActions() {
-            const backdrop = this._overlayRef.backdropClick();
-            const detachments = this._overlayRef.detachments();
-            const parentClose = this._parentMenu ? this._parentMenu.closed : observableOf();
-            const hover = this._parentMenu ? this._parentMenu._hovered().pipe(filter(active => active !== this._menuItemInstance), filter(() => this._menuOpen)) : observableOf();
-            return merge(backdrop, parentClose, hover, detachments);
+    }
+    /** Handles key presses on the trigger. */
+    _handleKeydown(event) {
+        const keyCode = event.keyCode;
+        if (this.triggersSubmenu() && ((keyCode === RIGHT_ARROW && this.dir === 'ltr') ||
+            (keyCode === LEFT_ARROW && this.dir === 'rtl'))) {
+            this.openMenu();
         }
-        /** Handles mouse presses on the trigger. */
-        _handleMousedown(event) {
-            if (!isFakeMousedownFromScreenReader(event)) {
-                // Since right or middle button clicks won't trigger the `click` event,
-                // we shouldn't consider the menu as opened by mouse in those cases.
-                this._openedBy = event.button === 0 ? 'mouse' : null;
-                // Since clicking on the trigger won't close the menu if it opens a sub-menu,
-                // we should prevent focus from moving onto it via click to avoid the
-                // highlight from lingering on the menu item.
-                if (this.triggersSubmenu()) {
-                    event.preventDefault();
-                }
-            }
+    }
+    /** Handles click events on the trigger. */
+    _handleClick(event) {
+        if (this.triggersSubmenu()) {
+            // Stop event propagation to avoid closing the parent menu.
+            event.stopPropagation();
+            this.openMenu();
         }
-        /** Handles key presses on the trigger. */
-        _handleKeydown(event) {
-            const keyCode = event.keyCode;
-            if (this.triggersSubmenu() && ((keyCode === RIGHT_ARROW && this.dir === 'ltr') ||
-                (keyCode === LEFT_ARROW && this.dir === 'rtl'))) {
-                this.openMenu();
-            }
+        else {
+            this.toggleMenu();
         }
-        /** Handles click events on the trigger. */
-        _handleClick(event) {
-            if (this.triggersSubmenu()) {
-                // Stop event propagation to avoid closing the parent menu.
-                event.stopPropagation();
-                this.openMenu();
-            }
-            else {
-                this.toggleMenu();
-            }
+    }
+    /** Handles the cases where the user hovers over the trigger. */
+    _handleHover() {
+        // Subscribe to changes in the hovered item in order to toggle the panel.
+        if (!this.triggersSubmenu()) {
+            return;
         }
-        /** Handles the cases where the user hovers over the trigger. */
-        _handleHover() {
-            // Subscribe to changes in the hovered item in order to toggle the panel.
-            if (!this.triggersSubmenu()) {
-                return;
+        this._hoverSubscription = this._parentMenu._hovered()
+            // Since we might have multiple competing triggers for the same menu (e.g. a sub-menu
+            // with different data and triggers), we have to delay it by a tick to ensure that
+            // it won't be closed immediately after it is opened.
+            .pipe(filter(active => active === this._menuItemInstance && !active.disabled), delay(0, asapScheduler))
+            .subscribe(() => {
+            this._openedBy = 'mouse';
+            // If the same menu is used between multiple triggers, it might still be animating
+            // while the new trigger tries to re-open it. Wait for the animation to finish
+            // before doing so. Also interrupt if the user moves to another item.
+            if (this.menu instanceof MatMenu && this.menu._isAnimating) {
+                // We need the `delay(0)` here in order to avoid
+                // 'changed after checked' errors in some cases. See #12194.
+                this.menu._animationDone
+                    .pipe(take(1), delay(0, asapScheduler), takeUntil(this._parentMenu._hovered()))
+                    .subscribe(() => this.openMenu());
             }
-            this._hoverSubscription = this._parentMenu._hovered()
-                // Since we might have multiple competing triggers for the same menu (e.g. a sub-menu
-                // with different data and triggers), we have to delay it by a tick to ensure that
-                // it won't be closed immediately after it is opened.
-                .pipe(filter(active => active === this._menuItemInstance && !active.disabled), delay(0, asapScheduler))
-                .subscribe(() => {
-                this._openedBy = 'mouse';
-                // If the same menu is used between multiple triggers, it might still be animating
-                // while the new trigger tries to re-open it. Wait for the animation to finish
-                // before doing so. Also interrupt if the user moves to another item.
-                if (this.menu instanceof MatMenu && this.menu._isAnimating) {
-                    // We need the `delay(0)` here in order to avoid
-                    // 'changed after checked' errors in some cases. See #12194.
-                    this.menu._animationDone
-                        .pipe(take(1), delay(0, asapScheduler), takeUntil(this._parentMenu._hovered()))
-                        .subscribe(() => this.openMenu());
-                }
-                else {
-                    this.openMenu();
-                }
-            });
-        }
-        /** Gets the portal that should be attached to the overlay. */
-        _getPortal() {
-            // Note that we can avoid this check by keeping the portal on the menu panel.
-            // While it would be cleaner, we'd have to introduce another required method on
-            // `MatMenuPanel`, making it harder to consume.
-            if (!this._portal || this._portal.templateRef !== this.menu.templateRef) {
-                this._portal = new TemplatePortal(this.menu.templateRef, this._viewContainerRef);
+            else {
+                this.openMenu();
             }
-            return this._portal;
+        });
+    }
+    /** Gets the portal that should be attached to the overlay. */
+    _getPortal() {
+        // Note that we can avoid this check by keeping the portal on the menu panel.
+        // While it would be cleaner, we'd have to introduce another required method on
+        // `MatMenuPanel`, making it harder to consume.
+        if (!this._portal || this._portal.templateRef !== this.menu.templateRef) {
+            this._portal = new TemplatePortal(this.menu.templateRef, this._viewContainerRef);
         }
+        return this._portal;
     }
-    MatMenuTrigger.decorators = [
-        { type: Directive, args: [{
-                    selector: `[mat-menu-trigger-for], [matMenuTriggerFor]`,
-                    host: {
-                        'class': 'mat-menu-trigger',
-                        'aria-haspopup': 'true',
-                        '[attr.aria-expanded]': 'menuOpen || null',
-                        '[attr.aria-controls]': 'menuOpen ? menu.panelId : null',
-                        '(mousedown)': '_handleMousedown($event)',
-                        '(keydown)': '_handleKeydown($event)',
-                        '(click)': '_handleClick($event)',
-                    },
-                    exportAs: 'matMenuTrigger'
-                },] }
-    ];
-    MatMenuTrigger.ctorParameters = () => [
-        { type: Overlay },
-        { type: ElementRef },
-        { type: ViewContainerRef },
-        { type: undefined, decorators: [{ type: Inject, args: [MAT_MENU_SCROLL_STRATEGY,] }] },
-        { type: MatMenu, decorators: [{ type: Optional }] },
-        { type: MatMenuItem, decorators: [{ type: Optional }, { type: Self }] },
-        { type: Directionality, decorators: [{ type: Optional }] },
-        { type: FocusMonitor }
-    ];
-    MatMenuTrigger.propDecorators = {
-        _deprecatedMatMenuTriggerFor: [{ type: Input, args: ['mat-menu-trigger-for',] }],
-        menu: [{ type: Input, args: ['matMenuTriggerFor',] }],
-        menuData: [{ type: Input, args: ['matMenuTriggerData',] }],
-        restoreFocus: [{ type: Input, args: ['matMenuTriggerRestoreFocus',] }],
-        menuOpened: [{ type: Output }],
-        onMenuOpen: [{ type: Output }],
-        menuClosed: [{ type: Output }],
-        onMenuClose: [{ type: Output }]
-    };
-    return MatMenuTrigger;
-})();
-export { MatMenuTrigger };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-trigger.js","sourceRoot":"","sources":["../../../../../../src/material/menu/menu-trigger.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {FocusMonitor, FocusOrigin, isFakeMousedownFromScreenReader} from '@angular/cdk/a11y';\nimport {Direction, Directionality} from '@angular/cdk/bidi';\nimport {LEFT_ARROW, RIGHT_ARROW} from '@angular/cdk/keycodes';\nimport {\n  FlexibleConnectedPositionStrategy,\n  HorizontalConnectionPos,\n  Overlay,\n  OverlayConfig,\n  OverlayRef,\n  VerticalConnectionPos,\n  ScrollStrategy,\n} from '@angular/cdk/overlay';\nimport {TemplatePortal} from '@angular/cdk/portal';\nimport {\n  AfterContentInit,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  InjectionToken,\n  Input,\n  OnDestroy,\n  Optional,\n  Output,\n  Self,\n  ViewContainerRef,\n} from '@angular/core';\nimport {normalizePassiveListenerOptions} from '@angular/cdk/platform';\nimport {asapScheduler, merge, of as observableOf, Subscription} from 'rxjs';\nimport {delay, filter, take, takeUntil} from 'rxjs/operators';\nimport {MatMenu} from './menu';\nimport {throwMatMenuMissingError} from './menu-errors';\nimport {MatMenuItem} from './menu-item';\nimport {MatMenuPanel} from './menu-panel';\nimport {MenuPositionX, MenuPositionY} from './menu-positions';\n\n/** Injection token that determines the scroll handling while the menu is open. */\nexport const MAT_MENU_SCROLL_STRATEGY =\n    new InjectionToken<() => ScrollStrategy>('mat-menu-scroll-strategy');\n\n/** @docs-private */\nexport function MAT_MENU_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy {\n  return () => overlay.scrollStrategies.reposition();\n}\n\n/** @docs-private */\nexport const MAT_MENU_SCROLL_STRATEGY_FACTORY_PROVIDER = {\n  provide: MAT_MENU_SCROLL_STRATEGY,\n  deps: [Overlay],\n  useFactory: MAT_MENU_SCROLL_STRATEGY_FACTORY,\n};\n\n/** Default top padding of the menu panel. */\nexport const MENU_PANEL_TOP_PADDING = 8;\n\n/** Options for binding a passive event listener. */\nconst passiveEventListenerOptions = normalizePassiveListenerOptions({passive: true});\n\n// TODO(andrewseguin): Remove the kebab versions in favor of camelCased attribute selectors\n\n/** Directive applied to an element that should trigger a `mat-menu`. */\n@Directive({\n  selector: `[mat-menu-trigger-for], [matMenuTriggerFor]`,\n  host: {\n    'class': 'mat-menu-trigger',\n    'aria-haspopup': 'true',\n    '[attr.aria-expanded]': 'menuOpen || null',\n    '[attr.aria-controls]': 'menuOpen ? menu.panelId : null',\n    '(mousedown)': '_handleMousedown($event)',\n    '(keydown)': '_handleKeydown($event)',\n    '(click)': '_handleClick($event)',\n  },\n  exportAs: 'matMenuTrigger'\n})\nexport class MatMenuTrigger implements AfterContentInit, OnDestroy {\n  private _portal: TemplatePortal;\n  private _overlayRef: OverlayRef | null = null;\n  private _menuOpen: boolean = false;\n  private _closingActionsSubscription = Subscription.EMPTY;\n  private _hoverSubscription = Subscription.EMPTY;\n  private _menuCloseSubscription = Subscription.EMPTY;\n  private _scrollStrategy: () => ScrollStrategy;\n\n  /**\n   * Handles touch start events on the trigger.\n   * Needs to be an arrow function so we can easily use addEventListener and removeEventListener.\n   */\n  private _handleTouchStart = () => this._openedBy = 'touch';\n\n  // Tracking input type is necessary so it's possible to only auto-focus\n  // the first item of the list when the menu is opened via the keyboard\n  _openedBy: 'mouse' | 'touch' | null = null;\n\n  /**\n   * @deprecated\n   * @breaking-change 8.0.0\n   */\n  @Input('mat-menu-trigger-for')\n  get _deprecatedMatMenuTriggerFor(): MatMenuPanel { return this.menu; }\n  set _deprecatedMatMenuTriggerFor(v: MatMenuPanel) {\n    this.menu = v;\n  }\n\n  /** References the menu instance that the trigger is associated with. */\n  @Input('matMenuTriggerFor')\n  get menu() { return this._menu; }\n  set menu(menu: MatMenuPanel) {\n    if (menu === this._menu) {\n      return;\n    }\n\n    this._menu = menu;\n    this._menuCloseSubscription.unsubscribe();\n\n    if (menu) {\n      this._menuCloseSubscription = menu.close.asObservable().subscribe(reason => {\n        this._destroyMenu();\n\n        // If a click closed the menu, we should close the entire chain of nested menus.\n        if ((reason === 'click' || reason === 'tab') && this._parentMenu) {\n          this._parentMenu.closed.emit(reason);\n        }\n      });\n    }\n  }\n  private _menu: MatMenuPanel;\n\n  /** Data to be passed along to any lazily-rendered content. */\n  @Input('matMenuTriggerData') menuData: any;\n\n  /**\n   * Whether focus should be restored when the menu is closed.\n   * Note that disabling this option can have accessibility implications\n   * and it's up to you to manage focus, if you decide to turn it off.\n   */\n  @Input('matMenuTriggerRestoreFocus') restoreFocus: boolean = true;\n\n  /** Event emitted when the associated menu is opened. */\n  @Output() readonly menuOpened: EventEmitter<void> = new EventEmitter<void>();\n\n  /**\n   * Event emitted when the associated menu is opened.\n   * @deprecated Switch to `menuOpened` instead\n   * @breaking-change 8.0.0\n   */\n  // tslint:disable-next-line:no-output-on-prefix\n  @Output() readonly onMenuOpen: EventEmitter<void> = this.menuOpened;\n\n  /** Event emitted when the associated menu is closed. */\n  @Output() readonly menuClosed: EventEmitter<void> = new EventEmitter<void>();\n\n  /**\n   * Event emitted when the associated menu is closed.\n   * @deprecated Switch to `menuClosed` instead\n   * @breaking-change 8.0.0\n   */\n  // tslint:disable-next-line:no-output-on-prefix\n  @Output() readonly onMenuClose: EventEmitter<void> = this.menuClosed;\n\n  constructor(private _overlay: Overlay,\n              private _element: ElementRef<HTMLElement>,\n              private _viewContainerRef: ViewContainerRef,\n              @Inject(MAT_MENU_SCROLL_STRATEGY) scrollStrategy: any,\n              @Optional() private _parentMenu: MatMenu,\n              @Optional() @Self() private _menuItemInstance: MatMenuItem,\n              @Optional() private _dir: Directionality,\n              // TODO(crisbeto): make the _focusMonitor required when doing breaking changes.\n              // @breaking-change 8.0.0\n              private _focusMonitor?: FocusMonitor) {\n\n    _element.nativeElement.addEventListener('touchstart', this._handleTouchStart,\n        passiveEventListenerOptions);\n\n    if (_menuItemInstance) {\n      _menuItemInstance._triggersSubmenu = this.triggersSubmenu();\n    }\n\n    this._scrollStrategy = scrollStrategy;\n  }\n\n  ngAfterContentInit() {\n    this._checkMenu();\n    this._handleHover();\n  }\n\n  ngOnDestroy() {\n    if (this._overlayRef) {\n      this._overlayRef.dispose();\n      this._overlayRef = null;\n    }\n\n    this._element.nativeElement.removeEventListener('touchstart', this._handleTouchStart,\n        passiveEventListenerOptions);\n\n    this._menuCloseSubscription.unsubscribe();\n    this._closingActionsSubscription.unsubscribe();\n    this._hoverSubscription.unsubscribe();\n  }\n\n  /** Whether the menu is open. */\n  get menuOpen(): boolean {\n    return this._menuOpen;\n  }\n\n  /** The text direction of the containing app. */\n  get dir(): Direction {\n    return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';\n  }\n\n  /** Whether the menu triggers a sub-menu or a top-level one. */\n  triggersSubmenu(): boolean {\n    return !!(this._menuItemInstance && this._parentMenu);\n  }\n\n  /** Toggles the menu between the open and closed states. */\n  toggleMenu(): void {\n    return this._menuOpen ? this.closeMenu() : this.openMenu();\n  }\n\n  /** Opens the menu. */\n  openMenu(): void {\n    if (this._menuOpen) {\n      return;\n    }\n\n    this._checkMenu();\n\n    const overlayRef = this._createOverlay();\n    const overlayConfig = overlayRef.getConfig();\n\n    this._setPosition(overlayConfig.positionStrategy as FlexibleConnectedPositionStrategy);\n    overlayConfig.hasBackdrop = this.menu.hasBackdrop == null ? !this.triggersSubmenu() :\n        this.menu.hasBackdrop;\n    overlayRef.attach(this._getPortal());\n\n    if (this.menu.lazyContent) {\n      this.menu.lazyContent.attach(this.menuData);\n    }\n\n    this._closingActionsSubscription = this._menuClosingActions().subscribe(() => this.closeMenu());\n    this._initMenu();\n\n    if (this.menu instanceof MatMenu) {\n      this.menu._startAnimation();\n    }\n  }\n\n  /** Closes the menu. */\n  closeMenu(): void {\n    this.menu.close.emit();\n  }\n\n  /**\n   * Focuses the menu trigger.\n   * @param origin Source of the menu trigger's focus.\n   */\n  focus(origin: FocusOrigin = 'program', options?: FocusOptions) {\n    if (this._focusMonitor) {\n      this._focusMonitor.focusVia(this._element, origin, options);\n    } else {\n      this._element.nativeElement.focus(options);\n    }\n  }\n\n  /** Closes the menu and does the necessary cleanup. */\n  private _destroyMenu() {\n    if (!this._overlayRef || !this.menuOpen) {\n      return;\n    }\n\n    const menu = this.menu;\n    this._closingActionsSubscription.unsubscribe();\n    this._overlayRef.detach();\n    this._restoreFocus();\n\n    if (menu instanceof MatMenu) {\n      menu._resetAnimation();\n\n      if (menu.lazyContent) {\n        // Wait for the exit animation to finish before detaching the content.\n        menu._animationDone\n          .pipe(\n            filter(event => event.toState === 'void'),\n            take(1),\n            // Interrupt if the content got re-attached.\n            takeUntil(menu.lazyContent._attached)\n          )\n          .subscribe({\n            next: () => menu.lazyContent!.detach(),\n            // No matter whether the content got re-attached, reset the menu.\n            complete: () => this._setIsMenuOpen(false)\n          });\n      } else {\n        this._setIsMenuOpen(false);\n      }\n    } else {\n      this._setIsMenuOpen(false);\n\n      if (menu.lazyContent) {\n        menu.lazyContent.detach();\n      }\n    }\n  }\n\n  /**\n   * This method sets the menu state to open and focuses the first item if\n   * the menu was opened via the keyboard.\n   */\n  private _initMenu(): void {\n    this.menu.parentMenu = this.triggersSubmenu() ? this._parentMenu : undefined;\n    this.menu.direction = this.dir;\n    this._setMenuElevation();\n    this._setIsMenuOpen(true);\n    this.menu.focusFirstItem(this._openedBy || 'program');\n  }\n\n  /** Updates the menu elevation based on the amount of parent menus that it has. */\n  private _setMenuElevation(): void {\n    if (this.menu.setElevation) {\n      let depth = 0;\n      let parentMenu = this.menu.parentMenu;\n\n      while (parentMenu) {\n        depth++;\n        parentMenu = parentMenu.parentMenu;\n      }\n\n      this.menu.setElevation(depth);\n    }\n  }\n\n  /** Restores focus to the element that was focused before the menu was open. */\n  private _restoreFocus() {\n    // We should reset focus if the user is navigating using a keyboard or\n    // if we have a top-level trigger which might cause focus to be lost\n    // when clicking on the backdrop.\n    if (this.restoreFocus) {\n      if (!this._openedBy) {\n        // Note that the focus style will show up both for `program` and\n        // `keyboard` so we don't have to specify which one it is.\n        this.focus();\n      } else if (!this.triggersSubmenu()) {\n        this.focus(this._openedBy);\n      }\n    }\n\n    this._openedBy = null;\n  }\n\n  // set state rather than toggle to support triggers sharing a menu\n  private _setIsMenuOpen(isOpen: boolean): void {\n    this._menuOpen = isOpen;\n    this._menuOpen ? this.menuOpened.emit() : this.menuClosed.emit();\n\n    if (this.triggersSubmenu()) {\n      this._menuItemInstance._highlighted = isOpen;\n    }\n  }\n\n  /**\n   * This method checks that a valid instance of MatMenu has been passed into\n   * matMenuTriggerFor. If not, an exception is thrown.\n   */\n  private _checkMenu() {\n    if (!this.menu) {\n      throwMatMenuMissingError();\n    }\n  }\n\n  /**\n   * This method creates the overlay from the provided menu's template and saves its\n   * OverlayRef so that it can be attached to the DOM when openMenu is called.\n   */\n  private _createOverlay(): OverlayRef {\n    if (!this._overlayRef) {\n      const config = this._getOverlayConfig();\n      this._subscribeToPositions(config.positionStrategy as FlexibleConnectedPositionStrategy);\n      this._overlayRef = this._overlay.create(config);\n\n      // Consume the `keydownEvents` in order to prevent them from going to another overlay.\n      // Ideally we'd also have our keyboard event logic in here, however doing so will\n      // break anybody that may have implemented the `MatMenuPanel` themselves.\n      this._overlayRef.keydownEvents().subscribe();\n    }\n\n    return this._overlayRef;\n  }\n\n  /**\n   * This method builds the configuration object needed to create the overlay, the OverlayState.\n   * @returns OverlayConfig\n   */\n  private _getOverlayConfig(): OverlayConfig {\n    return new OverlayConfig({\n      positionStrategy: this._overlay.position()\n          .flexibleConnectedTo(this._element)\n          .withLockedPosition()\n          .withTransformOriginOn('.mat-menu-panel, .mat-mdc-menu-panel'),\n      backdropClass: this.menu.backdropClass || 'cdk-overlay-transparent-backdrop',\n      scrollStrategy: this._scrollStrategy(),\n      direction: this._dir\n    });\n  }\n\n  /**\n   * Listens to changes in the position of the overlay and sets the correct classes\n   * on the menu based on the new position. This ensures the animation origin is always\n   * correct, even if a fallback position is used for the overlay.\n   */\n  private _subscribeToPositions(position: FlexibleConnectedPositionStrategy): void {\n    if (this.menu.setPositionClasses) {\n      position.positionChanges.subscribe(change => {\n        const posX: MenuPositionX = change.connectionPair.overlayX === 'start' ? 'after' : 'before';\n        const posY: MenuPositionY = change.connectionPair.overlayY === 'top' ? 'below' : 'above';\n\n        this.menu.setPositionClasses!(posX, posY);\n      });\n    }\n  }\n\n  /**\n   * Sets the appropriate positions on a position strategy\n   * so the overlay connects with the trigger correctly.\n   * @param positionStrategy Strategy whose position to update.\n   */\n  private _setPosition(positionStrategy: FlexibleConnectedPositionStrategy) {\n    let [originX, originFallbackX]: HorizontalConnectionPos[] =\n        this.menu.xPosition === 'before' ? ['end', 'start'] : ['start', 'end'];\n\n    let [overlayY, overlayFallbackY]: VerticalConnectionPos[] =\n        this.menu.yPosition === 'above' ? ['bottom', 'top'] : ['top', 'bottom'];\n\n    let [originY, originFallbackY] = [overlayY, overlayFallbackY];\n    let [overlayX, overlayFallbackX] = [originX, originFallbackX];\n    let offsetY = 0;\n\n    if (this.triggersSubmenu()) {\n      // When the menu is a sub-menu, it should always align itself\n      // to the edges of the trigger, instead of overlapping it.\n      overlayFallbackX = originX = this.menu.xPosition === 'before' ? 'start' : 'end';\n      originFallbackX = overlayX = originX === 'end' ? 'start' : 'end';\n      offsetY = overlayY === 'bottom' ? MENU_PANEL_TOP_PADDING : -MENU_PANEL_TOP_PADDING;\n    } else if (!this.menu.overlapTrigger) {\n      originY = overlayY === 'top' ? 'bottom' : 'top';\n      originFallbackY = overlayFallbackY === 'top' ? 'bottom' : 'top';\n    }\n\n    positionStrategy.withPositions([\n      {originX, originY, overlayX, overlayY, offsetY},\n      {originX: originFallbackX, originY, overlayX: overlayFallbackX, overlayY, offsetY},\n      {\n        originX,\n        originY: originFallbackY,\n        overlayX,\n        overlayY: overlayFallbackY,\n        offsetY: -offsetY\n      },\n      {\n        originX: originFallbackX,\n        originY: originFallbackY,\n        overlayX: overlayFallbackX,\n        overlayY: overlayFallbackY,\n        offsetY: -offsetY\n      }\n    ]);\n  }\n\n  /** Returns a stream that emits whenever an action that should close the menu occurs. */\n  private _menuClosingActions() {\n    const backdrop = this._overlayRef!.backdropClick();\n    const detachments = this._overlayRef!.detachments();\n    const parentClose = this._parentMenu ? this._parentMenu.closed : observableOf();\n    const hover = this._parentMenu ? this._parentMenu._hovered().pipe(\n      filter(active => active !== this._menuItemInstance),\n      filter(() => this._menuOpen)\n    ) : observableOf();\n\n    return merge(backdrop, parentClose, hover, detachments);\n  }\n\n  /** Handles mouse presses on the trigger. */\n  _handleMousedown(event: MouseEvent): void {\n    if (!isFakeMousedownFromScreenReader(event)) {\n      // Since right or middle button clicks won't trigger the `click` event,\n      // we shouldn't consider the menu as opened by mouse in those cases.\n      this._openedBy = event.button === 0 ? 'mouse' : null;\n\n      // Since clicking on the trigger won't close the menu if it opens a sub-menu,\n      // we should prevent focus from moving onto it via click to avoid the\n      // highlight from lingering on the menu item.\n      if (this.triggersSubmenu()) {\n        event.preventDefault();\n      }\n    }\n  }\n\n  /** Handles key presses on the trigger. */\n  _handleKeydown(event: KeyboardEvent): void {\n    const keyCode = event.keyCode;\n\n    if (this.triggersSubmenu() && (\n            (keyCode === RIGHT_ARROW && this.dir === 'ltr') ||\n            (keyCode === LEFT_ARROW && this.dir === 'rtl'))) {\n      this.openMenu();\n    }\n  }\n\n  /** Handles click events on the trigger. */\n  _handleClick(event: MouseEvent): void {\n    if (this.triggersSubmenu()) {\n      // Stop event propagation to avoid closing the parent menu.\n      event.stopPropagation();\n      this.openMenu();\n    } else {\n      this.toggleMenu();\n    }\n  }\n\n  /** Handles the cases where the user hovers over the trigger. */\n  private _handleHover() {\n    // Subscribe to changes in the hovered item in order to toggle the panel.\n    if (!this.triggersSubmenu()) {\n      return;\n    }\n\n    this._hoverSubscription = this._parentMenu._hovered()\n      // Since we might have multiple competing triggers for the same menu (e.g. a sub-menu\n      // with different data and triggers), we have to delay it by a tick to ensure that\n      // it won't be closed immediately after it is opened.\n      .pipe(\n        filter(active => active === this._menuItemInstance && !active.disabled),\n        delay(0, asapScheduler)\n      )\n      .subscribe(() => {\n        this._openedBy = 'mouse';\n\n        // If the same menu is used between multiple triggers, it might still be animating\n        // while the new trigger tries to re-open it. Wait for the animation to finish\n        // before doing so. Also interrupt if the user moves to another item.\n        if (this.menu instanceof MatMenu && this.menu._isAnimating) {\n          // We need the `delay(0)` here in order to avoid\n          // 'changed after checked' errors in some cases. See #12194.\n          this.menu._animationDone\n            .pipe(take(1), delay(0, asapScheduler), takeUntil(this._parentMenu._hovered()))\n            .subscribe(() => this.openMenu());\n        } else {\n          this.openMenu();\n        }\n      });\n  }\n\n  /** Gets the portal that should be attached to the overlay. */\n  private _getPortal(): TemplatePortal {\n    // Note that we can avoid this check by keeping the portal on the menu panel.\n    // While it would be cleaner, we'd have to introduce another required method on\n    // `MatMenuPanel`, making it harder to consume.\n    if (!this._portal || this._portal.templateRef !== this.menu.templateRef) {\n      this._portal = new TemplatePortal(this.menu.templateRef, this._viewContainerRef);\n    }\n\n    return this._portal;\n  }\n\n}\n"]}
+}
+MatMenuTrigger.decorators = [
+    { type: Directive, args: [{
+                selector: `[mat-menu-trigger-for], [matMenuTriggerFor]`,
+                host: {
+                    'class': 'mat-menu-trigger',
+                    'aria-haspopup': 'true',
+                    '[attr.aria-expanded]': 'menuOpen || null',
+                    '[attr.aria-controls]': 'menuOpen ? menu.panelId : null',
+                    '(mousedown)': '_handleMousedown($event)',
+                    '(keydown)': '_handleKeydown($event)',
+                    '(click)': '_handleClick($event)',
+                },
+                exportAs: 'matMenuTrigger'
+            },] }
+];
+MatMenuTrigger.ctorParameters = () => [
+    { type: Overlay },
+    { type: ElementRef },
+    { type: ViewContainerRef },
+    { type: undefined, decorators: [{ type: Inject, args: [MAT_MENU_SCROLL_STRATEGY,] }] },
+    { type: MatMenu, decorators: [{ type: Optional }] },
+    { type: MatMenuItem, decorators: [{ type: Optional }, { type: Self }] },
+    { type: Directionality, decorators: [{ type: Optional }] },
+    { type: FocusMonitor }
+];
+MatMenuTrigger.propDecorators = {
+    _deprecatedMatMenuTriggerFor: [{ type: Input, args: ['mat-menu-trigger-for',] }],
+    menu: [{ type: Input, args: ['matMenuTriggerFor',] }],
+    menuData: [{ type: Input, args: ['matMenuTriggerData',] }],
+    restoreFocus: [{ type: Input, args: ['matMenuTriggerRestoreFocus',] }],
+    menuOpened: [{ type: Output }],
+    onMenuOpen: [{ type: Output }],
+    menuClosed: [{ type: Output }],
+    onMenuClose: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-trigger.js","sourceRoot":"","sources":["../../../../../../src/material/menu/menu-trigger.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {FocusMonitor, FocusOrigin, isFakeMousedownFromScreenReader} from '@angular/cdk/a11y';\nimport {Direction, Directionality} from '@angular/cdk/bidi';\nimport {LEFT_ARROW, RIGHT_ARROW} from '@angular/cdk/keycodes';\nimport {\n  FlexibleConnectedPositionStrategy,\n  HorizontalConnectionPos,\n  Overlay,\n  OverlayConfig,\n  OverlayRef,\n  VerticalConnectionPos,\n  ScrollStrategy,\n} from '@angular/cdk/overlay';\nimport {TemplatePortal} from '@angular/cdk/portal';\nimport {\n  AfterContentInit,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  InjectionToken,\n  Input,\n  OnDestroy,\n  Optional,\n  Output,\n  Self,\n  ViewContainerRef,\n} from '@angular/core';\nimport {normalizePassiveListenerOptions} from '@angular/cdk/platform';\nimport {asapScheduler, merge, of as observableOf, Subscription} from 'rxjs';\nimport {delay, filter, take, takeUntil} from 'rxjs/operators';\nimport {MatMenu} from './menu';\nimport {throwMatMenuMissingError} from './menu-errors';\nimport {MatMenuItem} from './menu-item';\nimport {MatMenuPanel} from './menu-panel';\nimport {MenuPositionX, MenuPositionY} from './menu-positions';\n\n/** Injection token that determines the scroll handling while the menu is open. */\nexport const MAT_MENU_SCROLL_STRATEGY =\n    new InjectionToken<() => ScrollStrategy>('mat-menu-scroll-strategy');\n\n/** @docs-private */\nexport function MAT_MENU_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy {\n  return () => overlay.scrollStrategies.reposition();\n}\n\n/** @docs-private */\nexport const MAT_MENU_SCROLL_STRATEGY_FACTORY_PROVIDER = {\n  provide: MAT_MENU_SCROLL_STRATEGY,\n  deps: [Overlay],\n  useFactory: MAT_MENU_SCROLL_STRATEGY_FACTORY,\n};\n\n/** Default top padding of the menu panel. */\nexport const MENU_PANEL_TOP_PADDING = 8;\n\n/** Options for binding a passive event listener. */\nconst passiveEventListenerOptions = normalizePassiveListenerOptions({passive: true});\n\n// TODO(andrewseguin): Remove the kebab versions in favor of camelCased attribute selectors\n\n/** Directive applied to an element that should trigger a `mat-menu`. */\n@Directive({\n  selector: `[mat-menu-trigger-for], [matMenuTriggerFor]`,\n  host: {\n    'class': 'mat-menu-trigger',\n    'aria-haspopup': 'true',\n    '[attr.aria-expanded]': 'menuOpen || null',\n    '[attr.aria-controls]': 'menuOpen ? menu.panelId : null',\n    '(mousedown)': '_handleMousedown($event)',\n    '(keydown)': '_handleKeydown($event)',\n    '(click)': '_handleClick($event)',\n  },\n  exportAs: 'matMenuTrigger'\n})\nexport class MatMenuTrigger implements AfterContentInit, OnDestroy {\n  private _portal: TemplatePortal;\n  private _overlayRef: OverlayRef | null = null;\n  private _menuOpen: boolean = false;\n  private _closingActionsSubscription = Subscription.EMPTY;\n  private _hoverSubscription = Subscription.EMPTY;\n  private _menuCloseSubscription = Subscription.EMPTY;\n  private _scrollStrategy: () => ScrollStrategy;\n\n  /**\n   * Handles touch start events on the trigger.\n   * Needs to be an arrow function so we can easily use addEventListener and removeEventListener.\n   */\n  private _handleTouchStart = () => this._openedBy = 'touch';\n\n  // Tracking input type is necessary so it's possible to only auto-focus\n  // the first item of the list when the menu is opened via the keyboard\n  _openedBy: 'mouse' | 'touch' | null = null;\n\n  /**\n   * @deprecated\n   * @breaking-change 8.0.0\n   */\n  @Input('mat-menu-trigger-for')\n  get _deprecatedMatMenuTriggerFor(): MatMenuPanel { return this.menu; }\n  set _deprecatedMatMenuTriggerFor(v: MatMenuPanel) {\n    this.menu = v;\n  }\n\n  /** References the menu instance that the trigger is associated with. */\n  @Input('matMenuTriggerFor')\n  get menu() { return this._menu; }\n  set menu(menu: MatMenuPanel) {\n    if (menu === this._menu) {\n      return;\n    }\n\n    this._menu = menu;\n    this._menuCloseSubscription.unsubscribe();\n\n    if (menu) {\n      this._menuCloseSubscription = menu.close.asObservable().subscribe(reason => {\n        this._destroyMenu();\n\n        // If a click closed the menu, we should close the entire chain of nested menus.\n        if ((reason === 'click' || reason === 'tab') && this._parentMenu) {\n          this._parentMenu.closed.emit(reason);\n        }\n      });\n    }\n  }\n  private _menu: MatMenuPanel;\n\n  /** Data to be passed along to any lazily-rendered content. */\n  @Input('matMenuTriggerData') menuData: any;\n\n  /**\n   * Whether focus should be restored when the menu is closed.\n   * Note that disabling this option can have accessibility implications\n   * and it's up to you to manage focus, if you decide to turn it off.\n   */\n  @Input('matMenuTriggerRestoreFocus') restoreFocus: boolean = true;\n\n  /** Event emitted when the associated menu is opened. */\n  @Output() readonly menuOpened: EventEmitter<void> = new EventEmitter<void>();\n\n  /**\n   * Event emitted when the associated menu is opened.\n   * @deprecated Switch to `menuOpened` instead\n   * @breaking-change 8.0.0\n   */\n  // tslint:disable-next-line:no-output-on-prefix\n  @Output() readonly onMenuOpen: EventEmitter<void> = this.menuOpened;\n\n  /** Event emitted when the associated menu is closed. */\n  @Output() readonly menuClosed: EventEmitter<void> = new EventEmitter<void>();\n\n  /**\n   * Event emitted when the associated menu is closed.\n   * @deprecated Switch to `menuClosed` instead\n   * @breaking-change 8.0.0\n   */\n  // tslint:disable-next-line:no-output-on-prefix\n  @Output() readonly onMenuClose: EventEmitter<void> = this.menuClosed;\n\n  constructor(private _overlay: Overlay,\n              private _element: ElementRef<HTMLElement>,\n              private _viewContainerRef: ViewContainerRef,\n              @Inject(MAT_MENU_SCROLL_STRATEGY) scrollStrategy: any,\n              @Optional() private _parentMenu: MatMenu,\n              @Optional() @Self() private _menuItemInstance: MatMenuItem,\n              @Optional() private _dir: Directionality,\n              // TODO(crisbeto): make the _focusMonitor required when doing breaking changes.\n              // @breaking-change 8.0.0\n              private _focusMonitor?: FocusMonitor) {\n\n    _element.nativeElement.addEventListener('touchstart', this._handleTouchStart,\n        passiveEventListenerOptions);\n\n    if (_menuItemInstance) {\n      _menuItemInstance._triggersSubmenu = this.triggersSubmenu();\n    }\n\n    this._scrollStrategy = scrollStrategy;\n  }\n\n  ngAfterContentInit() {\n    this._checkMenu();\n    this._handleHover();\n  }\n\n  ngOnDestroy() {\n    if (this._overlayRef) {\n      this._overlayRef.dispose();\n      this._overlayRef = null;\n    }\n\n    this._element.nativeElement.removeEventListener('touchstart', this._handleTouchStart,\n        passiveEventListenerOptions);\n\n    this._menuCloseSubscription.unsubscribe();\n    this._closingActionsSubscription.unsubscribe();\n    this._hoverSubscription.unsubscribe();\n  }\n\n  /** Whether the menu is open. */\n  get menuOpen(): boolean {\n    return this._menuOpen;\n  }\n\n  /** The text direction of the containing app. */\n  get dir(): Direction {\n    return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';\n  }\n\n  /** Whether the menu triggers a sub-menu or a top-level one. */\n  triggersSubmenu(): boolean {\n    return !!(this._menuItemInstance && this._parentMenu);\n  }\n\n  /** Toggles the menu between the open and closed states. */\n  toggleMenu(): void {\n    return this._menuOpen ? this.closeMenu() : this.openMenu();\n  }\n\n  /** Opens the menu. */\n  openMenu(): void {\n    if (this._menuOpen) {\n      return;\n    }\n\n    this._checkMenu();\n\n    const overlayRef = this._createOverlay();\n    const overlayConfig = overlayRef.getConfig();\n\n    this._setPosition(overlayConfig.positionStrategy as FlexibleConnectedPositionStrategy);\n    overlayConfig.hasBackdrop = this.menu.hasBackdrop == null ? !this.triggersSubmenu() :\n        this.menu.hasBackdrop;\n    overlayRef.attach(this._getPortal());\n\n    if (this.menu.lazyContent) {\n      this.menu.lazyContent.attach(this.menuData);\n    }\n\n    this._closingActionsSubscription = this._menuClosingActions().subscribe(() => this.closeMenu());\n    this._initMenu();\n\n    if (this.menu instanceof MatMenu) {\n      this.menu._startAnimation();\n    }\n  }\n\n  /** Closes the menu. */\n  closeMenu(): void {\n    this.menu.close.emit();\n  }\n\n  /**\n   * Focuses the menu trigger.\n   * @param origin Source of the menu trigger's focus.\n   */\n  focus(origin: FocusOrigin = 'program', options?: FocusOptions) {\n    if (this._focusMonitor) {\n      this._focusMonitor.focusVia(this._element, origin, options);\n    } else {\n      this._element.nativeElement.focus(options);\n    }\n  }\n\n  /** Closes the menu and does the necessary cleanup. */\n  private _destroyMenu() {\n    if (!this._overlayRef || !this.menuOpen) {\n      return;\n    }\n\n    const menu = this.menu;\n    this._closingActionsSubscription.unsubscribe();\n    this._overlayRef.detach();\n    this._restoreFocus();\n\n    if (menu instanceof MatMenu) {\n      menu._resetAnimation();\n\n      if (menu.lazyContent) {\n        // Wait for the exit animation to finish before detaching the content.\n        menu._animationDone\n          .pipe(\n            filter(event => event.toState === 'void'),\n            take(1),\n            // Interrupt if the content got re-attached.\n            takeUntil(menu.lazyContent._attached)\n          )\n          .subscribe({\n            next: () => menu.lazyContent!.detach(),\n            // No matter whether the content got re-attached, reset the menu.\n            complete: () => this._setIsMenuOpen(false)\n          });\n      } else {\n        this._setIsMenuOpen(false);\n      }\n    } else {\n      this._setIsMenuOpen(false);\n\n      if (menu.lazyContent) {\n        menu.lazyContent.detach();\n      }\n    }\n  }\n\n  /**\n   * This method sets the menu state to open and focuses the first item if\n   * the menu was opened via the keyboard.\n   */\n  private _initMenu(): void {\n    this.menu.parentMenu = this.triggersSubmenu() ? this._parentMenu : undefined;\n    this.menu.direction = this.dir;\n    this._setMenuElevation();\n    this._setIsMenuOpen(true);\n    this.menu.focusFirstItem(this._openedBy || 'program');\n  }\n\n  /** Updates the menu elevation based on the amount of parent menus that it has. */\n  private _setMenuElevation(): void {\n    if (this.menu.setElevation) {\n      let depth = 0;\n      let parentMenu = this.menu.parentMenu;\n\n      while (parentMenu) {\n        depth++;\n        parentMenu = parentMenu.parentMenu;\n      }\n\n      this.menu.setElevation(depth);\n    }\n  }\n\n  /** Restores focus to the element that was focused before the menu was open. */\n  private _restoreFocus() {\n    // We should reset focus if the user is navigating using a keyboard or\n    // if we have a top-level trigger which might cause focus to be lost\n    // when clicking on the backdrop.\n    if (this.restoreFocus) {\n      if (!this._openedBy) {\n        // Note that the focus style will show up both for `program` and\n        // `keyboard` so we don't have to specify which one it is.\n        this.focus();\n      } else if (!this.triggersSubmenu()) {\n        this.focus(this._openedBy);\n      }\n    }\n\n    this._openedBy = null;\n  }\n\n  // set state rather than toggle to support triggers sharing a menu\n  private _setIsMenuOpen(isOpen: boolean): void {\n    this._menuOpen = isOpen;\n    this._menuOpen ? this.menuOpened.emit() : this.menuClosed.emit();\n\n    if (this.triggersSubmenu()) {\n      this._menuItemInstance._highlighted = isOpen;\n    }\n  }\n\n  /**\n   * This method checks that a valid instance of MatMenu has been passed into\n   * matMenuTriggerFor. If not, an exception is thrown.\n   */\n  private _checkMenu() {\n    if (!this.menu) {\n      throwMatMenuMissingError();\n    }\n  }\n\n  /**\n   * This method creates the overlay from the provided menu's template and saves its\n   * OverlayRef so that it can be attached to the DOM when openMenu is called.\n   */\n  private _createOverlay(): OverlayRef {\n    if (!this._overlayRef) {\n      const config = this._getOverlayConfig();\n      this._subscribeToPositions(config.positionStrategy as FlexibleConnectedPositionStrategy);\n      this._overlayRef = this._overlay.create(config);\n\n      // Consume the `keydownEvents` in order to prevent them from going to another overlay.\n      // Ideally we'd also have our keyboard event logic in here, however doing so will\n      // break anybody that may have implemented the `MatMenuPanel` themselves.\n      this._overlayRef.keydownEvents().subscribe();\n    }\n\n    return this._overlayRef;\n  }\n\n  /**\n   * This method builds the configuration object needed to create the overlay, the OverlayState.\n   * @returns OverlayConfig\n   */\n  private _getOverlayConfig(): OverlayConfig {\n    return new OverlayConfig({\n      positionStrategy: this._overlay.position()\n          .flexibleConnectedTo(this._element)\n          .withLockedPosition()\n          .withTransformOriginOn('.mat-menu-panel, .mat-mdc-menu-panel'),\n      backdropClass: this.menu.backdropClass || 'cdk-overlay-transparent-backdrop',\n      panelClass: this.menu.overlayPanelClass,\n      scrollStrategy: this._scrollStrategy(),\n      direction: this._dir\n    });\n  }\n\n  /**\n   * Listens to changes in the position of the overlay and sets the correct classes\n   * on the menu based on the new position. This ensures the animation origin is always\n   * correct, even if a fallback position is used for the overlay.\n   */\n  private _subscribeToPositions(position: FlexibleConnectedPositionStrategy): void {\n    if (this.menu.setPositionClasses) {\n      position.positionChanges.subscribe(change => {\n        const posX: MenuPositionX = change.connectionPair.overlayX === 'start' ? 'after' : 'before';\n        const posY: MenuPositionY = change.connectionPair.overlayY === 'top' ? 'below' : 'above';\n\n        this.menu.setPositionClasses!(posX, posY);\n      });\n    }\n  }\n\n  /**\n   * Sets the appropriate positions on a position strategy\n   * so the overlay connects with the trigger correctly.\n   * @param positionStrategy Strategy whose position to update.\n   */\n  private _setPosition(positionStrategy: FlexibleConnectedPositionStrategy) {\n    let [originX, originFallbackX]: HorizontalConnectionPos[] =\n        this.menu.xPosition === 'before' ? ['end', 'start'] : ['start', 'end'];\n\n    let [overlayY, overlayFallbackY]: VerticalConnectionPos[] =\n        this.menu.yPosition === 'above' ? ['bottom', 'top'] : ['top', 'bottom'];\n\n    let [originY, originFallbackY] = [overlayY, overlayFallbackY];\n    let [overlayX, overlayFallbackX] = [originX, originFallbackX];\n    let offsetY = 0;\n\n    if (this.triggersSubmenu()) {\n      // When the menu is a sub-menu, it should always align itself\n      // to the edges of the trigger, instead of overlapping it.\n      overlayFallbackX = originX = this.menu.xPosition === 'before' ? 'start' : 'end';\n      originFallbackX = overlayX = originX === 'end' ? 'start' : 'end';\n      offsetY = overlayY === 'bottom' ? MENU_PANEL_TOP_PADDING : -MENU_PANEL_TOP_PADDING;\n    } else if (!this.menu.overlapTrigger) {\n      originY = overlayY === 'top' ? 'bottom' : 'top';\n      originFallbackY = overlayFallbackY === 'top' ? 'bottom' : 'top';\n    }\n\n    positionStrategy.withPositions([\n      {originX, originY, overlayX, overlayY, offsetY},\n      {originX: originFallbackX, originY, overlayX: overlayFallbackX, overlayY, offsetY},\n      {\n        originX,\n        originY: originFallbackY,\n        overlayX,\n        overlayY: overlayFallbackY,\n        offsetY: -offsetY\n      },\n      {\n        originX: originFallbackX,\n        originY: originFallbackY,\n        overlayX: overlayFallbackX,\n        overlayY: overlayFallbackY,\n        offsetY: -offsetY\n      }\n    ]);\n  }\n\n  /** Returns a stream that emits whenever an action that should close the menu occurs. */\n  private _menuClosingActions() {\n    const backdrop = this._overlayRef!.backdropClick();\n    const detachments = this._overlayRef!.detachments();\n    const parentClose = this._parentMenu ? this._parentMenu.closed : observableOf();\n    const hover = this._parentMenu ? this._parentMenu._hovered().pipe(\n      filter(active => active !== this._menuItemInstance),\n      filter(() => this._menuOpen)\n    ) : observableOf();\n\n    return merge(backdrop, parentClose, hover, detachments);\n  }\n\n  /** Handles mouse presses on the trigger. */\n  _handleMousedown(event: MouseEvent): void {\n    if (!isFakeMousedownFromScreenReader(event)) {\n      // Since right or middle button clicks won't trigger the `click` event,\n      // we shouldn't consider the menu as opened by mouse in those cases.\n      this._openedBy = event.button === 0 ? 'mouse' : null;\n\n      // Since clicking on the trigger won't close the menu if it opens a sub-menu,\n      // we should prevent focus from moving onto it via click to avoid the\n      // highlight from lingering on the menu item.\n      if (this.triggersSubmenu()) {\n        event.preventDefault();\n      }\n    }\n  }\n\n  /** Handles key presses on the trigger. */\n  _handleKeydown(event: KeyboardEvent): void {\n    const keyCode = event.keyCode;\n\n    if (this.triggersSubmenu() && (\n            (keyCode === RIGHT_ARROW && this.dir === 'ltr') ||\n            (keyCode === LEFT_ARROW && this.dir === 'rtl'))) {\n      this.openMenu();\n    }\n  }\n\n  /** Handles click events on the trigger. */\n  _handleClick(event: MouseEvent): void {\n    if (this.triggersSubmenu()) {\n      // Stop event propagation to avoid closing the parent menu.\n      event.stopPropagation();\n      this.openMenu();\n    } else {\n      this.toggleMenu();\n    }\n  }\n\n  /** Handles the cases where the user hovers over the trigger. */\n  private _handleHover() {\n    // Subscribe to changes in the hovered item in order to toggle the panel.\n    if (!this.triggersSubmenu()) {\n      return;\n    }\n\n    this._hoverSubscription = this._parentMenu._hovered()\n      // Since we might have multiple competing triggers for the same menu (e.g. a sub-menu\n      // with different data and triggers), we have to delay it by a tick to ensure that\n      // it won't be closed immediately after it is opened.\n      .pipe(\n        filter(active => active === this._menuItemInstance && !active.disabled),\n        delay(0, asapScheduler)\n      )\n      .subscribe(() => {\n        this._openedBy = 'mouse';\n\n        // If the same menu is used between multiple triggers, it might still be animating\n        // while the new trigger tries to re-open it. Wait for the animation to finish\n        // before doing so. Also interrupt if the user moves to another item.\n        if (this.menu instanceof MatMenu && this.menu._isAnimating) {\n          // We need the `delay(0)` here in order to avoid\n          // 'changed after checked' errors in some cases. See #12194.\n          this.menu._animationDone\n            .pipe(take(1), delay(0, asapScheduler), takeUntil(this._parentMenu._hovered()))\n            .subscribe(() => this.openMenu());\n        } else {\n          this.openMenu();\n        }\n      });\n  }\n\n  /** Gets the portal that should be attached to the overlay. */\n  private _getPortal(): TemplatePortal {\n    // Note that we can avoid this check by keeping the portal on the menu panel.\n    // While it would be cleaner, we'd have to introduce another required method on\n    // `MatMenuPanel`, making it harder to consume.\n    if (!this._portal || this._portal.templateRef !== this.menu.templateRef) {\n      this._portal = new TemplatePortal(this.menu.templateRef, this._viewContainerRef);\n    }\n\n    return this._portal;\n  }\n\n}\n"]}