{"version":3,"file":"6662.a17579abc715d3a9.js","mappings":"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","names":["_c0","MatMenuItem__svg_svg_2_Template","rf","ctx","i0","_c1","MatMenu_ng_template_0_Template","_r2","$event","ctx_r1","_handleKeydown","ctx_r3","closed","emit","ctx_r4","_onAnimationStart","ctx_r5","_onAnimationDone","ctx_r0","panelId","_classList","_panelAnimationState","ariaLabel","ariaLabelledby","ariaDescribedby","matMenuAnimations","transformMenu","trigger","state","style","opacity","transform","transition","animate","fadeInItems","MAT_MENU_CONTENT","InjectionToken","MAT_MENU_PANEL","_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","_hasFocus","activeElement","ɵfac","t","DOCUMENT","i1","ɵcmp","type","selectors","hostAttrs","hostVars","hostBindings","toString","inputs","disableRipple","exportAs","features","attrs","ngContentSelectors","decls","vars","consts","template","dependencies","i2","i3","encapsulation","changeDetection","MAT_MENU_DEFAULT_OPTIONS","providedIn","factory","MAT_MENU_DEFAULT_OPTIONS_FACTORY","overlapTrigger","xPosition","yPosition","backdropClass","menuPanelUid","_MatMenuBase","_ngZone","_defaultOptions","_xPosition","_yPosition","_directDescendantItems","QueryList","_tabSubscription","Subscription","EMPTY","_animationDone","overlayPanelClass","_overlapTrigger","_hasBackdrop","hasBackdrop","EventEmitter","close","value","setPositionClasses","coerceBooleanProperty","panelClass","classes","previousPanelClass","_previousPanelClass","split","forEach","className","classList","ngOnInit","ngAfterContentInit","_updateDirectDescendants","_keyManager","FocusKeyManager","withWrap","withTypeAhead","withHomeAndEnd","tabOut","subscribe","changes","pipe","startWith","switchMap","items","merge","map","item","focusedItem","updateActiveItem","itemsList","manager","activeItem","toArray","index","Math","max","min","activeItemIndex","setActiveItem","setNextItemActive","destroy","unsubscribe","_item","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","_isAnimating","toState","element","scrollTop","_allItems","reset","filter","notifyOnChanges","ɵdir","contentQueries","dirIndex","_t","lazyContent","viewQuery","TemplateRef","templateRef","outputs","MatMenu","elementRef","ngZone","defaultOptions","changeDetectorRef","provide","useExisting","styles","data","animation","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","_overlay","_element","_viewContainerRef","scrollStrategy","_menuItemInstance","_dir","_overlayRef","_menuOpen","_closingActionsSubscription","_hoverSubscription","_menuCloseSubscription","_handleTouchStart","isFakeTouchstartFromScreenReader","_openedBy","undefined","restoreFocus","menuOpened","onMenuOpen","menuClosed","onMenuClose","_scrollStrategy","_parentMaterialMenu","addEventListener","triggersSubmenu","_deprecatedMatMenuTriggerFor","menu","v","_menu","reason","_destroyMenu","_handleHover","dispose","removeEventListener","menuOpen","dir","toggleMenu","closeMenu","openMenu","overlayRef","_createOverlay","overlayConfig","getConfig","positionStrategy","_setPosition","attach","_getPortal","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","TemplatePortal","i1$1","i3$1","MatMenuTrigger","ɵMatMenuTrigger_BaseFactory","MatMenuModule","ɵmod","ɵinj","providers","imports","CommonModule","MatCommonModule","MatRippleModule","OverlayModule","CdkScrollableModule"],"sourceRoot":"webpack:///","sources":["./node_modules/@angular/material/fesm2020/menu.mjs"],"sourcesContent":["import * 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 * as i0 from '@angular/core';\nimport { InjectionToken, Directive, Inject, Component, ChangeDetectionStrategy, ViewEncapsulation, Optional, Input, QueryList, EventEmitter, TemplateRef, ContentChildren, ViewChild, ContentChild, Output, Self, NgModule } from '@angular/core';\nimport { Subject, Subscription, merge, of, asapScheduler } from 'rxjs';\nimport { startWith, switchMap, take, takeUntil, filter, delay } from 'rxjs/operators';\nimport { trigger, state, style, transition, animate } from '@angular/animations';\nimport { TemplatePortal, DomPortalOutlet } from '@angular/cdk/portal';\nimport * as i2 from '@angular/common';\nimport { DOCUMENT, CommonModule } from '@angular/common';\nimport * as i3 from '@angular/material/core';\nimport { mixinDisableRipple, mixinDisabled, MatCommonModule, MatRippleModule } from '@angular/material/core';\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 * 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 */\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: \"14.2.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: \"14.2.0\", type: _MatMenuContentBase, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.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/**\n * Menu content that will be rendered lazily once the menu is opened.\n */\nclass MatMenuContent extends _MatMenuContentBase {\n}\nMatMenuContent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatMenuContent, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatMenuContent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.2.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: \"14.2.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 * 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 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    _hasFocus() {\n        return this._document && this._document.activeElement === this._getHostElement();\n    }\n}\nMatMenuItem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.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: \"14.2.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-menu-item\": \"true\", \"class.mat-menu-item-highlighted\": \"_highlighted\", \"class.mat-menu-item-submenu-trigger\": \"_triggersSubmenu\", \"attr.tabindex\": \"_getTabIndex()\", \"attr.aria-disabled\": \"disabled.toString()\", \"attr.disabled\": \"disabled || null\" }, classAttribute: \"mat-focus-indicator\" }, exportAs: [\"matMenuItem\"], usesInheritance: true, ngImport: i0, template: \"<ng-content></ng-content>\\n<div class=\\\"mat-menu-ripple\\\" matRipple\\n     [matRippleDisabled]=\\\"disableRipple || disabled\\\"\\n     [matRippleTrigger]=\\\"_getHostElement()\\\">\\n</div>\\n\\n<svg\\n  *ngIf=\\\"_triggersSubmenu\\\"\\n  class=\\\"mat-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: \"14.2.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-menu-item]': 'true',\n                        '[class.mat-menu-item-highlighted]': '_highlighted',\n                        '[class.mat-menu-item-submenu-trigger]': '_triggersSubmenu',\n                        '[attr.tabindex]': '_getTabIndex()',\n                        '[attr.aria-disabled]': 'disabled.toString()',\n                        '[attr.disabled]': 'disabled || null',\n                        'class': 'mat-focus-indicator',\n                        '(click)': '_checkDisabled($event)',\n                        '(mouseenter)': '_handleMouseEnter()',\n                    }, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: \"<ng-content></ng-content>\\n<div class=\\\"mat-menu-ripple\\\" matRipple\\n     [matRippleDisabled]=\\\"disableRipple || disabled\\\"\\n     [matRippleTrigger]=\\\"_getHostElement()\\\">\\n</div>\\n\\n<svg\\n  *ngIf=\\\"_triggersSubmenu\\\"\\n  class=\\\"mat-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/** 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}\nlet menuPanelUid = 0;\n/** Base class with all of the `MatMenu` functionality. */\nclass _MatMenuBase {\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        /** Subscription to tab events on the menu panel */\n        this._tabSubscription = Subscription.EMPTY;\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    /** 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    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._tabSubscription = 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._directDescendantItems.destroy();\n        this._tabSubscription.unsubscribe();\n        this.closed.complete();\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._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: \"14.2.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: \"14.2.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: \"14.2.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            }] } });\n/** @docs-public MatMenu */\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 = 4;\n    }\n}\nMatMenu.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.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: \"14.2.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-menu-panel\\\"\\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-menu-content\\\">\\n      <ng-content></ng-content>\\n    </div>\\n  </div>\\n</ng-template>\\n\", styles: [\"mat-menu{display:none}.mat-menu-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;max-height:calc(100vh - 48px);border-radius:4px;outline:0;min-height:64px;position:relative}.mat-menu-panel.ng-animating{pointer-events:none}.cdk-high-contrast-active .mat-menu-panel{outline:solid 1px}.mat-menu-content:not(:empty){padding-top:8px;padding-bottom:8px}.mat-menu-item{-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;line-height:48px;height:48px;padding:0 16px;text-align:left;text-decoration:none;max-width:100%;position:relative}.mat-menu-item::-moz-focus-inner{border:0}.mat-menu-item[disabled]{cursor:default}[dir=rtl] .mat-menu-item{text-align:right}.mat-menu-item .mat-icon{margin-right:16px;vertical-align:middle}.mat-menu-item .mat-icon svg{vertical-align:top}[dir=rtl] .mat-menu-item .mat-icon{margin-left:16px;margin-right:0}.mat-menu-item[disabled]::after{display:block;position:absolute;content:\\\"\\\";top:0;left:0;bottom:0;right:0}.cdk-high-contrast-active .mat-menu-item{margin-top:1px}.mat-menu-item-submenu-trigger{padding-right:32px}[dir=rtl] .mat-menu-item-submenu-trigger{padding-right:16px;padding-left:32px}.mat-menu-submenu-icon{position:absolute;top:50%;right:16px;transform:translateY(-50%);width:5px;height:10px;fill:currentColor}[dir=rtl] .mat-menu-submenu-icon{right:auto;left:16px;transform:translateY(-50%) scaleX(-1)}.cdk-high-contrast-active .mat-menu-submenu-icon{fill:CanvasText}button.mat-menu-item{width:100%}.mat-menu-item .mat-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: \"14.2.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-menu-panel\\\"\\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-menu-content\\\">\\n      <ng-content></ng-content>\\n    </div>\\n  </div>\\n</ng-template>\\n\", styles: [\"mat-menu{display:none}.mat-menu-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;max-height:calc(100vh - 48px);border-radius:4px;outline:0;min-height:64px;position:relative}.mat-menu-panel.ng-animating{pointer-events:none}.cdk-high-contrast-active .mat-menu-panel{outline:solid 1px}.mat-menu-content:not(:empty){padding-top:8px;padding-bottom:8px}.mat-menu-item{-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;line-height:48px;height:48px;padding:0 16px;text-align:left;text-decoration:none;max-width:100%;position:relative}.mat-menu-item::-moz-focus-inner{border:0}.mat-menu-item[disabled]{cursor:default}[dir=rtl] .mat-menu-item{text-align:right}.mat-menu-item .mat-icon{margin-right:16px;vertical-align:middle}.mat-menu-item .mat-icon svg{vertical-align:top}[dir=rtl] .mat-menu-item .mat-icon{margin-left:16px;margin-right:0}.mat-menu-item[disabled]::after{display:block;position:absolute;content:\\\"\\\";top:0;left:0;bottom:0;right:0}.cdk-high-contrast-active .mat-menu-item{margin-top:1px}.mat-menu-item-submenu-trigger{padding-right:32px}[dir=rtl] .mat-menu-item-submenu-trigger{padding-right:16px;padding-left:32px}.mat-menu-submenu-icon{position:absolute;top:50%;right:16px;transform:translateY(-50%);width:5px;height:10px;fill:currentColor}[dir=rtl] .mat-menu-submenu-icon{right:auto;left:16px;transform:translateY(-50%) scaleX(-1)}.cdk-high-contrast-active .mat-menu-submenu-icon{fill:CanvasText}button.mat-menu-item{width:100%}.mat-menu-item .mat-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/**\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;\n/** Options for binding a passive event listener. */\nconst passiveEventListenerOptions = normalizePassiveListenerOptions({ passive: true });\n// TODO(andrewseguin): Remove the kebab versions in favor of camelCased attribute selectors\nclass _MatMenuTriggerBase {\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        /**\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        if (_menuItemInstance) {\n            _menuItemInstance._triggersSubmenu = this.triggersSubmenu();\n        }\n    }\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    }\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);\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        this._menuOpen = isOpen;\n        this._menuOpen ? this.menuOpened.emit() : this.menuClosed.emit();\n        if (this.triggersSubmenu()) {\n            this._menuItemInstance._setHighlighted(isOpen);\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: \"14.2.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: \"14.2.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 || null\", \"attr.aria-controls\": \"menuOpen ? menu.panelId : null\" } }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.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 || null',\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: \"14.2.0\", ngImport: i0, type: MatMenuTrigger, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatMenuTrigger.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.2.0\", type: MatMenuTrigger, selector: \"[mat-menu-trigger-for], [matMenuTriggerFor]\", host: { classAttribute: \"mat-menu-trigger\" }, exportAs: [\"matMenuTrigger\"], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatMenuTrigger, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: `[mat-menu-trigger-for], [matMenuTriggerFor]`,\n                    host: {\n                        'class': 'mat-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: \"14.2.0\", ngImport: i0, type: MatMenuModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatMenuModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"14.2.0\", ngImport: i0, type: MatMenuModule, declarations: [MatMenu, MatMenuItem, MatMenuTrigger, MatMenuContent], imports: [CommonModule, MatCommonModule, MatRippleModule, OverlayModule], exports: [CdkScrollableModule,\n        MatCommonModule,\n        MatMenu,\n        MatMenuItem,\n        MatMenuTrigger,\n        MatMenuContent] });\nMatMenuModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatMenuModule, providers: [MAT_MENU_SCROLL_STRATEGY_FACTORY_PROVIDER], imports: [CommonModule, MatCommonModule, MatRippleModule, OverlayModule, CdkScrollableModule,\n        MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatMenuModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [CommonModule, MatCommonModule, MatRippleModule, OverlayModule],\n                    exports: [\n                        CdkScrollableModule,\n                        MatCommonModule,\n                        MatMenu,\n                        MatMenuItem,\n                        MatMenuTrigger,\n                        MatMenuContent,\n                    ],\n                    declarations: [MatMenu, MatMenuItem, MatMenuTrigger, MatMenuContent],\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, MatMenu, MatMenuContent, MatMenuItem, MatMenuModule, MatMenuTrigger, _MatMenuBase, _MatMenuContentBase, _MatMenuTriggerBase, fadeInItems, matMenuAnimations, transformMenu };\n"],"x_google_ignoreList":[0]}