{"version":3,"file":"777.690c29d0465fd4c1.js","mappings":"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","names":["CdkDialogContainer_ng_template_0_Template","rf","ctx","DialogConfig","constructor","this","role","panelClass","hasBackdrop","backdropClass","disableClose","width","height","data","ariaDescribedBy","ariaLabelledBy","ariaLabel","ariaModal","autoFocus","restoreFocus","closeOnNavigation","closeOnDestroy","closeOnOverlayDetachments","CdkDialogContainer","BasePortalOutlet","_elementRef","_focusTrapFactory","_document","_config","_interactivityChecker","_ngZone","_overlayRef","_focusMonitor","super","_elementFocusedBeforeDialogWasOpened","_closeInteractionType","attachDomPortal","portal","_portalOutlet","hasAttached","result","_contentAttached","_ariaLabelledBy","_initializeFocusTrap","_handleBackdropClicks","_captureInitialFocus","_trapFocus","ngOnDestroy","_restoreFocus","attachComponentPortal","attachTemplatePortal","_recaptureFocus","_containsFocus","_forceFocus","element","options","isFocusable","tabIndex","runOutsideAngular","callback","removeEventListener","removeAttribute","addEventListener","focus","_focusByCssSelector","selector","elementToFocus","nativeElement","querySelector","_focusTrap","focusInitialElementWhenReady","then","focusedSuccessfully","_focusDialogContainer","focusConfig","focusTargetElement","activeElement","_getFocusedElementPierceShadowDom","body","contains","focusVia","destroy","create","backdropClick","subscribe","static","ɵfac","t","i0","i1","DOCUMENT","i1$1","ɵcmp","type","selectors","viewQuery","CdkPortalOutlet","_t","first","hostAttrs","hostVars","hostBindings","id","features","decls","vars","consts","template","dependencies","i3","styles","encapsulation","DialogRef","overlayRef","config","closed","Subject","keydownEvents","outsidePointerEvents","event","keyCode","ESCAPE","hasModifierKey","preventDefault","close","undefined","focusOrigin","_detachSubscription","detachments","containerInstance","closedSubject","unsubscribe","dispose","next","complete","componentInstance","updatePosition","updateSize","addPanelClass","classes","removePanelClass","DIALOG_SCROLL_STRATEGY","InjectionToken","DIALOG_DATA","DEFAULT_DIALOG_CONFIG","DIALOG_SCROLL_STRATEGY_PROVIDER","provide","deps","Overlay","useFactory","DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY","overlay","scrollStrategies","block","uniqueId","Dialog","openDialogs","_parentDialog","_openDialogsAtThisLevel","afterOpened","_afterOpenedAtThisLevel","_overlay","_injector","_defaultOptions","_overlayContainer","scrollStrategy","_afterAllClosedAtThisLevel","_ariaHiddenElements","Map","afterAllClosed","defer","length","_getAfterAllClosed","pipe","startWith","_scrollStrategy","open","componentOrTemplateRef","getDialogById","overlayConfig","_getOverlayConfig","dialogRef","dialogContainer","_attachContainer","_attachDialogContent","_hideNonDialogContentFromAssistiveTechnology","push","_removeOpenDialog","closeAll","reverseForEach","dialog","find","state","OverlayConfig","positionStrategy","position","global","centerHorizontally","centerVertically","direction","minWidth","minHeight","maxWidth","maxHeight","disposeOnNavigation","userInjector","injector","viewContainerRef","providers","useValue","OverlayRef","containerType","container","containerPortal","ComponentPortal","Injector","parent","componentFactoryResolver","attach","instance","TemplateRef","_createInjector","context","$implicit","templateContext","TemplatePortal","contentRef","fallbackInjector","get","Directionality","optional","value","change","of","emitEvent","index","indexOf","splice","forEach","previousValue","setAttribute","clear","overlayContainer","getContainerElement","parentElement","siblings","children","i","sibling","nodeName","hasAttribute","set","getAttribute","ɵprov","token","factory","items","DialogModule","ɵmod","ɵinj","imports","OverlayModule","PortalModule","A11yModule","MatDialogContainer_ng_template_0_Template","defaultParams","params","enterAnimationDuration","exitAnimationDuration","matDialogAnimations","trigger","style","opacity","transform","transition","group","animate","query","animateChild","MatDialogConfig","delayFocusTrap","_MatDialogContainerBase","elementRef","focusTrapFactory","dialogConfig","interactivityChecker","ngZone","focusMonitor","_animationStateChanged","EventEmitter","_openAnimationDone","totalTime","MatDialogContainer","document","checker","_changeDetectorRef","_state","_onAnimationDone","toState","_onAnimationStart","_startExitAnimation","markForCheck","_getAnimationState","$event","i4","animation","MatDialogRef","_ref","_containerInstance","_afterOpened","_beforeClosed","filter","take","clearTimeout","_closeFallbackTimeout","_finishDialogClose","_result","merge","_closeDialogVia","dialogResult","detachBackdrop","setTimeout","afterClosed","beforeClosed","strategy","left","right","top","bottom","getState","ref","interactionType","MAT_DIALOG_DATA","MAT_DIALOG_DEFAULT_OPTIONS","MAT_DIALOG_SCROLL_STRATEGY","MAT_DIALOG_SCROLL_STRATEGY_PROVIDER","MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY","_MatDialogBase","_dialogRefConstructor","_dialogContainerType","_dialogDataToken","_animationMode","_idPrefix","_dialog","cdkRef","cdkConfig","_closeDialogs","dialogs","MatDialog","_location","defaultOptions","parentDialog","animationMode","i2","ANIMATION_MODULE_TYPE","dialogElementUid","MatDialogClose","ngOnInit","getClosestDialog","ngOnChanges","changes","proxiedChange","_matDialogClose","_matDialogCloseResult","currentValue","_onButtonClick","screenX","screenY","ɵdir","inputs","exportAs","MatDialogTitle","_dialogRef","Promise","resolve","MatDialogContent","MatDialogActions","align","classList","MatDialogModule","MatCommonModule"],"sourceRoot":"webpack:///","sources":["./node_modules/@angular/cdk/fesm2022/dialog.mjs","./node_modules/@angular/material/fesm2020/dialog.mjs"],"sourcesContent":["import * as i1 from '@angular/cdk/a11y';\nimport { A11yModule } from '@angular/cdk/a11y';\nimport * as i1$1 from '@angular/cdk/overlay';\nimport { Overlay, OverlayConfig, OverlayRef, OverlayModule } from '@angular/cdk/overlay';\nimport { _getFocusedElementPierceShadowDom } from '@angular/cdk/platform';\nimport * as i3 from '@angular/cdk/portal';\nimport { BasePortalOutlet, CdkPortalOutlet, ComponentPortal, TemplatePortal, PortalModule } from '@angular/cdk/portal';\nimport { DOCUMENT } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { Component, ViewEncapsulation, ChangeDetectionStrategy, Optional, Inject, ViewChild, InjectionToken, Injector, TemplateRef, Injectable, SkipSelf, NgModule } from '@angular/core';\nimport { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';\nimport { Subject, defer, of } from 'rxjs';\nimport { Directionality } from '@angular/cdk/bidi';\nimport { startWith } from 'rxjs/operators';\n\n/** Configuration for opening a modal dialog. */\nclass DialogConfig {\n    constructor() {\n        /** The ARIA role of the dialog element. */\n        this.role = 'dialog';\n        /** Optional CSS class or classes applied to the overlay panel. */\n        this.panelClass = '';\n        /** Whether the dialog has a backdrop. */\n        this.hasBackdrop = true;\n        /** Optional CSS class or classes applied to the overlay backdrop. */\n        this.backdropClass = '';\n        /** Whether the dialog closes with the escape key or pointer events outside the panel element. */\n        this.disableClose = false;\n        /** Width of the dialog. */\n        this.width = '';\n        /** Height of the dialog. */\n        this.height = '';\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        /** Dialog label applied via `aria-label` */\n        this.ariaLabel = null;\n        /** Whether this is a modal dialog. Used to set the `aria-modal` attribute. */\n        this.ariaModal = true;\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 previously-focused element upon closing.\n         * Has the following behavior based on the type that is passed in:\n         * - `boolean` - when true, will return focus to the element that was focused before the dialog\n         *    was opened, otherwise won't restore focus at all.\n         * - `string` - focus will be restored to the first element that matches the CSS selector.\n         * - `HTMLElement` - focus will be restored to the specific element.\n         */\n        this.restoreFocus = true;\n        /**\n         * Whether the dialog should close when the user navigates backwards or forwards through browser\n         * history. This does not apply to navigation via anchor element unless using URL-hash based\n         * routing (`HashLocationStrategy` in the Angular router).\n         */\n        this.closeOnNavigation = true;\n        /**\n         * Whether the dialog should close when the dialog service is destroyed. This is useful if\n         * another service is wrapping the dialog and is managing the destruction instead.\n         */\n        this.closeOnDestroy = true;\n        /**\n         * Whether the dialog should close when the underlying overlay is detached. This is useful if\n         * another service is wrapping the dialog and is managing the destruction instead. E.g. an\n         * external detachment can happen as a result of a scroll strategy triggering it or when the\n         * browser location changes.\n         */\n        this.closeOnOverlayDetachments = true;\n    }\n}\n\nfunction throwDialogContentAlreadyAttachedError() {\n    throw Error('Attempting to attach dialog content after content is already attached');\n}\n/**\n * Internal component that wraps user-provided dialog content.\n * @docs-private\n */\nclass CdkDialogContainer extends BasePortalOutlet {\n    constructor(_elementRef, _focusTrapFactory, _document, _config, _interactivityChecker, _ngZone, _overlayRef, _focusMonitor) {\n        super();\n        this._elementRef = _elementRef;\n        this._focusTrapFactory = _focusTrapFactory;\n        this._config = _config;\n        this._interactivityChecker = _interactivityChecker;\n        this._ngZone = _ngZone;\n        this._overlayRef = _overlayRef;\n        this._focusMonitor = _focusMonitor;\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                throwDialogContentAlreadyAttachedError();\n            }\n            const result = this._portalOutlet.attachDomPortal(portal);\n            this._contentAttached();\n            return result;\n        };\n        this._ariaLabelledBy = this._config.ariaLabelledBy || null;\n        this._document = _document;\n    }\n    _contentAttached() {\n        this._initializeFocusTrap();\n        this._handleBackdropClicks();\n        this._captureInitialFocus();\n    }\n    /**\n     * Can be used by child classes to customize the initial focus\n     * capturing behavior (e.g. if it's tied to an animation).\n     */\n    _captureInitialFocus() {\n        this._trapFocus();\n    }\n    ngOnDestroy() {\n        this._restoreFocus();\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            throwDialogContentAlreadyAttachedError();\n        }\n        const result = this._portalOutlet.attachComponentPortal(portal);\n        this._contentAttached();\n        return result;\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            throwDialogContentAlreadyAttachedError();\n        }\n        const result = this._portalOutlet.attachTemplatePortal(portal);\n        this._contentAttached();\n        return result;\n    }\n    // TODO(crisbeto): this shouldn't be exposed, but there are internal references to it.\n    /** Captures focus if it isn't already inside the dialog. */\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 focusConfig = this._config.restoreFocus;\n        let focusTargetElement = null;\n        if (typeof focusConfig === 'string') {\n            focusTargetElement = this._document.querySelector(focusConfig);\n        }\n        else if (typeof focusConfig === 'boolean') {\n            focusTargetElement = focusConfig ? this._elementFocusedBeforeDialogWasOpened : null;\n        }\n        else if (focusConfig) {\n            focusTargetElement = focusConfig;\n        }\n        // We need the extra check, because IE can set the `activeElement` to null in some cases.\n        if (this._config.restoreFocus &&\n            focusTargetElement &&\n            typeof focusTargetElement.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(focusTargetElement, this._closeInteractionType);\n                    this._closeInteractionType = null;\n                }\n                else {\n                    focusTargetElement.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    /** Sets up the focus trap. */\n    _initializeFocusTrap() {\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    /** Sets up the listener that handles clicks on the dialog backdrop. */\n    _handleBackdropClicks() {\n        // Clicking on the backdrop will move focus out of dialog.\n        // Recapture it if closing via the backdrop is disabled.\n        this._overlayRef.backdropClick().subscribe(() => {\n            if (this._config.disableClose) {\n                this._recaptureFocus();\n            }\n        });\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkDialogContainer, deps: [{ token: i0.ElementRef }, { token: i1.FocusTrapFactory }, { token: DOCUMENT, optional: true }, { token: DialogConfig }, { token: i1.InteractivityChecker }, { token: i0.NgZone }, { token: i1$1.OverlayRef }, { token: i1.FocusMonitor }], target: i0.ɵɵFactoryTarget.Component }); }\n    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"14.0.0\", version: \"16.1.1\", type: CdkDialogContainer, selector: \"cdk-dialog-container\", host: { attributes: { \"tabindex\": \"-1\" }, properties: { \"attr.id\": \"_config.id || null\", \"attr.role\": \"_config.role\", \"attr.aria-modal\": \"_config.ariaModal\", \"attr.aria-labelledby\": \"_config.ariaLabel ? null : _ariaLabelledBy\", \"attr.aria-label\": \"_config.ariaLabel\", \"attr.aria-describedby\": \"_config.ariaDescribedBy || null\" }, classAttribute: \"cdk-dialog-container\" }, viewQueries: [{ propertyName: \"_portalOutlet\", first: true, predicate: CdkPortalOutlet, descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: \"<ng-template cdkPortalOutlet></ng-template>\\n\", styles: [\".cdk-dialog-container{display:block;width:100%;height:100%;min-height:inherit;max-height:inherit}\"], dependencies: [{ kind: \"directive\", type: i3.CdkPortalOutlet, selector: \"[cdkPortalOutlet]\", inputs: [\"cdkPortalOutlet\"], outputs: [\"attached\"], exportAs: [\"cdkPortalOutlet\"] }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkDialogContainer, decorators: [{\n            type: Component,\n            args: [{ selector: 'cdk-dialog-container', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.Default, host: {\n                        'class': 'cdk-dialog-container',\n                        'tabindex': '-1',\n                        '[attr.id]': '_config.id || null',\n                        '[attr.role]': '_config.role',\n                        '[attr.aria-modal]': '_config.ariaModal',\n                        '[attr.aria-labelledby]': '_config.ariaLabel ? null : _ariaLabelledBy',\n                        '[attr.aria-label]': '_config.ariaLabel',\n                        '[attr.aria-describedby]': '_config.ariaDescribedBy || null',\n                    }, template: \"<ng-template cdkPortalOutlet></ng-template>\\n\", styles: [\".cdk-dialog-container{display:block;width:100%;height:100%;min-height:inherit;max-height:inherit}\"] }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FocusTrapFactory }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DialogConfig]\n                }] }, { type: i1.InteractivityChecker }, { type: i0.NgZone }, { type: i1$1.OverlayRef }, { type: i1.FocusMonitor }]; }, propDecorators: { _portalOutlet: [{\n                type: ViewChild,\n                args: [CdkPortalOutlet, { static: true }]\n            }] } });\n\n/**\n * Reference to a dialog opened via the Dialog service.\n */\nclass DialogRef {\n    constructor(overlayRef, config) {\n        this.overlayRef = overlayRef;\n        this.config = config;\n        /** Emits when the dialog has been closed. */\n        this.closed = new Subject();\n        this.disableClose = config.disableClose;\n        this.backdropClick = overlayRef.backdropClick();\n        this.keydownEvents = overlayRef.keydownEvents();\n        this.outsidePointerEvents = overlayRef.outsidePointerEvents();\n        this.id = config.id; // By the time the dialog is created we are guaranteed to have an ID.\n        this.keydownEvents.subscribe(event => {\n            if (event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event)) {\n                event.preventDefault();\n                this.close(undefined, { focusOrigin: 'keyboard' });\n            }\n        });\n        this.backdropClick.subscribe(() => {\n            if (!this.disableClose) {\n                this.close(undefined, { focusOrigin: 'mouse' });\n            }\n        });\n        this._detachSubscription = overlayRef.detachments().subscribe(() => {\n            // Check specifically for `false`, because we want `undefined` to be treated like `true`.\n            if (config.closeOnOverlayDetachments !== false) {\n                this.close();\n            }\n        });\n    }\n    /**\n     * Close the dialog.\n     * @param result Optional result to return to the dialog opener.\n     * @param options Additional options to customize the closing behavior.\n     */\n    close(result, options) {\n        if (this.containerInstance) {\n            const closedSubject = this.closed;\n            this.containerInstance._closeInteractionType = options?.focusOrigin || 'program';\n            // Drop the detach subscription first since it can be triggered by the\n            // `dispose` call and override the result of this closing sequence.\n            this._detachSubscription.unsubscribe();\n            this.overlayRef.dispose();\n            closedSubject.next(result);\n            closedSubject.complete();\n            this.componentInstance = this.containerInstance = null;\n        }\n    }\n    /** Updates the position of the dialog based on the current position strategy. */\n    updatePosition() {\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        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}\n\n/** Injection token for the Dialog's ScrollStrategy. */\nconst DIALOG_SCROLL_STRATEGY = new InjectionToken('DialogScrollStrategy');\n/** Injection token for the Dialog's Data. */\nconst DIALOG_DATA = new InjectionToken('DialogData');\n/** Injection token that can be used to provide default options for the dialog module. */\nconst DEFAULT_DIALOG_CONFIG = new InjectionToken('DefaultDialogConfig');\n/** @docs-private */\nfunction DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {\n    return () => overlay.scrollStrategies.block();\n}\n/** @docs-private */\nconst DIALOG_SCROLL_STRATEGY_PROVIDER = {\n    provide: DIALOG_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY,\n};\n\n/** Unique id for the created dialog. */\nlet uniqueId = 0;\nclass Dialog {\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    constructor(_overlay, _injector, _defaultOptions, _parentDialog, _overlayContainer, scrollStrategy) {\n        this._overlay = _overlay;\n        this._injector = _injector;\n        this._defaultOptions = _defaultOptions;\n        this._parentDialog = _parentDialog;\n        this._overlayContainer = _overlayContainer;\n        this._openDialogsAtThisLevel = [];\n        this._afterAllClosedAtThisLevel = new Subject();\n        this._afterOpenedAtThisLevel = new Subject();\n        this._ariaHiddenElements = new Map();\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    open(componentOrTemplateRef, config) {\n        const defaults = (this._defaultOptions || new DialogConfig());\n        config = { ...defaults, ...config };\n        config.id = config.id || `cdk-dialog-${uniqueId++}`;\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 overlayConfig = this._getOverlayConfig(config);\n        const overlayRef = this._overlay.create(overlayConfig);\n        const dialogRef = new DialogRef(overlayRef, config);\n        const dialogContainer = this._attachContainer(overlayRef, dialogRef, config);\n        dialogRef.containerInstance = dialogContainer;\n        this._attachDialogContent(componentOrTemplateRef, dialogRef, dialogContainer, 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.closed.subscribe(() => this._removeOpenDialog(dialogRef, true));\n        this.afterOpened.next(dialogRef);\n        return dialogRef;\n    }\n    /**\n     * Closes all of the currently-open dialogs.\n     */\n    closeAll() {\n        reverseForEach(this.openDialogs, dialog => dialog.close());\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        // Make one pass over all the dialogs that need to be untracked, but should not be closed. We\n        // want to stop tracking the open dialog even if it hasn't been closed, because the tracking\n        // determines when `aria-hidden` is removed from elements outside the dialog.\n        reverseForEach(this._openDialogsAtThisLevel, dialog => {\n            // Check for `false` specifically since we want `undefined` to be interpreted as `true`.\n            if (dialog.config.closeOnDestroy === false) {\n                this._removeOpenDialog(dialog, false);\n            }\n        });\n        // Make a second pass and close the remaining dialogs. We do this second pass in order to\n        // correctly dispatch the `afterAllClosed` event in case we have a mixed array of dialogs\n        // that should be closed and dialogs that should not.\n        reverseForEach(this._openDialogsAtThisLevel, dialog => dialog.close());\n        this._afterAllClosedAtThisLevel.complete();\n        this._afterOpenedAtThisLevel.complete();\n        this._openDialogsAtThisLevel = [];\n    }\n    /**\n     * Creates an overlay config from a dialog config.\n     * @param config The dialog configuration.\n     * @returns The overlay configuration.\n     */\n    _getOverlayConfig(config) {\n        const state = new OverlayConfig({\n            positionStrategy: config.positionStrategy ||\n                this._overlay.position().global().centerHorizontally().centerVertically(),\n            scrollStrategy: config.scrollStrategy || this._scrollStrategy(),\n            panelClass: config.panelClass,\n            hasBackdrop: config.hasBackdrop,\n            direction: config.direction,\n            minWidth: config.minWidth,\n            minHeight: config.minHeight,\n            maxWidth: config.maxWidth,\n            maxHeight: config.maxHeight,\n            width: config.width,\n            height: config.height,\n            disposeOnNavigation: config.closeOnNavigation,\n        });\n        if (config.backdropClass) {\n            state.backdropClass = config.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    _attachContainer(overlay, dialogRef, config) {\n        const userInjector = config.injector || config.viewContainerRef?.injector;\n        const providers = [\n            { provide: DialogConfig, useValue: config },\n            { provide: DialogRef, useValue: dialogRef },\n            { provide: OverlayRef, useValue: overlay },\n        ];\n        let containerType;\n        if (config.container) {\n            if (typeof config.container === 'function') {\n                containerType = config.container;\n            }\n            else {\n                containerType = config.container.type;\n                providers.push(...config.container.providers(config));\n            }\n        }\n        else {\n            containerType = CdkDialogContainer;\n        }\n        const containerPortal = new ComponentPortal(containerType, config.viewContainerRef, Injector.create({ parent: userInjector || this._injector, providers }), 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 dialogRef Reference to the dialog being opened.\n     * @param dialogContainer Component that is going to wrap the dialog content.\n     * @param config Configuration used to open the dialog.\n     */\n    _attachDialogContent(componentOrTemplateRef, dialogRef, dialogContainer, config) {\n        if (componentOrTemplateRef instanceof TemplateRef) {\n            const injector = this._createInjector(config, dialogRef, dialogContainer, undefined);\n            let context = { $implicit: config.data, dialogRef };\n            if (config.templateContext) {\n                context = {\n                    ...context,\n                    ...(typeof config.templateContext === 'function'\n                        ? config.templateContext()\n                        : config.templateContext),\n                };\n            }\n            dialogContainer.attachTemplatePortal(new TemplatePortal(componentOrTemplateRef, null, context, injector));\n        }\n        else {\n            const injector = this._createInjector(config, dialogRef, dialogContainer, this._injector);\n            const contentRef = dialogContainer.attachComponentPortal(new ComponentPortal(componentOrTemplateRef, config.viewContainerRef, injector, config.componentFactoryResolver));\n            dialogRef.componentInstance = contentRef.instance;\n        }\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 being opened.\n     * @param dialogContainer Component that is going to wrap the dialog content.\n     * @param fallbackInjector Injector to use as a fallback when a lookup fails in the custom\n     * dialog injector, if the user didn't provide a custom one.\n     * @returns The custom injector that can be used inside the dialog.\n     */\n    _createInjector(config, dialogRef, dialogContainer, fallbackInjector) {\n        const userInjector = config.injector || config.viewContainerRef?.injector;\n        const providers = [\n            { provide: DIALOG_DATA, useValue: config.data },\n            { provide: DialogRef, useValue: dialogRef },\n        ];\n        if (config.providers) {\n            if (typeof config.providers === 'function') {\n                providers.push(...config.providers(dialogRef, config, dialogContainer));\n            }\n            else {\n                providers.push(...config.providers);\n            }\n        }\n        if (config.direction &&\n            (!userInjector ||\n                !userInjector.get(Directionality, null, { optional: true }))) {\n            providers.push({\n                provide: Directionality,\n                useValue: { value: config.direction, change: of() },\n            });\n        }\n        return Injector.create({ parent: userInjector || fallbackInjector, providers });\n    }\n    /**\n     * Removes a dialog from the array of open dialogs.\n     * @param dialogRef Dialog to be removed.\n     * @param emitEvent Whether to emit an event if this is the last dialog.\n     */\n    _removeOpenDialog(dialogRef, emitEvent) {\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                if (emitEvent) {\n                    this._getAfterAllClosed().next();\n                }\n            }\n        }\n    }\n    /** Hides all of the content that isn't an overlay from assistive technology. */\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                const 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    _getAfterAllClosed() {\n        const parent = this._parentDialog;\n        return parent ? parent._getAfterAllClosed() : this._afterAllClosedAtThisLevel;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: Dialog, deps: [{ token: i1$1.Overlay }, { token: i0.Injector }, { token: DEFAULT_DIALOG_CONFIG, optional: true }, { token: Dialog, optional: true, skipSelf: true }, { token: i1$1.OverlayContainer }, { token: DIALOG_SCROLL_STRATEGY }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: Dialog }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: Dialog, decorators: [{\n            type: Injectable\n        }], ctorParameters: function () { return [{ type: i1$1.Overlay }, { type: i0.Injector }, { type: DialogConfig, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [DEFAULT_DIALOG_CONFIG]\n                }] }, { type: Dialog, decorators: [{\n                    type: Optional\n                }, {\n                    type: SkipSelf\n                }] }, { type: i1$1.OverlayContainer }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DIALOG_SCROLL_STRATEGY]\n                }] }]; } });\n/**\n * Executes a callback against all elements in an array while iterating in reverse.\n * Useful if the array is being modified as it is being iterated.\n */\nfunction reverseForEach(items, callback) {\n    let i = items.length;\n    while (i--) {\n        callback(items[i]);\n    }\n}\n\nclass DialogModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: DialogModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: DialogModule, declarations: [CdkDialogContainer], imports: [OverlayModule, PortalModule, A11yModule], exports: [\n            // Re-export the PortalModule so that people extending the `CdkDialogContainer`\n            // don't have to remember to import it or be faced with an unhelpful error.\n            PortalModule,\n            CdkDialogContainer] }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: DialogModule, providers: [Dialog, DIALOG_SCROLL_STRATEGY_PROVIDER], imports: [OverlayModule, PortalModule, A11yModule, \n            // Re-export the PortalModule so that people extending the `CdkDialogContainer`\n            // don't have to remember to import it or be faced with an unhelpful error.\n            PortalModule] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: DialogModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [OverlayModule, PortalModule, A11yModule],\n                    exports: [\n                        // Re-export the PortalModule so that people extending the `CdkDialogContainer`\n                        // don't have to remember to import it or be faced with an unhelpful error.\n                        PortalModule,\n                        CdkDialogContainer,\n                    ],\n                    declarations: [CdkDialogContainer],\n                    providers: [Dialog, DIALOG_SCROLL_STRATEGY_PROVIDER],\n                }]\n        }] });\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { CdkDialogContainer, DEFAULT_DIALOG_CONFIG, DIALOG_DATA, DIALOG_SCROLL_STRATEGY, DIALOG_SCROLL_STRATEGY_PROVIDER, DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY, Dialog, DialogConfig, DialogModule, DialogRef, throwDialogContentAlreadyAttachedError };\n","import { CdkDialogContainer, Dialog, DialogConfig, DialogModule } from '@angular/cdk/dialog';\nimport * as i1$1 from '@angular/cdk/overlay';\nimport { Overlay, OverlayModule } from '@angular/cdk/overlay';\nimport * as i4 from '@angular/cdk/portal';\nimport { PortalModule } from '@angular/cdk/portal';\nimport * as i0 from '@angular/core';\nimport { EventEmitter, Component, Optional, Inject, ViewEncapsulation, ChangeDetectionStrategy, InjectionToken, Injectable, SkipSelf, Directive, Input, NgModule } from '@angular/core';\nimport { MatCommonModule } from '@angular/material/core';\nimport * as i2 from '@angular/common';\nimport { DOCUMENT } from '@angular/common';\nimport { Subject, merge, defer } from 'rxjs';\nimport { filter, take, startWith } from 'rxjs/operators';\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 * Default parameters for the animation for backwards compatibility.\n * @docs-private\n */\nconst defaultParams = {\n    params: { enterAnimationDuration: '150ms', exitAnimationDuration: '75ms' },\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('{{enterAnimationDuration}} cubic-bezier(0, 0, 0.2, 1)', style({ transform: 'none', opacity: 1 })),\n            query('@*', animateChild(), { optional: true }),\n        ]), defaultParams),\n        transition('* => void, * => exit', group([\n            animate('{{exitAnimationDuration}} cubic-bezier(0.4, 0.0, 0.2, 1)', style({ opacity: 0 })),\n            query('@*', animateChild(), { optional: true }),\n        ]), defaultParams),\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 * 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        /** Whether this is a modal dialog. Used to set the `aria-modal` attribute. */\n        this.ariaModal = true;\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        /** Duration of the enter animation. Has to be a valid CSS value (e.g. 100ms). */\n        this.enterAnimationDuration = defaultParams.params.enterAnimationDuration;\n        /** Duration of the exit animation. Has to be a valid CSS value (e.g. 50ms). */\n        this.exitAnimationDuration = defaultParams.params.exitAnimationDuration;\n        // TODO(jelbourn): add configuration for lifecycle hooks, ARIA labelling.\n    }\n}\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 */\n// tslint:disable-next-line:validate-decorators\nclass _MatDialogContainerBase extends CdkDialogContainer {\n    constructor(elementRef, focusTrapFactory, _document, dialogConfig, interactivityChecker, ngZone, overlayRef, focusMonitor) {\n        super(elementRef, focusTrapFactory, _document, dialogConfig, interactivityChecker, ngZone, overlayRef, focusMonitor);\n        /** Emits when an animation state changes. */\n        this._animationStateChanged = new EventEmitter();\n    }\n    _captureInitialFocus() {\n        if (!this._config.delayFocusTrap) {\n            this._trapFocus();\n        }\n    }\n    /**\n     * Callback for when the open dialog animation has finished. Intended to\n     * be called by sub-classes that use different animation implementations.\n     */\n    _openAnimationDone(totalTime) {\n        if (this._config.delayFocusTrap) {\n            this._trapFocus();\n        }\n        this._animationStateChanged.next({ state: 'opened', totalTime });\n    }\n}\n_MatDialogContainerBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: _MatDialogContainerBase, deps: [{ token: i0.ElementRef }, { token: i1.FocusTrapFactory }, { token: DOCUMENT, optional: true }, { token: MatDialogConfig }, { token: i1.InteractivityChecker }, { token: i0.NgZone }, { token: i1$1.OverlayRef }, { token: i1.FocusMonitor }], target: i0.ɵɵFactoryTarget.Component });\n_MatDialogContainerBase.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"14.0.0\", version: \"14.2.0\", type: _MatDialogContainerBase, selector: \"ng-component\", usesInheritance: true, ngImport: i0, template: '', isInline: true });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: _MatDialogContainerBase, decorators: [{\n            type: Component,\n            args: [{ template: '' }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FocusTrapFactory }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: MatDialogConfig }, { type: i1.InteractivityChecker }, { type: i0.NgZone }, { type: i1$1.OverlayRef }, { type: i1.FocusMonitor }]; } });\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(elementRef, focusTrapFactory, document, dialogConfig, checker, ngZone, overlayRef, _changeDetectorRef, focusMonitor) {\n        super(elementRef, focusTrapFactory, document, dialogConfig, checker, ngZone, overlayRef, focusMonitor);\n        this._changeDetectorRef = _changeDetectorRef;\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            this._openAnimationDone(totalTime);\n        }\n        else if (toState === 'exit') {\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    _getAnimationState() {\n        return {\n            value: this._state,\n            params: {\n                'enterAnimationDuration': this._config.enterAnimationDuration || defaultParams.params.enterAnimationDuration,\n                'exitAnimationDuration': this._config.exitAnimationDuration || defaultParams.params.exitAnimationDuration,\n            },\n        };\n    }\n}\nMatDialogContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatDialogContainer, deps: [{ token: i0.ElementRef }, { token: i1.FocusTrapFactory }, { token: DOCUMENT, optional: true }, { token: MatDialogConfig }, { token: i1.InteractivityChecker }, { token: i0.NgZone }, { token: i1$1.OverlayRef }, { token: i0.ChangeDetectorRef }, { token: i1.FocusMonitor }], target: i0.ɵɵFactoryTarget.Component });\nMatDialogContainer.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"14.0.0\", version: \"14.2.0\", type: MatDialogContainer, selector: \"mat-dialog-container\", host: { attributes: { \"tabindex\": \"-1\" }, listeners: { \"@dialogContainer.start\": \"_onAnimationStart($event)\", \"@dialogContainer.done\": \"_onAnimationDone($event)\" }, properties: { \"attr.aria-modal\": \"_config.ariaModal\", \"id\": \"_config.id\", \"attr.role\": \"_config.role\", \"attr.aria-labelledby\": \"_config.ariaLabel ? null : _ariaLabelledBy\", \"attr.aria-label\": \"_config.ariaLabel\", \"attr.aria-describedby\": \"_config.ariaDescribedBy || null\", \"@dialogContainer\": \"_getAnimationState()\" }, 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.mat-dialog-actions-align-center,.mat-dialog-actions[align=center]{justify-content:center}.mat-dialog-actions.mat-dialog-actions-align-end,.mat-dialog-actions[align=end]{justify-content:flex-end}.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}\"], dependencies: [{ kind: \"directive\", type: i4.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: \"14.2.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                        '[attr.aria-modal]': '_config.ariaModal',\n                        '[id]': '_config.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]': `_getAnimationState()`,\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.mat-dialog-actions-align-center,.mat-dialog-actions[align=center]{justify-content:center}.mat-dialog-actions.mat-dialog-actions-align-end,.mat-dialog-actions[align=end]{justify-content:flex-end}.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        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FocusTrapFactory }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: MatDialogConfig }, { type: i1.InteractivityChecker }, { type: i0.NgZone }, { type: i1$1.OverlayRef }, { type: i0.ChangeDetectorRef }, { type: i1.FocusMonitor }]; } });\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 * Reference to a dialog opened via the MatDialog service.\n */\nclass MatDialogRef {\n    constructor(_ref, config, _containerInstance) {\n        this._ref = _ref;\n        this._containerInstance = _containerInstance;\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 started closing. */\n        this._beforeClosed = new Subject();\n        /** Current state of the dialog. */\n        this._state = 0 /* MatDialogState.OPEN */;\n        this.disableClose = config.disableClose;\n        this.id = _ref.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        _ref.overlayRef.detachments().subscribe(() => {\n            this._beforeClosed.next(this._result);\n            this._beforeClosed.complete();\n            this._finishDialogClose();\n        });\n        merge(this.backdropClick(), this.keydownEvents().pipe(filter(event => event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event)))).subscribe(event => {\n            if (!this.disableClose) {\n                event.preventDefault();\n                _closeDialogVia(this, event.type === 'keydown' ? 'keyboard' : '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._ref.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 /* MatDialogState.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._ref.closed;\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._ref.backdropClick;\n    }\n    /**\n     * Gets an observable that emits when keydown events are targeted on the overlay.\n     */\n    keydownEvents() {\n        return this._ref.keydownEvents;\n    }\n    /**\n     * Updates the dialog's position.\n     * @param position New dialog position.\n     */\n    updatePosition(position) {\n        let strategy = this._ref.config.positionStrategy;\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._ref.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._ref.updateSize(width, height);\n        return this;\n    }\n    /** Add a CSS class or an array of classes to the overlay pane. */\n    addPanelClass(classes) {\n        this._ref.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._ref.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 /* MatDialogState.CLOSED */;\n        this._ref.close(this._result, { focusOrigin: this._closeInteractionType });\n        this.componentInstance = null;\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: Move this back into `MatDialogRef` when we provide an official mock dialog ref.\nfunction _closeDialogVia(ref, interactionType, result) {\n    ref._closeInteractionType = interactionType;\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// Counter for unique dialog ids.\nlet uniqueId = 0;\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, \n    /**\n     * @deprecated No longer used. To be removed.\n     * @breaking-change 15.0.0\n     */\n    _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._defaultOptions = _defaultOptions;\n        this._parentDialog = _parentDialog;\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._idPrefix = 'mat-dialog-';\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        this._dialog = injector.get(Dialog);\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        let dialogRef;\n        config = { ...(this._defaultOptions || new MatDialogConfig()), ...config };\n        config.id = config.id || `${this._idPrefix}${uniqueId++}`;\n        config.scrollStrategy = config.scrollStrategy || this._scrollStrategy();\n        const cdkRef = this._dialog.open(componentOrTemplateRef, {\n            ...config,\n            positionStrategy: this._overlay.position().global().centerHorizontally().centerVertically(),\n            // Disable closing since we need to sync it up to the animation ourselves.\n            disableClose: true,\n            // Disable closing on destroy, because this service cleans up its open dialogs as well.\n            // We want to do the cleanup here, rather than the CDK service, because the CDK destroys\n            // the dialogs immediately whereas we want it to wait for the animations to finish.\n            closeOnDestroy: false,\n            container: {\n                type: this._dialogContainerType,\n                providers: () => [\n                    // Provide our config as the CDK config as well since it has the same interface as the\n                    // CDK one, but it contains the actual values passed in by the user for things like\n                    // `disableClose` which we disable for the CDK dialog since we handle it ourselves.\n                    { provide: MatDialogConfig, useValue: config },\n                    { provide: DialogConfig, useValue: config },\n                ],\n            },\n            templateContext: () => ({ dialogRef }),\n            providers: (ref, cdkConfig, dialogContainer) => {\n                dialogRef = new this._dialogRefConstructor(ref, config, dialogContainer);\n                dialogRef.updatePosition(config?.position);\n                return [\n                    { provide: this._dialogContainerType, useValue: dialogContainer },\n                    { provide: this._dialogDataToken, useValue: cdkConfig.data },\n                    { provide: this._dialogRefConstructor, useValue: dialogRef },\n                ];\n            },\n        });\n        // This can't be assigned in the `providers` callback, because\n        // the instance hasn't been assigned to the CDK ref yet.\n        dialogRef.componentInstance = cdkRef.componentInstance;\n        this.openDialogs.push(dialogRef);\n        this.afterOpened.next(dialogRef);\n        dialogRef.afterClosed().subscribe(() => {\n            const index = this.openDialogs.indexOf(dialogRef);\n            if (index > -1) {\n                this.openDialogs.splice(index, 1);\n                if (!this.openDialogs.length) {\n                    this._getAfterAllClosed().next();\n                }\n            }\n        });\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    _closeDialogs(dialogs) {\n        let i = dialogs.length;\n        while (i--) {\n            dialogs[i].close();\n        }\n    }\n}\n_MatDialogBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: _MatDialogBase, deps: \"invalid\", target: i0.ɵɵFactoryTarget.Injectable });\n_MatDialogBase.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: _MatDialogBase });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: _MatDialogBase, decorators: [{\n            type: Injectable\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, \n    /**\n     * @deprecated No longer used. To be removed.\n     * @breaking-change 15.0.0\n     */\n    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: \"14.2.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: \"14.2.0\", ngImport: i0, type: MatDialog });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatDialog, decorators: [{\n            type: Injectable\n        }], ctorParameters: function () { 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 * @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: \"14.2.0\", ngImport: i0, type: MatDialogClose, deps: [{ token: MatDialogRef, optional: true }, { token: i0.ElementRef }, { token: MatDialog }], target: i0.ɵɵFactoryTarget.Directive });\nMatDialogClose.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.2.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: \"14.2.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 () { return [{ type: MatDialogRef, decorators: [{\n                    type: Optional\n                }] }, { type: i0.ElementRef }, { type: MatDialog }]; }, 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: \"14.2.0\", ngImport: i0, type: MatDialogTitle, deps: [{ token: MatDialogRef, optional: true }, { token: i0.ElementRef }, { token: MatDialog }], target: i0.ɵɵFactoryTarget.Directive });\nMatDialogTitle.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.2.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: \"14.2.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 () { return [{ type: MatDialogRef, decorators: [{\n                    type: Optional\n                }] }, { type: i0.ElementRef }, { type: MatDialog }]; }, 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: \"14.2.0\", ngImport: i0, type: MatDialogContent, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatDialogContent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.2.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: \"14.2.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    constructor() {\n        /**\n         * Horizontal alignment of action buttons.\n         */\n        this.align = 'start';\n    }\n}\nMatDialogActions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatDialogActions, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatDialogActions.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.2.0\", type: MatDialogActions, selector: \"[mat-dialog-actions], mat-dialog-actions, [matDialogActions]\", inputs: { align: \"align\" }, host: { properties: { \"class.mat-dialog-actions-align-center\": \"align === \\\"center\\\"\", \"class.mat-dialog-actions-align-end\": \"align === \\\"end\\\"\" }, classAttribute: \"mat-dialog-actions\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatDialogActions, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: `[mat-dialog-actions], mat-dialog-actions, [matDialogActions]`,\n                    host: {\n                        'class': 'mat-dialog-actions',\n                        '[class.mat-dialog-actions-align-center]': 'align === \"center\"',\n                        '[class.mat-dialog-actions-align-end]': 'align === \"end\"',\n                    },\n                }]\n        }], propDecorators: { align: [{\n                type: Input\n            }] } });\n// TODO(crisbeto): this utility shouldn't be necessary anymore, because the dialog ref is provided\n// both to component and template dialogs through DI. We need to keep it around, because there are\n// some internal wrappers around `MatDialog` that happened to work by accident, because we had this\n// fallback logic in place.\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: \"14.2.0\", ngImport: i0, type: MatDialogModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatDialogModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"14.2.0\", ngImport: i0, type: MatDialogModule, declarations: [MatDialogContainer,\n        MatDialogClose,\n        MatDialogTitle,\n        MatDialogActions,\n        MatDialogContent], imports: [DialogModule, OverlayModule, PortalModule, MatCommonModule], exports: [MatDialogContainer,\n        MatDialogClose,\n        MatDialogTitle,\n        MatDialogContent,\n        MatDialogActions,\n        MatCommonModule] });\nMatDialogModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatDialogModule, providers: [MatDialog, MAT_DIALOG_SCROLL_STRATEGY_PROVIDER], imports: [DialogModule, OverlayModule, PortalModule, MatCommonModule, MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatDialogModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [DialogModule, 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 };\n"],"x_google_ignoreList":[0,1]}