{"version":3,"file":"217.96e62b49965b576a.js","mappings":"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","names":["i0","_r2","ctx_r1","ctx_r3","ctx_r4","ctx_r5","MAT_MENU_PANEL","InjectionToken","_MatMenuItemBase","mixinDisableRipple","mixinDisabled","MatMenuItem","constructor","_elementRef","_document","_focusMonitor","_parentMenu","_changeDetectorRef","super","this","role","_hovered","Subject","_focused","_highlighted","_triggersSubmenu","addItem","focus","origin","options","focusVia","_getHostElement","next","ngAfterViewInit","monitor","ngOnDestroy","stopMonitoring","removeItem","complete","_getTabIndex","disabled","nativeElement","_checkDisabled","event","preventDefault","stopPropagation","_handleMouseEnter","getLabel","clone","cloneNode","icons","querySelectorAll","i","length","remove","textContent","trim","_setHighlighted","isHighlighted","markForCheck","_setTriggersSubmenu","triggersSubmenu","_hasFocus","activeElement","ɵfac","DOCUMENT","i1","ɵcmp","selectors","ctx","attrs","_c1","i2","i3","encapsulation","MAT_MENU_CONTENT","matMenuAnimations","transformMenu","trigger","state","style","opacity","transform","transition","animate","fadeInItems","menuPanelUid","MAT_MENU_DEFAULT_OPTIONS","providedIn","factory","MAT_MENU_DEFAULT_OPTIONS_FACTORY","overlapTrigger","xPosition","yPosition","backdropClass","_MatMenuBase","_xPosition","value","setPositionClasses","_yPosition","_overlapTrigger","coerceBooleanProperty","hasBackdrop","_hasBackdrop","panelClass","classes","previousPanelClass","_previousPanelClass","split","forEach","className","_classList","classList","_ngZone","_defaultOptions","_directDescendantItems","QueryList","_panelAnimationState","_animationDone","overlayPanelClass","closed","EventEmitter","close","panelId","ngOnInit","ngAfterContentInit","_updateDirectDescendants","_keyManager","FocusKeyManager","withWrap","withTypeAhead","withHomeAndEnd","tabOut","subscribe","emit","changes","pipe","startWith","switchMap","items","merge","map","item","focusedItem","updateActiveItem","itemsList","manager","activeItem","toArray","index","Math","max","min","activeItemIndex","setActiveItem","setNextItemActive","destroy","_firstItemFocusSubscription","unsubscribe","_item","_handleKeydown","keyCode","ESCAPE","hasModifierKey","LEFT_ARROW","parentMenu","direction","RIGHT_ARROW","UP_ARROW","DOWN_ARROW","setFocusOrigin","onKeydown","focusFirstItem","onStable","take","menuPanel","first","closest","contains","document","setFirstItemActive","resetActiveItem","setElevation","depth","elevation","_baseElevation","newElevation","_elevationPrefix","customElevation","Object","keys","find","startsWith","_previousElevation","posX","posY","_startAnimation","_resetAnimation","_onAnimationDone","_isAnimating","_onAnimationStart","toState","element","scrollTop","_allItems","reset","filter","notifyOnChanges","ɵdir","contentQueries","dirIndex","_t","TemplateRef","MatMenu","changeDetectorRef","provide","useExisting","ngContentSelectors","styles","changeDetection","MAT_MENU_SCROLL_STRATEGY","MAT_MENU_SCROLL_STRATEGY_FACTORY_PROVIDER","deps","Overlay","useFactory","MAT_MENU_SCROLL_STRATEGY_FACTORY","overlay","scrollStrategies","reposition","passiveEventListenerOptions","normalizePassiveListenerOptions","passive","_MatMenuTriggerBase","_deprecatedMatMenuTriggerFor","menu","v","_menu","_menuCloseSubscription","reason","_destroyMenu","_parentMaterialMenu","_menuItemInstance","_overlay","_element","_viewContainerRef","scrollStrategy","_dir","_overlayRef","_menuOpen","_closingActionsSubscription","Subscription","_hoverSubscription","inject","ChangeDetectorRef","_handleTouchStart","isFakeTouchstartFromScreenReader","_openedBy","undefined","restoreFocus","menuOpened","onMenuOpen","menuClosed","onMenuClose","_scrollStrategy","addEventListener","_handleHover","dispose","removeEventListener","menuOpen","dir","toggleMenu","closeMenu","openMenu","overlayRef","_createOverlay","overlayConfig","getConfig","positionStrategy","_setPosition","attach","_getPortal","lazyContent","menuData","_menuClosingActions","_initMenu","takeUntil","withLockedPosition","reapplyLastPosition","updatePosition","detach","_attached","_setIsMenuOpen","_setMenuElevation","isOpen","config","_getOverlayConfig","_subscribeToPositions","create","keydownEvents","OverlayConfig","position","flexibleConnectedTo","withGrowAfterOpen","withTransformOriginOn","positionChanges","change","connectionPair","overlayX","overlayY","run","originX","originFallbackX","overlayFallbackY","originY","originFallbackY","overlayFallbackX","offsetY","_parentInnerPadding","firstItem","offsetTop","withPositions","backdrop","backdropClick","detachments","parentClose","of","hover","active","_handleMousedown","isFakeMousedownFromScreenReader","button","ENTER","SPACE","_handleClick","delay","asapScheduler","_portal","templateRef","TemplatePortal","i1$1","i3$1","hostVars","MatMenuTrigger","t","MatMenuModule","ɵmod","ɵinj","imports","CommonModule","MatRippleModule","MatCommonModule","OverlayModule","CdkScrollableModule"],"sourceRoot":"webpack:///","sources":["./node_modules/@angular/material/fesm2020/menu.mjs"],"sourcesContent":["import * as i0 from '@angular/core';\nimport { InjectionToken, Component, ChangeDetectionStrategy, ViewEncapsulation, Inject, Optional, Input, Directive, QueryList, EventEmitter, TemplateRef, ContentChildren, ViewChild, ContentChild, Output, inject, ChangeDetectorRef, Self, NgModule } from '@angular/core';\nimport * as i1 from '@angular/cdk/a11y';\nimport { FocusKeyManager, isFakeTouchstartFromScreenReader, isFakeMousedownFromScreenReader } from '@angular/cdk/a11y';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { UP_ARROW, DOWN_ARROW, RIGHT_ARROW, LEFT_ARROW, ESCAPE, hasModifierKey, ENTER, SPACE } from '@angular/cdk/keycodes';\nimport { Subject, merge, Subscription, of, asapScheduler } from 'rxjs';\nimport { startWith, switchMap, take, takeUntil, filter, delay } from 'rxjs/operators';\nimport * as i3 from '@angular/material/core';\nimport { mixinDisableRipple, mixinDisabled, MatRippleModule, MatCommonModule } from '@angular/material/core';\nimport * as i2 from '@angular/common';\nimport { DOCUMENT, CommonModule } from '@angular/common';\nimport { TemplatePortal, DomPortalOutlet } from '@angular/cdk/portal';\nimport { trigger, state, style, transition, animate } from '@angular/animations';\nimport * as i3$1 from '@angular/cdk/bidi';\nimport * as i1$1 from '@angular/cdk/overlay';\nimport { Overlay, OverlayConfig, OverlayModule } from '@angular/cdk/overlay';\nimport { normalizePassiveListenerOptions } from '@angular/cdk/platform';\nimport { CdkScrollableModule } from '@angular/cdk/scrolling';\n\n/**\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/**\n * Injection token used to provide the parent menu to menu-specific components.\n * @docs-private\n */\nconst MAT_MENU_PANEL = new InjectionToken('MAT_MENU_PANEL');\n\n/**\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// Boilerplate for applying mixins to MatMenuItem.\n/** @docs-private */\nconst _MatMenuItemBase = mixinDisableRipple(mixinDisabled(class {\n}));\n/**\n * Single item inside of a `mat-menu`. Provides the menu item styling and accessibility treatment.\n */\nclass MatMenuItem extends _MatMenuItemBase {\n    constructor(_elementRef, _document, _focusMonitor, _parentMenu, _changeDetectorRef) {\n        super();\n        this._elementRef = _elementRef;\n        this._document = _document;\n        this._focusMonitor = _focusMonitor;\n        this._parentMenu = _parentMenu;\n        this._changeDetectorRef = _changeDetectorRef;\n        /** ARIA role for the menu item. */\n        this.role = 'menuitem';\n        /** Stream that emits when the menu item is hovered. */\n        this._hovered = new Subject();\n        /** Stream that emits when the menu item is focused. */\n        this._focused = new Subject();\n        /** Whether the menu item is highlighted. */\n        this._highlighted = false;\n        /** Whether the menu item acts as a trigger for a sub-menu. */\n        this._triggersSubmenu = false;\n        _parentMenu?.addItem?.(this);\n    }\n    /** Focuses the menu item. */\n    focus(origin, options) {\n        if (this._focusMonitor && origin) {\n            this._focusMonitor.focusVia(this._getHostElement(), origin, options);\n        }\n        else {\n            this._getHostElement().focus(options);\n        }\n        this._focused.next(this);\n    }\n    ngAfterViewInit() {\n        if (this._focusMonitor) {\n            // Start monitoring the element so it gets the appropriate focused classes. We want\n            // to show the focus style for menu items only when the focus was not caused by a\n            // mouse or touch interaction.\n            this._focusMonitor.monitor(this._elementRef, false);\n        }\n    }\n    ngOnDestroy() {\n        if (this._focusMonitor) {\n            this._focusMonitor.stopMonitoring(this._elementRef);\n        }\n        if (this._parentMenu && this._parentMenu.removeItem) {\n            this._parentMenu.removeItem(this);\n        }\n        this._hovered.complete();\n        this._focused.complete();\n    }\n    /** Used to set the `tabindex`. */\n    _getTabIndex() {\n        return this.disabled ? '-1' : '0';\n    }\n    /** Returns the host DOM element. */\n    _getHostElement() {\n        return this._elementRef.nativeElement;\n    }\n    /** Prevents the default element actions if it is disabled. */\n    _checkDisabled(event) {\n        if (this.disabled) {\n            event.preventDefault();\n            event.stopPropagation();\n        }\n    }\n    /** Emits to the hover stream. */\n    _handleMouseEnter() {\n        this._hovered.next(this);\n    }\n    /** Gets the label to be used when determining whether the option should be focused. */\n    getLabel() {\n        const clone = this._elementRef.nativeElement.cloneNode(true);\n        const icons = clone.querySelectorAll('mat-icon, .material-icons');\n        // Strip away icons so they don't show up in the text.\n        for (let i = 0; i < icons.length; i++) {\n            icons[i].remove();\n        }\n        return clone.textContent?.trim() || '';\n    }\n    _setHighlighted(isHighlighted) {\n        // We need to mark this for check for the case where the content is coming from a\n        // `matMenuContent` whose change detection tree is at the declaration position,\n        // not the insertion position. See #23175.\n        // @breaking-change 12.0.0 Remove null check for `_changeDetectorRef`.\n        this._highlighted = isHighlighted;\n        this._changeDetectorRef?.markForCheck();\n    }\n    _setTriggersSubmenu(triggersSubmenu) {\n        // @breaking-change 12.0.0 Remove null check for `_changeDetectorRef`.\n        this._triggersSubmenu = triggersSubmenu;\n        this._changeDetectorRef?.markForCheck();\n    }\n    _hasFocus() {\n        return this._document && this._document.activeElement === this._getHostElement();\n    }\n}\nMatMenuItem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatMenuItem, deps: [{ token: i0.ElementRef }, { token: DOCUMENT }, { token: i1.FocusMonitor }, { token: MAT_MENU_PANEL, optional: true }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });\nMatMenuItem.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", type: MatMenuItem, selector: \"[mat-menu-item]\", inputs: { disabled: \"disabled\", disableRipple: \"disableRipple\", role: \"role\" }, host: { listeners: { \"click\": \"_checkDisabled($event)\", \"mouseenter\": \"_handleMouseEnter()\" }, properties: { \"attr.role\": \"role\", \"class.mat-mdc-menu-item-highlighted\": \"_highlighted\", \"class.mat-mdc-menu-item-submenu-trigger\": \"_triggersSubmenu\", \"attr.tabindex\": \"_getTabIndex()\", \"attr.aria-disabled\": \"disabled\", \"attr.disabled\": \"disabled || null\" }, classAttribute: \"mat-mdc-menu-item mat-mdc-focus-indicator mdc-list-item\" }, exportAs: [\"matMenuItem\"], usesInheritance: true, ngImport: i0, template: \"<ng-content select=\\\"mat-icon, [matMenuItemIcon]\\\"></ng-content>\\n<span class=\\\"mdc-list-item__primary-text\\\"><ng-content></ng-content></span>\\n<div class=\\\"mat-mdc-menu-ripple\\\" matRipple\\n     [matRippleDisabled]=\\\"disableRipple || disabled\\\"\\n     [matRippleTrigger]=\\\"_getHostElement()\\\">\\n</div>\\n<svg\\n  *ngIf=\\\"_triggersSubmenu\\\"\\n  class=\\\"mat-mdc-menu-submenu-icon\\\"\\n  viewBox=\\\"0 0 5 10\\\"\\n  focusable=\\\"false\\\"><polygon points=\\\"0,0 5,5 0,10\\\"/></svg>\\n\", dependencies: [{ kind: \"directive\", type: i2.NgIf, selector: \"[ngIf]\", inputs: [\"ngIf\", \"ngIfThen\", \"ngIfElse\"] }, { kind: \"directive\", type: i3.MatRipple, selector: \"[mat-ripple], [matRipple]\", inputs: [\"matRippleColor\", \"matRippleUnbounded\", \"matRippleCentered\", \"matRippleRadius\", \"matRippleAnimation\", \"matRippleDisabled\", \"matRippleTrigger\"], exportAs: [\"matRipple\"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatMenuItem, decorators: [{\n            type: Component,\n            args: [{ selector: '[mat-menu-item]', exportAs: 'matMenuItem', inputs: ['disabled', 'disableRipple'], host: {\n                        '[attr.role]': 'role',\n                        'class': 'mat-mdc-menu-item mat-mdc-focus-indicator mdc-list-item',\n                        '[class.mat-mdc-menu-item-highlighted]': '_highlighted',\n                        '[class.mat-mdc-menu-item-submenu-trigger]': '_triggersSubmenu',\n                        '[attr.tabindex]': '_getTabIndex()',\n                        '[attr.aria-disabled]': 'disabled',\n                        '[attr.disabled]': 'disabled || null',\n                        '(click)': '_checkDisabled($event)',\n                        '(mouseenter)': '_handleMouseEnter()',\n                    }, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: \"<ng-content select=\\\"mat-icon, [matMenuItemIcon]\\\"></ng-content>\\n<span class=\\\"mdc-list-item__primary-text\\\"><ng-content></ng-content></span>\\n<div class=\\\"mat-mdc-menu-ripple\\\" matRipple\\n     [matRippleDisabled]=\\\"disableRipple || disabled\\\"\\n     [matRippleTrigger]=\\\"_getHostElement()\\\">\\n</div>\\n<svg\\n  *ngIf=\\\"_triggersSubmenu\\\"\\n  class=\\\"mat-mdc-menu-submenu-icon\\\"\\n  viewBox=\\\"0 0 5 10\\\"\\n  focusable=\\\"false\\\"><polygon points=\\\"0,0 5,5 0,10\\\"/></svg>\\n\" }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: i1.FocusMonitor }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_MENU_PANEL]\n                }, {\n                    type: Optional\n                }] }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { role: [{\n                type: Input\n            }] } });\n\n/**\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/**\n * Throws an exception for the case when menu's x-position value isn't valid.\n * In other words, it doesn't match 'before' or 'after'.\n * @docs-private\n */\nfunction throwMatMenuInvalidPositionX() {\n    throw Error(`xPosition value must be either 'before' or after'.\n      Example: <mat-menu xPosition=\"before\" #menu=\"matMenu\"></mat-menu>`);\n}\n/**\n * Throws an exception for the case when menu's y-position value isn't valid.\n * In other words, it doesn't match 'above' or 'below'.\n * @docs-private\n */\nfunction throwMatMenuInvalidPositionY() {\n    throw Error(`yPosition value must be either 'above' or below'.\n      Example: <mat-menu yPosition=\"above\" #menu=\"matMenu\"></mat-menu>`);\n}\n/**\n * Throws an exception for the case when a menu is assigned\n * to a trigger that is placed inside the same menu.\n * @docs-private\n */\nfunction throwMatMenuRecursiveError() {\n    throw Error(`matMenuTriggerFor: menu cannot contain its own trigger. Assign a menu that is ` +\n        `not a parent of the trigger or move the trigger outside of the menu.`);\n}\n\n/**\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/**\n * Injection token that can be used to reference instances of `MatMenuContent`. It serves\n * as alternative token to the actual `MatMenuContent` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */\nconst MAT_MENU_CONTENT = new InjectionToken('MatMenuContent');\nclass _MatMenuContentBase {\n    constructor(_template, _componentFactoryResolver, _appRef, _injector, _viewContainerRef, _document, _changeDetectorRef) {\n        this._template = _template;\n        this._componentFactoryResolver = _componentFactoryResolver;\n        this._appRef = _appRef;\n        this._injector = _injector;\n        this._viewContainerRef = _viewContainerRef;\n        this._document = _document;\n        this._changeDetectorRef = _changeDetectorRef;\n        /** Emits when the menu content has been attached. */\n        this._attached = new Subject();\n    }\n    /**\n     * Attaches the content with a particular context.\n     * @docs-private\n     */\n    attach(context = {}) {\n        if (!this._portal) {\n            this._portal = new TemplatePortal(this._template, this._viewContainerRef);\n        }\n        this.detach();\n        if (!this._outlet) {\n            this._outlet = new DomPortalOutlet(this._document.createElement('div'), this._componentFactoryResolver, this._appRef, this._injector);\n        }\n        const element = this._template.elementRef.nativeElement;\n        // Because we support opening the same menu from different triggers (which in turn have their\n        // own `OverlayRef` panel), we have to re-insert the host element every time, otherwise we\n        // risk it staying attached to a pane that's no longer in the DOM.\n        element.parentNode.insertBefore(this._outlet.outletElement, element);\n        // When `MatMenuContent` is used in an `OnPush` component, the insertion of the menu\n        // content via `createEmbeddedView` does not cause the content to be seen as \"dirty\"\n        // by Angular. This causes the `@ContentChildren` for menu items within the menu to\n        // not be updated by Angular. By explicitly marking for check here, we tell Angular that\n        // it needs to check for new menu items and update the `@ContentChild` in `MatMenu`.\n        // @breaking-change 9.0.0 Make change detector ref required\n        this._changeDetectorRef?.markForCheck();\n        this._portal.attach(this._outlet, context);\n        this._attached.next();\n    }\n    /**\n     * Detaches the content.\n     * @docs-private\n     */\n    detach() {\n        if (this._portal.isAttached) {\n            this._portal.detach();\n        }\n    }\n    ngOnDestroy() {\n        if (this._outlet) {\n            this._outlet.dispose();\n        }\n    }\n}\n_MatMenuContentBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: _MatMenuContentBase, deps: [{ token: i0.TemplateRef }, { token: i0.ComponentFactoryResolver }, { token: i0.ApplicationRef }, { token: i0.Injector }, { token: i0.ViewContainerRef }, { token: DOCUMENT }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });\n_MatMenuContentBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", type: _MatMenuContentBase, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: _MatMenuContentBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ComponentFactoryResolver }, { type: i0.ApplicationRef }, { type: i0.Injector }, { type: i0.ViewContainerRef }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: i0.ChangeDetectorRef }]; } });\n/** Menu content that will be rendered lazily once the menu is opened. */\nclass MatMenuContent extends _MatMenuContentBase {\n}\nMatMenuContent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatMenuContent, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatMenuContent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", type: MatMenuContent, selector: \"ng-template[matMenuContent]\", providers: [{ provide: MAT_MENU_CONTENT, useExisting: MatMenuContent }], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatMenuContent, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'ng-template[matMenuContent]',\n                    providers: [{ provide: MAT_MENU_CONTENT, useExisting: MatMenuContent }],\n                }]\n        }] });\n\n/**\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/**\n * Animations used by the mat-menu component.\n * Animation duration and timing values are based on:\n * https://material.io/guidelines/components/menus.html#menus-usage\n * @docs-private\n */\nconst matMenuAnimations = {\n    /**\n     * This animation controls the menu panel's entry and exit from the page.\n     *\n     * When the menu panel is added to the DOM, it scales in and fades in its border.\n     *\n     * When the menu panel is removed from the DOM, it simply fades out after a brief\n     * delay to display the ripple.\n     */\n    transformMenu: trigger('transformMenu', [\n        state('void', style({\n            opacity: 0,\n            transform: 'scale(0.8)',\n        })),\n        transition('void => enter', animate('120ms cubic-bezier(0, 0, 0.2, 1)', style({\n            opacity: 1,\n            transform: 'scale(1)',\n        }))),\n        transition('* => void', animate('100ms 25ms linear', style({ opacity: 0 }))),\n    ]),\n    /**\n     * This animation fades in the background color and content of the menu panel\n     * after its containing element is scaled in.\n     */\n    fadeInItems: trigger('fadeInItems', [\n        // TODO(crisbeto): this is inside the `transformMenu`\n        // now. Remove next time we do breaking changes.\n        state('showing', style({ opacity: 1 })),\n        transition('void => *', [\n            style({ opacity: 0 }),\n            animate('400ms 100ms cubic-bezier(0.55, 0, 0.55, 0.2)'),\n        ]),\n    ]),\n};\n/**\n * @deprecated\n * @breaking-change 8.0.0\n * @docs-private\n */\nconst fadeInItems = matMenuAnimations.fadeInItems;\n/**\n * @deprecated\n * @breaking-change 8.0.0\n * @docs-private\n */\nconst transformMenu = matMenuAnimations.transformMenu;\n\n/**\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 */\nlet menuPanelUid = 0;\n/** Injection token to be used to override the default options for `mat-menu`. */\nconst MAT_MENU_DEFAULT_OPTIONS = new InjectionToken('mat-menu-default-options', {\n    providedIn: 'root',\n    factory: MAT_MENU_DEFAULT_OPTIONS_FACTORY,\n});\n/** @docs-private */\nfunction MAT_MENU_DEFAULT_OPTIONS_FACTORY() {\n    return {\n        overlapTrigger: false,\n        xPosition: 'after',\n        yPosition: 'below',\n        backdropClass: 'cdk-overlay-transparent-backdrop',\n    };\n}\n/** Base class with all of the `MatMenu` functionality. */\nclass _MatMenuBase {\n    /** Position of the menu in the X axis. */\n    get xPosition() {\n        return this._xPosition;\n    }\n    set xPosition(value) {\n        if (value !== 'before' &&\n            value !== 'after' &&\n            (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throwMatMenuInvalidPositionX();\n        }\n        this._xPosition = value;\n        this.setPositionClasses();\n    }\n    /** Position of the menu in the Y axis. */\n    get yPosition() {\n        return this._yPosition;\n    }\n    set yPosition(value) {\n        if (value !== 'above' && value !== 'below' && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throwMatMenuInvalidPositionY();\n        }\n        this._yPosition = value;\n        this.setPositionClasses();\n    }\n    /** Whether the menu should overlap its trigger. */\n    get overlapTrigger() {\n        return this._overlapTrigger;\n    }\n    set overlapTrigger(value) {\n        this._overlapTrigger = coerceBooleanProperty(value);\n    }\n    /** Whether the menu has a backdrop. */\n    get hasBackdrop() {\n        return this._hasBackdrop;\n    }\n    set hasBackdrop(value) {\n        this._hasBackdrop = coerceBooleanProperty(value);\n    }\n    /**\n     * This method takes classes set on the host mat-menu element and applies them on the\n     * menu template that displays in the overlay container.  Otherwise, it's difficult\n     * to style the containing menu from outside the component.\n     * @param classes list of class names\n     */\n    set panelClass(classes) {\n        const previousPanelClass = this._previousPanelClass;\n        if (previousPanelClass && previousPanelClass.length) {\n            previousPanelClass.split(' ').forEach((className) => {\n                this._classList[className] = false;\n            });\n        }\n        this._previousPanelClass = classes;\n        if (classes && classes.length) {\n            classes.split(' ').forEach((className) => {\n                this._classList[className] = true;\n            });\n            this._elementRef.nativeElement.className = '';\n        }\n    }\n    /**\n     * This method takes classes set on the host mat-menu element and applies them on the\n     * menu template that displays in the overlay container.  Otherwise, it's difficult\n     * to style the containing menu from outside the component.\n     * @deprecated Use `panelClass` instead.\n     * @breaking-change 8.0.0\n     */\n    get classList() {\n        return this.panelClass;\n    }\n    set classList(classes) {\n        this.panelClass = classes;\n    }\n    constructor(_elementRef, _ngZone, _defaultOptions, \n    // @breaking-change 15.0.0 `_changeDetectorRef` to become a required parameter.\n    _changeDetectorRef) {\n        this._elementRef = _elementRef;\n        this._ngZone = _ngZone;\n        this._defaultOptions = _defaultOptions;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._xPosition = this._defaultOptions.xPosition;\n        this._yPosition = this._defaultOptions.yPosition;\n        /** Only the direct descendant menu items. */\n        this._directDescendantItems = new QueryList();\n        /** Config object to be passed into the menu's ngClass */\n        this._classList = {};\n        /** Current state of the panel animation. */\n        this._panelAnimationState = 'void';\n        /** Emits whenever an animation on the menu completes. */\n        this._animationDone = new Subject();\n        /** Class or list of classes to be added to the overlay panel. */\n        this.overlayPanelClass = this._defaultOptions.overlayPanelClass || '';\n        /** Class to be added to the backdrop element. */\n        this.backdropClass = this._defaultOptions.backdropClass;\n        this._overlapTrigger = this._defaultOptions.overlapTrigger;\n        this._hasBackdrop = this._defaultOptions.hasBackdrop;\n        /** Event emitted when the menu is closed. */\n        this.closed = new EventEmitter();\n        /**\n         * Event emitted when the menu is closed.\n         * @deprecated Switch to `closed` instead\n         * @breaking-change 8.0.0\n         */\n        this.close = this.closed;\n        this.panelId = `mat-menu-panel-${menuPanelUid++}`;\n    }\n    ngOnInit() {\n        this.setPositionClasses();\n    }\n    ngAfterContentInit() {\n        this._updateDirectDescendants();\n        this._keyManager = new FocusKeyManager(this._directDescendantItems)\n            .withWrap()\n            .withTypeAhead()\n            .withHomeAndEnd();\n        this._keyManager.tabOut.subscribe(() => this.closed.emit('tab'));\n        // If a user manually (programmatically) focuses a menu item, we need to reflect that focus\n        // change back to the key manager. Note that we don't need to unsubscribe here because _focused\n        // is internal and we know that it gets completed on destroy.\n        this._directDescendantItems.changes\n            .pipe(startWith(this._directDescendantItems), switchMap(items => merge(...items.map((item) => item._focused))))\n            .subscribe(focusedItem => this._keyManager.updateActiveItem(focusedItem));\n        this._directDescendantItems.changes.subscribe((itemsList) => {\n            // Move focus to another item, if the active item is removed from the list.\n            // We need to debounce the callback, because multiple items might be removed\n            // in quick succession.\n            const manager = this._keyManager;\n            if (this._panelAnimationState === 'enter' && manager.activeItem?._hasFocus()) {\n                const items = itemsList.toArray();\n                const index = Math.max(0, Math.min(items.length - 1, manager.activeItemIndex || 0));\n                if (items[index] && !items[index].disabled) {\n                    manager.setActiveItem(index);\n                }\n                else {\n                    manager.setNextItemActive();\n                }\n            }\n        });\n    }\n    ngOnDestroy() {\n        this._keyManager?.destroy();\n        this._directDescendantItems.destroy();\n        this.closed.complete();\n        this._firstItemFocusSubscription?.unsubscribe();\n    }\n    /** Stream that emits whenever the hovered menu item changes. */\n    _hovered() {\n        // Coerce the `changes` property because Angular types it as `Observable<any>`\n        const itemChanges = this._directDescendantItems.changes;\n        return itemChanges.pipe(startWith(this._directDescendantItems), switchMap(items => merge(...items.map((item) => item._hovered))));\n    }\n    /*\n     * Registers a menu item with the menu.\n     * @docs-private\n     * @deprecated No longer being used. To be removed.\n     * @breaking-change 9.0.0\n     */\n    addItem(_item) { }\n    /**\n     * Removes an item from the menu.\n     * @docs-private\n     * @deprecated No longer being used. To be removed.\n     * @breaking-change 9.0.0\n     */\n    removeItem(_item) { }\n    /** Handle a keyboard event from the menu, delegating to the appropriate action. */\n    _handleKeydown(event) {\n        const keyCode = event.keyCode;\n        const manager = this._keyManager;\n        switch (keyCode) {\n            case ESCAPE:\n                if (!hasModifierKey(event)) {\n                    event.preventDefault();\n                    this.closed.emit('keydown');\n                }\n                break;\n            case LEFT_ARROW:\n                if (this.parentMenu && this.direction === 'ltr') {\n                    this.closed.emit('keydown');\n                }\n                break;\n            case RIGHT_ARROW:\n                if (this.parentMenu && this.direction === 'rtl') {\n                    this.closed.emit('keydown');\n                }\n                break;\n            default:\n                if (keyCode === UP_ARROW || keyCode === DOWN_ARROW) {\n                    manager.setFocusOrigin('keyboard');\n                }\n                manager.onKeydown(event);\n                return;\n        }\n        // Don't allow the event to propagate if we've already handled it, or it may\n        // end up reaching other overlays that were opened earlier (see #22694).\n        event.stopPropagation();\n    }\n    /**\n     * Focus the first item in the menu.\n     * @param origin Action from which the focus originated. Used to set the correct styling.\n     */\n    focusFirstItem(origin = 'program') {\n        // Wait for `onStable` to ensure iOS VoiceOver screen reader focuses the first item (#24735).\n        this._firstItemFocusSubscription?.unsubscribe();\n        this._firstItemFocusSubscription = this._ngZone.onStable.pipe(take(1)).subscribe(() => {\n            let menuPanel = null;\n            if (this._directDescendantItems.length) {\n                // Because the `mat-menuPanel` is at the DOM insertion point, not inside the overlay, we don't\n                // have a nice way of getting a hold of the menuPanel panel. We can't use a `ViewChild` either\n                // because the panel is inside an `ng-template`. We work around it by starting from one of\n                // the items and walking up the DOM.\n                menuPanel = this._directDescendantItems.first._getHostElement().closest('[role=\"menu\"]');\n            }\n            // If an item in the menuPanel is already focused, avoid overriding the focus.\n            if (!menuPanel || !menuPanel.contains(document.activeElement)) {\n                const manager = this._keyManager;\n                manager.setFocusOrigin(origin).setFirstItemActive();\n                // If there's no active item at this point, it means that all the items are disabled.\n                // Move focus to the menuPanel panel so keyboard events like Escape still work. Also this will\n                // give _some_ feedback to screen readers.\n                if (!manager.activeItem && menuPanel) {\n                    menuPanel.focus();\n                }\n            }\n        });\n    }\n    /**\n     * Resets the active item in the menu. This is used when the menu is opened, allowing\n     * the user to start from the first option when pressing the down arrow.\n     */\n    resetActiveItem() {\n        this._keyManager.setActiveItem(-1);\n    }\n    /**\n     * Sets the menu panel elevation.\n     * @param depth Number of parent menus that come before the menu.\n     */\n    setElevation(depth) {\n        // The elevation starts at the base and increases by one for each level.\n        // Capped at 24 because that's the maximum elevation defined in the Material design spec.\n        const elevation = Math.min(this._baseElevation + depth, 24);\n        const newElevation = `${this._elevationPrefix}${elevation}`;\n        const customElevation = Object.keys(this._classList).find(className => {\n            return className.startsWith(this._elevationPrefix);\n        });\n        if (!customElevation || customElevation === this._previousElevation) {\n            if (this._previousElevation) {\n                this._classList[this._previousElevation] = false;\n            }\n            this._classList[newElevation] = true;\n            this._previousElevation = newElevation;\n        }\n    }\n    /**\n     * Adds classes to the menu panel based on its position. Can be used by\n     * consumers to add specific styling based on the position.\n     * @param posX Position of the menu along the x axis.\n     * @param posY Position of the menu along the y axis.\n     * @docs-private\n     */\n    setPositionClasses(posX = this.xPosition, posY = this.yPosition) {\n        const classes = this._classList;\n        classes['mat-menu-before'] = posX === 'before';\n        classes['mat-menu-after'] = posX === 'after';\n        classes['mat-menu-above'] = posY === 'above';\n        classes['mat-menu-below'] = posY === 'below';\n        // @breaking-change 15.0.0 Remove null check for `_changeDetectorRef`.\n        this._changeDetectorRef?.markForCheck();\n    }\n    /** Starts the enter animation. */\n    _startAnimation() {\n        // @breaking-change 8.0.0 Combine with _resetAnimation.\n        this._panelAnimationState = 'enter';\n    }\n    /** Resets the panel animation to its initial state. */\n    _resetAnimation() {\n        // @breaking-change 8.0.0 Combine with _startAnimation.\n        this._panelAnimationState = 'void';\n    }\n    /** Callback that is invoked when the panel animation completes. */\n    _onAnimationDone(event) {\n        this._animationDone.next(event);\n        this._isAnimating = false;\n    }\n    _onAnimationStart(event) {\n        this._isAnimating = true;\n        // Scroll the content element to the top as soon as the animation starts. This is necessary,\n        // because we move focus to the first item while it's still being animated, which can throw\n        // the browser off when it determines the scroll position. Alternatively we can move focus\n        // when the animation is done, however moving focus asynchronously will interrupt screen\n        // readers which are in the process of reading out the menu already. We take the `element`\n        // from the `event` since we can't use a `ViewChild` to access the pane.\n        if (event.toState === 'enter' && this._keyManager.activeItemIndex === 0) {\n            event.element.scrollTop = 0;\n        }\n    }\n    /**\n     * Sets up a stream that will keep track of any newly-added menu items and will update the list\n     * of direct descendants. We collect the descendants this way, because `_allItems` can include\n     * items that are part of child menus, and using a custom way of registering items is unreliable\n     * when it comes to maintaining the item order.\n     */\n    _updateDirectDescendants() {\n        this._allItems.changes\n            .pipe(startWith(this._allItems))\n            .subscribe((items) => {\n            this._directDescendantItems.reset(items.filter(item => item._parentMenu === this));\n            this._directDescendantItems.notifyOnChanges();\n        });\n    }\n}\n_MatMenuBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: _MatMenuBase, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: MAT_MENU_DEFAULT_OPTIONS }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });\n_MatMenuBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", type: _MatMenuBase, inputs: { backdropClass: \"backdropClass\", ariaLabel: [\"aria-label\", \"ariaLabel\"], ariaLabelledby: [\"aria-labelledby\", \"ariaLabelledby\"], ariaDescribedby: [\"aria-describedby\", \"ariaDescribedby\"], xPosition: \"xPosition\", yPosition: \"yPosition\", overlapTrigger: \"overlapTrigger\", hasBackdrop: \"hasBackdrop\", panelClass: [\"class\", \"panelClass\"], classList: \"classList\" }, outputs: { closed: \"closed\", close: \"close\" }, queries: [{ propertyName: \"lazyContent\", first: true, predicate: MAT_MENU_CONTENT, descendants: true }, { propertyName: \"_allItems\", predicate: MatMenuItem, descendants: true }, { propertyName: \"items\", predicate: MatMenuItem }], viewQueries: [{ propertyName: \"templateRef\", first: true, predicate: TemplateRef, descendants: true }], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: _MatMenuBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_MENU_DEFAULT_OPTIONS]\n                }] }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { _allItems: [{\n                type: ContentChildren,\n                args: [MatMenuItem, { descendants: true }]\n            }], backdropClass: [{\n                type: Input\n            }], ariaLabel: [{\n                type: Input,\n                args: ['aria-label']\n            }], ariaLabelledby: [{\n                type: Input,\n                args: ['aria-labelledby']\n            }], ariaDescribedby: [{\n                type: Input,\n                args: ['aria-describedby']\n            }], xPosition: [{\n                type: Input\n            }], yPosition: [{\n                type: Input\n            }], templateRef: [{\n                type: ViewChild,\n                args: [TemplateRef]\n            }], items: [{\n                type: ContentChildren,\n                args: [MatMenuItem, { descendants: false }]\n            }], lazyContent: [{\n                type: ContentChild,\n                args: [MAT_MENU_CONTENT]\n            }], overlapTrigger: [{\n                type: Input\n            }], hasBackdrop: [{\n                type: Input\n            }], panelClass: [{\n                type: Input,\n                args: ['class']\n            }], classList: [{\n                type: Input\n            }], closed: [{\n                type: Output\n            }], close: [{\n                type: Output\n            }] } });\nclass MatMenu extends _MatMenuBase {\n    constructor(_elementRef, _ngZone, _defaultOptions, changeDetectorRef) {\n        super(_elementRef, _ngZone, _defaultOptions, changeDetectorRef);\n        this._elevationPrefix = 'mat-elevation-z';\n        this._baseElevation = 8;\n    }\n}\nMatMenu.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatMenu, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: MAT_MENU_DEFAULT_OPTIONS }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });\nMatMenu.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", type: MatMenu, selector: \"mat-menu\", host: { properties: { \"attr.aria-label\": \"null\", \"attr.aria-labelledby\": \"null\", \"attr.aria-describedby\": \"null\" } }, providers: [{ provide: MAT_MENU_PANEL, useExisting: MatMenu }], exportAs: [\"matMenu\"], usesInheritance: true, ngImport: i0, template: \"<ng-template>\\n  <div\\n    class=\\\"mat-mdc-menu-panel mdc-menu-surface mdc-menu-surface--open mat-mdc-elevation-specific\\\"\\n    [id]=\\\"panelId\\\"\\n    [ngClass]=\\\"_classList\\\"\\n    (keydown)=\\\"_handleKeydown($event)\\\"\\n    (click)=\\\"closed.emit('click')\\\"\\n    [@transformMenu]=\\\"_panelAnimationState\\\"\\n    (@transformMenu.start)=\\\"_onAnimationStart($event)\\\"\\n    (@transformMenu.done)=\\\"_onAnimationDone($event)\\\"\\n    tabindex=\\\"-1\\\"\\n    role=\\\"menu\\\"\\n    [attr.aria-label]=\\\"ariaLabel || null\\\"\\n    [attr.aria-labelledby]=\\\"ariaLabelledby || null\\\"\\n    [attr.aria-describedby]=\\\"ariaDescribedby || null\\\">\\n    <div class=\\\"mat-mdc-menu-content mdc-list\\\">\\n      <ng-content></ng-content>\\n    </div>\\n  </div>\\n</ng-template>\\n\", styles: [\".mdc-menu-surface{display:none;position:absolute;box-sizing:border-box;max-width:var(--mdc-menu-max-width, calc(100vw - 32px));max-height:var(--mdc-menu-max-height, calc(100vh - 32px));margin:0;padding:0;transform:scale(1);transform-origin:top left;opacity:0;overflow:auto;will-change:transform,opacity;z-index:8;border-radius:var(--mdc-shape-medium, 4px);transform-origin-left:top left;transform-origin-right:top right}.mdc-menu-surface:focus{outline:none}.mdc-menu-surface--animating-open{display:inline-block;transform:scale(0.8);opacity:0}.mdc-menu-surface--open{display:inline-block;transform:scale(1);opacity:1}.mdc-menu-surface--animating-closed{display:inline-block;opacity:0}[dir=rtl] .mdc-menu-surface,.mdc-menu-surface[dir=rtl]{transform-origin-left:top right;transform-origin-right:top left}.mdc-menu-surface--anchor{position:relative;overflow:visible}.mdc-menu-surface--fixed{position:fixed}.mdc-menu-surface--fullwidth{width:100%}mat-menu{display:none}.mat-mdc-menu-content{margin:0;padding:8px 0;list-style-type:none}.mat-mdc-menu-content:focus{outline:none}.mat-mdc-menu-panel.ng-animating{pointer-events:none}.cdk-high-contrast-active .mat-mdc-menu-panel{outline:solid 1px}.mat-mdc-menu-panel.mat-mdc-menu-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;position:relative}.mat-mdc-menu-item{display:flex;position:relative;align-items:center;justify-content:flex-start;overflow:hidden;padding:0;padding-left:16px;padding-right:16px;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);cursor:pointer;width:100%;text-align:left;box-sizing:border-box;color:inherit;font-size:inherit;background:none;text-decoration:none;margin:0;min-height:48px}.mat-mdc-menu-item:focus{outline:none}[dir=rtl] .mat-mdc-menu-item,.mat-mdc-menu-item[dir=rtl]{padding-left:16px;padding-right:16px}.mat-mdc-menu-item::-moz-focus-inner{border:0}.mat-mdc-menu-item.mdc-list-item{align-items:center}.mat-mdc-menu-item[disabled]{cursor:default;opacity:.38}.mat-mdc-menu-item[disabled]::after{display:block;position:absolute;content:\\\"\\\";top:0;left:0;bottom:0;right:0}.mat-mdc-menu-item .mat-icon{margin-right:16px}[dir=rtl] .mat-mdc-menu-item{text-align:right}[dir=rtl] .mat-mdc-menu-item .mat-icon{margin-right:0;margin-left:16px}.mat-mdc-menu-item .mdc-list-item__primary-text{white-space:normal}.mat-mdc-menu-item.mat-mdc-menu-item-submenu-trigger{padding-right:32px}[dir=rtl] .mat-mdc-menu-item.mat-mdc-menu-item-submenu-trigger{padding-right:16px;padding-left:32px}.cdk-high-contrast-active .mat-mdc-menu-item{margin-top:1px}.mat-mdc-menu-submenu-icon{position:absolute;top:50%;right:16px;transform:translateY(-50%);width:5px;height:10px;fill:currentColor}[dir=rtl] .mat-mdc-menu-submenu-icon{right:auto;left:16px;transform:translateY(-50%) scaleX(-1)}.cdk-high-contrast-active .mat-mdc-menu-submenu-icon{fill:CanvasText}.mat-mdc-menu-item .mat-mdc-menu-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}\"], dependencies: [{ kind: \"directive\", type: i2.NgClass, selector: \"[ngClass]\", inputs: [\"class\", \"ngClass\"] }], animations: [matMenuAnimations.transformMenu, matMenuAnimations.fadeInItems], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatMenu, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-menu', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, exportAs: 'matMenu', host: {\n                        '[attr.aria-label]': 'null',\n                        '[attr.aria-labelledby]': 'null',\n                        '[attr.aria-describedby]': 'null',\n                    }, animations: [matMenuAnimations.transformMenu, matMenuAnimations.fadeInItems], providers: [{ provide: MAT_MENU_PANEL, useExisting: MatMenu }], template: \"<ng-template>\\n  <div\\n    class=\\\"mat-mdc-menu-panel mdc-menu-surface mdc-menu-surface--open mat-mdc-elevation-specific\\\"\\n    [id]=\\\"panelId\\\"\\n    [ngClass]=\\\"_classList\\\"\\n    (keydown)=\\\"_handleKeydown($event)\\\"\\n    (click)=\\\"closed.emit('click')\\\"\\n    [@transformMenu]=\\\"_panelAnimationState\\\"\\n    (@transformMenu.start)=\\\"_onAnimationStart($event)\\\"\\n    (@transformMenu.done)=\\\"_onAnimationDone($event)\\\"\\n    tabindex=\\\"-1\\\"\\n    role=\\\"menu\\\"\\n    [attr.aria-label]=\\\"ariaLabel || null\\\"\\n    [attr.aria-labelledby]=\\\"ariaLabelledby || null\\\"\\n    [attr.aria-describedby]=\\\"ariaDescribedby || null\\\">\\n    <div class=\\\"mat-mdc-menu-content mdc-list\\\">\\n      <ng-content></ng-content>\\n    </div>\\n  </div>\\n</ng-template>\\n\", styles: [\".mdc-menu-surface{display:none;position:absolute;box-sizing:border-box;max-width:var(--mdc-menu-max-width, calc(100vw - 32px));max-height:var(--mdc-menu-max-height, calc(100vh - 32px));margin:0;padding:0;transform:scale(1);transform-origin:top left;opacity:0;overflow:auto;will-change:transform,opacity;z-index:8;border-radius:var(--mdc-shape-medium, 4px);transform-origin-left:top left;transform-origin-right:top right}.mdc-menu-surface:focus{outline:none}.mdc-menu-surface--animating-open{display:inline-block;transform:scale(0.8);opacity:0}.mdc-menu-surface--open{display:inline-block;transform:scale(1);opacity:1}.mdc-menu-surface--animating-closed{display:inline-block;opacity:0}[dir=rtl] .mdc-menu-surface,.mdc-menu-surface[dir=rtl]{transform-origin-left:top right;transform-origin-right:top left}.mdc-menu-surface--anchor{position:relative;overflow:visible}.mdc-menu-surface--fixed{position:fixed}.mdc-menu-surface--fullwidth{width:100%}mat-menu{display:none}.mat-mdc-menu-content{margin:0;padding:8px 0;list-style-type:none}.mat-mdc-menu-content:focus{outline:none}.mat-mdc-menu-panel.ng-animating{pointer-events:none}.cdk-high-contrast-active .mat-mdc-menu-panel{outline:solid 1px}.mat-mdc-menu-panel.mat-mdc-menu-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;position:relative}.mat-mdc-menu-item{display:flex;position:relative;align-items:center;justify-content:flex-start;overflow:hidden;padding:0;padding-left:16px;padding-right:16px;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);cursor:pointer;width:100%;text-align:left;box-sizing:border-box;color:inherit;font-size:inherit;background:none;text-decoration:none;margin:0;min-height:48px}.mat-mdc-menu-item:focus{outline:none}[dir=rtl] .mat-mdc-menu-item,.mat-mdc-menu-item[dir=rtl]{padding-left:16px;padding-right:16px}.mat-mdc-menu-item::-moz-focus-inner{border:0}.mat-mdc-menu-item.mdc-list-item{align-items:center}.mat-mdc-menu-item[disabled]{cursor:default;opacity:.38}.mat-mdc-menu-item[disabled]::after{display:block;position:absolute;content:\\\"\\\";top:0;left:0;bottom:0;right:0}.mat-mdc-menu-item .mat-icon{margin-right:16px}[dir=rtl] .mat-mdc-menu-item{text-align:right}[dir=rtl] .mat-mdc-menu-item .mat-icon{margin-right:0;margin-left:16px}.mat-mdc-menu-item .mdc-list-item__primary-text{white-space:normal}.mat-mdc-menu-item.mat-mdc-menu-item-submenu-trigger{padding-right:32px}[dir=rtl] .mat-mdc-menu-item.mat-mdc-menu-item-submenu-trigger{padding-right:16px;padding-left:32px}.cdk-high-contrast-active .mat-mdc-menu-item{margin-top:1px}.mat-mdc-menu-submenu-icon{position:absolute;top:50%;right:16px;transform:translateY(-50%);width:5px;height:10px;fill:currentColor}[dir=rtl] .mat-mdc-menu-submenu-icon{right:auto;left:16px;transform:translateY(-50%) scaleX(-1)}.cdk-high-contrast-active .mat-mdc-menu-submenu-icon{fill:CanvasText}.mat-mdc-menu-item .mat-mdc-menu-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}\"] }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_MENU_DEFAULT_OPTIONS]\n                }] }, { type: i0.ChangeDetectorRef }]; } });\n\n/**\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/** Injection token that determines the scroll handling while the menu is open. */\nconst MAT_MENU_SCROLL_STRATEGY = new InjectionToken('mat-menu-scroll-strategy');\n/** @docs-private */\nfunction MAT_MENU_SCROLL_STRATEGY_FACTORY(overlay) {\n    return () => overlay.scrollStrategies.reposition();\n}\n/** @docs-private */\nconst MAT_MENU_SCROLL_STRATEGY_FACTORY_PROVIDER = {\n    provide: MAT_MENU_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: MAT_MENU_SCROLL_STRATEGY_FACTORY,\n};\n/** Options for binding a passive event listener. */\nconst passiveEventListenerOptions = normalizePassiveListenerOptions({ passive: true });\n/**\n * Default top padding of the menu panel.\n * @deprecated No longer being used. Will be removed.\n * @breaking-change 15.0.0\n */\nconst MENU_PANEL_TOP_PADDING = 8;\nclass _MatMenuTriggerBase {\n    /**\n     * @deprecated\n     * @breaking-change 8.0.0\n     */\n    get _deprecatedMatMenuTriggerFor() {\n        return this.menu;\n    }\n    set _deprecatedMatMenuTriggerFor(v) {\n        this.menu = v;\n    }\n    /** References the menu instance that the trigger is associated with. */\n    get menu() {\n        return this._menu;\n    }\n    set menu(menu) {\n        if (menu === this._menu) {\n            return;\n        }\n        this._menu = menu;\n        this._menuCloseSubscription.unsubscribe();\n        if (menu) {\n            if (menu === this._parentMaterialMenu && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                throwMatMenuRecursiveError();\n            }\n            this._menuCloseSubscription = menu.close.subscribe((reason) => {\n                this._destroyMenu(reason);\n                // If a click closed the menu, we should close the entire chain of nested menus.\n                if ((reason === 'click' || reason === 'tab') && this._parentMaterialMenu) {\n                    this._parentMaterialMenu.closed.emit(reason);\n                }\n            });\n        }\n        this._menuItemInstance?._setTriggersSubmenu(this.triggersSubmenu());\n    }\n    constructor(_overlay, _element, _viewContainerRef, scrollStrategy, parentMenu, \n    // `MatMenuTrigger` is commonly used in combination with a `MatMenuItem`.\n    // tslint:disable-next-line: lightweight-tokens\n    _menuItemInstance, _dir, _focusMonitor, _ngZone) {\n        this._overlay = _overlay;\n        this._element = _element;\n        this._viewContainerRef = _viewContainerRef;\n        this._menuItemInstance = _menuItemInstance;\n        this._dir = _dir;\n        this._focusMonitor = _focusMonitor;\n        this._ngZone = _ngZone;\n        this._overlayRef = null;\n        this._menuOpen = false;\n        this._closingActionsSubscription = Subscription.EMPTY;\n        this._hoverSubscription = Subscription.EMPTY;\n        this._menuCloseSubscription = Subscription.EMPTY;\n        this._changeDetectorRef = inject(ChangeDetectorRef);\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        this._handleTouchStart = (event) => {\n            if (!isFakeTouchstartFromScreenReader(event)) {\n                this._openedBy = 'touch';\n            }\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        this._openedBy = undefined;\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        this.restoreFocus = true;\n        /** Event emitted when the associated menu is opened. */\n        this.menuOpened = new EventEmitter();\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        this.onMenuOpen = this.menuOpened;\n        /** Event emitted when the associated menu is closed. */\n        this.menuClosed = new EventEmitter();\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        this.onMenuClose = this.menuClosed;\n        this._scrollStrategy = scrollStrategy;\n        this._parentMaterialMenu = parentMenu instanceof _MatMenuBase ? parentMenu : undefined;\n        _element.nativeElement.addEventListener('touchstart', this._handleTouchStart, passiveEventListenerOptions);\n    }\n    ngAfterContentInit() {\n        this._handleHover();\n    }\n    ngOnDestroy() {\n        if (this._overlayRef) {\n            this._overlayRef.dispose();\n            this._overlayRef = null;\n        }\n        this._element.nativeElement.removeEventListener('touchstart', this._handleTouchStart, passiveEventListenerOptions);\n        this._menuCloseSubscription.unsubscribe();\n        this._closingActionsSubscription.unsubscribe();\n        this._hoverSubscription.unsubscribe();\n    }\n    /** Whether the menu is open. */\n    get menuOpen() {\n        return this._menuOpen;\n    }\n    /** The text direction of the containing app. */\n    get dir() {\n        return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';\n    }\n    /** Whether the menu triggers a sub-menu or a top-level one. */\n    triggersSubmenu() {\n        return !!(this._menuItemInstance && this._parentMaterialMenu && this.menu);\n    }\n    /** Toggles the menu between the open and closed states. */\n    toggleMenu() {\n        return this._menuOpen ? this.closeMenu() : this.openMenu();\n    }\n    /** Opens the menu. */\n    openMenu() {\n        const menu = this.menu;\n        if (this._menuOpen || !menu) {\n            return;\n        }\n        const overlayRef = this._createOverlay(menu);\n        const overlayConfig = overlayRef.getConfig();\n        const positionStrategy = overlayConfig.positionStrategy;\n        this._setPosition(menu, positionStrategy);\n        overlayConfig.hasBackdrop =\n            menu.hasBackdrop == null ? !this.triggersSubmenu() : menu.hasBackdrop;\n        overlayRef.attach(this._getPortal(menu));\n        if (menu.lazyContent) {\n            menu.lazyContent.attach(this.menuData);\n        }\n        this._closingActionsSubscription = this._menuClosingActions().subscribe(() => this.closeMenu());\n        this._initMenu(menu);\n        if (menu instanceof _MatMenuBase) {\n            menu._startAnimation();\n            menu._directDescendantItems.changes.pipe(takeUntil(menu.close)).subscribe(() => {\n                // Re-adjust the position without locking when the amount of items\n                // changes so that the overlay is allowed to pick a new optimal position.\n                positionStrategy.withLockedPosition(false).reapplyLastPosition();\n                positionStrategy.withLockedPosition(true);\n            });\n        }\n    }\n    /** Closes the menu. */\n    closeMenu() {\n        this.menu?.close.emit();\n    }\n    /**\n     * Focuses the menu trigger.\n     * @param origin Source of the menu trigger's focus.\n     */\n    focus(origin, options) {\n        if (this._focusMonitor && origin) {\n            this._focusMonitor.focusVia(this._element, origin, options);\n        }\n        else {\n            this._element.nativeElement.focus(options);\n        }\n    }\n    /**\n     * Updates the position of the menu to ensure that it fits all options within the viewport.\n     */\n    updatePosition() {\n        this._overlayRef?.updatePosition();\n    }\n    /** Closes the menu and does the necessary cleanup. */\n    _destroyMenu(reason) {\n        if (!this._overlayRef || !this.menuOpen) {\n            return;\n        }\n        const menu = this.menu;\n        this._closingActionsSubscription.unsubscribe();\n        this._overlayRef.detach();\n        // Always restore focus if the user is navigating using the keyboard or the menu was opened\n        // programmatically. We don't restore for non-root triggers, because it can prevent focus\n        // from making it back to the root trigger when closing a long chain of menus by clicking\n        // on the backdrop.\n        if (this.restoreFocus && (reason === 'keydown' || !this._openedBy || !this.triggersSubmenu())) {\n            this.focus(this._openedBy);\n        }\n        this._openedBy = undefined;\n        if (menu instanceof _MatMenuBase) {\n            menu._resetAnimation();\n            if (menu.lazyContent) {\n                // Wait for the exit animation to finish before detaching the content.\n                menu._animationDone\n                    .pipe(filter(event => event.toState === 'void'), take(1), \n                // Interrupt if the content got re-attached.\n                takeUntil(menu.lazyContent._attached))\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            }\n            else {\n                this._setIsMenuOpen(false);\n            }\n        }\n        else {\n            this._setIsMenuOpen(false);\n            menu?.lazyContent?.detach();\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    _initMenu(menu) {\n        menu.parentMenu = this.triggersSubmenu() ? this._parentMaterialMenu : undefined;\n        menu.direction = this.dir;\n        this._setMenuElevation(menu);\n        menu.focusFirstItem(this._openedBy || 'program');\n        this._setIsMenuOpen(true);\n    }\n    /** Updates the menu elevation based on the amount of parent menus that it has. */\n    _setMenuElevation(menu) {\n        if (menu.setElevation) {\n            let depth = 0;\n            let parentMenu = menu.parentMenu;\n            while (parentMenu) {\n                depth++;\n                parentMenu = parentMenu.parentMenu;\n            }\n            menu.setElevation(depth);\n        }\n    }\n    // set state rather than toggle to support triggers sharing a menu\n    _setIsMenuOpen(isOpen) {\n        if (isOpen !== this._menuOpen) {\n            this._menuOpen = isOpen;\n            this._menuOpen ? this.menuOpened.emit() : this.menuClosed.emit();\n            if (this.triggersSubmenu()) {\n                this._menuItemInstance._setHighlighted(isOpen);\n            }\n            this._changeDetectorRef.markForCheck();\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    _createOverlay(menu) {\n        if (!this._overlayRef) {\n            const config = this._getOverlayConfig(menu);\n            this._subscribeToPositions(menu, config.positionStrategy);\n            this._overlayRef = this._overlay.create(config);\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        return this._overlayRef;\n    }\n    /**\n     * This method builds the configuration object needed to create the overlay, the OverlayState.\n     * @returns OverlayConfig\n     */\n    _getOverlayConfig(menu) {\n        return new OverlayConfig({\n            positionStrategy: this._overlay\n                .position()\n                .flexibleConnectedTo(this._element)\n                .withLockedPosition()\n                .withGrowAfterOpen()\n                .withTransformOriginOn('.mat-menu-panel, .mat-mdc-menu-panel'),\n            backdropClass: menu.backdropClass || 'cdk-overlay-transparent-backdrop',\n            panelClass: menu.overlayPanelClass,\n            scrollStrategy: this._scrollStrategy(),\n            direction: this._dir,\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    _subscribeToPositions(menu, position) {\n        if (menu.setPositionClasses) {\n            position.positionChanges.subscribe(change => {\n                const posX = change.connectionPair.overlayX === 'start' ? 'after' : 'before';\n                const posY = change.connectionPair.overlayY === 'top' ? 'below' : 'above';\n                // @breaking-change 15.0.0 Remove null check for `ngZone`.\n                // `positionChanges` fires outside of the `ngZone` and `setPositionClasses` might be\n                // updating something in the view so we need to bring it back in.\n                if (this._ngZone) {\n                    this._ngZone.run(() => menu.setPositionClasses(posX, posY));\n                }\n                else {\n                    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    _setPosition(menu, positionStrategy) {\n        let [originX, originFallbackX] = menu.xPosition === 'before' ? ['end', 'start'] : ['start', 'end'];\n        let [overlayY, overlayFallbackY] = menu.yPosition === 'above' ? ['bottom', 'top'] : ['top', 'bottom'];\n        let [originY, originFallbackY] = [overlayY, overlayFallbackY];\n        let [overlayX, overlayFallbackX] = [originX, originFallbackX];\n        let offsetY = 0;\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 = menu.xPosition === 'before' ? 'start' : 'end';\n            originFallbackX = overlayX = originX === 'end' ? 'start' : 'end';\n            if (this._parentMaterialMenu) {\n                if (this._parentInnerPadding == null) {\n                    const firstItem = this._parentMaterialMenu.items.first;\n                    this._parentInnerPadding = firstItem ? firstItem._getHostElement().offsetTop : 0;\n                }\n                offsetY = overlayY === 'bottom' ? this._parentInnerPadding : -this._parentInnerPadding;\n            }\n        }\n        else if (!menu.overlapTrigger) {\n            originY = overlayY === 'top' ? 'bottom' : 'top';\n            originFallbackY = overlayFallbackY === 'top' ? 'bottom' : 'top';\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    /** Returns a stream that emits whenever an action that should close the menu occurs. */\n    _menuClosingActions() {\n        const backdrop = this._overlayRef.backdropClick();\n        const detachments = this._overlayRef.detachments();\n        const parentClose = this._parentMaterialMenu ? this._parentMaterialMenu.closed : of();\n        const hover = this._parentMaterialMenu\n            ? this._parentMaterialMenu._hovered().pipe(filter(active => active !== this._menuItemInstance), filter(() => this._menuOpen))\n            : of();\n        return merge(backdrop, parentClose, hover, detachments);\n    }\n    /** Handles mouse presses on the trigger. */\n    _handleMousedown(event) {\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' : undefined;\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    /** Handles key presses on the trigger. */\n    _handleKeydown(event) {\n        const keyCode = event.keyCode;\n        // Pressing enter on the trigger will trigger the click handler later.\n        if (keyCode === ENTER || keyCode === SPACE) {\n            this._openedBy = 'keyboard';\n        }\n        if (this.triggersSubmenu() &&\n            ((keyCode === RIGHT_ARROW && this.dir === 'ltr') ||\n                (keyCode === LEFT_ARROW && this.dir === 'rtl'))) {\n            this._openedBy = 'keyboard';\n            this.openMenu();\n        }\n    }\n    /** Handles click events on the trigger. */\n    _handleClick(event) {\n        if (this.triggersSubmenu()) {\n            // Stop event propagation to avoid closing the parent menu.\n            event.stopPropagation();\n            this.openMenu();\n        }\n        else {\n            this.toggleMenu();\n        }\n    }\n    /** Handles the cases where the user hovers over the trigger. */\n    _handleHover() {\n        // Subscribe to changes in the hovered item in order to toggle the panel.\n        if (!this.triggersSubmenu() || !this._parentMaterialMenu) {\n            return;\n        }\n        this._hoverSubscription = this._parentMaterialMenu\n            ._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(filter(active => active === this._menuItemInstance && !active.disabled), delay(0, asapScheduler))\n            .subscribe(() => {\n            this._openedBy = 'mouse';\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 _MatMenuBase && 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._parentMaterialMenu._hovered()))\n                    .subscribe(() => this.openMenu());\n            }\n            else {\n                this.openMenu();\n            }\n        });\n    }\n    /** Gets the portal that should be attached to the overlay. */\n    _getPortal(menu) {\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 !== menu.templateRef) {\n            this._portal = new TemplatePortal(menu.templateRef, this._viewContainerRef);\n        }\n        return this._portal;\n    }\n}\n_MatMenuTriggerBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: _MatMenuTriggerBase, deps: [{ token: i1$1.Overlay }, { token: i0.ElementRef }, { token: i0.ViewContainerRef }, { token: MAT_MENU_SCROLL_STRATEGY }, { token: MAT_MENU_PANEL, optional: true }, { token: MatMenuItem, optional: true, self: true }, { token: i3$1.Directionality, optional: true }, { token: i1.FocusMonitor }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });\n_MatMenuTriggerBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", type: _MatMenuTriggerBase, inputs: { _deprecatedMatMenuTriggerFor: [\"mat-menu-trigger-for\", \"_deprecatedMatMenuTriggerFor\"], menu: [\"matMenuTriggerFor\", \"menu\"], menuData: [\"matMenuTriggerData\", \"menuData\"], restoreFocus: [\"matMenuTriggerRestoreFocus\", \"restoreFocus\"] }, outputs: { menuOpened: \"menuOpened\", onMenuOpen: \"onMenuOpen\", menuClosed: \"menuClosed\", onMenuClose: \"onMenuClose\" }, host: { listeners: { \"click\": \"_handleClick($event)\", \"mousedown\": \"_handleMousedown($event)\", \"keydown\": \"_handleKeydown($event)\" }, properties: { \"attr.aria-haspopup\": \"menu ? \\\"menu\\\" : null\", \"attr.aria-expanded\": \"menuOpen\", \"attr.aria-controls\": \"menuOpen ? menu.panelId : null\" } }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: _MatMenuTriggerBase, decorators: [{\n            type: Directive,\n            args: [{\n                    host: {\n                        '[attr.aria-haspopup]': 'menu ? \"menu\" : null',\n                        '[attr.aria-expanded]': 'menuOpen',\n                        '[attr.aria-controls]': 'menuOpen ? menu.panelId : null',\n                        '(click)': '_handleClick($event)',\n                        '(mousedown)': '_handleMousedown($event)',\n                        '(keydown)': '_handleKeydown($event)',\n                    },\n                }]\n        }], ctorParameters: function () { return [{ type: i1$1.Overlay }, { type: i0.ElementRef }, { type: i0.ViewContainerRef }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_MENU_SCROLL_STRATEGY]\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_MENU_PANEL]\n                }, {\n                    type: Optional\n                }] }, { type: MatMenuItem, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }] }, { type: i3$1.Directionality, decorators: [{\n                    type: Optional\n                }] }, { type: i1.FocusMonitor }, { type: i0.NgZone }]; }, propDecorators: { _deprecatedMatMenuTriggerFor: [{\n                type: Input,\n                args: ['mat-menu-trigger-for']\n            }], menu: [{\n                type: Input,\n                args: ['matMenuTriggerFor']\n            }], menuData: [{\n                type: Input,\n                args: ['matMenuTriggerData']\n            }], restoreFocus: [{\n                type: Input,\n                args: ['matMenuTriggerRestoreFocus']\n            }], menuOpened: [{\n                type: Output\n            }], onMenuOpen: [{\n                type: Output\n            }], menuClosed: [{\n                type: Output\n            }], onMenuClose: [{\n                type: Output\n            }] } });\n/** Directive applied to an element that should trigger a `mat-menu`. */\nclass MatMenuTrigger extends _MatMenuTriggerBase {\n}\nMatMenuTrigger.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatMenuTrigger, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatMenuTrigger.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", type: MatMenuTrigger, selector: \"[mat-menu-trigger-for], [matMenuTriggerFor]\", host: { classAttribute: \"mat-mdc-menu-trigger\" }, exportAs: [\"matMenuTrigger\"], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatMenuTrigger, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: `[mat-menu-trigger-for], [matMenuTriggerFor]`,\n                    host: {\n                        'class': 'mat-mdc-menu-trigger',\n                    },\n                    exportAs: 'matMenuTrigger',\n                }]\n        }] });\n\n/**\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 */\nclass MatMenuModule {\n}\nMatMenuModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatMenuModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatMenuModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatMenuModule, declarations: [MatMenu, MatMenuItem, MatMenuContent, MatMenuTrigger], imports: [CommonModule, MatRippleModule, MatCommonModule, OverlayModule], exports: [CdkScrollableModule,\n        MatMenu,\n        MatCommonModule,\n        MatMenuItem,\n        MatMenuContent,\n        MatMenuTrigger] });\nMatMenuModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatMenuModule, providers: [MAT_MENU_SCROLL_STRATEGY_FACTORY_PROVIDER], imports: [CommonModule, MatRippleModule, MatCommonModule, OverlayModule, CdkScrollableModule,\n        MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatMenuModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [CommonModule, MatRippleModule, MatCommonModule, OverlayModule],\n                    exports: [\n                        CdkScrollableModule,\n                        MatMenu,\n                        MatCommonModule,\n                        MatMenuItem,\n                        MatMenuContent,\n                        MatMenuTrigger,\n                    ],\n                    declarations: [MatMenu, MatMenuItem, MatMenuContent, MatMenuTrigger],\n                    providers: [MAT_MENU_SCROLL_STRATEGY_FACTORY_PROVIDER],\n                }]\n        }] });\n\n/**\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\n/**\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\n/**\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\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_MENU_CONTENT, MAT_MENU_DEFAULT_OPTIONS, MAT_MENU_PANEL, MAT_MENU_SCROLL_STRATEGY, MAT_MENU_SCROLL_STRATEGY_FACTORY_PROVIDER, MENU_PANEL_TOP_PADDING, MatMenu, MatMenuContent, MatMenuItem, MatMenuModule, MatMenuTrigger, _MatMenuBase, _MatMenuContentBase, _MatMenuTriggerBase, fadeInItems, matMenuAnimations, transformMenu };\n"],"x_google_ignoreList":[0]}