@angular/cdk-experimental 13.0.0-next.7 → 13.0.0-rc.2

package/fesm2015/{menu.js → menu.mjs}

@@ -1,13 +1,15 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Injectable, NgZone, Directive, EventEmitter, ElementRef, ViewContainerRef, Optional, Inject, Input, Output, Self, HostListener, ContentChildren, TemplateRef, NgModule } from '@angular/core';
-import { OverlayConfig, Overlay, OverlayModule } from '@angular/cdk/overlay';
+import { InjectionToken, Injectable, Directive, EventEmitter, Optional, Inject, Input, Output, Self, HostListener, ContentChildren, NgModule } from '@angular/core';
+import * as i1 from '@angular/cdk/overlay';
+import { OverlayConfig, OverlayModule } from '@angular/cdk/overlay';
 import { FocusKeyManager } from '@angular/cdk/a11y';
 import { UP_ARROW, DOWN_ARROW, LEFT_ARROW, RIGHT_ARROW, ENTER, SPACE, TAB, ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';
-import { Directionality } from '@angular/cdk/bidi';
 import { Subject, fromEvent, merge, defer } from 'rxjs';
 import { filter, takeUntil, startWith, mergeMap, mapTo, mergeAll, take, switchMap } from 'rxjs/operators';
+import * as i1$1 from '@angular/cdk/collections';
 import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
 import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import * as i2 from '@angular/cdk/bidi';
 import { TemplatePortal } from '@angular/cdk/portal';
 
 /**
@@ -20,111 +22,6 @@ import { TemplatePortal } from '@angular/cdk/portal';
 /** Injection token used to return classes implementing the Menu interface */
 const CDK_MENU = new InjectionToken('cdk-menu');
 
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-/**
- * MenuStack allows subscribers to listen for close events (when a MenuStackItem is popped off
- * of the stack) in order to perform closing actions. Upon the MenuStack being empty it emits
- * from the `empty` observable specifying the next focus action which the listener should perform
- * as requested by the closer.
- */
-class MenuStack {
-    constructor() {
-        /** All MenuStackItems tracked by this MenuStack. */
-        this._elements = [];
-        /** Emits the element which was popped off of the stack when requested by a closer. */
-        this._close = new Subject();
-        /** Emits once the MenuStack has become empty after popping off elements. */
-        this._empty = new Subject();
-        /** Observable which emits the MenuStackItem which has been requested to close. */
-        this.closed = this._close;
-        /**
-         * Observable which emits when the MenuStack is empty after popping off the last element. It
-         * emits a FocusNext event which specifies the action the closer has requested the listener
-         * perform.
-         */
-        this.emptied = this._empty;
-    }
-    /** @param menu the MenuStackItem to put on the stack. */
-    push(menu) {
-        this._elements.push(menu);
-    }
-    /**
-     * Pop items off of the stack up to and including `lastItem` and emit each on the close
-     * observable. If the stack is empty or `lastItem` is not on the stack it does nothing.
-     * @param lastItem the last item to pop off the stack.
-     * @param focusNext the event to emit on the `empty` observable if the method call resulted in an
-     * empty stack. Does not emit if the stack was initially empty or if `lastItem` was not on the
-     * stack.
-     */
-    close(lastItem, focusNext) {
-        if (this._elements.indexOf(lastItem) >= 0) {
-            let poppedElement;
-            do {
-                poppedElement = this._elements.pop();
-                this._close.next(poppedElement);
-            } while (poppedElement !== lastItem);
-            if (this.isEmpty()) {
-                this._empty.next(focusNext);
-            }
-        }
-    }
-    /**
-     * Pop items off of the stack up to but excluding `lastItem` and emit each on the close
-     * observable. If the stack is empty or `lastItem` is not on the stack it does nothing.
-     * @param lastItem the element which should be left on the stack
-     * @return whether or not an item was removed from the stack
-     */
-    closeSubMenuOf(lastItem) {
-        let removed = false;
-        if (this._elements.indexOf(lastItem) >= 0) {
-            removed = this.peek() !== lastItem;
-            while (this.peek() !== lastItem) {
-                this._close.next(this._elements.pop());
-            }
-        }
-        return removed;
-    }
-    /**
-     * Pop off all MenuStackItems and emit each one on the `close` observable one by one.
-     * @param focusNext the event to emit on the `empty` observable once the stack is emptied. Does
-     * not emit if the stack was initially empty.
-     */
-    closeAll(focusNext) {
-        if (!this.isEmpty()) {
-            while (!this.isEmpty()) {
-                const menuStackItem = this._elements.pop();
-                if (menuStackItem) {
-                    this._close.next(menuStackItem);
-                }
-            }
-            this._empty.next(focusNext);
-        }
-    }
-    /** Return true if this stack is empty. */
-    isEmpty() {
-        return !this._elements.length;
-    }
-    /** Return the length of the stack. */
-    length() {
-        return this._elements.length;
-    }
-    /** Get the top most element on the stack. */
-    peek() {
-        return this._elements[this._elements.length - 1];
-    }
-}
-/** NoopMenuStack is a placeholder MenuStack used for inline menus. */
-class NoopMenuStack extends MenuStack {
-    /** Noop push - does not add elements to the MenuStack. */
-    push(_) { }
-}
-
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -326,25 +223,132 @@ class TargetMenuAim {
         this._destroyed.complete();
     }
 }
-TargetMenuAim.decorators = [
-    { type: Injectable }
-];
-TargetMenuAim.ctorParameters = () => [
-    { type: NgZone }
-];
+TargetMenuAim.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: TargetMenuAim, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+TargetMenuAim.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: TargetMenuAim });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: TargetMenuAim, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.NgZone }]; } });
 /**
  * CdkTargetMenuAim is a provider for the TargetMenuAim service. It should be added to an
  * element with either the `cdkMenu` or `cdkMenuBar` directive and child menu items.
  */
 class CdkTargetMenuAim {
 }
-CdkTargetMenuAim.decorators = [
-    { type: Directive, args: [{
-                selector: '[cdkTargetMenuAim]',
-                exportAs: 'cdkTargetMenuAim',
-                providers: [{ provide: MENU_AIM, useClass: TargetMenuAim }],
-            },] }
-];
+CdkTargetMenuAim.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkTargetMenuAim, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CdkTargetMenuAim.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkTargetMenuAim, selector: "[cdkTargetMenuAim]", providers: [{ provide: MENU_AIM, useClass: TargetMenuAim }], exportAs: ["cdkTargetMenuAim"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkTargetMenuAim, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkTargetMenuAim]',
+                    exportAs: 'cdkTargetMenuAim',
+                    providers: [{ provide: MENU_AIM, useClass: TargetMenuAim }],
+                }]
+        }] });
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * MenuStack allows subscribers to listen for close events (when a MenuStackItem is popped off
+ * of the stack) in order to perform closing actions. Upon the MenuStack being empty it emits
+ * from the `empty` observable specifying the next focus action which the listener should perform
+ * as requested by the closer.
+ */
+class MenuStack {
+    constructor() {
+        /** All MenuStackItems tracked by this MenuStack. */
+        this._elements = [];
+        /** Emits the element which was popped off of the stack when requested by a closer. */
+        this._close = new Subject();
+        /** Emits once the MenuStack has become empty after popping off elements. */
+        this._empty = new Subject();
+        /** Observable which emits the MenuStackItem which has been requested to close. */
+        this.closed = this._close;
+        /**
+         * Observable which emits when the MenuStack is empty after popping off the last element. It
+         * emits a FocusNext event which specifies the action the closer has requested the listener
+         * perform.
+         */
+        this.emptied = this._empty;
+    }
+    /** @param menu the MenuStackItem to put on the stack. */
+    push(menu) {
+        this._elements.push(menu);
+    }
+    /**
+     * Pop items off of the stack up to and including `lastItem` and emit each on the close
+     * observable. If the stack is empty or `lastItem` is not on the stack it does nothing.
+     * @param lastItem the last item to pop off the stack.
+     * @param focusNext the event to emit on the `empty` observable if the method call resulted in an
+     * empty stack. Does not emit if the stack was initially empty or if `lastItem` was not on the
+     * stack.
+     */
+    close(lastItem, focusNext) {
+        if (this._elements.indexOf(lastItem) >= 0) {
+            let poppedElement;
+            do {
+                poppedElement = this._elements.pop();
+                this._close.next(poppedElement);
+            } while (poppedElement !== lastItem);
+            if (this.isEmpty()) {
+                this._empty.next(focusNext);
+            }
+        }
+    }
+    /**
+     * Pop items off of the stack up to but excluding `lastItem` and emit each on the close
+     * observable. If the stack is empty or `lastItem` is not on the stack it does nothing.
+     * @param lastItem the element which should be left on the stack
+     * @return whether or not an item was removed from the stack
+     */
+    closeSubMenuOf(lastItem) {
+        let removed = false;
+        if (this._elements.indexOf(lastItem) >= 0) {
+            removed = this.peek() !== lastItem;
+            while (this.peek() !== lastItem) {
+                this._close.next(this._elements.pop());
+            }
+        }
+        return removed;
+    }
+    /**
+     * Pop off all MenuStackItems and emit each one on the `close` observable one by one.
+     * @param focusNext the event to emit on the `empty` observable once the stack is emptied. Does
+     * not emit if the stack was initially empty.
+     */
+    closeAll(focusNext) {
+        if (!this.isEmpty()) {
+            while (!this.isEmpty()) {
+                const menuStackItem = this._elements.pop();
+                if (menuStackItem) {
+                    this._close.next(menuStackItem);
+                }
+            }
+            this._empty.next(focusNext);
+        }
+    }
+    /** Return true if this stack is empty. */
+    isEmpty() {
+        return !this._elements.length;
+    }
+    /** Return the length of the stack. */
+    length() {
+        return this._elements.length;
+    }
+    /** Get the top most element on the stack. */
+    peek() {
+        return this._elements[this._elements.length - 1];
+    }
+}
+/** NoopMenuStack is a placeholder MenuStack used for inline menus. */
+class NoopMenuStack extends MenuStack {
+    /** Noop push - does not add elements to the MenuStack. */
+    push(_) { }
+}
 
 /**
  * @license
@@ -661,33 +665,45 @@ class CdkMenuItemTrigger {
         }
     }
 }
-CdkMenuItemTrigger.decorators = [
-    { type: Directive, args: [{
-                selector: '[cdkMenuTriggerFor]',
-                exportAs: 'cdkMenuTriggerFor',
-                host: {
-                    '(keydown)': '_toggleOnKeydown($event)',
-                    '(click)': 'toggle()',
-                    'class': 'cdk-menu-trigger',
-                    'aria-haspopup': 'menu',
-                    '[attr.aria-expanded]': 'isMenuOpen()',
-                },
-            },] }
-];
-CdkMenuItemTrigger.ctorParameters = () => [
-    { type: ElementRef },
-    { type: ViewContainerRef },
-    { type: Overlay },
-    { type: NgZone },
-    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [CDK_MENU,] }] },
-    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MENU_AIM,] }] },
-    { type: Directionality, decorators: [{ type: Optional }] }
-];
-CdkMenuItemTrigger.propDecorators = {
-    menuPanel: [{ type: Input, args: ['cdkMenuTriggerFor',] }],
-    opened: [{ type: Output, args: ['cdkMenuOpened',] }],
-    closed: [{ type: Output, args: ['cdkMenuClosed',] }]
-};
+CdkMenuItemTrigger.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuItemTrigger, deps: [{ token: i0.ElementRef }, { token: i0.ViewContainerRef }, { token: i1.Overlay }, { token: i0.NgZone }, { token: CDK_MENU, optional: true }, { token: MENU_AIM, optional: true }, { token: i2.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuItemTrigger.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkMenuItemTrigger, selector: "[cdkMenuTriggerFor]", inputs: { menuPanel: ["cdkMenuTriggerFor", "menuPanel"] }, outputs: { opened: "cdkMenuOpened", closed: "cdkMenuClosed" }, host: { attributes: { "aria-haspopup": "menu" }, listeners: { "keydown": "_toggleOnKeydown($event)", "click": "toggle()" }, properties: { "attr.aria-expanded": "isMenuOpen()" }, classAttribute: "cdk-menu-trigger" }, exportAs: ["cdkMenuTriggerFor"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuItemTrigger, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenuTriggerFor]',
+                    exportAs: 'cdkMenuTriggerFor',
+                    host: {
+                        '(keydown)': '_toggleOnKeydown($event)',
+                        '(click)': 'toggle()',
+                        'class': 'cdk-menu-trigger',
+                        'aria-haspopup': 'menu',
+                        '[attr.aria-expanded]': 'isMenuOpen()',
+                    },
+                }]
+        }], ctorParameters: function () {
+        return [{ type: i0.ElementRef }, { type: i0.ViewContainerRef }, { type: i1.Overlay }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                        type: Optional
+                    }, {
+                        type: Inject,
+                        args: [CDK_MENU]
+                    }] }, { type: undefined, decorators: [{
+                        type: Optional
+                    }, {
+                        type: Inject,
+                        args: [MENU_AIM]
+                    }] }, { type: i2.Directionality, decorators: [{
+                        type: Optional
+                    }] }];
+    }, propDecorators: { menuPanel: [{
+                type: Input,
+                args: ['cdkMenuTriggerFor']
+            }], opened: [{
+                type: Output,
+                args: ['cdkMenuOpened']
+            }], closed: [{
+                type: Output,
+                args: ['cdkMenuClosed']
+            }] } });
 
 /**
  * @license
@@ -699,9 +715,8 @@ CdkMenuItemTrigger.propDecorators = {
 // TODO refactor this to be configurable allowing for custom elements to be removed
 /** Removes all icons from within the given element. */
 function removeIcons(element) {
-    var _a;
     for (const icon of Array.from(element.querySelectorAll('mat-icon, .material-icons'))) {
-        (_a = icon.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(icon);
+        icon.remove();
     }
 }
 /**
@@ -903,35 +918,82 @@ class CdkMenuItem {
         this._destroyed.next();
     }
 }
-CdkMenuItem.decorators = [
-    { type: Directive, args: [{
-                selector: '[cdkMenuItem]',
-                exportAs: 'cdkMenuItem',
-                host: {
-                    '[tabindex]': '_tabindex',
-                    'type': 'button',
-                    'role': 'menuitem',
-                    'class': 'cdk-menu-item',
-                    '[attr.aria-disabled]': 'disabled || null',
-                },
-            },] }
-];
-CdkMenuItem.ctorParameters = () => [
-    { type: ElementRef },
-    { type: NgZone },
-    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [CDK_MENU,] }] },
-    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MENU_AIM,] }] },
-    { type: Directionality, decorators: [{ type: Optional }] },
-    { type: CdkMenuItemTrigger, decorators: [{ type: Self }, { type: Optional }] }
-];
-CdkMenuItem.propDecorators = {
-    disabled: [{ type: Input }],
-    triggered: [{ type: Output, args: ['cdkMenuItemTriggered',] }],
-    _resetTabIndex: [{ type: HostListener, args: ['blur',] }, { type: HostListener, args: ['mouseout',] }],
-    _setTabIndex: [{ type: HostListener, args: ['focus',] }, { type: HostListener, args: ['mouseenter', ['$event'],] }],
-    trigger: [{ type: HostListener, args: ['click',] }],
-    _onKeydown: [{ type: HostListener, args: ['keydown', ['$event'],] }]
-};
+CdkMenuItem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuItem, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: CDK_MENU, optional: true }, { token: MENU_AIM, optional: true }, { token: i2.Directionality, optional: true }, { token: CdkMenuItemTrigger, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuItem.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkMenuItem, selector: "[cdkMenuItem]", inputs: { disabled: "disabled" }, outputs: { triggered: "cdkMenuItemTriggered" }, host: { attributes: { "type": "button", "role": "menuitem" }, listeners: { "blur": "_resetTabIndex()", "mouseout": "_resetTabIndex()", "focus": "_setTabIndex()", "mouseenter": "_setTabIndex($event)", "click": "trigger()", "keydown": "_onKeydown($event)" }, properties: { "tabindex": "_tabindex", "attr.aria-disabled": "disabled || null" }, classAttribute: "cdk-menu-item" }, exportAs: ["cdkMenuItem"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuItem, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenuItem]',
+                    exportAs: 'cdkMenuItem',
+                    host: {
+                        '[tabindex]': '_tabindex',
+                        'type': 'button',
+                        'role': 'menuitem',
+                        'class': 'cdk-menu-item',
+                        '[attr.aria-disabled]': 'disabled || null',
+                    },
+                }]
+        }], ctorParameters: function () {
+        return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                        type: Optional
+                    }, {
+                        type: Inject,
+                        args: [CDK_MENU]
+                    }] }, { type: undefined, decorators: [{
+                        type: Optional
+                    }, {
+                        type: Inject,
+                        args: [MENU_AIM]
+                    }] }, { type: i2.Directionality, decorators: [{
+                        type: Optional
+                    }] }, { type: CdkMenuItemTrigger, decorators: [{
+                        type: Self
+                    }, {
+                        type: Optional
+                    }] }];
+    }, propDecorators: { disabled: [{
+                type: Input
+            }], triggered: [{
+                type: Output,
+                args: ['cdkMenuItemTriggered']
+            }],
+        /** Reset the _tabindex to -1. */
+        _resetTabIndex: [{
+                type: HostListener,
+                args: ['blur']
+            }, {
+                type: HostListener,
+                args: ['mouseout']
+            }],
+        /**
+         * Set the tab index to 0 if not disabled and it's a focus event, or a mouse enter if this element
+         * is not in a menu bar.
+         */
+        _setTabIndex: [{
+                type: HostListener,
+                args: ['focus']
+            }, {
+                type: HostListener,
+                args: ['mouseenter', ['$event']]
+            }],
+        /**
+         * If the menu item is not disabled and the element does not have a menu trigger attached, emit
+         * on the cdkMenuItemTriggered emitter and close all open menus.
+         */
+        trigger: [{
+                type: HostListener,
+                args: ['click']
+            }],
+        /**
+         * Handles keyboard events for the menu item, specifically either triggering the user defined
+         * callback or opening/closing the current menu based on whether the left or right arrow key was
+         * pressed.
+         * @param event the keyboard event to handle
+         */
+        _onKeydown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
 
 /**
  * @license
@@ -971,15 +1033,20 @@ class CdkMenuItemSelectable extends CdkMenuItem {
         }
     }
 }
-CdkMenuItemSelectable.decorators = [
-    { type: Directive }
-];
-CdkMenuItemSelectable.propDecorators = {
-    toggled: [{ type: Output, args: ['cdkMenuItemToggled',] }],
-    checked: [{ type: Input }],
-    name: [{ type: Input }],
-    id: [{ type: Input }]
-};
+CdkMenuItemSelectable.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuItemSelectable, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuItemSelectable.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkMenuItemSelectable, inputs: { checked: "checked", name: "name", id: "id" }, outputs: { toggled: "cdkMenuItemToggled" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuItemSelectable, decorators: [{
+            type: Directive
+        }], propDecorators: { toggled: [{
+                type: Output,
+                args: ['cdkMenuItemToggled']
+            }], checked: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }] } });
 
 /**
  * @license
@@ -1024,57 +1091,25 @@ class CdkMenuGroup {
         this._selectableChanges.complete();
     }
 }
-CdkMenuGroup.decorators = [
-    { type: Directive, args: [{
-                selector: '[cdkMenuGroup]',
-                exportAs: 'cdkMenuGroup',
-                host: {
-                    'role': 'group',
-                    'class': 'cdk-menu-group',
-                },
-                providers: [{ provide: UniqueSelectionDispatcher, useClass: UniqueSelectionDispatcher }],
-            },] }
-];
-CdkMenuGroup.propDecorators = {
-    change: [{ type: Output }],
-    _selectableItems: [{ type: ContentChildren, args: [CdkMenuItemSelectable, { descendants: true },] }]
-};
-
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-/**
- * Directive applied to an ng-template which wraps a CdkMenu and provides a reference to the
- * child element it wraps which allows for opening of the CdkMenu in an overlay.
- */
-class CdkMenuPanel {
-    constructor(_templateRef) {
-        this._templateRef = _templateRef;
-    }
-    /**
-     * Set the Menu component on the menu panel. Since we cannot use ContentChild to fetch the
-     * child Menu component, the child Menu must register its self with the parent MenuPanel.
-     */
-    _registerMenu(child) {
-        var _a;
-        this._menu = child;
-        // The ideal solution would be to affect the CdkMenuPanel injector from the CdkMenuTrigger and
-        // inject the menu stack reference into the child menu and menu items, however this isn't
-        // possible at this time.
-        this._menu._menuStack = this._menuStack;
-        (_a = this._menuStack) === null || _a === void 0 ? void 0 : _a.push(child);
-    }
-}
-CdkMenuPanel.decorators = [
-    { type: Directive, args: [{ selector: 'ng-template[cdkMenuPanel]', exportAs: 'cdkMenuPanel' },] }
-];
-CdkMenuPanel.ctorParameters = () => [
-    { type: TemplateRef }
-];
+CdkMenuGroup.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuGroup, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuGroup.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkMenuGroup, selector: "[cdkMenuGroup]", outputs: { change: "change" }, host: { attributes: { "role": "group" }, classAttribute: "cdk-menu-group" }, providers: [{ provide: UniqueSelectionDispatcher, useClass: UniqueSelectionDispatcher }], queries: [{ propertyName: "_selectableItems", predicate: CdkMenuItemSelectable, descendants: true }], exportAs: ["cdkMenuGroup"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuGroup, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenuGroup]',
+                    exportAs: 'cdkMenuGroup',
+                    host: {
+                        'role': 'group',
+                        'class': 'cdk-menu-group',
+                    },
+                    providers: [{ provide: UniqueSelectionDispatcher, useClass: UniqueSelectionDispatcher }],
+                }]
+        }], propDecorators: { change: [{
+                type: Output
+            }], _selectableItems: [{
+                type: ContentChildren,
+                args: [CdkMenuItemSelectable, { descendants: true }]
+            }] } });
 
 /**
  * @license
@@ -1123,6 +1158,42 @@ class PointerFocusTracker {
     }
 }
 
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Directive applied to an ng-template which wraps a CdkMenu and provides a reference to the
+ * child element it wraps which allows for opening of the CdkMenu in an overlay.
+ */
+class CdkMenuPanel {
+    constructor(_templateRef) {
+        this._templateRef = _templateRef;
+    }
+    /**
+     * Set the Menu component on the menu panel. Since we cannot use ContentChild to fetch the
+     * child Menu component, the child Menu must register its self with the parent MenuPanel.
+     */
+    _registerMenu(child) {
+        var _a;
+        this._menu = child;
+        // The ideal solution would be to affect the CdkMenuPanel injector from the CdkMenuTrigger and
+        // inject the menu stack reference into the child menu and menu items, however this isn't
+        // possible at this time.
+        this._menu._menuStack = this._menuStack;
+        (_a = this._menuStack) === null || _a === void 0 ? void 0 : _a.push(child);
+    }
+}
+CdkMenuPanel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuPanel, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuPanel.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkMenuPanel, selector: "ng-template[cdkMenuPanel]", exportAs: ["cdkMenuPanel"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuPanel, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[cdkMenuPanel]', exportAs: 'cdkMenuPanel' }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -1369,39 +1440,66 @@ class CdkMenu extends CdkMenuGroup {
         this.closed.complete();
     }
 }
-CdkMenu.decorators = [
-    { type: Directive, args: [{
-                selector: '[cdkMenu]',
-                exportAs: 'cdkMenu',
-                host: {
-                    '[tabindex]': '_isInline() ? 0 : null',
-                    'role': 'menu',
-                    'class': 'cdk-menu',
-                    '[class.cdk-menu-inline]': '_isInline()',
-                    '[attr.aria-orientation]': 'orientation',
-                },
-                providers: [
-                    { provide: CdkMenuGroup, useExisting: CdkMenu },
-                    { provide: CDK_MENU, useExisting: CdkMenu },
-                ],
-            },] }
-];
-CdkMenu.ctorParameters = () => [
-    { type: NgZone },
-    { type: ElementRef },
-    { type: undefined, decorators: [{ type: Self }, { type: Optional }, { type: Inject, args: [MENU_AIM,] }] },
-    { type: Directionality, decorators: [{ type: Optional }] },
-    { type: CdkMenuPanel, decorators: [{ type: Optional }] }
-];
-CdkMenu.propDecorators = {
-    orientation: [{ type: Input, args: ['cdkMenuOrientation',] }],
-    closed: [{ type: Output }],
-    _nestedGroups: [{ type: ContentChildren, args: [CdkMenuGroup, { descendants: true },] }],
-    _allItems: [{ type: ContentChildren, args: [CdkMenuItem, { descendants: true },] }],
-    _explicitPanel: [{ type: Input, args: ['cdkMenuPanel',] }],
-    focusFirstItem: [{ type: HostListener, args: ['focus',] }],
-    _handleKeyEvent: [{ type: HostListener, args: ['keydown', ['$event'],] }]
-};
+CdkMenu.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenu, deps: [{ token: i0.NgZone }, { token: i0.ElementRef }, { token: MENU_AIM, optional: true, self: true }, { token: i2.Directionality, optional: true }, { token: CdkMenuPanel, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenu.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkMenu, selector: "[cdkMenu]", inputs: { orientation: ["cdkMenuOrientation", "orientation"], _explicitPanel: ["cdkMenuPanel", "_explicitPanel"] }, outputs: { closed: "closed" }, host: { attributes: { "role": "menu" }, listeners: { "focus": "focusFirstItem()", "keydown": "_handleKeyEvent($event)" }, properties: { "tabindex": "_isInline() ? 0 : null", "class.cdk-menu-inline": "_isInline()", "attr.aria-orientation": "orientation" }, classAttribute: "cdk-menu" }, providers: [
+        { provide: CdkMenuGroup, useExisting: CdkMenu },
+        { provide: CDK_MENU, useExisting: CdkMenu },
+    ], queries: [{ propertyName: "_nestedGroups", predicate: CdkMenuGroup, descendants: true }, { propertyName: "_allItems", predicate: CdkMenuItem, descendants: true }], exportAs: ["cdkMenu"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenu, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenu]',
+                    exportAs: 'cdkMenu',
+                    host: {
+                        '[tabindex]': '_isInline() ? 0 : null',
+                        'role': 'menu',
+                        'class': 'cdk-menu',
+                        '[class.cdk-menu-inline]': '_isInline()',
+                        '[attr.aria-orientation]': 'orientation',
+                    },
+                    providers: [
+                        { provide: CdkMenuGroup, useExisting: CdkMenu },
+                        { provide: CDK_MENU, useExisting: CdkMenu },
+                    ],
+                }]
+        }], ctorParameters: function () {
+        return [{ type: i0.NgZone }, { type: i0.ElementRef }, { type: undefined, decorators: [{
+                        type: Self
+                    }, {
+                        type: Optional
+                    }, {
+                        type: Inject,
+                        args: [MENU_AIM]
+                    }] }, { type: i2.Directionality, decorators: [{
+                        type: Optional
+                    }] }, { type: CdkMenuPanel, decorators: [{
+                        type: Optional
+                    }] }];
+    }, propDecorators: { orientation: [{
+                type: Input,
+                args: ['cdkMenuOrientation']
+            }], closed: [{
+                type: Output
+            }], _nestedGroups: [{
+                type: ContentChildren,
+                args: [CdkMenuGroup, { descendants: true }]
+            }], _allItems: [{
+                type: ContentChildren,
+                args: [CdkMenuItem, { descendants: true }]
+            }], _explicitPanel: [{
+                type: Input,
+                args: ['cdkMenuPanel']
+            }],
+        /** Place focus on the first MenuItem in the menu and set the focus origin. */
+        focusFirstItem: [{
+                type: HostListener,
+                args: ['focus']
+            }],
+        /** Handle keyboard events for the Menu. */
+        _handleKeyEvent: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
 
 /**
  * @license
@@ -1612,44 +1710,62 @@ class CdkMenuBar extends CdkMenuGroup {
         (_a = this._pointerTracker) === null || _a === void 0 ? void 0 : _a.destroy();
     }
 }
-CdkMenuBar.decorators = [
-    { type: Directive, args: [{
-                selector: '[cdkMenuBar]',
-                exportAs: 'cdkMenuBar',
-                host: {
-                    'role': 'menubar',
-                    'class': 'cdk-menu-bar',
-                    'tabindex': '0',
-                    '[attr.aria-orientation]': 'orientation',
-                },
-                providers: [
-                    { provide: CdkMenuGroup, useExisting: CdkMenuBar },
-                    { provide: CDK_MENU, useExisting: CdkMenuBar },
-                    { provide: MenuStack, useClass: MenuStack },
-                ],
-            },] }
-];
-CdkMenuBar.ctorParameters = () => [
-    { type: MenuStack },
-    { type: NgZone },
-    { type: ElementRef },
-    { type: undefined, decorators: [{ type: Self }, { type: Optional }, { type: Inject, args: [MENU_AIM,] }] },
-    { type: Directionality, decorators: [{ type: Optional }] }
-];
-CdkMenuBar.propDecorators = {
-    orientation: [{ type: Input, args: ['cdkMenuBarOrientation',] }],
-    _allItems: [{ type: ContentChildren, args: [CdkMenuItem, { descendants: true },] }],
-    focusFirstItem: [{ type: HostListener, args: ['focus',] }],
-    _handleKeyEvent: [{ type: HostListener, args: ['keydown', ['$event'],] }]
-};
+CdkMenuBar.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuBar, deps: [{ token: MenuStack }, { token: i0.NgZone }, { token: i0.ElementRef }, { token: MENU_AIM, optional: true, self: true }, { token: i2.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuBar.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkMenuBar, selector: "[cdkMenuBar]", inputs: { orientation: ["cdkMenuBarOrientation", "orientation"] }, host: { attributes: { "role": "menubar", "tabindex": "0" }, listeners: { "focus": "focusFirstItem()", "keydown": "_handleKeyEvent($event)" }, properties: { "attr.aria-orientation": "orientation" }, classAttribute: "cdk-menu-bar" }, providers: [
+        { provide: CdkMenuGroup, useExisting: CdkMenuBar },
+        { provide: CDK_MENU, useExisting: CdkMenuBar },
+        { provide: MenuStack, useClass: MenuStack },
+    ], queries: [{ propertyName: "_allItems", predicate: CdkMenuItem, descendants: true }], exportAs: ["cdkMenuBar"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuBar, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenuBar]',
+                    exportAs: 'cdkMenuBar',
+                    host: {
+                        'role': 'menubar',
+                        'class': 'cdk-menu-bar',
+                        'tabindex': '0',
+                        '[attr.aria-orientation]': 'orientation',
+                    },
+                    providers: [
+                        { provide: CdkMenuGroup, useExisting: CdkMenuBar },
+                        { provide: CDK_MENU, useExisting: CdkMenuBar },
+                        { provide: MenuStack, useClass: MenuStack },
+                    ],
+                }]
+        }], ctorParameters: function () {
+        return [{ type: MenuStack }, { type: i0.NgZone }, { type: i0.ElementRef }, { type: undefined, decorators: [{
+                        type: Self
+                    }, {
+                        type: Optional
+                    }, {
+                        type: Inject,
+                        args: [MENU_AIM]
+                    }] }, { type: i2.Directionality, decorators: [{
+                        type: Optional
+                    }] }];
+    }, propDecorators: { orientation: [{
+                type: Input,
+                args: ['cdkMenuBarOrientation']
+            }], _allItems: [{
+                type: ContentChildren,
+                args: [CdkMenuItem, { descendants: true }]
+            }],
+        /** Place focus on the first MenuItem in the menu and set the focus origin. */
+        focusFirstItem: [{
+                type: HostListener,
+                args: ['focus']
+            }],
+        /**
+         * Handle keyboard events, specifically changing the focused element and/or toggling the active
+         * items menu.
+         * @param event the KeyboardEvent to handle.
+         */
+        _handleKeyEvent: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
 
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
 /**
  * A directive providing behavior for the "menuitemradio" ARIA role, which behaves similarly to
  * a conventional radio-button. Any sibling `CdkMenuItemRadio` instances within the same `CdkMenu`
@@ -1681,32 +1797,47 @@ class CdkMenuItemRadio extends CdkMenuItemSelectable {
         this._removeDispatcherListener();
     }
 }
-CdkMenuItemRadio.decorators = [
-    { type: Directive, args: [{
-                selector: '[cdkMenuItemRadio]',
-                exportAs: 'cdkMenuItemRadio',
-                host: {
-                    '[tabindex]': '_tabindex',
-                    'type': 'button',
-                    'role': 'menuitemradio',
-                    '[attr.aria-checked]': 'checked || null',
-                    '[attr.aria-disabled]': 'disabled || null',
-                },
-                providers: [
-                    { provide: CdkMenuItemSelectable, useExisting: CdkMenuItemRadio },
-                    { provide: CdkMenuItem, useExisting: CdkMenuItemSelectable },
-                ],
-            },] }
-];
-CdkMenuItemRadio.ctorParameters = () => [
-    { type: UniqueSelectionDispatcher },
-    { type: ElementRef },
-    { type: NgZone },
-    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [CDK_MENU,] }] },
-    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MENU_AIM,] }] },
-    { type: Directionality, decorators: [{ type: Optional }] },
-    { type: CdkMenuItemTrigger, decorators: [{ type: Self }, { type: Optional }] }
-];
+CdkMenuItemRadio.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuItemRadio, deps: [{ token: i1$1.UniqueSelectionDispatcher }, { token: i0.ElementRef }, { token: i0.NgZone }, { token: CDK_MENU, optional: true }, { token: MENU_AIM, optional: true }, { token: i2.Directionality, optional: true }, { token: CdkMenuItemTrigger, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuItemRadio.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkMenuItemRadio, selector: "[cdkMenuItemRadio]", host: { attributes: { "type": "button", "role": "menuitemradio" }, properties: { "tabindex": "_tabindex", "attr.aria-checked": "checked || null", "attr.aria-disabled": "disabled || null" } }, providers: [
+        { provide: CdkMenuItemSelectable, useExisting: CdkMenuItemRadio },
+        { provide: CdkMenuItem, useExisting: CdkMenuItemSelectable },
+    ], exportAs: ["cdkMenuItemRadio"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuItemRadio, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenuItemRadio]',
+                    exportAs: 'cdkMenuItemRadio',
+                    host: {
+                        '[tabindex]': '_tabindex',
+                        'type': 'button',
+                        'role': 'menuitemradio',
+                        '[attr.aria-checked]': 'checked || null',
+                        '[attr.aria-disabled]': 'disabled || null',
+                    },
+                    providers: [
+                        { provide: CdkMenuItemSelectable, useExisting: CdkMenuItemRadio },
+                        { provide: CdkMenuItem, useExisting: CdkMenuItemSelectable },
+                    ],
+                }]
+        }], ctorParameters: function () {
+        return [{ type: i1$1.UniqueSelectionDispatcher }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                        type: Optional
+                    }, {
+                        type: Inject,
+                        args: [CDK_MENU]
+                    }] }, { type: undefined, decorators: [{
+                        type: Optional
+                    }, {
+                        type: Inject,
+                        args: [MENU_AIM]
+                    }] }, { type: i2.Directionality, decorators: [{
+                        type: Optional
+                    }] }, { type: CdkMenuItemTrigger, decorators: [{
+                        type: Self
+                    }, {
+                        type: Optional
+                    }] }];
+    } });
 
 /**
  * @license
@@ -1728,23 +1859,29 @@ class CdkMenuItemCheckbox extends CdkMenuItemSelectable {
         }
     }
 }
-CdkMenuItemCheckbox.decorators = [
-    { type: Directive, args: [{
-                selector: '[cdkMenuItemCheckbox]',
-                exportAs: 'cdkMenuItemCheckbox',
-                host: {
-                    '[tabindex]': '_tabindex',
-                    'type': 'button',
-                    'role': 'menuitemcheckbox',
-                    '[attr.aria-checked]': 'checked || null',
-                    '[attr.aria-disabled]': 'disabled || null',
-                },
-                providers: [
-                    { provide: CdkMenuItemSelectable, useExisting: CdkMenuItemCheckbox },
-                    { provide: CdkMenuItem, useExisting: CdkMenuItemSelectable },
-                ],
-            },] }
-];
+CdkMenuItemCheckbox.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuItemCheckbox, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuItemCheckbox.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkMenuItemCheckbox, selector: "[cdkMenuItemCheckbox]", host: { attributes: { "type": "button", "role": "menuitemcheckbox" }, properties: { "tabindex": "_tabindex", "attr.aria-checked": "checked || null", "attr.aria-disabled": "disabled || null" } }, providers: [
+        { provide: CdkMenuItemSelectable, useExisting: CdkMenuItemCheckbox },
+        { provide: CdkMenuItem, useExisting: CdkMenuItemSelectable },
+    ], exportAs: ["cdkMenuItemCheckbox"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuItemCheckbox, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenuItemCheckbox]',
+                    exportAs: 'cdkMenuItemCheckbox',
+                    host: {
+                        '[tabindex]': '_tabindex',
+                        'type': 'button',
+                        'role': 'menuitemcheckbox',
+                        '[attr.aria-checked]': 'checked || null',
+                        '[attr.aria-disabled]': 'disabled || null',
+                    },
+                    providers: [
+                        { provide: CdkMenuItemSelectable, useExisting: CdkMenuItemCheckbox },
+                        { provide: CdkMenuItem, useExisting: CdkMenuItemSelectable },
+                    ],
+                }]
+        }] });
 
 /**
  * @license
@@ -1767,13 +1904,14 @@ class ContextMenuTracker {
         }
     }
 }
-ContextMenuTracker.ɵprov = i0.ɵɵdefineInjectable({ factory: function ContextMenuTracker_Factory() { return new ContextMenuTracker(); }, token: ContextMenuTracker, providedIn: "root" });
-ContextMenuTracker.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
+ContextMenuTracker.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: ContextMenuTracker, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ContextMenuTracker.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: ContextMenuTracker, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: ContextMenuTracker, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 /** Injection token for the ContextMenu options object. */
 const CDK_CONTEXT_MENU_DEFAULT_OPTIONS = new InjectionToken('cdk-context-menu-default-options');
-const ɵ0 = { offsetX: 2, offsetY: 2 };
 /**
  * A directive which when placed on some element opens a the Menu it is bound to when a user
  * right-clicks within that element. It is aware of nested Context Menus and the lowest level
@@ -1833,15 +1971,13 @@ class CdkContextMenuTrigger {
             // since we're moving this menu we need to close any submenus first otherwise they end up
             // disconnected from this one.
             this._menuStack.closeSubMenuOf(this._menuPanel._menu);
-            this._overlayRef.getConfig()
-                .positionStrategy.setOrigin(coordinates);
+            this._overlayRef.getConfig().positionStrategy.setOrigin(coordinates);
             this._overlayRef.updatePosition();
         }
         else {
             this.opened.next();
             if (this._overlayRef) {
-                this._overlayRef.getConfig()
-                    .positionStrategy.setOrigin(coordinates);
+                this._overlayRef.getConfig().positionStrategy.setOrigin(coordinates);
                 this._overlayRef.updatePosition();
             }
             else {
@@ -1985,33 +2121,46 @@ class CdkContextMenuTrigger {
         }
     }
 }
-CdkContextMenuTrigger.decorators = [
-    { type: Directive, args: [{
-                selector: '[cdkContextMenuTriggerFor]',
-                exportAs: 'cdkContextMenuTriggerFor',
-                host: {
-                    '(contextmenu)': '_openOnContextMenu($event)',
-                },
-                providers: [
-                    // In cases where the first menu item in the context menu is a trigger the submenu opens on a
-                    // hover event. Offsetting the opened context menu by 2px prevents this from occurring.
-                    { provide: CDK_CONTEXT_MENU_DEFAULT_OPTIONS, useValue: ɵ0 },
-                ],
-            },] }
-];
-CdkContextMenuTrigger.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: Overlay },
-    { type: ContextMenuTracker },
-    { type: undefined, decorators: [{ type: Inject, args: [CDK_CONTEXT_MENU_DEFAULT_OPTIONS,] }] },
-    { type: Directionality, decorators: [{ type: Optional }] }
-];
-CdkContextMenuTrigger.propDecorators = {
-    menuPanel: [{ type: Input, args: ['cdkContextMenuTriggerFor',] }],
-    opened: [{ type: Output, args: ['cdkContextMenuOpened',] }],
-    closed: [{ type: Output, args: ['cdkContextMenuClosed',] }],
-    disabled: [{ type: Input, args: ['cdkContextMenuDisabled',] }]
-};
+CdkContextMenuTrigger.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkContextMenuTrigger, deps: [{ token: i0.ViewContainerRef }, { token: i1.Overlay }, { token: ContextMenuTracker }, { token: CDK_CONTEXT_MENU_DEFAULT_OPTIONS }, { token: i2.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkContextMenuTrigger.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkContextMenuTrigger, selector: "[cdkContextMenuTriggerFor]", inputs: { menuPanel: ["cdkContextMenuTriggerFor", "menuPanel"], disabled: ["cdkContextMenuDisabled", "disabled"] }, outputs: { opened: "cdkContextMenuOpened", closed: "cdkContextMenuClosed" }, host: { listeners: { "contextmenu": "_openOnContextMenu($event)" } }, providers: [
+        // In cases where the first menu item in the context menu is a trigger the submenu opens on a
+        // hover event. Offsetting the opened context menu by 2px prevents this from occurring.
+        { provide: CDK_CONTEXT_MENU_DEFAULT_OPTIONS, useValue: { offsetX: 2, offsetY: 2 } },
+    ], exportAs: ["cdkContextMenuTriggerFor"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkContextMenuTrigger, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkContextMenuTriggerFor]',
+                    exportAs: 'cdkContextMenuTriggerFor',
+                    host: {
+                        '(contextmenu)': '_openOnContextMenu($event)',
+                    },
+                    providers: [
+                        // In cases where the first menu item in the context menu is a trigger the submenu opens on a
+                        // hover event. Offsetting the opened context menu by 2px prevents this from occurring.
+                        { provide: CDK_CONTEXT_MENU_DEFAULT_OPTIONS, useValue: { offsetX: 2, offsetY: 2 } },
+                    ],
+                }]
+        }], ctorParameters: function () {
+        return [{ type: i0.ViewContainerRef }, { type: i1.Overlay }, { type: ContextMenuTracker }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [CDK_CONTEXT_MENU_DEFAULT_OPTIONS]
+                    }] }, { type: i2.Directionality, decorators: [{
+                        type: Optional
+                    }] }];
+    }, propDecorators: { menuPanel: [{
+                type: Input,
+                args: ['cdkContextMenuTriggerFor']
+            }], opened: [{
+                type: Output,
+                args: ['cdkContextMenuOpened']
+            }], closed: [{
+                type: Output,
+                args: ['cdkContextMenuClosed']
+            }], disabled: [{
+                type: Input,
+                args: ['cdkContextMenuDisabled']
+            }] } });
 
 /**
  * @license
@@ -2034,13 +2183,43 @@ const EXPORTED_DECLARATIONS = [
 ];
 class CdkMenuModule {
 }
-CdkMenuModule.decorators = [
-    { type: NgModule, args: [{
-                imports: [OverlayModule],
-                exports: EXPORTED_DECLARATIONS,
-                declarations: EXPORTED_DECLARATIONS,
-            },] }
-];
+CdkMenuModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CdkMenuModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuModule, declarations: [CdkMenuBar,
+        CdkMenu,
+        CdkMenuPanel,
+        CdkMenuItem,
+        CdkMenuItemRadio,
+        CdkMenuItemCheckbox,
+        CdkMenuItemTrigger,
+        CdkMenuGroup,
+        CdkContextMenuTrigger,
+        CdkTargetMenuAim], imports: [OverlayModule], exports: [CdkMenuBar,
+        CdkMenu,
+        CdkMenuPanel,
+        CdkMenuItem,
+        CdkMenuItemRadio,
+        CdkMenuItemCheckbox,
+        CdkMenuItemTrigger,
+        CdkMenuGroup,
+        CdkContextMenuTrigger,
+        CdkTargetMenuAim] });
+CdkMenuModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuModule, imports: [[OverlayModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenuModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [OverlayModule],
+                    exports: EXPORTED_DECLARATIONS,
+                    declarations: EXPORTED_DECLARATIONS,
+                }]
+        }] });
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
 
 /**
  * @license
@@ -2054,5 +2233,5 @@ CdkMenuModule.decorators = [
  * Generated bundle index. Do not edit.
  */
 
-export { CDK_CONTEXT_MENU_DEFAULT_OPTIONS, CDK_MENU, CdkContextMenuTrigger, CdkMenu, CdkMenuBar, CdkMenuGroup, CdkMenuItem, CdkMenuItemCheckbox, CdkMenuItemRadio, CdkMenuItemTrigger, CdkMenuModule, CdkMenuPanel, CdkTargetMenuAim, ContextMenuTracker, MENU_AIM, MenuStack, TargetMenuAim, isClickInsideMenuOverlay, ɵ0, CdkMenuItemSelectable as ɵangular_material_src_cdk_experimental_menu_menu_b };
-//# sourceMappingURL=menu.js.map
+export { CDK_CONTEXT_MENU_DEFAULT_OPTIONS, CDK_MENU, CdkContextMenuTrigger, CdkMenu, CdkMenuBar, CdkMenuGroup, CdkMenuItem, CdkMenuItemCheckbox, CdkMenuItemRadio, CdkMenuItemTrigger, CdkMenuModule, CdkMenuPanel, CdkTargetMenuAim, ContextMenuTracker, MENU_AIM, MenuStack, TargetMenuAim, isClickInsideMenuOverlay };
+//# sourceMappingURL=menu.mjs.map