{"version":3,"file":"5758.9b38aadd99da2e03.js","mappings":"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","names":["constructor","this","role","panelClass","hasBackdrop","backdropClass","disableClose","width","height","maxWidth","data","ariaDescribedBy","ariaLabelledBy","ariaLabel","autoFocus","restoreFocus","delayFocusTrap","closeOnNavigation","matDialogAnimations","dialogContainer","trigger","state","style","opacity","transform","transition","group","animate","query","animateChild","optional","_MatDialogContainerBase","BasePortalOutlet","_elementRef","_focusTrapFactory","_changeDetectorRef","_document","_config","_interactivityChecker","_ngZone","_focusMonitor","super","_animationStateChanged","EventEmitter","_elementFocusedBeforeDialogWasOpened","_closeInteractionType","attachDomPortal","portal","_portalOutlet","hasAttached","_ariaLabelledBy","_initializeWithAttachedContent","_focusTrap","create","nativeElement","_getFocusedElementPierceShadowDom","attachComponentPortal","attachTemplatePortal","_recaptureFocus","_containsFocus","_trapFocus","_forceFocus","element","options","isFocusable","tabIndex","runOutsideAngular","callback","removeEventListener","removeAttribute","addEventListener","focus","_focusByCssSelector","selector","elementToFocus","querySelector","focusInitialElementWhenReady","then","focusedSuccessfully","_focusDialogContainer","_restoreFocus","previousElement","activeElement","body","contains","focusVia","destroy","ɵfac","i0","i1","DOCUMENT","MatDialogConfig","ɵdir","viewQuery","CdkPortalOutlet","n","e","MatDialogContainer","arguments","_state","_onAnimationDone","toState","totalTime","next","_onAnimationStart","_startExitAnimation","markForCheck","ɵcmp","selectors","decls","directives","i3","styles","uniqueId","_overlayRef","_containerInstance","id","_afterOpened","Subject","_afterClosed","_beforeClosed","_id","pipe","filter","event","take","subscribe","complete","clearTimeout","_closeFallbackTimeout","_finishDialogClose","detachments","_result","componentInstance","dispose","keydownEvents","keyCode","ESCAPE","hasModifierKey","preventDefault","_closeDialogVia","backdropClick","close","dialogResult","detachBackdrop","setTimeout","afterOpened","afterClosed","beforeClosed","updatePosition","position","strategy","_getPositionStrategy","left","right","centerHorizontally","a","top","bottom","centerVertically","updateSize","addPanelClass","classes","removePanelClass","getState","getConfig","positionStrategy","ref","interactionType","result","undefined","MAT_DIALOG_DATA","InjectionToken","MAT_DIALOG_DEFAULT_OPTIONS","MAT_DIALOG_SCROLL_STRATEGY","MAT_DIALOG_SCROLL_STRATEGY_PROVIDER","provide","deps","Overlay","useFactory","overlay","scrollStrategies","block","_MatDialogBase","_overlay","_injector","_defaultOptions","_parentDialog","_overlayContainer","scrollStrategy","_dialogRefConstructor","_dialogContainerType","_dialogDataToken","_animationMode","_openDialogsAtThisLevel","_afterAllClosedAtThisLevel","_afterOpenedAtThisLevel","_ariaHiddenElements","Map","afterAllClosed","defer","openDialogs","length","_getAfterAllClosed","startWith","_scrollStrategy","parent","open","componentOrTemplateRef","config","defaultOptions","Object","assign","_applyConfigDefaults","getDialogById","overlayRef","_createOverlay","_attachDialogContainer","dialogRef","_attachDialogContent","_hideNonDialogContentFromAssistiveTechnology","push","_removeOpenDialog","closeAll","_closeDialogs","find","dialog","ngOnDestroy","overlayConfig","_getOverlayConfig","dialogConfig","OverlayConfig","global","direction","minWidth","minHeight","maxHeight","disposeOnNavigation","injector","Injector","viewContainerRef","providers","useValue","containerPortal","ComponentPortal","componentFactoryResolver","containerRef","attach","instance","TemplateRef","TemplatePortal","$implicit","_createInjector","contentRef","userInjector","get","Directionality","InjectFlags","value","change","of","index","indexOf","splice","forEach","previousValue","setAttribute","clear","overlayContainer","getContainerElement","parentElement","siblings","children","i","sibling","nodeName","hasAttribute","set","getAttribute","dialogs","MatDialog","location","parentDialog","animationMode","MatDialogRef","i1$1","i2","ANIMATION_MODULE_TYPE","ɵprov","factory","dialogElementUid","MatDialogTitle","_dialogRef","_dialog","ngOnInit","classList","getClosestDialog","Promise","resolve","container","MatDialogContent","MatDialogActions","MatDialogModule","ɵmod","ɵinj","imports","OverlayModule","PortalModule","MatCommonModule"],"sourceRoot":"webpack:///","sources":["./node_modules/@angular/material/fesm2015/dialog.mjs"],"sourcesContent":["import * as i1$1 from '@angular/cdk/overlay';\nimport { Overlay, OverlayConfig, OverlayModule } from '@angular/cdk/overlay';\nimport * as i3 from '@angular/cdk/portal';\nimport { BasePortalOutlet, CdkPortalOutlet, ComponentPortal, TemplatePortal, PortalModule } from '@angular/cdk/portal';\nimport * as i0 from '@angular/core';\nimport { EventEmitter, Directive, Optional, Inject, ViewChild, Component, ViewEncapsulation, ChangeDetectionStrategy, InjectionToken, Injector, TemplateRef, InjectFlags, Injectable, SkipSelf, Input, NgModule } from '@angular/core';\nimport { MatCommonModule } from '@angular/material/core';\nimport { Directionality } from '@angular/cdk/bidi';\nimport { Subject, defer, of } from 'rxjs';\nimport { filter, take, startWith } from 'rxjs/operators';\nimport { _getFocusedElementPierceShadowDom } from '@angular/cdk/platform';\nimport * as i2 from '@angular/common';\nimport { DOCUMENT } from '@angular/common';\nimport { trigger, state, style, transition, group, animate, query, animateChild } from '@angular/animations';\nimport * as i1 from '@angular/cdk/a11y';\nimport { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';\nimport { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';\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 * Configuration for opening a modal dialog with the MatDialog service.\n */\nclass MatDialogConfig {\n    constructor() {\n        /** The ARIA role of the dialog element. */\n        this.role = 'dialog';\n        /** Custom class for the overlay pane. */\n        this.panelClass = '';\n        /** Whether the dialog has a backdrop. */\n        this.hasBackdrop = true;\n        /** Custom class for the backdrop. */\n        this.backdropClass = '';\n        /** Whether the user can use escape or clicking on the backdrop to close the modal. */\n        this.disableClose = false;\n        /** Width of the dialog. */\n        this.width = '';\n        /** Height of the dialog. */\n        this.height = '';\n        /** Max-width of the dialog. If a number is provided, assumes pixel units. Defaults to 80vw. */\n        this.maxWidth = '80vw';\n        /** Data being injected into the child component. */\n        this.data = null;\n        /** ID of the element that describes the dialog. */\n        this.ariaDescribedBy = null;\n        /** ID of the element that labels the dialog. */\n        this.ariaLabelledBy = null;\n        /** Aria label to assign to the dialog element. */\n        this.ariaLabel = null;\n        /**\n         * Where the dialog should focus on open.\n         * @breaking-change 14.0.0 Remove boolean option from autoFocus. Use string or\n         * AutoFocusTarget instead.\n         */\n        this.autoFocus = 'first-tabbable';\n        /**\n         * Whether the dialog should restore focus to the\n         * previously-focused element, after it's closed.\n         */\n        this.restoreFocus = true;\n        /** Whether to wait for the opening animation to finish before trapping focus. */\n        this.delayFocusTrap = true;\n        /**\n         * Whether the dialog should close when the user goes backwards/forwards in history.\n         * Note that this usually doesn't include clicking on links (unless the user is using\n         * the `HashLocationStrategy`).\n         */\n        this.closeOnNavigation = true;\n        // TODO(jelbourn): add configuration for lifecycle hooks, ARIA labelling.\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Animations used by MatDialog.\n * @docs-private\n */\nconst matDialogAnimations = {\n    /** Animation that is applied on the dialog container by default. */\n    dialogContainer: trigger('dialogContainer', [\n        // Note: The `enter` animation transitions to `transform: none`, because for some reason\n        // specifying the transform explicitly, causes IE both to blur the dialog content and\n        // decimate the animation performance. Leaving it as `none` solves both issues.\n        state('void, exit', style({ opacity: 0, transform: 'scale(0.7)' })),\n        state('enter', style({ transform: 'none' })),\n        transition('* => enter', group([\n            animate('150ms cubic-bezier(0, 0, 0.2, 1)', style({ transform: 'none', opacity: 1 })),\n            query('@*', animateChild(), { optional: true }),\n        ])),\n        transition('* => void, * => exit', group([\n            animate('75ms cubic-bezier(0.4, 0.0, 0.2, 1)', style({ opacity: 0 })),\n            query('@*', animateChild(), { optional: true }),\n        ])),\n    ]),\n};\n\n/**\n * Throws an exception for the case when a ComponentPortal is\n * attached to a DomPortalOutlet without an origin.\n * @docs-private\n */\nfunction throwMatDialogContentAlreadyAttachedError() {\n    throw Error('Attempting to attach dialog content after content is already attached');\n}\n/**\n * Base class for the `MatDialogContainer`. The base class does not implement\n * animations as these are left to implementers of the dialog container.\n */\nclass _MatDialogContainerBase extends BasePortalOutlet {\n    constructor(_elementRef, _focusTrapFactory, _changeDetectorRef, _document, \n    /** The dialog configuration. */\n    _config, _interactivityChecker, _ngZone, _focusMonitor) {\n        super();\n        this._elementRef = _elementRef;\n        this._focusTrapFactory = _focusTrapFactory;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._config = _config;\n        this._interactivityChecker = _interactivityChecker;\n        this._ngZone = _ngZone;\n        this._focusMonitor = _focusMonitor;\n        /** Emits when an animation state changes. */\n        this._animationStateChanged = new EventEmitter();\n        /** Element that was focused before the dialog was opened. Save this to restore upon close. */\n        this._elementFocusedBeforeDialogWasOpened = null;\n        /**\n         * Type of interaction that led to the dialog being closed. This is used to determine\n         * whether the focus style will be applied when returning focus to its original location\n         * after the dialog is closed.\n         */\n        this._closeInteractionType = null;\n        /**\n         * Attaches a DOM portal to the dialog container.\n         * @param portal Portal to be attached.\n         * @deprecated To be turned into a method.\n         * @breaking-change 10.0.0\n         */\n        this.attachDomPortal = (portal) => {\n            if (this._portalOutlet.hasAttached() && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                throwMatDialogContentAlreadyAttachedError();\n            }\n            return this._portalOutlet.attachDomPortal(portal);\n        };\n        this._ariaLabelledBy = _config.ariaLabelledBy || null;\n        this._document = _document;\n    }\n    /** Initializes the dialog container with the attached content. */\n    _initializeWithAttachedContent() {\n        this._focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement);\n        // Save the previously focused element. This element will be re-focused\n        // when the dialog closes.\n        if (this._document) {\n            this._elementFocusedBeforeDialogWasOpened = _getFocusedElementPierceShadowDom();\n        }\n    }\n    /**\n     * Attach a ComponentPortal as content to this dialog container.\n     * @param portal Portal to be attached as the dialog content.\n     */\n    attachComponentPortal(portal) {\n        if (this._portalOutlet.hasAttached() && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throwMatDialogContentAlreadyAttachedError();\n        }\n        return this._portalOutlet.attachComponentPortal(portal);\n    }\n    /**\n     * Attach a TemplatePortal as content to this dialog container.\n     * @param portal Portal to be attached as the dialog content.\n     */\n    attachTemplatePortal(portal) {\n        if (this._portalOutlet.hasAttached() && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throwMatDialogContentAlreadyAttachedError();\n        }\n        return this._portalOutlet.attachTemplatePortal(portal);\n    }\n    /** Moves focus back into the dialog if it was moved out. */\n    _recaptureFocus() {\n        if (!this._containsFocus()) {\n            this._trapFocus();\n        }\n    }\n    /**\n     * Focuses the provided element. If the element is not focusable, it will add a tabIndex\n     * attribute to forcefully focus it. The attribute is removed after focus is moved.\n     * @param element The element to focus.\n     */\n    _forceFocus(element, options) {\n        if (!this._interactivityChecker.isFocusable(element)) {\n            element.tabIndex = -1;\n            // The tabindex attribute should be removed to avoid navigating to that element again\n            this._ngZone.runOutsideAngular(() => {\n                const callback = () => {\n                    element.removeEventListener('blur', callback);\n                    element.removeEventListener('mousedown', callback);\n                    element.removeAttribute('tabindex');\n                };\n                element.addEventListener('blur', callback);\n                element.addEventListener('mousedown', callback);\n            });\n        }\n        element.focus(options);\n    }\n    /**\n     * Focuses the first element that matches the given selector within the focus trap.\n     * @param selector The CSS selector for the element to set focus to.\n     */\n    _focusByCssSelector(selector, options) {\n        let elementToFocus = this._elementRef.nativeElement.querySelector(selector);\n        if (elementToFocus) {\n            this._forceFocus(elementToFocus, options);\n        }\n    }\n    /**\n     * Moves the focus inside the focus trap. When autoFocus is not set to 'dialog', if focus\n     * cannot be moved then focus will go to the dialog container.\n     */\n    _trapFocus() {\n        const element = this._elementRef.nativeElement;\n        // If were to attempt to focus immediately, then the content of the dialog would not yet be\n        // ready in instances where change detection has to run first. To deal with this, we simply\n        // wait for the microtask queue to be empty when setting focus when autoFocus isn't set to\n        // dialog. If the element inside the dialog can't be focused, then the container is focused\n        // so the user can't tab into other elements behind it.\n        switch (this._config.autoFocus) {\n            case false:\n            case 'dialog':\n                // Ensure that focus is on the dialog container. It's possible that a different\n                // component tried to move focus while the open animation was running. See:\n                // https://github.com/angular/components/issues/16215. Note that we only want to do this\n                // if the focus isn't inside the dialog already, because it's possible that the consumer\n                // turned off `autoFocus` in order to move focus themselves.\n                if (!this._containsFocus()) {\n                    element.focus();\n                }\n                break;\n            case true:\n            case 'first-tabbable':\n                this._focusTrap.focusInitialElementWhenReady().then(focusedSuccessfully => {\n                    // If we weren't able to find a focusable element in the dialog, then focus the dialog\n                    // container instead.\n                    if (!focusedSuccessfully) {\n                        this._focusDialogContainer();\n                    }\n                });\n                break;\n            case 'first-heading':\n                this._focusByCssSelector('h1, h2, h3, h4, h5, h6, [role=\"heading\"]');\n                break;\n            default:\n                this._focusByCssSelector(this._config.autoFocus);\n                break;\n        }\n    }\n    /** Restores focus to the element that was focused before the dialog opened. */\n    _restoreFocus() {\n        const previousElement = this._elementFocusedBeforeDialogWasOpened;\n        // We need the extra check, because IE can set the `activeElement` to null in some cases.\n        if (this._config.restoreFocus &&\n            previousElement &&\n            typeof previousElement.focus === 'function') {\n            const activeElement = _getFocusedElementPierceShadowDom();\n            const element = this._elementRef.nativeElement;\n            // Make sure that focus is still inside the dialog or is on the body (usually because a\n            // non-focusable element like the backdrop was clicked) before moving it. It's possible that\n            // the consumer moved it themselves before the animation was done, in which case we shouldn't\n            // do anything.\n            if (!activeElement ||\n                activeElement === this._document.body ||\n                activeElement === element ||\n                element.contains(activeElement)) {\n                if (this._focusMonitor) {\n                    this._focusMonitor.focusVia(previousElement, this._closeInteractionType);\n                    this._closeInteractionType = null;\n                }\n                else {\n                    previousElement.focus();\n                }\n            }\n        }\n        if (this._focusTrap) {\n            this._focusTrap.destroy();\n        }\n    }\n    /** Focuses the dialog container. */\n    _focusDialogContainer() {\n        // Note that there is no focus method when rendering on the server.\n        if (this._elementRef.nativeElement.focus) {\n            this._elementRef.nativeElement.focus();\n        }\n    }\n    /** Returns whether focus is inside the dialog. */\n    _containsFocus() {\n        const element = this._elementRef.nativeElement;\n        const activeElement = _getFocusedElementPierceShadowDom();\n        return element === activeElement || element.contains(activeElement);\n    }\n}\n_MatDialogContainerBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatDialogContainerBase, deps: [{ token: i0.ElementRef }, { token: i1.FocusTrapFactory }, { token: i0.ChangeDetectorRef }, { token: DOCUMENT, optional: true }, { token: MatDialogConfig }, { token: i1.InteractivityChecker }, { token: i0.NgZone }, { token: i1.FocusMonitor }], target: i0.ɵɵFactoryTarget.Directive });\n_MatDialogContainerBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: _MatDialogContainerBase, viewQueries: [{ propertyName: \"_portalOutlet\", first: true, predicate: CdkPortalOutlet, descendants: true, static: true }], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatDialogContainerBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () {\n        return [{ type: i0.ElementRef }, { type: i1.FocusTrapFactory }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{\n                        type: Optional\n                    }, {\n                        type: Inject,\n                        args: [DOCUMENT]\n                    }] }, { type: MatDialogConfig }, { type: i1.InteractivityChecker }, { type: i0.NgZone }, { type: i1.FocusMonitor }];\n    }, propDecorators: { _portalOutlet: [{\n                type: ViewChild,\n                args: [CdkPortalOutlet, { static: true }]\n            }] } });\n/**\n * Internal component that wraps user-provided dialog content.\n * Animation is based on https://material.io/guidelines/motion/choreography.html.\n * @docs-private\n */\nclass MatDialogContainer extends _MatDialogContainerBase {\n    constructor() {\n        super(...arguments);\n        /** State of the dialog animation. */\n        this._state = 'enter';\n    }\n    /** Callback, invoked whenever an animation on the host completes. */\n    _onAnimationDone({ toState, totalTime }) {\n        if (toState === 'enter') {\n            if (this._config.delayFocusTrap) {\n                this._trapFocus();\n            }\n            this._animationStateChanged.next({ state: 'opened', totalTime });\n        }\n        else if (toState === 'exit') {\n            this._restoreFocus();\n            this._animationStateChanged.next({ state: 'closed', totalTime });\n        }\n    }\n    /** Callback, invoked when an animation on the host starts. */\n    _onAnimationStart({ toState, totalTime }) {\n        if (toState === 'enter') {\n            this._animationStateChanged.next({ state: 'opening', totalTime });\n        }\n        else if (toState === 'exit' || toState === 'void') {\n            this._animationStateChanged.next({ state: 'closing', totalTime });\n        }\n    }\n    /** Starts the dialog exit animation. */\n    _startExitAnimation() {\n        this._state = 'exit';\n        // Mark the container for check so it can react if the\n        // view container is using OnPush change detection.\n        this._changeDetectorRef.markForCheck();\n    }\n    _initializeWithAttachedContent() {\n        super._initializeWithAttachedContent();\n        if (!this._config.delayFocusTrap) {\n            this._trapFocus();\n        }\n    }\n}\nMatDialogContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialogContainer, deps: null, target: i0.ɵɵFactoryTarget.Component });\nMatDialogContainer.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDialogContainer, selector: \"mat-dialog-container\", host: { attributes: { \"tabindex\": \"-1\", \"aria-modal\": \"true\" }, listeners: { \"@dialogContainer.start\": \"_onAnimationStart($event)\", \"@dialogContainer.done\": \"_onAnimationDone($event)\" }, properties: { \"id\": \"_id\", \"attr.role\": \"_config.role\", \"attr.aria-labelledby\": \"_config.ariaLabel ? null : _ariaLabelledBy\", \"attr.aria-label\": \"_config.ariaLabel\", \"attr.aria-describedby\": \"_config.ariaDescribedBy || null\", \"@dialogContainer\": \"_state\" }, classAttribute: \"mat-dialog-container\" }, usesInheritance: true, ngImport: i0, template: \"<ng-template cdkPortalOutlet></ng-template>\\n\", styles: [\".mat-dialog-container{display:block;padding:24px;border-radius:4px;box-sizing:border-box;overflow:auto;outline:0;width:100%;height:100%;min-height:inherit;max-height:inherit}.cdk-high-contrast-active .mat-dialog-container{outline:solid 1px}.mat-dialog-content{display:block;margin:0 -24px;padding:0 24px;max-height:65vh;overflow:auto;-webkit-overflow-scrolling:touch}.mat-dialog-title{margin:0 0 20px;display:block}.mat-dialog-actions{padding:8px 0;display:flex;flex-wrap:wrap;min-height:52px;align-items:center;box-sizing:content-box;margin-bottom:-24px}.mat-dialog-actions[align=end]{justify-content:flex-end}.mat-dialog-actions[align=center]{justify-content:center}.mat-dialog-actions .mat-button-base+.mat-button-base,.mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:8px}[dir=rtl] .mat-dialog-actions .mat-button-base+.mat-button-base,[dir=rtl] .mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:0;margin-right:8px}\\n\"], directives: [{ type: i3.CdkPortalOutlet, selector: \"[cdkPortalOutlet]\", inputs: [\"cdkPortalOutlet\"], outputs: [\"attached\"], exportAs: [\"cdkPortalOutlet\"] }], animations: [matDialogAnimations.dialogContainer], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialogContainer, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-dialog-container', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.Default, animations: [matDialogAnimations.dialogContainer], host: {\n                        'class': 'mat-dialog-container',\n                        'tabindex': '-1',\n                        'aria-modal': 'true',\n                        '[id]': '_id',\n                        '[attr.role]': '_config.role',\n                        '[attr.aria-labelledby]': '_config.ariaLabel ? null : _ariaLabelledBy',\n                        '[attr.aria-label]': '_config.ariaLabel',\n                        '[attr.aria-describedby]': '_config.ariaDescribedBy || null',\n                        '[@dialogContainer]': '_state',\n                        '(@dialogContainer.start)': '_onAnimationStart($event)',\n                        '(@dialogContainer.done)': '_onAnimationDone($event)',\n                    }, template: \"<ng-template cdkPortalOutlet></ng-template>\\n\", styles: [\".mat-dialog-container{display:block;padding:24px;border-radius:4px;box-sizing:border-box;overflow:auto;outline:0;width:100%;height:100%;min-height:inherit;max-height:inherit}.cdk-high-contrast-active .mat-dialog-container{outline:solid 1px}.mat-dialog-content{display:block;margin:0 -24px;padding:0 24px;max-height:65vh;overflow:auto;-webkit-overflow-scrolling:touch}.mat-dialog-title{margin:0 0 20px;display:block}.mat-dialog-actions{padding:8px 0;display:flex;flex-wrap:wrap;min-height:52px;align-items:center;box-sizing:content-box;margin-bottom:-24px}.mat-dialog-actions[align=end]{justify-content:flex-end}.mat-dialog-actions[align=center]{justify-content:center}.mat-dialog-actions .mat-button-base+.mat-button-base,.mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:8px}[dir=rtl] .mat-dialog-actions .mat-button-base+.mat-button-base,[dir=rtl] .mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:0;margin-right:8px}\\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// TODO(jelbourn): resizing\n// Counter for unique dialog ids.\nlet uniqueId = 0;\n/**\n * Reference to a dialog opened via the MatDialog service.\n */\nclass MatDialogRef {\n    constructor(_overlayRef, _containerInstance, \n    /** Id of the dialog. */\n    id = `mat-dialog-${uniqueId++}`) {\n        this._overlayRef = _overlayRef;\n        this._containerInstance = _containerInstance;\n        this.id = id;\n        /** Whether the user is allowed to close the dialog. */\n        this.disableClose = this._containerInstance._config.disableClose;\n        /** Subject for notifying the user that the dialog has finished opening. */\n        this._afterOpened = new Subject();\n        /** Subject for notifying the user that the dialog has finished closing. */\n        this._afterClosed = new Subject();\n        /** Subject for notifying the user that the dialog has started closing. */\n        this._beforeClosed = new Subject();\n        /** Current state of the dialog. */\n        this._state = 0 /* OPEN */;\n        // Pass the id along to the container.\n        _containerInstance._id = id;\n        // Emit when opening animation completes\n        _containerInstance._animationStateChanged\n            .pipe(filter(event => event.state === 'opened'), take(1))\n            .subscribe(() => {\n            this._afterOpened.next();\n            this._afterOpened.complete();\n        });\n        // Dispose overlay when closing animation is complete\n        _containerInstance._animationStateChanged\n            .pipe(filter(event => event.state === 'closed'), take(1))\n            .subscribe(() => {\n            clearTimeout(this._closeFallbackTimeout);\n            this._finishDialogClose();\n        });\n        _overlayRef.detachments().subscribe(() => {\n            this._beforeClosed.next(this._result);\n            this._beforeClosed.complete();\n            this._afterClosed.next(this._result);\n            this._afterClosed.complete();\n            this.componentInstance = null;\n            this._overlayRef.dispose();\n        });\n        _overlayRef\n            .keydownEvents()\n            .pipe(filter(event => {\n            return event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event);\n        }))\n            .subscribe(event => {\n            event.preventDefault();\n            _closeDialogVia(this, 'keyboard');\n        });\n        _overlayRef.backdropClick().subscribe(() => {\n            if (this.disableClose) {\n                this._containerInstance._recaptureFocus();\n            }\n            else {\n                _closeDialogVia(this, 'mouse');\n            }\n        });\n    }\n    /**\n     * Close the dialog.\n     * @param dialogResult Optional result to return to the dialog opener.\n     */\n    close(dialogResult) {\n        this._result = dialogResult;\n        // Transition the backdrop in parallel to the dialog.\n        this._containerInstance._animationStateChanged\n            .pipe(filter(event => event.state === 'closing'), take(1))\n            .subscribe(event => {\n            this._beforeClosed.next(dialogResult);\n            this._beforeClosed.complete();\n            this._overlayRef.detachBackdrop();\n            // The logic that disposes of the overlay depends on the exit animation completing, however\n            // it isn't guaranteed if the parent view is destroyed while it's running. Add a fallback\n            // timeout which will clean everything up if the animation hasn't fired within the specified\n            // amount of time plus 100ms. We don't need to run this outside the NgZone, because for the\n            // vast majority of cases the timeout will have been cleared before it has the chance to fire.\n            this._closeFallbackTimeout = setTimeout(() => this._finishDialogClose(), event.totalTime + 100);\n        });\n        this._state = 1 /* CLOSING */;\n        this._containerInstance._startExitAnimation();\n    }\n    /**\n     * Gets an observable that is notified when the dialog is finished opening.\n     */\n    afterOpened() {\n        return this._afterOpened;\n    }\n    /**\n     * Gets an observable that is notified when the dialog is finished closing.\n     */\n    afterClosed() {\n        return this._afterClosed;\n    }\n    /**\n     * Gets an observable that is notified when the dialog has started closing.\n     */\n    beforeClosed() {\n        return this._beforeClosed;\n    }\n    /**\n     * Gets an observable that emits when the overlay's backdrop has been clicked.\n     */\n    backdropClick() {\n        return this._overlayRef.backdropClick();\n    }\n    /**\n     * Gets an observable that emits when keydown events are targeted on the overlay.\n     */\n    keydownEvents() {\n        return this._overlayRef.keydownEvents();\n    }\n    /**\n     * Updates the dialog's position.\n     * @param position New dialog position.\n     */\n    updatePosition(position) {\n        let strategy = this._getPositionStrategy();\n        if (position && (position.left || position.right)) {\n            position.left ? strategy.left(position.left) : strategy.right(position.right);\n        }\n        else {\n            strategy.centerHorizontally();\n        }\n        if (position && (position.top || position.bottom)) {\n            position.top ? strategy.top(position.top) : strategy.bottom(position.bottom);\n        }\n        else {\n            strategy.centerVertically();\n        }\n        this._overlayRef.updatePosition();\n        return this;\n    }\n    /**\n     * Updates the dialog's width and height.\n     * @param width New width of the dialog.\n     * @param height New height of the dialog.\n     */\n    updateSize(width = '', height = '') {\n        this._overlayRef.updateSize({ width, height });\n        this._overlayRef.updatePosition();\n        return this;\n    }\n    /** Add a CSS class or an array of classes to the overlay pane. */\n    addPanelClass(classes) {\n        this._overlayRef.addPanelClass(classes);\n        return this;\n    }\n    /** Remove a CSS class or an array of classes from the overlay pane. */\n    removePanelClass(classes) {\n        this._overlayRef.removePanelClass(classes);\n        return this;\n    }\n    /** Gets the current state of the dialog's lifecycle. */\n    getState() {\n        return this._state;\n    }\n    /**\n     * Finishes the dialog close by updating the state of the dialog\n     * and disposing the overlay.\n     */\n    _finishDialogClose() {\n        this._state = 2 /* CLOSED */;\n        this._overlayRef.dispose();\n    }\n    /** Fetches the position strategy object from the overlay ref. */\n    _getPositionStrategy() {\n        return this._overlayRef.getConfig().positionStrategy;\n    }\n}\n/**\n * Closes the dialog with the specified interaction type. This is currently not part of\n * `MatDialogRef` as that would conflict with custom dialog ref mocks provided in tests.\n * More details. See: https://github.com/angular/components/pull/9257#issuecomment-651342226.\n */\n// TODO: TODO: Move this back into `MatDialogRef` when we provide an official mock dialog ref.\nfunction _closeDialogVia(ref, interactionType, result) {\n    // Some mock dialog ref instances in tests do not have the `_containerInstance` property.\n    // For those, we keep the behavior as is and do not deal with the interaction type.\n    if (ref._containerInstance !== undefined) {\n        ref._containerInstance._closeInteractionType = interactionType;\n    }\n    return ref.close(result);\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 that can be used to access the data that was passed in to a dialog. */\nconst MAT_DIALOG_DATA = new InjectionToken('MatDialogData');\n/** Injection token that can be used to specify default dialog options. */\nconst MAT_DIALOG_DEFAULT_OPTIONS = new InjectionToken('mat-dialog-default-options');\n/** Injection token that determines the scroll handling while the dialog is open. */\nconst MAT_DIALOG_SCROLL_STRATEGY = new InjectionToken('mat-dialog-scroll-strategy');\n/** @docs-private */\nfunction MAT_DIALOG_SCROLL_STRATEGY_FACTORY(overlay) {\n    return () => overlay.scrollStrategies.block();\n}\n/** @docs-private */\nfunction MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {\n    return () => overlay.scrollStrategies.block();\n}\n/** @docs-private */\nconst MAT_DIALOG_SCROLL_STRATEGY_PROVIDER = {\n    provide: MAT_DIALOG_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY,\n};\n/**\n * Base class for dialog services. The base dialog service allows\n * for arbitrary dialog refs and dialog container components.\n */\nclass _MatDialogBase {\n    constructor(_overlay, _injector, _defaultOptions, _parentDialog, _overlayContainer, scrollStrategy, _dialogRefConstructor, _dialogContainerType, _dialogDataToken, \n    /**\n     * @deprecated No longer used. To be removed.\n     * @breaking-change 14.0.0\n     */\n    _animationMode) {\n        this._overlay = _overlay;\n        this._injector = _injector;\n        this._defaultOptions = _defaultOptions;\n        this._parentDialog = _parentDialog;\n        this._overlayContainer = _overlayContainer;\n        this._dialogRefConstructor = _dialogRefConstructor;\n        this._dialogContainerType = _dialogContainerType;\n        this._dialogDataToken = _dialogDataToken;\n        this._openDialogsAtThisLevel = [];\n        this._afterAllClosedAtThisLevel = new Subject();\n        this._afterOpenedAtThisLevel = new Subject();\n        this._ariaHiddenElements = new Map();\n        // TODO (jelbourn): tighten the typing right-hand side of this expression.\n        /**\n         * Stream that emits when all open dialog have finished closing.\n         * Will emit on subscribe if there are no open dialogs to begin with.\n         */\n        this.afterAllClosed = defer(() => this.openDialogs.length\n            ? this._getAfterAllClosed()\n            : this._getAfterAllClosed().pipe(startWith(undefined)));\n        this._scrollStrategy = scrollStrategy;\n    }\n    /** Keeps track of the currently-open dialogs. */\n    get openDialogs() {\n        return this._parentDialog ? this._parentDialog.openDialogs : this._openDialogsAtThisLevel;\n    }\n    /** Stream that emits when a dialog has been opened. */\n    get afterOpened() {\n        return this._parentDialog ? this._parentDialog.afterOpened : this._afterOpenedAtThisLevel;\n    }\n    _getAfterAllClosed() {\n        const parent = this._parentDialog;\n        return parent ? parent._getAfterAllClosed() : this._afterAllClosedAtThisLevel;\n    }\n    open(componentOrTemplateRef, config) {\n        config = _applyConfigDefaults(config, this._defaultOptions || new MatDialogConfig());\n        if (config.id &&\n            this.getDialogById(config.id) &&\n            (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw Error(`Dialog with id \"${config.id}\" exists already. The dialog id must be unique.`);\n        }\n        const overlayRef = this._createOverlay(config);\n        const dialogContainer = this._attachDialogContainer(overlayRef, config);\n        const dialogRef = this._attachDialogContent(componentOrTemplateRef, dialogContainer, overlayRef, config);\n        // If this is the first dialog that we're opening, hide all the non-overlay content.\n        if (!this.openDialogs.length) {\n            this._hideNonDialogContentFromAssistiveTechnology();\n        }\n        this.openDialogs.push(dialogRef);\n        dialogRef.afterClosed().subscribe(() => this._removeOpenDialog(dialogRef));\n        this.afterOpened.next(dialogRef);\n        // Notify the dialog container that the content has been attached.\n        dialogContainer._initializeWithAttachedContent();\n        return dialogRef;\n    }\n    /**\n     * Closes all of the currently-open dialogs.\n     */\n    closeAll() {\n        this._closeDialogs(this.openDialogs);\n    }\n    /**\n     * Finds an open dialog by its id.\n     * @param id ID to use when looking up the dialog.\n     */\n    getDialogById(id) {\n        return this.openDialogs.find(dialog => dialog.id === id);\n    }\n    ngOnDestroy() {\n        // Only close the dialogs at this level on destroy\n        // since the parent service may still be active.\n        this._closeDialogs(this._openDialogsAtThisLevel);\n        this._afterAllClosedAtThisLevel.complete();\n        this._afterOpenedAtThisLevel.complete();\n    }\n    /**\n     * Creates the overlay into which the dialog will be loaded.\n     * @param config The dialog configuration.\n     * @returns A promise resolving to the OverlayRef for the created overlay.\n     */\n    _createOverlay(config) {\n        const overlayConfig = this._getOverlayConfig(config);\n        return this._overlay.create(overlayConfig);\n    }\n    /**\n     * Creates an overlay config from a dialog config.\n     * @param dialogConfig The dialog configuration.\n     * @returns The overlay configuration.\n     */\n    _getOverlayConfig(dialogConfig) {\n        const state = new OverlayConfig({\n            positionStrategy: this._overlay.position().global(),\n            scrollStrategy: dialogConfig.scrollStrategy || this._scrollStrategy(),\n            panelClass: dialogConfig.panelClass,\n            hasBackdrop: dialogConfig.hasBackdrop,\n            direction: dialogConfig.direction,\n            minWidth: dialogConfig.minWidth,\n            minHeight: dialogConfig.minHeight,\n            maxWidth: dialogConfig.maxWidth,\n            maxHeight: dialogConfig.maxHeight,\n            disposeOnNavigation: dialogConfig.closeOnNavigation,\n        });\n        if (dialogConfig.backdropClass) {\n            state.backdropClass = dialogConfig.backdropClass;\n        }\n        return state;\n    }\n    /**\n     * Attaches a dialog container to a dialog's already-created overlay.\n     * @param overlay Reference to the dialog's underlying overlay.\n     * @param config The dialog configuration.\n     * @returns A promise resolving to a ComponentRef for the attached container.\n     */\n    _attachDialogContainer(overlay, config) {\n        const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;\n        const injector = Injector.create({\n            parent: userInjector || this._injector,\n            providers: [{ provide: MatDialogConfig, useValue: config }],\n        });\n        const containerPortal = new ComponentPortal(this._dialogContainerType, config.viewContainerRef, injector, config.componentFactoryResolver);\n        const containerRef = overlay.attach(containerPortal);\n        return containerRef.instance;\n    }\n    /**\n     * Attaches the user-provided component to the already-created dialog container.\n     * @param componentOrTemplateRef The type of component being loaded into the dialog,\n     *     or a TemplateRef to instantiate as the content.\n     * @param dialogContainer Reference to the wrapping dialog container.\n     * @param overlayRef Reference to the overlay in which the dialog resides.\n     * @param config The dialog configuration.\n     * @returns A promise resolving to the MatDialogRef that should be returned to the user.\n     */\n    _attachDialogContent(componentOrTemplateRef, dialogContainer, overlayRef, config) {\n        // Create a reference to the dialog we're creating in order to give the user a handle\n        // to modify and close it.\n        const dialogRef = new this._dialogRefConstructor(overlayRef, dialogContainer, config.id);\n        if (componentOrTemplateRef instanceof TemplateRef) {\n            dialogContainer.attachTemplatePortal(new TemplatePortal(componentOrTemplateRef, null, {\n                $implicit: config.data,\n                dialogRef,\n            }));\n        }\n        else {\n            const injector = this._createInjector(config, dialogRef, dialogContainer);\n            const contentRef = dialogContainer.attachComponentPortal(new ComponentPortal(componentOrTemplateRef, config.viewContainerRef, injector, config.componentFactoryResolver));\n            dialogRef.componentInstance = contentRef.instance;\n        }\n        dialogRef.updateSize(config.width, config.height).updatePosition(config.position);\n        return dialogRef;\n    }\n    /**\n     * Creates a custom injector to be used inside the dialog. This allows a component loaded inside\n     * of a dialog to close itself and, optionally, to return a value.\n     * @param config Config object that is used to construct the dialog.\n     * @param dialogRef Reference to the dialog.\n     * @param dialogContainer Dialog container element that wraps all of the contents.\n     * @returns The custom injector that can be used inside the dialog.\n     */\n    _createInjector(config, dialogRef, dialogContainer) {\n        const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;\n        // The dialog container should be provided as the dialog container and the dialog's\n        // content are created out of the same `ViewContainerRef` and as such, are siblings\n        // for injector purposes. To allow the hierarchy that is expected, the dialog\n        // container is explicitly provided in the injector.\n        const providers = [\n            { provide: this._dialogContainerType, useValue: dialogContainer },\n            { provide: this._dialogDataToken, useValue: config.data },\n            { provide: this._dialogRefConstructor, useValue: dialogRef },\n        ];\n        if (config.direction &&\n            (!userInjector ||\n                !userInjector.get(Directionality, null, InjectFlags.Optional))) {\n            providers.push({\n                provide: Directionality,\n                useValue: { value: config.direction, change: of() },\n            });\n        }\n        return Injector.create({ parent: userInjector || this._injector, providers });\n    }\n    /**\n     * Removes a dialog from the array of open dialogs.\n     * @param dialogRef Dialog to be removed.\n     */\n    _removeOpenDialog(dialogRef) {\n        const index = this.openDialogs.indexOf(dialogRef);\n        if (index > -1) {\n            this.openDialogs.splice(index, 1);\n            // If all the dialogs were closed, remove/restore the `aria-hidden`\n            // to a the siblings and emit to the `afterAllClosed` stream.\n            if (!this.openDialogs.length) {\n                this._ariaHiddenElements.forEach((previousValue, element) => {\n                    if (previousValue) {\n                        element.setAttribute('aria-hidden', previousValue);\n                    }\n                    else {\n                        element.removeAttribute('aria-hidden');\n                    }\n                });\n                this._ariaHiddenElements.clear();\n                this._getAfterAllClosed().next();\n            }\n        }\n    }\n    /**\n     * Hides all of the content that isn't an overlay from assistive technology.\n     */\n    _hideNonDialogContentFromAssistiveTechnology() {\n        const overlayContainer = this._overlayContainer.getContainerElement();\n        // Ensure that the overlay container is attached to the DOM.\n        if (overlayContainer.parentElement) {\n            const siblings = overlayContainer.parentElement.children;\n            for (let i = siblings.length - 1; i > -1; i--) {\n                let sibling = siblings[i];\n                if (sibling !== overlayContainer &&\n                    sibling.nodeName !== 'SCRIPT' &&\n                    sibling.nodeName !== 'STYLE' &&\n                    !sibling.hasAttribute('aria-live')) {\n                    this._ariaHiddenElements.set(sibling, sibling.getAttribute('aria-hidden'));\n                    sibling.setAttribute('aria-hidden', 'true');\n                }\n            }\n        }\n    }\n    /** Closes all of the dialogs in an array. */\n    _closeDialogs(dialogs) {\n        let i = dialogs.length;\n        while (i--) {\n            // The `_openDialogs` property isn't updated after close until the rxjs subscription\n            // runs on the next microtask, in addition to modifying the array as we're going\n            // through it. We loop through all of them and call close without assuming that\n            // they'll be removed from the list instantaneously.\n            dialogs[i].close();\n        }\n    }\n}\n_MatDialogBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatDialogBase, deps: \"invalid\", target: i0.ɵɵFactoryTarget.Directive });\n_MatDialogBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: _MatDialogBase, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatDialogBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i1$1.Overlay }, { type: i0.Injector }, { type: undefined }, { type: undefined }, { type: i1$1.OverlayContainer }, { type: undefined }, { type: i0.Type }, { type: i0.Type }, { type: i0.InjectionToken }, { type: undefined }]; } });\n/**\n * Service to open Material Design modal dialogs.\n */\nclass MatDialog extends _MatDialogBase {\n    constructor(overlay, injector, \n    /**\n     * @deprecated `_location` parameter to be removed.\n     * @breaking-change 10.0.0\n     */\n    location, defaultOptions, scrollStrategy, parentDialog, overlayContainer, \n    /**\n     * @deprecated No longer used. To be removed.\n     * @breaking-change 14.0.0\n     */\n    animationMode) {\n        super(overlay, injector, defaultOptions, parentDialog, overlayContainer, scrollStrategy, MatDialogRef, MatDialogContainer, MAT_DIALOG_DATA, animationMode);\n    }\n}\nMatDialog.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialog, deps: [{ token: i1$1.Overlay }, { token: i0.Injector }, { token: i2.Location, optional: true }, { token: MAT_DIALOG_DEFAULT_OPTIONS, optional: true }, { token: MAT_DIALOG_SCROLL_STRATEGY }, { token: MatDialog, optional: true, skipSelf: true }, { token: i1$1.OverlayContainer }, { token: ANIMATION_MODULE_TYPE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });\nMatDialog.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialog });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialog, decorators: [{\n            type: Injectable\n        }], ctorParameters: function () {\n        return [{ type: i1$1.Overlay }, { type: i0.Injector }, { type: i2.Location, decorators: [{\n                        type: Optional\n                    }] }, { type: MatDialogConfig, decorators: [{\n                        type: Optional\n                    }, {\n                        type: Inject,\n                        args: [MAT_DIALOG_DEFAULT_OPTIONS]\n                    }] }, { type: undefined, decorators: [{\n                        type: Inject,\n                        args: [MAT_DIALOG_SCROLL_STRATEGY]\n                    }] }, { type: MatDialog, decorators: [{\n                        type: Optional\n                    }, {\n                        type: SkipSelf\n                    }] }, { type: i1$1.OverlayContainer }, { type: undefined, decorators: [{\n                        type: Optional\n                    }, {\n                        type: Inject,\n                        args: [ANIMATION_MODULE_TYPE]\n                    }] }];\n    } });\n/**\n * Applies default options to the dialog config.\n * @param config Config to be modified.\n * @param defaultOptions Default options provided.\n * @returns The new configuration object.\n */\nfunction _applyConfigDefaults(config, defaultOptions) {\n    return Object.assign(Object.assign({}, defaultOptions), config);\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/** Counter used to generate unique IDs for dialog elements. */\nlet dialogElementUid = 0;\n/**\n * Button that will close the current dialog.\n */\nclass MatDialogClose {\n    constructor(\n    /**\n     * Reference to the containing dialog.\n     * @deprecated `dialogRef` property to become private.\n     * @breaking-change 13.0.0\n     */\n    // The dialog title directive is always used in combination with a `MatDialogRef`.\n    // tslint:disable-next-line: lightweight-tokens\n    dialogRef, _elementRef, _dialog) {\n        this.dialogRef = dialogRef;\n        this._elementRef = _elementRef;\n        this._dialog = _dialog;\n        /** Default to \"button\" to prevents accidental form submits. */\n        this.type = 'button';\n    }\n    ngOnInit() {\n        if (!this.dialogRef) {\n            // When this directive is included in a dialog via TemplateRef (rather than being\n            // in a Component), the DialogRef isn't available via injection because embedded\n            // views cannot be given a custom injector. Instead, we look up the DialogRef by\n            // ID. This must occur in `onInit`, as the ID binding for the dialog container won't\n            // be resolved at constructor time.\n            this.dialogRef = getClosestDialog(this._elementRef, this._dialog.openDialogs);\n        }\n    }\n    ngOnChanges(changes) {\n        const proxiedChange = changes['_matDialogClose'] || changes['_matDialogCloseResult'];\n        if (proxiedChange) {\n            this.dialogResult = proxiedChange.currentValue;\n        }\n    }\n    _onButtonClick(event) {\n        // Determinate the focus origin using the click event, because using the FocusMonitor will\n        // result in incorrect origins. Most of the time, close buttons will be auto focused in the\n        // dialog, and therefore clicking the button won't result in a focus change. This means that\n        // the FocusMonitor won't detect any origin change, and will always output `program`.\n        _closeDialogVia(this.dialogRef, event.screenX === 0 && event.screenY === 0 ? 'keyboard' : 'mouse', this.dialogResult);\n    }\n}\nMatDialogClose.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialogClose, deps: [{ token: MatDialogRef, optional: true }, { token: i0.ElementRef }, { token: MatDialog }], target: i0.ɵɵFactoryTarget.Directive });\nMatDialogClose.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDialogClose, selector: \"[mat-dialog-close], [matDialogClose]\", inputs: { ariaLabel: [\"aria-label\", \"ariaLabel\"], type: \"type\", dialogResult: [\"mat-dialog-close\", \"dialogResult\"], _matDialogClose: [\"matDialogClose\", \"_matDialogClose\"] }, host: { listeners: { \"click\": \"_onButtonClick($event)\" }, properties: { \"attr.aria-label\": \"ariaLabel || null\", \"attr.type\": \"type\" } }, exportAs: [\"matDialogClose\"], usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialogClose, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[mat-dialog-close], [matDialogClose]',\n                    exportAs: 'matDialogClose',\n                    host: {\n                        '(click)': '_onButtonClick($event)',\n                        '[attr.aria-label]': 'ariaLabel || null',\n                        '[attr.type]': 'type',\n                    },\n                }]\n        }], ctorParameters: function () {\n        return [{ type: MatDialogRef, decorators: [{\n                        type: Optional\n                    }] }, { type: i0.ElementRef }, { type: MatDialog }];\n    }, propDecorators: { ariaLabel: [{\n                type: Input,\n                args: ['aria-label']\n            }], type: [{\n                type: Input\n            }], dialogResult: [{\n                type: Input,\n                args: ['mat-dialog-close']\n            }], _matDialogClose: [{\n                type: Input,\n                args: ['matDialogClose']\n            }] } });\n/**\n * Title of a dialog element. Stays fixed to the top of the dialog when scrolling.\n */\nclass MatDialogTitle {\n    constructor(\n    // The dialog title directive is always used in combination with a `MatDialogRef`.\n    // tslint:disable-next-line: lightweight-tokens\n    _dialogRef, _elementRef, _dialog) {\n        this._dialogRef = _dialogRef;\n        this._elementRef = _elementRef;\n        this._dialog = _dialog;\n        /** Unique id for the dialog title. If none is supplied, it will be auto-generated. */\n        this.id = `mat-dialog-title-${dialogElementUid++}`;\n    }\n    ngOnInit() {\n        if (!this._dialogRef) {\n            this._dialogRef = getClosestDialog(this._elementRef, this._dialog.openDialogs);\n        }\n        if (this._dialogRef) {\n            Promise.resolve().then(() => {\n                const container = this._dialogRef._containerInstance;\n                if (container && !container._ariaLabelledBy) {\n                    container._ariaLabelledBy = this.id;\n                }\n            });\n        }\n    }\n}\nMatDialogTitle.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialogTitle, deps: [{ token: MatDialogRef, optional: true }, { token: i0.ElementRef }, { token: MatDialog }], target: i0.ɵɵFactoryTarget.Directive });\nMatDialogTitle.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDialogTitle, selector: \"[mat-dialog-title], [matDialogTitle]\", inputs: { id: \"id\" }, host: { properties: { \"id\": \"id\" }, classAttribute: \"mat-dialog-title\" }, exportAs: [\"matDialogTitle\"], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialogTitle, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[mat-dialog-title], [matDialogTitle]',\n                    exportAs: 'matDialogTitle',\n                    host: {\n                        'class': 'mat-dialog-title',\n                        '[id]': 'id',\n                    },\n                }]\n        }], ctorParameters: function () {\n        return [{ type: MatDialogRef, decorators: [{\n                        type: Optional\n                    }] }, { type: i0.ElementRef }, { type: MatDialog }];\n    }, propDecorators: { id: [{\n                type: Input\n            }] } });\n/**\n * Scrollable content container of a dialog.\n */\nclass MatDialogContent {\n}\nMatDialogContent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialogContent, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatDialogContent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDialogContent, selector: \"[mat-dialog-content], mat-dialog-content, [matDialogContent]\", host: { classAttribute: \"mat-dialog-content\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialogContent, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: `[mat-dialog-content], mat-dialog-content, [matDialogContent]`,\n                    host: { 'class': 'mat-dialog-content' },\n                }]\n        }] });\n/**\n * Container for the bottom action buttons in a dialog.\n * Stays fixed to the bottom when scrolling.\n */\nclass MatDialogActions {\n}\nMatDialogActions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialogActions, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatDialogActions.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDialogActions, selector: \"[mat-dialog-actions], mat-dialog-actions, [matDialogActions]\", host: { classAttribute: \"mat-dialog-actions\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialogActions, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: `[mat-dialog-actions], mat-dialog-actions, [matDialogActions]`,\n                    host: { 'class': 'mat-dialog-actions' },\n                }]\n        }] });\n/**\n * Finds the closest MatDialogRef to an element by looking at the DOM.\n * @param element Element relative to which to look for a dialog.\n * @param openDialogs References to the currently-open dialogs.\n */\nfunction getClosestDialog(element, openDialogs) {\n    let parent = element.nativeElement.parentElement;\n    while (parent && !parent.classList.contains('mat-dialog-container')) {\n        parent = parent.parentElement;\n    }\n    return parent ? openDialogs.find(dialog => dialog.id === parent.id) : null;\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 MatDialogModule {\n}\nMatDialogModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialogModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatDialogModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialogModule, declarations: [MatDialogContainer,\n        MatDialogClose,\n        MatDialogTitle,\n        MatDialogActions,\n        MatDialogContent], imports: [OverlayModule, PortalModule, MatCommonModule], exports: [MatDialogContainer,\n        MatDialogClose,\n        MatDialogTitle,\n        MatDialogContent,\n        MatDialogActions,\n        MatCommonModule] });\nMatDialogModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialogModule, providers: [MatDialog, MAT_DIALOG_SCROLL_STRATEGY_PROVIDER], imports: [[OverlayModule, PortalModule, MatCommonModule], MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDialogModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [OverlayModule, PortalModule, MatCommonModule],\n                    exports: [\n                        MatDialogContainer,\n                        MatDialogClose,\n                        MatDialogTitle,\n                        MatDialogContent,\n                        MatDialogActions,\n                        MatCommonModule,\n                    ],\n                    declarations: [\n                        MatDialogContainer,\n                        MatDialogClose,\n                        MatDialogTitle,\n                        MatDialogActions,\n                        MatDialogContent,\n                    ],\n                    providers: [MatDialog, MAT_DIALOG_SCROLL_STRATEGY_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 * Generated bundle index. Do not edit.\n */\n\nexport { MAT_DIALOG_DATA, MAT_DIALOG_DEFAULT_OPTIONS, MAT_DIALOG_SCROLL_STRATEGY, MAT_DIALOG_SCROLL_STRATEGY_FACTORY, MAT_DIALOG_SCROLL_STRATEGY_PROVIDER, MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY, MatDialog, MatDialogActions, MatDialogClose, MatDialogConfig, MatDialogContainer, MatDialogContent, MatDialogModule, MatDialogRef, MatDialogTitle, _MatDialogBase, _MatDialogContainerBase, _closeDialogVia, matDialogAnimations, throwMatDialogContentAlreadyAttachedError };\n"]}