| {"version":3,"sources":["src/material/material-dialog.umd.js"],"names":["global","factory","exports","module","require","define","amd","self","ng","material","dialog","cdk","overlay","portal","core","bidi","common","rxjs","operators","a11y","animations","keycodes","this","core$1","extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","__extends","TypeError","String","__","constructor","create","__read","o","n","m","Symbol","iterator","r","e","i","ar","next","done","push","value","error","__spread","arguments","length","concat","MatDialogConfig","role","panelClass","hasBackdrop","backdropClass","disableClose","width","height","maxWidth","data","ariaDescribedBy","ariaLabelledBy","ariaLabel","autoFocus","restoreFocus","closeOnNavigation","matDialogAnimations","dialogContainer","trigger","state","style","opacity","transform","transition","animate","_MatDialogContainerBase","_super","_elementRef","_focusTrapFactory","_changeDetectorRef","_document","_config","_focusMonitor","_this","_animationStateChanged","EventEmitter","_elementFocusedBeforeDialogWasOpened","_closeInteractionType","attachDomPortal","_portalOutlet","hasAttached","_ariaLabelledBy","_initializeWithAttachedContent","_setupFocusTrap","_capturePreviouslyFocusedElement","_focusDialogContainer","attachComponentPortal","attachTemplatePortal","_recaptureFocus","_containsFocus","_focusTrap","focusInitialElement","nativeElement","focus","_trapFocus","focusInitialElementWhenReady","_restoreFocus","previousElement","activeElement","_getActiveElement","element","body","contains","focusVia","destroy","_a","shadowRoot","BasePortalOutlet","decorators","type","Directive","ctorParameters","ElementRef","FocusTrapFactory","ChangeDetectorRef","undefined","Optional","Inject","args","DOCUMENT","FocusMonitor","propDecorators","ViewChild","CdkPortalOutlet","static","MatDialogContainer","apply","_state","_onAnimationDone","_b","toState","totalTime","_onAnimationStart","_startExitAnimation","markForCheck","Component","selector","template","encapsulation","ViewEncapsulation","None","changeDetection","ChangeDetectionStrategy","Default","host","class","tabindex","aria-modal","[id]","[attr.role]","[attr.aria-labelledby]","[attr.aria-label]","[attr.aria-describedby]","[@dialogContainer]","(@dialogContainer.start)","(@dialogContainer.done)","styles","uniqueId","MatDialogRef","_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","top","bottom","centerVertically","updateSize","addPanelClass","classes","removePanelClass","getState","getConfig","positionStrategy","ref","interactionType","result","MAT_DIALOG_DATA","InjectionToken","MAT_DIALOG_DEFAULT_OPTIONS","MAT_DIALOG_SCROLL_STRATEGY","MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY","scrollStrategies","block","MAT_DIALOG_SCROLL_STRATEGY_PROVIDER","provide","deps","Overlay","useFactory","_MatDialogBase","_overlay","_injector","_defaultOptions","_parentDialog","_overlayContainer","scrollStrategy","_dialogRefConstructor","_dialogContainerType","_dialogDataToken","_openDialogsAtThisLevel","_afterAllClosedAtThisLevel","_afterOpenedAtThisLevel","_ariaHiddenElements","Map","afterAllClosed","defer","openDialogs","_getAfterAllClosed","startWith","_scrollStrategy","defineProperty","get","enumerable","configurable","parent","open","componentOrTemplateRef","config","_applyConfigDefaults","defaultOptions","assign","getDialogById","overlayRef","_createOverlay","_attachDialogContainer","dialogRef","_attachDialogContent","_hideNonDialogContentFromAssistiveTechnology","_removeOpenDialog","closeAll","_closeDialogs","find","ngOnDestroy","overlayConfig","_getOverlayConfig","dialogConfig","OverlayConfig","direction","minWidth","minHeight","maxHeight","disposeOnNavigation","injector","Injector","viewContainerRef","providers","useValue","containerPortal","ComponentPortal","componentFactoryResolver","attach","instance","TemplateRef","TemplatePortal","$implicit","_createInjector","contentRef","userInjector","Directionality","change","of","index","indexOf","splice","forEach","previousValue","setAttribute","removeAttribute","clear","overlayContainer","getContainerElement","parentElement","siblings","children","sibling","nodeName","hasAttribute","set","getAttribute","dialogs","OverlayContainer","Type","MatDialog","location","parentDialog","Injectable","Location","SkipSelf","dialogElementUid","MatDialogClose","_dialog","ngOnInit","getClosestDialog","ngOnChanges","changes","proxiedChange","currentValue","_onButtonClick","screenX","screenY","exportAs","(click)","[attr.type]","Input","_matDialogClose","MatDialogContent","MatDialogActions","MatDialogModule","MatDialogTitle","_dialogRef","Promise","resolve","then","container","classList","NgModule","imports","OverlayModule","PortalModule","MatCommonModule","declarations","entryComponents","MAT_DIALOG_SCROLL_STRATEGY_FACTORY","throwMatDialogContentAlreadyAttachedError","Error"],"mappings":"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","sourcesContent":["(function (global, factory) {\n typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/cdk/overlay'), require('@angular/cdk/portal'), require('@angular/core'), require('@angular/material/core'), require('@angular/cdk/bidi'), require('@angular/common'), require('rxjs'), require('rxjs/operators'), require('@angular/cdk/a11y'), require('@angular/animations'), require('@angular/cdk/keycodes')) :\n typeof define === 'function' && define.amd ? define('@angular/material/dialog', ['exports', '@angular/cdk/overlay', '@angular/cdk/portal', '@angular/core', '@angular/material/core', '@angular/cdk/bidi', '@angular/common', 'rxjs', 'rxjs/operators', '@angular/cdk/a11y', '@angular/animations', '@angular/cdk/keycodes'], factory) :\n (global = global || self, factory((global.ng = global.ng || {}, global.ng.material = global.ng.material || {}, global.ng.material.dialog = {}), global.ng.cdk.overlay, global.ng.cdk.portal, global.ng.core, global.ng.material.core, global.ng.cdk.bidi, global.ng.common, global.rxjs, global.rxjs.operators, global.ng.cdk.a11y, global.ng.animations, global.ng.cdk.keycodes));\n}(this, (function (exports, overlay, portal, core, core$1, bidi, common, rxjs, operators, a11y, animations, keycodes) { 'use strict';\n\n /*! *****************************************************************************\n Copyright (c) Microsoft Corporation.\n\n Permission to use, copy, modify, and/or distribute this software for any\n purpose with or without fee is hereby granted.\n\n THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\n AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\n LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\n OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\n PERFORMANCE OF THIS SOFTWARE.\n ***************************************************************************** */\n /* global Reflect, Promise */\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b)\n if (Object.prototype.hasOwnProperty.call(b, p))\n d[p] = b[p]; };\n return extendStatics(d, b);\n };\n function __extends(d, b) {\n if (typeof b !== \"function\" && b !== null)\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n }\n var __assign = function () {\n __assign = Object.assign || function __assign(t) {\n for (var s, i = 1, n = arguments.length; i < n; i++) {\n s = arguments[i];\n for (var p in s)\n if (Object.prototype.hasOwnProperty.call(s, p))\n t[p] = s[p];\n }\n return t;\n };\n return __assign.apply(this, arguments);\n };\n function __rest(s, e) {\n var t = {};\n for (var p in s)\n if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n t[p] = s[p];\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n t[p[i]] = s[p[i]];\n }\n return t;\n }\n function __decorate(decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\")\n r = Reflect.decorate(decorators, target, key, desc);\n else\n for (var i = decorators.length - 1; i >= 0; i--)\n if (d = decorators[i])\n r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n }\n function __param(paramIndex, decorator) {\n return function (target, key) { decorator(target, key, paramIndex); };\n }\n function __metadata(metadataKey, metadataValue) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\")\n return Reflect.metadata(metadataKey, metadataValue);\n }\n function __awaiter(thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try {\n step(generator.next(value));\n }\n catch (e) {\n reject(e);\n } }\n function rejected(value) { try {\n step(generator[\"throw\"](value));\n }\n catch (e) {\n reject(e);\n } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n }\n function __generator(thisArg, body) {\n var _ = { label: 0, sent: function () { if (t[0] & 1)\n throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function () { return this; }), g;\n function verb(n) { return function (v) { return step([n, v]); }; }\n function step(op) {\n if (f)\n throw new TypeError(\"Generator is already executing.\");\n while (_)\n try {\n if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)\n return t;\n if (y = 0, t)\n op = [op[0] & 2, t.value];\n switch (op[0]) {\n case 0:\n case 1:\n t = op;\n break;\n case 4:\n _.label++;\n return { value: op[1], done: false };\n case 5:\n _.label++;\n y = op[1];\n op = [0];\n continue;\n case 7:\n op = _.ops.pop();\n _.trys.pop();\n continue;\n default:\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {\n _ = 0;\n continue;\n }\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {\n _.label = op[1];\n break;\n }\n if (op[0] === 6 && _.label < t[1]) {\n _.label = t[1];\n t = op;\n break;\n }\n if (t && _.label < t[2]) {\n _.label = t[2];\n _.ops.push(op);\n break;\n }\n if (t[2])\n _.ops.pop();\n _.trys.pop();\n continue;\n }\n op = body.call(thisArg, _);\n }\n catch (e) {\n op = [6, e];\n y = 0;\n }\n finally {\n f = t = 0;\n }\n if (op[0] & 5)\n throw op[1];\n return { value: op[0] ? op[1] : void 0, done: true };\n }\n }\n var __createBinding = Object.create ? (function (o, m, k, k2) {\n if (k2 === undefined)\n k2 = k;\n Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });\n }) : (function (o, m, k, k2) {\n if (k2 === undefined)\n k2 = k;\n o[k2] = m[k];\n });\n function __exportStar(m, o) {\n for (var p in m)\n if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p))\n __createBinding(o, m, p);\n }\n function __values(o) {\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n if (m)\n return m.call(o);\n if (o && typeof o.length === \"number\")\n return {\n next: function () {\n if (o && i >= o.length)\n o = void 0;\n return { value: o && o[i++], done: !o };\n }\n };\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n }\n function __read(o, n) {\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n if (!m)\n return o;\n var i = m.call(o), r, ar = [], e;\n try {\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done)\n ar.push(r.value);\n }\n catch (error) {\n e = { error: error };\n }\n finally {\n try {\n if (r && !r.done && (m = i[\"return\"]))\n m.call(i);\n }\n finally {\n if (e)\n throw e.error;\n }\n }\n return ar;\n }\n /** @deprecated */\n function __spread() {\n for (var ar = [], i = 0; i < arguments.length; i++)\n ar = ar.concat(__read(arguments[i]));\n return ar;\n }\n /** @deprecated */\n function __spreadArrays() {\n for (var s = 0, i = 0, il = arguments.length; i < il; i++)\n s += arguments[i].length;\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n r[k] = a[j];\n return r;\n }\n function __spreadArray(to, from) {\n for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\n to[j] = from[i];\n return to;\n }\n function __await(v) {\n return this instanceof __await ? (this.v = v, this) : new __await(v);\n }\n function __asyncGenerator(thisArg, _arguments, generator) {\n if (!Symbol.asyncIterator)\n throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\n function verb(n) { if (g[n])\n i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\n function resume(n, v) { try {\n step(g[n](v));\n }\n catch (e) {\n settle(q[0][3], e);\n } }\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n function fulfill(value) { resume(\"next\", value); }\n function reject(value) { resume(\"throw\", value); }\n function settle(f, v) { if (f(v), q.shift(), q.length)\n resume(q[0][0], q[0][1]); }\n }\n function __asyncDelegator(o) {\n var i, p;\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\n }\n function __asyncValues(o) {\n if (!Symbol.asyncIterator)\n throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n var m = o[Symbol.asyncIterator], i;\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }\n }\n function __makeTemplateObject(cooked, raw) {\n if (Object.defineProperty) {\n Object.defineProperty(cooked, \"raw\", { value: raw });\n }\n else {\n cooked.raw = raw;\n }\n return cooked;\n }\n ;\n var __setModuleDefault = Object.create ? (function (o, v) {\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n }) : function (o, v) {\n o[\"default\"] = v;\n };\n function __importStar(mod) {\n if (mod && mod.__esModule)\n return mod;\n var result = {};\n if (mod != null)\n for (var k in mod)\n if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k))\n __createBinding(result, mod, k);\n __setModuleDefault(result, mod);\n return result;\n }\n function __importDefault(mod) {\n return (mod && mod.__esModule) ? mod : { default: mod };\n }\n function __classPrivateFieldGet(receiver, privateMap) {\n if (!privateMap.has(receiver)) {\n throw new TypeError(\"attempted to get private field on non-instance\");\n }\n return privateMap.get(receiver);\n }\n function __classPrivateFieldSet(receiver, privateMap, value) {\n if (!privateMap.has(receiver)) {\n throw new TypeError(\"attempted to set private field on non-instance\");\n }\n privateMap.set(receiver, value);\n return value;\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 */\n var MatDialogConfig = /** @class */ (function () {\n function MatDialogConfig() {\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 the dialog should focus the first focusable element on open. */\n this.autoFocus = true;\n /**\n * Whether the dialog should restore focus to the\n * previously-focused element, after it's closed.\n */\n this.restoreFocus = 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 return MatDialogConfig;\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 */\n var matDialogAnimations = {\n /** Animation that is applied on the dialog container by default. */\n dialogContainer: animations.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 animations.state('void, exit', animations.style({ opacity: 0, transform: 'scale(0.7)' })),\n animations.state('enter', animations.style({ transform: 'none' })),\n animations.transition('* => enter', animations.animate('150ms cubic-bezier(0, 0, 0.2, 1)', animations.style({ transform: 'none', opacity: 1 }))),\n animations.transition('* => void, * => exit', animations.animate('75ms cubic-bezier(0.4, 0.0, 0.2, 1)', animations.style({ opacity: 0 }))),\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 */\n function 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 */\n var _MatDialogContainerBase = /** @class */ (function (_super) {\n __extends(_MatDialogContainerBase, _super);\n function _MatDialogContainerBase(_elementRef, _focusTrapFactory, _changeDetectorRef, _document, \n /** The dialog configuration. */\n _config, _focusMonitor) {\n var _this = _super.call(this) || this;\n _this._elementRef = _elementRef;\n _this._focusTrapFactory = _focusTrapFactory;\n _this._changeDetectorRef = _changeDetectorRef;\n _this._config = _config;\n _this._focusMonitor = _focusMonitor;\n /** Emits when an animation state changes. */\n _this._animationStateChanged = new core.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 = function (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 return _this;\n }\n /** Initializes the dialog container with the attached content. */\n _MatDialogContainerBase.prototype._initializeWithAttachedContent = function () {\n this._setupFocusTrap();\n // Save the previously focused element. This element will be re-focused\n // when the dialog closes.\n this._capturePreviouslyFocusedElement();\n // Move focus onto the dialog immediately in order to prevent the user\n // from accidentally opening multiple dialogs at the same time.\n this._focusDialogContainer();\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 _MatDialogContainerBase.prototype.attachComponentPortal = function (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 _MatDialogContainerBase.prototype.attachTemplatePortal = function (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 _MatDialogContainerBase.prototype._recaptureFocus = function () {\n if (!this._containsFocus()) {\n var focusContainer = !this._config.autoFocus || !this._focusTrap.focusInitialElement();\n if (focusContainer) {\n this._elementRef.nativeElement.focus();\n }\n }\n };\n /** Moves the focus inside the focus trap. */\n _MatDialogContainerBase.prototype._trapFocus = function () {\n // If we 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.\n if (this._config.autoFocus) {\n this._focusTrap.focusInitialElementWhenReady();\n }\n else if (!this._containsFocus()) {\n // Otherwise 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 this._elementRef.nativeElement.focus();\n }\n };\n /** Restores focus to the element that was focused before the dialog opened. */\n _MatDialogContainerBase.prototype._restoreFocus = function () {\n var 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 && previousElement &&\n typeof previousElement.focus === 'function') {\n var activeElement = this._getActiveElement();\n var 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 || activeElement === this._document.body || 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 /** Sets up the focus trap. */\n _MatDialogContainerBase.prototype._setupFocusTrap = function () {\n this._focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement);\n };\n /** Captures the element that was focused before the dialog was opened. */\n _MatDialogContainerBase.prototype._capturePreviouslyFocusedElement = function () {\n if (this._document) {\n this._elementFocusedBeforeDialogWasOpened = this._getActiveElement();\n }\n };\n /** Focuses the dialog container. */\n _MatDialogContainerBase.prototype._focusDialogContainer = function () {\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 _MatDialogContainerBase.prototype._containsFocus = function () {\n var element = this._elementRef.nativeElement;\n var activeElement = this._getActiveElement();\n return element === activeElement || element.contains(activeElement);\n };\n /** Gets the currently-focused element on the page. */\n _MatDialogContainerBase.prototype._getActiveElement = function () {\n var _a;\n // If the `activeElement` is inside a shadow root, `document.activeElement` will\n // point to the shadow root so we have to descend into it ourselves.\n var activeElement = this._document.activeElement;\n return ((_a = activeElement === null || activeElement === void 0 ? void 0 : activeElement.shadowRoot) === null || _a === void 0 ? void 0 : _a.activeElement) || activeElement;\n };\n return _MatDialogContainerBase;\n }(portal.BasePortalOutlet));\n _MatDialogContainerBase.decorators = [\n { type: core.Directive }\n ];\n _MatDialogContainerBase.ctorParameters = function () { return [\n { type: core.ElementRef },\n { type: a11y.FocusTrapFactory },\n { type: core.ChangeDetectorRef },\n { type: undefined, decorators: [{ type: core.Optional }, { type: core.Inject, args: [common.DOCUMENT,] }] },\n { type: MatDialogConfig },\n { type: a11y.FocusMonitor }\n ]; };\n _MatDialogContainerBase.propDecorators = {\n _portalOutlet: [{ type: core.ViewChild, args: [portal.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 */\n var MatDialogContainer = /** @class */ (function (_super) {\n __extends(MatDialogContainer, _super);\n function MatDialogContainer() {\n var _this = _super.apply(this, __spread(arguments)) || this;\n /** State of the dialog animation. */\n _this._state = 'enter';\n return _this;\n }\n /** Callback, invoked whenever an animation on the host completes. */\n MatDialogContainer.prototype._onAnimationDone = function (_b) {\n var toState = _b.toState, totalTime = _b.totalTime;\n if (toState === 'enter') {\n this._trapFocus();\n this._animationStateChanged.next({ state: 'opened', totalTime: totalTime });\n }\n else if (toState === 'exit') {\n this._restoreFocus();\n this._animationStateChanged.next({ state: 'closed', totalTime: totalTime });\n }\n };\n /** Callback, invoked when an animation on the host starts. */\n MatDialogContainer.prototype._onAnimationStart = function (_b) {\n var toState = _b.toState, totalTime = _b.totalTime;\n if (toState === 'enter') {\n this._animationStateChanged.next({ state: 'opening', totalTime: totalTime });\n }\n else if (toState === 'exit' || toState === 'void') {\n this._animationStateChanged.next({ state: 'closing', totalTime: totalTime });\n }\n };\n /** Starts the dialog exit animation. */\n MatDialogContainer.prototype._startExitAnimation = function () {\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 return MatDialogContainer;\n }(_MatDialogContainerBase));\n MatDialogContainer.decorators = [\n { type: core.Component, args: [{\n selector: 'mat-dialog-container',\n template: \"<ng-template cdkPortalOutlet></ng-template>\\n\",\n encapsulation: core.ViewEncapsulation.None,\n // Using OnPush for dialogs caused some G3 sync issues. Disabled until we can track them down.\n // tslint:disable-next-line:validate-decorators\n changeDetection: core.ChangeDetectionStrategy.Default,\n animations: [matDialogAnimations.dialogContainer],\n 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 },\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 /**\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.\n var uniqueId = 0;\n /**\n * Reference to a dialog opened via the MatDialog service.\n */\n var MatDialogRef = /** @class */ (function () {\n function MatDialogRef(_overlayRef, _containerInstance, id) {\n var _this = this;\n if (id === void 0) { 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 rxjs.Subject();\n /** Subject for notifying the user that the dialog has finished closing. */\n this._afterClosed = new rxjs.Subject();\n /** Subject for notifying the user that the dialog has started closing. */\n this._beforeClosed = new rxjs.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.pipe(operators.filter(function (event) { return event.state === 'opened'; }), operators.take(1))\n .subscribe(function () {\n _this._afterOpened.next();\n _this._afterOpened.complete();\n });\n // Dispose overlay when closing animation is complete\n _containerInstance._animationStateChanged.pipe(operators.filter(function (event) { return event.state === 'closed'; }), operators.take(1)).subscribe(function () {\n clearTimeout(_this._closeFallbackTimeout);\n _this._finishDialogClose();\n });\n _overlayRef.detachments().subscribe(function () {\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.keydownEvents()\n .pipe(operators.filter(function (event) {\n return event.keyCode === keycodes.ESCAPE && !_this.disableClose && !keycodes.hasModifierKey(event);\n }))\n .subscribe(function (event) {\n event.preventDefault();\n _closeDialogVia(_this, 'keyboard');\n });\n _overlayRef.backdropClick().subscribe(function () {\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 MatDialogRef.prototype.close = function (dialogResult) {\n var _this = this;\n this._result = dialogResult;\n // Transition the backdrop in parallel to the dialog.\n this._containerInstance._animationStateChanged.pipe(operators.filter(function (event) { return event.state === 'closing'; }), operators.take(1))\n .subscribe(function (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(function () { return _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 MatDialogRef.prototype.afterOpened = function () {\n return this._afterOpened;\n };\n /**\n * Gets an observable that is notified when the dialog is finished closing.\n */\n MatDialogRef.prototype.afterClosed = function () {\n return this._afterClosed;\n };\n /**\n * Gets an observable that is notified when the dialog has started closing.\n */\n MatDialogRef.prototype.beforeClosed = function () {\n return this._beforeClosed;\n };\n /**\n * Gets an observable that emits when the overlay's backdrop has been clicked.\n */\n MatDialogRef.prototype.backdropClick = function () {\n return this._overlayRef.backdropClick();\n };\n /**\n * Gets an observable that emits when keydown events are targeted on the overlay.\n */\n MatDialogRef.prototype.keydownEvents = function () {\n return this._overlayRef.keydownEvents();\n };\n /**\n * Updates the dialog's position.\n * @param position New dialog position.\n */\n MatDialogRef.prototype.updatePosition = function (position) {\n var 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 MatDialogRef.prototype.updateSize = function (width, height) {\n if (width === void 0) { width = ''; }\n if (height === void 0) { height = ''; }\n this._overlayRef.updateSize({ width: width, height: height });\n this._overlayRef.updatePosition();\n return this;\n };\n /** Add a CSS class or an array of classes to the overlay pane. */\n MatDialogRef.prototype.addPanelClass = function (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 MatDialogRef.prototype.removePanelClass = function (classes) {\n this._overlayRef.removePanelClass(classes);\n return this;\n };\n /** Gets the current state of the dialog's lifecycle. */\n MatDialogRef.prototype.getState = function () {\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 MatDialogRef.prototype._finishDialogClose = function () {\n this._state = 2 /* CLOSED */;\n this._overlayRef.dispose();\n };\n /** Fetches the position strategy object from the overlay ref. */\n MatDialogRef.prototype._getPositionStrategy = function () {\n return this._overlayRef.getConfig().positionStrategy;\n };\n return MatDialogRef;\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.\n function _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 /** Injection token that can be used to access the data that was passed in to a dialog. */\n var MAT_DIALOG_DATA = new core.InjectionToken('MatDialogData');\n /** Injection token that can be used to specify default dialog options. */\n var MAT_DIALOG_DEFAULT_OPTIONS = new core.InjectionToken('mat-dialog-default-options');\n /** Injection token that determines the scroll handling while the dialog is open. */\n var MAT_DIALOG_SCROLL_STRATEGY = new core.InjectionToken('mat-dialog-scroll-strategy');\n /** @docs-private */\n function MAT_DIALOG_SCROLL_STRATEGY_FACTORY(overlay) {\n return function () { return overlay.scrollStrategies.block(); };\n }\n /** @docs-private */\n function MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {\n return function () { return overlay.scrollStrategies.block(); };\n }\n /** @docs-private */\n var MAT_DIALOG_SCROLL_STRATEGY_PROVIDER = {\n provide: MAT_DIALOG_SCROLL_STRATEGY,\n deps: [overlay.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 */\n var _MatDialogBase = /** @class */ (function () {\n function _MatDialogBase(_overlay, _injector, _defaultOptions, _parentDialog, _overlayContainer, scrollStrategy, _dialogRefConstructor, _dialogContainerType, _dialogDataToken) {\n var _this = this;\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 rxjs.Subject();\n this._afterOpenedAtThisLevel = new rxjs.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 = rxjs.defer(function () { return _this.openDialogs.length ?\n _this._getAfterAllClosed() :\n _this._getAfterAllClosed().pipe(operators.startWith(undefined)); });\n this._scrollStrategy = scrollStrategy;\n }\n Object.defineProperty(_MatDialogBase.prototype, \"openDialogs\", {\n /** Keeps track of the currently-open dialogs. */\n get: function () {\n return this._parentDialog ? this._parentDialog.openDialogs : this._openDialogsAtThisLevel;\n },\n enumerable: false,\n configurable: true\n });\n Object.defineProperty(_MatDialogBase.prototype, \"afterOpened\", {\n /** Stream that emits when a dialog has been opened. */\n get: function () {\n return this._parentDialog ? this._parentDialog.afterOpened : this._afterOpenedAtThisLevel;\n },\n enumerable: false,\n configurable: true\n });\n _MatDialogBase.prototype._getAfterAllClosed = function () {\n var parent = this._parentDialog;\n return parent ? parent._getAfterAllClosed() : this._afterAllClosedAtThisLevel;\n };\n _MatDialogBase.prototype.open = function (componentOrTemplateRef, config) {\n var _this = this;\n config = _applyConfigDefaults(config, this._defaultOptions || new MatDialogConfig());\n if (config.id && 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 var overlayRef = this._createOverlay(config);\n var dialogContainer = this._attachDialogContainer(overlayRef, config);\n var 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(function () { return _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 _MatDialogBase.prototype.closeAll = function () {\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 _MatDialogBase.prototype.getDialogById = function (id) {\n return this.openDialogs.find(function (dialog) { return dialog.id === id; });\n };\n _MatDialogBase.prototype.ngOnDestroy = function () {\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 _MatDialogBase.prototype._createOverlay = function (config) {\n var 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 _MatDialogBase.prototype._getOverlayConfig = function (dialogConfig) {\n var state = new overlay.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 _MatDialogBase.prototype._attachDialogContainer = function (overlay, config) {\n var userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;\n var injector = core.Injector.create({\n parent: userInjector || this._injector,\n providers: [{ provide: MatDialogConfig, useValue: config }]\n });\n var containerPortal = new portal.ComponentPortal(this._dialogContainerType, config.viewContainerRef, injector, config.componentFactoryResolver);\n var 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 _MatDialogBase.prototype._attachDialogContent = function (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 var dialogRef = new this._dialogRefConstructor(overlayRef, dialogContainer, config.id);\n if (componentOrTemplateRef instanceof core.TemplateRef) {\n dialogContainer.attachTemplatePortal(new portal.TemplatePortal(componentOrTemplateRef, null, { $implicit: config.data, dialogRef: dialogRef }));\n }\n else {\n var injector = this._createInjector(config, dialogRef, dialogContainer);\n var contentRef = dialogContainer.attachComponentPortal(new portal.ComponentPortal(componentOrTemplateRef, config.viewContainerRef, injector));\n dialogRef.componentInstance = contentRef.instance;\n }\n dialogRef\n .updateSize(config.width, config.height)\n .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 _MatDialogBase.prototype._createInjector = function (config, dialogRef, dialogContainer) {\n var 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 var 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 || !userInjector.get(bidi.Directionality, null))) {\n providers.push({\n provide: bidi.Directionality,\n useValue: { value: config.direction, change: rxjs.of() }\n });\n }\n return core.Injector.create({ parent: userInjector || this._injector, providers: providers });\n };\n /**\n * Removes a dialog from the array of open dialogs.\n * @param dialogRef Dialog to be removed.\n */\n _MatDialogBase.prototype._removeOpenDialog = function (dialogRef) {\n var 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(function (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 _MatDialogBase.prototype._hideNonDialogContentFromAssistiveTechnology = function () {\n var overlayContainer = this._overlayContainer.getContainerElement();\n // Ensure that the overlay container is attached to the DOM.\n if (overlayContainer.parentElement) {\n var siblings = overlayContainer.parentElement.children;\n for (var i = siblings.length - 1; i > -1; i--) {\n var 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 _MatDialogBase.prototype._closeDialogs = function (dialogs) {\n var 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 return _MatDialogBase;\n }());\n _MatDialogBase.decorators = [\n { type: core.Directive }\n ];\n _MatDialogBase.ctorParameters = function () { return [\n { type: overlay.Overlay },\n { type: core.Injector },\n { type: undefined },\n { type: undefined },\n { type: overlay.OverlayContainer },\n { type: undefined },\n { type: core.Type },\n { type: core.Type },\n { type: core.InjectionToken }\n ]; };\n /**\n * Service to open Material Design modal dialogs.\n */\n var MatDialog = /** @class */ (function (_super) {\n __extends(MatDialog, _super);\n function MatDialog(overlay, injector, \n /**\n * @deprecated `_location` parameter to be removed.\n * @breaking-change 10.0.0\n */\n location, defaultOptions, scrollStrategy, parentDialog, overlayContainer) {\n return _super.call(this, overlay, injector, defaultOptions, parentDialog, overlayContainer, scrollStrategy, MatDialogRef, MatDialogContainer, MAT_DIALOG_DATA) || this;\n }\n return MatDialog;\n }(_MatDialogBase));\n MatDialog.decorators = [\n { type: core.Injectable }\n ];\n MatDialog.ctorParameters = function () { return [\n { type: overlay.Overlay },\n { type: core.Injector },\n { type: common.Location, decorators: [{ type: core.Optional }] },\n { type: MatDialogConfig, decorators: [{ type: core.Optional }, { type: core.Inject, args: [MAT_DIALOG_DEFAULT_OPTIONS,] }] },\n { type: undefined, decorators: [{ type: core.Inject, args: [MAT_DIALOG_SCROLL_STRATEGY,] }] },\n { type: MatDialog, decorators: [{ type: core.Optional }, { type: core.SkipSelf }] },\n { type: overlay.OverlayContainer }\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 */\n function _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. */\n var dialogElementUid = 0;\n /**\n * Button that will close the current dialog.\n */\n var MatDialogClose = /** @class */ (function () {\n function MatDialogClose(\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 MatDialogClose.prototype.ngOnInit = function () {\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 MatDialogClose.prototype.ngOnChanges = function (changes) {\n var proxiedChange = changes['_matDialogClose'] || changes['_matDialogCloseResult'];\n if (proxiedChange) {\n this.dialogResult = proxiedChange.currentValue;\n }\n };\n MatDialogClose.prototype._onButtonClick = function (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 return MatDialogClose;\n }());\n MatDialogClose.decorators = [\n { type: core.Directive, 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 ];\n MatDialogClose.ctorParameters = function () { return [\n { type: MatDialogRef, decorators: [{ type: core.Optional }] },\n { type: core.ElementRef },\n { type: MatDialog }\n ]; };\n MatDialogClose.propDecorators = {\n ariaLabel: [{ type: core.Input, args: ['aria-label',] }],\n type: [{ type: core.Input }],\n dialogResult: [{ type: core.Input, args: ['mat-dialog-close',] }],\n _matDialogClose: [{ type: core.Input, args: ['matDialogClose',] }]\n };\n /**\n * Title of a dialog element. Stays fixed to the top of the dialog when scrolling.\n */\n var MatDialogTitle = /** @class */ (function () {\n function MatDialogTitle(\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 this.id = \"mat-dialog-title-\" + dialogElementUid++;\n }\n MatDialogTitle.prototype.ngOnInit = function () {\n var _this = this;\n if (!this._dialogRef) {\n this._dialogRef = getClosestDialog(this._elementRef, this._dialog.openDialogs);\n }\n if (this._dialogRef) {\n Promise.resolve().then(function () {\n var container = _this._dialogRef._containerInstance;\n if (container && !container._ariaLabelledBy) {\n container._ariaLabelledBy = _this.id;\n }\n });\n }\n };\n return MatDialogTitle;\n }());\n MatDialogTitle.decorators = [\n { type: core.Directive, args: [{\n selector: '[mat-dialog-title], [matDialogTitle]',\n exportAs: 'matDialogTitle',\n host: {\n 'class': 'mat-dialog-title',\n '[id]': 'id',\n },\n },] }\n ];\n MatDialogTitle.ctorParameters = function () { return [\n { type: MatDialogRef, decorators: [{ type: core.Optional }] },\n { type: core.ElementRef },\n { type: MatDialog }\n ]; };\n MatDialogTitle.propDecorators = {\n id: [{ type: core.Input }]\n };\n /**\n * Scrollable content container of a dialog.\n */\n var MatDialogContent = /** @class */ (function () {\n function MatDialogContent() {\n }\n return MatDialogContent;\n }());\n MatDialogContent.decorators = [\n { type: core.Directive, 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 */\n var MatDialogActions = /** @class */ (function () {\n function MatDialogActions() {\n }\n return MatDialogActions;\n }());\n MatDialogActions.decorators = [\n { type: core.Directive, 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 */\n function getClosestDialog(element, openDialogs) {\n var parent = element.nativeElement.parentElement;\n while (parent && !parent.classList.contains('mat-dialog-container')) {\n parent = parent.parentElement;\n }\n return parent ? openDialogs.find(function (dialog) { return 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 */\n var MatDialogModule = /** @class */ (function () {\n function MatDialogModule() {\n }\n return MatDialogModule;\n }());\n MatDialogModule.decorators = [\n { type: core.NgModule, args: [{\n imports: [\n overlay.OverlayModule,\n portal.PortalModule,\n core$1.MatCommonModule,\n ],\n exports: [\n MatDialogContainer,\n MatDialogClose,\n MatDialogTitle,\n MatDialogContent,\n MatDialogActions,\n core$1.MatCommonModule,\n ],\n declarations: [\n MatDialogContainer,\n MatDialogClose,\n MatDialogTitle,\n MatDialogActions,\n MatDialogContent,\n ],\n providers: [\n MatDialog,\n MAT_DIALOG_SCROLL_STRATEGY_PROVIDER,\n ],\n entryComponents: [MatDialogContainer],\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 * Generated bundle index. Do not edit.\n */\n\n exports.MAT_DIALOG_DATA = MAT_DIALOG_DATA;\n exports.MAT_DIALOG_DEFAULT_OPTIONS = MAT_DIALOG_DEFAULT_OPTIONS;\n exports.MAT_DIALOG_SCROLL_STRATEGY = MAT_DIALOG_SCROLL_STRATEGY;\n exports.MAT_DIALOG_SCROLL_STRATEGY_FACTORY = MAT_DIALOG_SCROLL_STRATEGY_FACTORY;\n exports.MAT_DIALOG_SCROLL_STRATEGY_PROVIDER = MAT_DIALOG_SCROLL_STRATEGY_PROVIDER;\n exports.MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY = MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY;\n exports.MatDialog = MatDialog;\n exports.MatDialogActions = MatDialogActions;\n exports.MatDialogClose = MatDialogClose;\n exports.MatDialogConfig = MatDialogConfig;\n exports.MatDialogContainer = MatDialogContainer;\n exports.MatDialogContent = MatDialogContent;\n exports.MatDialogModule = MatDialogModule;\n exports.MatDialogRef = MatDialogRef;\n exports.MatDialogTitle = MatDialogTitle;\n exports._MatDialogBase = _MatDialogBase;\n exports._MatDialogContainerBase = _MatDialogContainerBase;\n exports._closeDialogVia = _closeDialogVia;\n exports.matDialogAnimations = matDialogAnimations;\n exports.throwMatDialogContentAlreadyAttachedError = throwMatDialogContentAlreadyAttachedError;\n\n Object.defineProperty(exports, '__esModule', { value: true });\n\n})));\n//# sourceMappingURL=material-dialog.umd.js.map\n"]} |