\\r\\n\",\n host: {\n 'class': 'mat-datepicker-content',\n '[@transformPanel]': '\"enter\"',\n '[class.mat-datepicker-content-touch]': 'datepicker.touchUi'\n },\n animations: [\n matDatepickerAnimations.transformPanel,\n matDatepickerAnimations.fadeInCalendar,\n ],\n exportAs: 'ngxMatDatetimeContent',\n encapsulation: ViewEncapsulation.None,\n changeDetection: ChangeDetectionStrategy.OnPush,\n inputs: ['color'],\n styles: [\".mat-datepicker-content{display:block;border-radius:4px;box-shadow:0 2px 4px -1px rgba(0,0,0,.2),0 4px 5px 0 rgba(0,0,0,.14),0 1px 10px 0 rgba(0,0,0,.12)}.mat-datepicker-content .mat-calendar{width:296px}.mat-datepicker-content .time-container{display:flex;position:relative;padding-top:5px;justify-content:center}.mat-datepicker-content .time-container.disable-seconds .ngx-mat-timepicker .table{margin-left:9px}.mat-datepicker-content .time-container::before{content:'';position:absolute;top:0;left:0;right:0;height:1px;background-color:rgba(0,0,0,.12)}.mat-datepicker-content .actions{display:flex;padding:5px 15px 10px;justify-content:flex-end}\"]\n }]\n }], function () { return [{ type: ɵngcc0.ElementRef }]; }, { _calendar: [{\n type: ViewChild,\n args: [NgxMatCalendar]\n }], _timePicker: [{\n type: ViewChild,\n args: [NgxMatTimepickerComponent]\n }] }); })();\r\n// TODO(mmalerba): We use a component instead of a directive here so the user can use implicit\r\n// template reference variables (e.g. #d vs #d=\"matDatepicker\"). We can change this to a directive\r\n// if angular adds support for `exportAs: '$implicit'` on directives.\r\n/**\r\n * Component responsible for managing the datepicker popup/dialog.\r\n * @template D\r\n */\r\nclass NgxMatDatetimePicker {\r\n /**\r\n * @param {?} _dialog\r\n * @param {?} _overlay\r\n * @param {?} _ngZone\r\n * @param {?} _viewContainerRef\r\n * @param {?} scrollStrategy\r\n * @param {?} _dateAdapter\r\n * @param {?} _dir\r\n * @param {?} _document\r\n */\r\n constructor(_dialog, _overlay, _ngZone, _viewContainerRef, scrollStrategy, _dateAdapter, _dir, _document) {\r\n this._dialog = _dialog;\r\n this._overlay = _overlay;\r\n this._ngZone = _ngZone;\r\n this._viewContainerRef = _viewContainerRef;\r\n this._dateAdapter = _dateAdapter;\r\n this._dir = _dir;\r\n this._document = _document;\r\n /**\r\n * The view that the calendar should start in.\r\n */\r\n this.startView = 'month';\r\n this._touchUi = false;\r\n this._hideTime = false;\r\n /**\r\n * Emits selected year in multiyear view.\r\n * This doesn't imply a change on the selected date.\r\n */\r\n this.yearSelected = new EventEmitter();\r\n /**\r\n * Emits selected month in year view.\r\n * This doesn't imply a change on the selected date.\r\n */\r\n this.monthSelected = new EventEmitter();\r\n /**\r\n * Emits when the datepicker has been opened.\r\n */\r\n this.openedStream = new EventEmitter();\r\n /**\r\n * Emits when the datepicker has been closed.\r\n */\r\n this.closedStream = new EventEmitter();\r\n this._opened = false;\r\n this._showSpinners = true;\r\n this._showSeconds = false;\r\n this._stepHour = DEFAULT_STEP;\r\n this._stepMinute = DEFAULT_STEP;\r\n this._stepSecond = DEFAULT_STEP;\r\n this._enableMeridian = false;\r\n this._hasBackdrop = true;\r\n /**\r\n * The id for the datepicker calendar.\r\n */\r\n this.id = `mat-datepicker-${datepickerUid++}`;\r\n this._validSelected = null;\r\n /**\r\n * The element that was focused before the datepicker was opened.\r\n */\r\n this._focusedElementBeforeOpen = null;\r\n /**\r\n * Subscription to value changes in the associated input element.\r\n */\r\n this._inputSubscription = Subscription.EMPTY;\r\n /**\r\n * Emits when the datepicker is disabled.\r\n */\r\n this._disabledChange = new Subject();\r\n /**\r\n * Emits new selected date when selected date changes.\r\n */\r\n this._selectedChanged = new Subject();\r\n /**\r\n * The form control validator for the min date.\r\n */\r\n this._minValidator = (/**\r\n * @return {?}\r\n */\r\n () => {\r\n return (!this._minDate || !this._selected ||\r\n this._dateAdapter.compareDateWithTime(this._minDate, this._selected, this.showSeconds) <= 0) ?\r\n null : { 'matDatetimePickerMin': { 'min': this._minDate, 'actual': this._selected } };\r\n });\r\n /**\r\n * The form control validator for the max date.\r\n */\r\n this._maxValidator = (/**\r\n * @return {?}\r\n */\r\n () => {\r\n return (!this._maxDate || !this._selected ||\r\n this._dateAdapter.compareDateWithTime(this._maxDate, this._selected, this.showSeconds) >= 0) ?\r\n null : { 'matDatetimePickerMax': { 'max': this._maxDate, 'actual': this._selected } };\r\n });\r\n if (!this._dateAdapter) {\r\n throw createMissingDateImplError('NgxMatDateAdapter');\r\n }\r\n this._scrollStrategy = scrollStrategy;\r\n }\r\n /**\r\n * The date to open the calendar to initially.\r\n * @return {?}\r\n */\r\n get startAt() {\r\n // If an explicit startAt is set we start there, otherwise we start at whatever the currently\r\n // selected value is.\r\n return this._startAt || (this._datepickerInput ? this._datepickerInput.value : null);\r\n }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set startAt(value) {\r\n this._startAt = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\r\n }\r\n /**\r\n * Color palette to use on the datepicker's calendar.\r\n * @return {?}\r\n */\r\n get color() {\r\n return this._color ||\r\n (this._datepickerInput ? this._datepickerInput._getThemePalette() : 'primary');\r\n }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set color(value) {\r\n this._color = value;\r\n }\r\n /**\r\n * Whether the calendar UI is in touch mode. In touch mode the calendar opens in a dialog rather\r\n * than a popup and elements have more padding to allow for bigger touch targets.\r\n * @return {?}\r\n */\r\n get touchUi() { return this._touchUi; }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set touchUi(value) {\r\n this._touchUi = coerceBooleanProperty(value);\r\n }\r\n /**\r\n * @return {?}\r\n */\r\n get hideTime() { return this._hideTime; }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set hideTime(value) {\r\n this._hideTime = coerceBooleanProperty(value);\r\n }\r\n /**\r\n * Whether the datepicker pop-up should be disabled.\r\n * @return {?}\r\n */\r\n get disabled() {\r\n return this._disabled === undefined && this._datepickerInput ?\r\n this._datepickerInput.disabled : !!this._disabled;\r\n }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set disabled(value) {\r\n /** @type {?} */\r\n const newValue = coerceBooleanProperty(value);\r\n if (newValue !== this._disabled) {\r\n this._disabled = newValue;\r\n this._disabledChange.next(newValue);\r\n }\r\n }\r\n /**\r\n * Whether the calendar is open.\r\n * @return {?}\r\n */\r\n get opened() { return this._opened; }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set opened(value) { value ? this.open() : this.close(); }\r\n /**\r\n * Whether the timepicker'spinners is shown.\r\n * @return {?}\r\n */\r\n get showSpinners() { return this._showSpinners; }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set showSpinners(value) { this._showSpinners = value; }\r\n /**\r\n * Whether the second part is disabled.\r\n * @return {?}\r\n */\r\n get showSeconds() { return this._showSeconds; }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set showSeconds(value) { this._showSeconds = value; }\r\n /**\r\n * Step hour\r\n * @return {?}\r\n */\r\n get stepHour() { return this._stepHour; }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set stepHour(value) { this._stepHour = value; }\r\n /**\r\n * Step minute\r\n * @return {?}\r\n */\r\n get stepMinute() { return this._stepMinute; }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set stepMinute(value) { this._stepMinute = value; }\r\n /**\r\n * Step second\r\n * @return {?}\r\n */\r\n get stepSecond() { return this._stepSecond; }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set stepSecond(value) { this._stepSecond = value; }\r\n /**\r\n * Enable meridian\r\n * @return {?}\r\n */\r\n get enableMeridian() { return this._enableMeridian; }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set enableMeridian(value) { this._enableMeridian = value; }\r\n /**\r\n * disable minute\r\n * @return {?}\r\n */\r\n get disableMinute() { return this._disableMinute; }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set disableMinute(value) { this._disableMinute = value; }\r\n /**\r\n * Step second\r\n * @return {?}\r\n */\r\n get defaultTime() { return this._defaultTime; }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set defaultTime(value) { this._defaultTime = value; }\r\n /**\r\n * The currently selected date.\r\n * @return {?}\r\n */\r\n get _selected() { return this._validSelected; }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set _selected(value) { this._validSelected = value; }\r\n /**\r\n * The minimum selectable date.\r\n * @return {?}\r\n */\r\n get _minDate() {\r\n return this._datepickerInput && this._datepickerInput.min;\r\n }\r\n /**\r\n * The maximum selectable date.\r\n * @return {?}\r\n */\r\n get _maxDate() {\r\n return this._datepickerInput && this._datepickerInput.max;\r\n }\r\n /**\r\n * @return {?}\r\n */\r\n get valid() {\r\n /** @type {?} */\r\n const minValidators = this._minValidator();\r\n /** @type {?} */\r\n const maxValidators = this._maxValidator();\r\n return minValidators == null && maxValidators == null;\r\n }\r\n /**\r\n * @return {?}\r\n */\r\n get _dateFilter() {\r\n return this._datepickerInput && this._datepickerInput._dateFilter;\r\n }\r\n /**\r\n * @return {?}\r\n */\r\n ngOnDestroy() {\r\n this.close();\r\n this._inputSubscription.unsubscribe();\r\n this._disabledChange.complete();\r\n if (this._popupRef) {\r\n this._popupRef.dispose();\r\n this._popupComponentRef = null;\r\n }\r\n }\r\n /**\r\n * Selects the given date\r\n * @param {?} date\r\n * @return {?}\r\n */\r\n select(date) {\r\n this._dateAdapter.copyTime(date, this._selected);\r\n this._selected = date;\r\n }\r\n /**\r\n * Emits the selected year in multiyear view\r\n * @param {?} normalizedYear\r\n * @return {?}\r\n */\r\n _selectYear(normalizedYear) {\r\n this.yearSelected.emit(normalizedYear);\r\n }\r\n /**\r\n * Emits selected month in year view\r\n * @param {?} normalizedMonth\r\n * @return {?}\r\n */\r\n _selectMonth(normalizedMonth) {\r\n this.monthSelected.emit(normalizedMonth);\r\n }\r\n /**\r\n * OK button handler and close\r\n * @return {?}\r\n */\r\n ok() {\r\n /** @type {?} */\r\n const cloned = this._dateAdapter.clone(this._selected);\r\n this._selectedChanged.next(cloned);\r\n this.close();\r\n }\r\n /**\r\n * Cancel and close\r\n * @return {?}\r\n */\r\n cancel() {\r\n this._selected = this._rawValue;\r\n this.close();\r\n }\r\n /**\r\n * Register an input with this datepicker.\r\n * @param {?} input The datepicker input to register with this datepicker.\r\n * @return {?}\r\n */\r\n _registerInput(input) {\r\n if (this._datepickerInput) {\r\n throw Error('A NgxMatDatepicker can only be associated with a single input.');\r\n }\r\n this._datepickerInput = input;\r\n this._inputSubscription =\r\n this._datepickerInput._valueChange.subscribe((/**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n (value) => this._selected = value));\r\n }\r\n /**\r\n * Open the calendar.\r\n * @return {?}\r\n */\r\n open() {\r\n this._rawValue = this._selected != null\r\n ? this._dateAdapter.clone(this._selected) : null;\r\n if (this._selected == null) {\r\n this._selected = this._dateAdapter.today();\r\n if (this.defaultTime != null) {\r\n this._dateAdapter.setTimeByDefaultValues(this._selected, this.defaultTime);\r\n }\r\n }\r\n if (this._opened || this.disabled) {\r\n return;\r\n }\r\n if (!this._datepickerInput) {\r\n throw Error('Attempted to open an NgxMatDatepicker with no associated input.');\r\n }\r\n if (this._document) {\r\n this._focusedElementBeforeOpen = this._document.activeElement;\r\n }\r\n this.touchUi ? this._openAsDialog() : this._openAsPopup();\r\n this._opened = true;\r\n this.openedStream.emit();\r\n }\r\n /**\r\n * Close the calendar.\r\n * @return {?}\r\n */\r\n close() {\r\n if (!this._opened) {\r\n return;\r\n }\r\n if (this._popupRef && this._popupRef.hasAttached()) {\r\n this._popupRef.detach();\r\n }\r\n if (this._dialogRef) {\r\n this._dialogRef.close();\r\n this._dialogRef = null;\r\n }\r\n if (this._calendarPortal && this._calendarPortal.isAttached) {\r\n this._calendarPortal.detach();\r\n }\r\n /** @type {?} */\r\n const completeClose = (/**\r\n * @return {?}\r\n */\r\n () => {\r\n // The `_opened` could've been reset already if\r\n // we got two events in quick succession.\r\n if (this._opened) {\r\n this._opened = false;\r\n this.closedStream.emit();\r\n this._focusedElementBeforeOpen = null;\r\n }\r\n });\r\n if (this._focusedElementBeforeOpen &&\r\n typeof this._focusedElementBeforeOpen.focus === 'function') {\r\n // Because IE moves focus asynchronously, we can't count on it being restored before we've\r\n // marked the datepicker as closed. If the event fires out of sequence and the element that\r\n // we're refocusing opens the datepicker on focus, the user could be stuck with not being\r\n // able to close the calendar at all. We work around it by making the logic, that marks\r\n // the datepicker as closed, async as well.\r\n this._focusedElementBeforeOpen.focus();\r\n setTimeout(completeClose);\r\n }\r\n else {\r\n completeClose();\r\n }\r\n }\r\n /**\r\n * Open the calendar as a dialog.\r\n * @private\r\n * @return {?}\r\n */\r\n _openAsDialog() {\r\n // Usually this would be handled by `open` which ensures that we can only have one overlay\r\n // open at a time, however since we reset the variables in async handlers some overlays\r\n // may slip through if the user opens and closes multiple times in quick succession (e.g.\r\n // by holding down the enter key).\r\n if (this._dialogRef) {\r\n this._dialogRef.close();\r\n }\r\n this._dialogRef = this._dialog.open(NgxMatDatetimeContent, {\r\n direction: this._dir ? this._dir.value : 'ltr',\r\n viewContainerRef: this._viewContainerRef,\r\n panelClass: 'mat-datepicker-dialog',\r\n hasBackdrop: this._hasBackdrop\r\n });\r\n this._dialogRef.afterClosed().subscribe((/**\r\n * @return {?}\r\n */\r\n () => this.close()));\r\n this._dialogRef.componentInstance.datepicker = this;\r\n this._setColor();\r\n }\r\n /**\r\n * Open the calendar as a popup.\r\n * @private\r\n * @return {?}\r\n */\r\n _openAsPopup() {\r\n if (!this._calendarPortal) {\r\n this._calendarPortal = new ComponentPortal(NgxMatDatetimeContent, this._viewContainerRef);\r\n }\r\n if (!this._popupRef) {\r\n this._createPopup();\r\n }\r\n if (!this._popupRef.hasAttached()) {\r\n this._popupComponentRef = this._popupRef.attach(this._calendarPortal);\r\n this._popupComponentRef.instance.datepicker = this;\r\n this._setColor();\r\n // Update the position once the calendar has rendered.\r\n this._ngZone.onStable.asObservable().pipe(take(1)).subscribe((/**\r\n * @return {?}\r\n */\r\n () => {\r\n this._popupRef.updatePosition();\r\n }));\r\n }\r\n }\r\n /**\r\n * Create the popup.\r\n * @private\r\n * @return {?}\r\n */\r\n _createPopup() {\r\n /** @type {?} */\r\n const overlayConfig = new OverlayConfig({\r\n positionStrategy: this._createPopupPositionStrategy(),\r\n hasBackdrop: this._hasBackdrop,\r\n backdropClass: 'mat-overlay-transparent-backdrop',\r\n direction: this._dir,\r\n scrollStrategy: this._scrollStrategy(),\r\n panelClass: 'mat-datepicker-popup',\r\n });\r\n this._popupRef = this._overlay.create(overlayConfig);\r\n this._popupRef.overlayElement.setAttribute('role', 'dialog');\r\n merge(this._popupRef.backdropClick(), this._popupRef.detachments(), this._popupRef.keydownEvents().pipe(filter((/**\r\n * @param {?} event\r\n * @return {?}\r\n */\r\n event => {\r\n // Closing on alt + up is only valid when there's an input associated with the datepicker.\r\n return event.keyCode === ESCAPE ||\r\n (this._datepickerInput && event.altKey && event.keyCode === UP_ARROW);\r\n })))).subscribe((/**\r\n * @param {?} event\r\n * @return {?}\r\n */\r\n event => {\r\n if (event) {\r\n event.preventDefault();\r\n }\r\n (this._hasBackdrop && event) ? this.cancel() : this.close();\r\n }));\r\n }\r\n /**\r\n * Create the popup PositionStrategy.\r\n * @private\r\n * @return {?}\r\n */\r\n _createPopupPositionStrategy() {\r\n return this._overlay.position()\r\n .flexibleConnectedTo(this._datepickerInput.getConnectedOverlayOrigin())\r\n .withTransformOriginOn('.mat-datepicker-content')\r\n .withFlexibleDimensions(false)\r\n .withViewportMargin(8)\r\n .withLockedPosition()\r\n .withPositions([\r\n {\r\n originX: 'start',\r\n originY: 'bottom',\r\n overlayX: 'start',\r\n overlayY: 'top'\r\n },\r\n {\r\n originX: 'start',\r\n originY: 'top',\r\n overlayX: 'start',\r\n overlayY: 'bottom'\r\n },\r\n {\r\n originX: 'end',\r\n originY: 'bottom',\r\n overlayX: 'end',\r\n overlayY: 'top'\r\n },\r\n {\r\n originX: 'end',\r\n originY: 'top',\r\n overlayX: 'end',\r\n overlayY: 'bottom'\r\n }\r\n ]);\r\n }\r\n /**\r\n * @private\r\n * @param {?} obj The object to check.\r\n * @return {?} The given object if it is both a date instance and valid, otherwise null.\r\n */\r\n _getValidDateOrNull(obj) {\r\n return (this._dateAdapter.isDateInstance(obj) && this._dateAdapter.isValid(obj)) ? obj : null;\r\n }\r\n /**\r\n * Passes the current theme color along to the calendar overlay.\r\n * @private\r\n * @return {?}\r\n */\r\n _setColor() {\r\n /** @type {?} */\r\n const color = this.color;\r\n if (this._popupComponentRef) {\r\n this._popupComponentRef.instance.color = color;\r\n }\r\n if (this._dialogRef) {\r\n this._dialogRef.componentInstance.color = color;\r\n }\r\n }\r\n}\nNgxMatDatetimePicker.ɵfac = function NgxMatDatetimePicker_Factory(t) { return new (t || NgxMatDatetimePicker)(ɵngcc0.ɵɵdirectiveInject(ɵngcc10.MatDialog), ɵngcc0.ɵɵdirectiveInject(ɵngcc11.Overlay), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(MAT_DATEPICKER_SCROLL_STRATEGY), ɵngcc0.ɵɵdirectiveInject(NgxMatDateAdapter, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.Directionality, 8), ɵngcc0.ɵɵdirectiveInject(DOCUMENT, 8)); };\nNgxMatDatetimePicker.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: NgxMatDatetimePicker, selectors: [[\"ngx-mat-datetime-picker\"]], inputs: { startView: \"startView\", startAt: \"startAt\", color: \"color\", touchUi: \"touchUi\", hideTime: \"hideTime\", disabled: \"disabled\", opened: \"opened\", showSpinners: \"showSpinners\", showSeconds: \"showSeconds\", stepHour: \"stepHour\", stepMinute: \"stepMinute\", stepSecond: \"stepSecond\", enableMeridian: \"enableMeridian\", disableMinute: \"disableMinute\", defaultTime: \"defaultTime\", calendarHeaderComponent: \"calendarHeaderComponent\", panelClass: \"panelClass\", dateClass: \"dateClass\" }, outputs: { yearSelected: \"yearSelected\", monthSelected: \"monthSelected\", openedStream: \"opened\", closedStream: \"closed\" }, exportAs: [\"ngxMatDatetimePicker\"], decls: 0, vars: 0, template: function NgxMatDatetimePicker_Template(rf, ctx) { }, encapsulation: 2, changeDetection: 0 });\r\n/** @nocollapse */\r\nNgxMatDatetimePicker.ctorParameters = () => [\r\n { type: MatDialog },\r\n { type: Overlay },\r\n { type: NgZone },\r\n { type: ViewContainerRef },\r\n { type: undefined, decorators: [{ type: Inject, args: [MAT_DATEPICKER_SCROLL_STRATEGY,] }] },\r\n { type: NgxMatDateAdapter, decorators: [{ type: Optional }] },\r\n { type: Directionality, decorators: [{ type: Optional }] },\r\n { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] }\r\n];\r\nNgxMatDatetimePicker.propDecorators = {\r\n calendarHeaderComponent: [{ type: Input }],\r\n startAt: [{ type: Input }],\r\n startView: [{ type: Input }],\r\n color: [{ type: Input }],\r\n touchUi: [{ type: Input }],\r\n hideTime: [{ type: Input }],\r\n disabled: [{ type: Input }],\r\n yearSelected: [{ type: Output }],\r\n monthSelected: [{ type: Output }],\r\n panelClass: [{ type: Input }],\r\n dateClass: [{ type: Input }],\r\n openedStream: [{ type: Output, args: ['opened',] }],\r\n closedStream: [{ type: Output, args: ['closed',] }],\r\n opened: [{ type: Input }],\r\n showSpinners: [{ type: Input }],\r\n showSeconds: [{ type: Input }],\r\n stepHour: [{ type: Input }],\r\n stepMinute: [{ type: Input }],\r\n stepSecond: [{ type: Input }],\r\n enableMeridian: [{ type: Input }],\r\n disableMinute: [{ type: Input }],\r\n defaultTime: [{ type: Input }]\r\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(NgxMatDatetimePicker, [{\n type: Component,\n args: [{\n selector: 'ngx-mat-datetime-picker',\n template: '',\n exportAs: 'ngxMatDatetimePicker',\n changeDetection: ChangeDetectionStrategy.OnPush,\n encapsulation: ViewEncapsulation.None\n }]\n }], function () { return [{ type: ɵngcc10.MatDialog }, { type: ɵngcc11.Overlay }, { type: ɵngcc0.NgZone }, { type: ɵngcc0.ViewContainerRef }, { type: undefined, decorators: [{\n type: Inject,\n args: [MAT_DATEPICKER_SCROLL_STRATEGY]\n }] }, { type: NgxMatDateAdapter, decorators: [{\n type: Optional\n }] }, { type: ɵngcc1.Directionality, decorators: [{\n type: Optional\n }] }, { type: undefined, decorators: [{\n type: Optional\n }, {\n type: Inject,\n args: [DOCUMENT]\n }] }]; }, { startView: [{\n type: Input\n }], yearSelected: [{\n type: Output\n }], monthSelected: [{\n type: Output\n }], openedStream: [{\n type: Output,\n args: ['opened']\n }], closedStream: [{\n type: Output,\n args: ['closed']\n }], startAt: [{\n type: Input\n }], color: [{\n type: Input\n }], touchUi: [{\n type: Input\n }], hideTime: [{\n type: Input\n }], disabled: [{\n type: Input\n }], opened: [{\n type: Input\n }], showSpinners: [{\n type: Input\n }], showSeconds: [{\n type: Input\n }], stepHour: [{\n type: Input\n }], stepMinute: [{\n type: Input\n }], stepSecond: [{\n type: Input\n }], enableMeridian: [{\n type: Input\n }], disableMinute: [{\n type: Input\n }], defaultTime: [{\n type: Input\n }], calendarHeaderComponent: [{\n type: Input\n }], panelClass: [{\n type: Input\n }], dateClass: [{\n type: Input\n }] }); })();\n\n/**\r\n * @fileoverview added by tsickle\r\n * Generated from: lib/datetime-input.ts\r\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\r\n */\r\n/**\r\n * \\@docs-private\r\n * @type {?}\r\n */\r\nconst MAT_DATEPICKER_VALUE_ACCESSOR = {\r\n provide: NG_VALUE_ACCESSOR,\r\n useExisting: forwardRef((/**\r\n * @return {?}\r\n */\r\n () => NgxMatDatetimeInput)),\r\n multi: true\r\n};\r\n/**\r\n * \\@docs-private\r\n * @type {?}\r\n */\r\nconst MAT_DATEPICKER_VALIDATORS = {\r\n provide: NG_VALIDATORS,\r\n useExisting: forwardRef((/**\r\n * @return {?}\r\n */\r\n () => NgxMatDatetimeInput)),\r\n multi: true\r\n};\r\n/**\r\n * An event used for datepicker input and change events. We don't always have access to a native\r\n * input or change event because the event may have been triggered by the user clicking on the\r\n * calendar popup. For consistency, we always use MatDatetimePickerInputEvent instead.\r\n * @template D\r\n */\r\nclass MatDatetimePickerInputEvent {\r\n /**\r\n * @param {?} target\r\n * @param {?} targetElement\r\n */\r\n constructor(target, targetElement) {\r\n this.target = target;\r\n this.targetElement = targetElement;\r\n this.value = this.target.value;\r\n }\r\n}\r\n/**\r\n * Directive used to connect an input to a matDatetimePicker.\r\n * @template D\r\n */\r\nclass NgxMatDatetimeInput {\r\n /**\r\n * @param {?} _elementRef\r\n * @param {?} _dateAdapter\r\n * @param {?} _dateFormats\r\n * @param {?} _formField\r\n */\r\n constructor(_elementRef, _dateAdapter, _dateFormats, _formField) {\r\n this._elementRef = _elementRef;\r\n this._dateAdapter = _dateAdapter;\r\n this._dateFormats = _dateFormats;\r\n this._formField = _formField;\r\n /**\r\n * Emits when a `change` event is fired on this ``.\r\n */\r\n this.dateChange = new EventEmitter();\r\n /**\r\n * Emits when an `input` event is fired on this ``.\r\n */\r\n this.dateInput = new EventEmitter();\r\n /**\r\n * Emits when the value changes (either due to user input or programmatic change).\r\n */\r\n this._valueChange = new EventEmitter();\r\n /**\r\n * Emits when the disabled state has changed\r\n */\r\n this._disabledChange = new EventEmitter();\r\n this._onTouched = (/**\r\n * @return {?}\r\n */\r\n () => { });\r\n this._cvaOnChange = (/**\r\n * @return {?}\r\n */\r\n () => { });\r\n this._validatorOnChange = (/**\r\n * @return {?}\r\n */\r\n () => { });\r\n this._datepickerSubscription = Subscription.EMPTY;\r\n this._localeSubscription = Subscription.EMPTY;\r\n /**\r\n * The form control validator for whether the input parses.\r\n */\r\n this._parseValidator = (/**\r\n * @return {?}\r\n */\r\n () => {\r\n return this._lastValueValid ?\r\n null : { 'matDatetimePickerParse': { 'text': this._elementRef.nativeElement.value } };\r\n });\r\n /**\r\n * The form control validator for the min date.\r\n */\r\n this._minValidator = (/**\r\n * @param {?} control\r\n * @return {?}\r\n */\r\n (control) => {\r\n /** @type {?} */\r\n const controlValue = this._getValidDateOrNull(this._dateAdapter.deserialize(control.value));\r\n return (!this.min || !controlValue ||\r\n this._dateAdapter.compareDateWithTime(this.min, controlValue, this._datepicker.showSeconds) <= 0) ?\r\n null : { 'matDatetimePickerMin': { 'min': this.min, 'actual': controlValue } };\r\n });\r\n /**\r\n * The form control validator for the max date.\r\n */\r\n this._maxValidator = (/**\r\n * @param {?} control\r\n * @return {?}\r\n */\r\n (control) => {\r\n /** @type {?} */\r\n const controlValue = this._getValidDateOrNull(this._dateAdapter.deserialize(control.value));\r\n return (!this.max || !controlValue ||\r\n this._dateAdapter.compareDateWithTime(this.max, controlValue, this._datepicker.showSeconds) >= 0) ?\r\n null : { 'matDatetimePickerMax': { 'max': this.max, 'actual': controlValue } };\r\n });\r\n /**\r\n * The form control validator for the date filter.\r\n */\r\n this._filterValidator = (/**\r\n * @param {?} control\r\n * @return {?}\r\n */\r\n (control) => {\r\n /** @type {?} */\r\n const controlValue = this._getValidDateOrNull(this._dateAdapter.deserialize(control.value));\r\n return !this._dateFilter || !controlValue || this._dateFilter(controlValue) ?\r\n null : { 'matDatetimePickerFilter': true };\r\n });\r\n /**\r\n * The combined form control validator for this input.\r\n */\r\n this._validator = Validators.compose([this._parseValidator, this._minValidator, this._maxValidator, this._filterValidator]);\r\n /**\r\n * Whether the last value set on the input was valid.\r\n */\r\n this._lastValueValid = false;\r\n if (!this._dateAdapter) {\r\n throw createMissingDateImplError('NgxMatDateAdapter');\r\n }\r\n if (!this._dateFormats) {\r\n throw createMissingDateImplError('NGX_MAT_DATE_FORMATS');\r\n }\r\n // Update the displayed date when the locale changes.\r\n this._localeSubscription = _dateAdapter.localeChanges.subscribe((/**\r\n * @return {?}\r\n */\r\n () => {\r\n this.value = this.value;\r\n }));\r\n }\r\n /**\r\n * The datepicker that this input is associated with.\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set ngxMatDatetimePicker(value) {\r\n if (!value) {\r\n return;\r\n }\r\n this._datepicker = value;\r\n this._datepicker._registerInput(this);\r\n this._datepickerSubscription.unsubscribe();\r\n this._datepickerSubscription = this._datepicker._selectedChanged.subscribe((/**\r\n * @param {?} selected\r\n * @return {?}\r\n */\r\n (selected) => {\r\n this.value = selected;\r\n this._cvaOnChange(selected);\r\n this._onTouched();\r\n this.dateInput.emit(new MatDatetimePickerInputEvent(this, this._elementRef.nativeElement));\r\n this.dateChange.emit(new MatDatetimePickerInputEvent(this, this._elementRef.nativeElement));\r\n }));\r\n }\r\n /**\r\n * Function that can be used to filter out dates within the datepicker.\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set ngxMatDatetimePickerFilter(value) {\r\n this._dateFilter = value;\r\n this._validatorOnChange();\r\n }\r\n /**\r\n * The value of the input.\r\n * @return {?}\r\n */\r\n get value() { return this._value; }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set value(value) {\r\n value = this._dateAdapter.deserialize(value);\r\n this._lastValueValid = !value || this._dateAdapter.isValid(value);\r\n value = this._getValidDateOrNull(value);\r\n /** @type {?} */\r\n const oldDate = this.value;\r\n this._value = value;\r\n this._formatValue(value);\r\n if (!this._dateAdapter.sameDate(oldDate, value)) {\r\n this._valueChange.emit(value);\r\n }\r\n }\r\n /**\r\n * The minimum valid date.\r\n * @return {?}\r\n */\r\n get min() { return this._min; }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set min(value) {\r\n this._min = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\r\n this._validatorOnChange();\r\n }\r\n /**\r\n * The maximum valid date.\r\n * @return {?}\r\n */\r\n get max() { return this._max; }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set max(value) {\r\n this._max = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\r\n this._validatorOnChange();\r\n }\r\n /**\r\n * Whether the datepicker-input is disabled.\r\n * @return {?}\r\n */\r\n get disabled() { return !!this._disabled; }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n set disabled(value) {\r\n /** @type {?} */\r\n const newValue = value != null && `${value}` !== 'false';\r\n /** @type {?} */\r\n const element = this._elementRef.nativeElement;\r\n if (this._disabled !== newValue) {\r\n this._disabled = newValue;\r\n this._disabledChange.emit(newValue);\r\n }\r\n // We need to null check the `blur` method, because it's undefined during SSR.\r\n if (newValue && element.blur) {\r\n // Normally, native input elements automatically blur if they turn disabled. This behavior\r\n // is problematic, because it would mean that it triggers another change detection cycle,\r\n // which then causes a changed after checked error if the input element was focused before.\r\n element.blur();\r\n }\r\n }\r\n /**\r\n * @return {?}\r\n */\r\n ngOnDestroy() {\r\n this._datepickerSubscription.unsubscribe();\r\n this._localeSubscription.unsubscribe();\r\n this._valueChange.complete();\r\n this._disabledChange.complete();\r\n }\r\n /**\r\n * \\@docs-private\r\n * @param {?} fn\r\n * @return {?}\r\n */\r\n registerOnValidatorChange(fn) {\r\n this._validatorOnChange = fn;\r\n }\r\n /**\r\n * \\@docs-private\r\n * @param {?} c\r\n * @return {?}\r\n */\r\n validate(c) {\r\n return this._validator ? this._validator(c) : null;\r\n }\r\n /**\r\n * @deprecated\r\n * \\@breaking-change 8.0.0 Use `getConnectedOverlayOrigin` instead\r\n * @return {?}\r\n */\r\n getPopupConnectionElementRef() {\r\n return this.getConnectedOverlayOrigin();\r\n }\r\n /**\r\n * Gets the element that the datepicker popup should be connected to.\r\n * @return {?} The element to connect the popup to.\r\n */\r\n getConnectedOverlayOrigin() {\r\n return this._formField ? this._formField.getConnectedOverlayOrigin() : this._elementRef;\r\n }\r\n // Implemented as part of ControlValueAccessor.\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n writeValue(value) {\r\n this.value = value;\r\n }\r\n // Implemented as part of ControlValueAccessor.\r\n /**\r\n * @param {?} fn\r\n * @return {?}\r\n */\r\n registerOnChange(fn) {\r\n this._cvaOnChange = fn;\r\n }\r\n // Implemented as part of ControlValueAccessor.\r\n /**\r\n * @param {?} fn\r\n * @return {?}\r\n */\r\n registerOnTouched(fn) {\r\n this._onTouched = fn;\r\n }\r\n // Implemented as part of ControlValueAccessor.\r\n /**\r\n * @param {?} isDisabled\r\n * @return {?}\r\n */\r\n setDisabledState(isDisabled) {\r\n this.disabled = isDisabled;\r\n }\r\n /**\r\n * @param {?} event\r\n * @return {?}\r\n */\r\n _onKeydown(event) {\r\n /** @type {?} */\r\n const isAltDownArrow = event.altKey && event.keyCode === DOWN_ARROW;\r\n if (this._datepicker && isAltDownArrow && !this._elementRef.nativeElement.readOnly) {\r\n this._datepicker.open();\r\n event.preventDefault();\r\n }\r\n }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n _onInput(value) {\r\n /** @type {?} */\r\n const lastValueWasValid = this._lastValueValid;\r\n /** @type {?} */\r\n let date = this._dateAdapter.parse(value, this._dateFormats.parse.dateInput);\r\n this._lastValueValid = !date || this._dateAdapter.isValid(date);\r\n date = this._getValidDateOrNull(date);\r\n /** @type {?} */\r\n const isSameTime = this._dateAdapter.isSameTime(date, this._value);\r\n if ((date != null && (!isSameTime || !this._dateAdapter.sameDate(date, this._value)))\r\n || (date == null && this._value != null)) {\r\n this._value = date;\r\n this._cvaOnChange(date);\r\n this._valueChange.emit(date);\r\n this.dateInput.emit(new MatDatetimePickerInputEvent(this, this._elementRef.nativeElement));\r\n }\r\n else if (lastValueWasValid !== this._lastValueValid) {\r\n this._validatorOnChange();\r\n }\r\n }\r\n /**\r\n * @return {?}\r\n */\r\n _onChange() {\r\n this.dateChange.emit(new MatDatetimePickerInputEvent(this, this._elementRef.nativeElement));\r\n }\r\n /**\r\n * Returns the palette used by the input's form field, if any.\r\n * @return {?}\r\n */\r\n _getThemePalette() {\r\n return this._formField ? this._formField.color : undefined;\r\n }\r\n /**\r\n * Handles blur events on the input.\r\n * @return {?}\r\n */\r\n _onBlur() {\r\n // Reformat the input only if we have a valid value.\r\n if (this.value) {\r\n this._formatValue(this.value);\r\n }\r\n this._onTouched();\r\n }\r\n /**\r\n * Handles focus events on the input.\r\n * @return {?}\r\n */\r\n _onFocus() {\r\n // Close datetime picker if opened\r\n if (this._datepicker && this._datepicker.opened) {\r\n this._datepicker.cancel();\r\n }\r\n }\r\n /**\r\n * Formats a value and sets it on the input element.\r\n * @private\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n _formatValue(value) {\r\n this._elementRef.nativeElement.value =\r\n value ? this._dateAdapter.format(value, this._dateFormats.display.dateInput) : '';\r\n }\r\n /**\r\n * @private\r\n * @param {?} obj The object to check.\r\n * @return {?} The given object if it is both a date instance and valid, otherwise null.\r\n */\r\n _getValidDateOrNull(obj) {\r\n return (this._dateAdapter.isDateInstance(obj) && this._dateAdapter.isValid(obj)) ? obj : null;\r\n }\r\n}\nNgxMatDatetimeInput.ɵfac = function NgxMatDatetimeInput_Factory(t) { return new (t || NgxMatDatetimeInput)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(NgxMatDateAdapter, 8), ɵngcc0.ɵɵdirectiveInject(NGX_MAT_DATE_FORMATS, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc7.MatFormField, 8)); };\nNgxMatDatetimeInput.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: NgxMatDatetimeInput, selectors: [[\"input\", \"ngxMatDatetimePicker\", \"\"]], hostVars: 5, hostBindings: function NgxMatDatetimeInput_HostBindings(rf, ctx) { if (rf & 1) {\n ɵngcc0.ɵɵlistener(\"input\", function NgxMatDatetimeInput_input_HostBindingHandler($event) { return ctx._onInput($event.target.value); })(\"change\", function NgxMatDatetimeInput_change_HostBindingHandler() { return ctx._onChange(); })(\"blur\", function NgxMatDatetimeInput_blur_HostBindingHandler() { return ctx._onBlur(); })(\"focus\", function NgxMatDatetimeInput_focus_HostBindingHandler() { return ctx._onFocus(); })(\"keydown\", function NgxMatDatetimeInput_keydown_HostBindingHandler($event) { return ctx._onKeydown($event); });\n } if (rf & 2) {\n ɵngcc0.ɵɵhostProperty(\"disabled\", ctx.disabled);\n ɵngcc0.ɵɵattribute(\"aria-haspopup\", ctx._datepicker ? \"dialog\" : null)(\"aria-owns\", (ctx._datepicker == null ? null : ctx._datepicker.opened) && ctx._datepicker.id || null)(\"min\", ctx.min ? ctx._dateAdapter.toIso8601(ctx.min) : null)(\"max\", ctx.max ? ctx._dateAdapter.toIso8601(ctx.max) : null);\n } }, inputs: { value: \"value\", ngxMatDatetimePicker: \"ngxMatDatetimePicker\", ngxMatDatetimePickerFilter: \"ngxMatDatetimePickerFilter\", min: \"min\", max: \"max\", disabled: \"disabled\" }, outputs: { dateChange: \"dateChange\", dateInput: \"dateInput\" }, exportAs: [\"ngxMatDatetimePickerInput\"], features: [ɵngcc0.ɵɵProvidersFeature([\n MAT_DATEPICKER_VALUE_ACCESSOR,\n MAT_DATEPICKER_VALIDATORS,\n { provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: NgxMatDatetimeInput },\n ])] });\r\n/** @nocollapse */\r\nNgxMatDatetimeInput.ctorParameters = () => [\r\n { type: ElementRef },\r\n { type: NgxMatDateAdapter, decorators: [{ type: Optional }] },\r\n { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NGX_MAT_DATE_FORMATS,] }] },\r\n { type: MatFormField, decorators: [{ type: Optional }] }\r\n];\r\nNgxMatDatetimeInput.propDecorators = {\r\n ngxMatDatetimePicker: [{ type: Input }],\r\n ngxMatDatetimePickerFilter: [{ type: Input }],\r\n value: [{ type: Input }],\r\n min: [{ type: Input }],\r\n max: [{ type: Input }],\r\n disabled: [{ type: Input }],\r\n dateChange: [{ type: Output }],\r\n dateInput: [{ type: Output }]\r\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(NgxMatDatetimeInput, [{\n type: Directive,\n args: [{\n selector: 'input[ngxMatDatetimePicker]',\n providers: [\n MAT_DATEPICKER_VALUE_ACCESSOR,\n MAT_DATEPICKER_VALIDATORS,\n { provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: NgxMatDatetimeInput },\n ],\n host: {\n '[attr.aria-haspopup]': '_datepicker ? \"dialog\" : null',\n '[attr.aria-owns]': '(_datepicker?.opened && _datepicker.id) || null',\n '[attr.min]': 'min ? _dateAdapter.toIso8601(min) : null',\n '[attr.max]': 'max ? _dateAdapter.toIso8601(max) : null',\n '[disabled]': 'disabled',\n '(input)': '_onInput($event.target.value)',\n '(change)': '_onChange()',\n '(blur)': '_onBlur()',\n '(focus)': '_onFocus()',\n '(keydown)': '_onKeydown($event)'\n },\n exportAs: 'ngxMatDatetimePickerInput'\n }]\n }], function () { return [{ type: ɵngcc0.ElementRef }, { type: NgxMatDateAdapter, decorators: [{\n type: Optional\n }] }, { type: undefined, decorators: [{\n type: Optional\n }, {\n type: Inject,\n args: [NGX_MAT_DATE_FORMATS]\n }] }, { type: ɵngcc7.MatFormField, decorators: [{\n type: Optional\n }] }]; }, { dateChange: [{\n type: Output\n }], dateInput: [{\n type: Output\n }], value: [{\n type: Input\n }], ngxMatDatetimePicker: [{\n type: Input\n }], ngxMatDatetimePickerFilter: [{\n type: Input\n }], min: [{\n type: Input\n }], max: [{\n type: Input\n }], disabled: [{\n type: Input\n }] }); })();\n\n/**\r\n * @fileoverview added by tsickle\r\n * Generated from: lib/timepicker.module.ts\r\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\r\n */\r\nclass NgxMatTimepickerModule {\r\n}\nNgxMatTimepickerModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: NgxMatTimepickerModule });\nNgxMatTimepickerModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function NgxMatTimepickerModule_Factory(t) { return new (t || NgxMatTimepickerModule)(); }, imports: [[\n CommonModule,\n MatInputModule,\n ReactiveFormsModule,\n FormsModule,\n MatIconModule,\n MatButtonModule,\n ]] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(NgxMatTimepickerModule, { declarations: function () { return [NgxMatTimepickerComponent]; }, imports: function () { return [CommonModule,\n MatInputModule,\n ReactiveFormsModule,\n FormsModule,\n MatIconModule,\n MatButtonModule]; }, exports: function () { return [NgxMatTimepickerComponent]; } }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(NgxMatTimepickerModule, [{\n type: NgModule,\n args: [{\n imports: [\n CommonModule,\n MatInputModule,\n ReactiveFormsModule,\n FormsModule,\n MatIconModule,\n MatButtonModule,\n ],\n exports: [\n NgxMatTimepickerComponent\n ],\n declarations: [\n NgxMatTimepickerComponent\n ]\n }]\n }], null, null); })();\n\n/**\r\n * @fileoverview added by tsickle\r\n * Generated from: lib/datetime-picker.module.ts\r\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\r\n */\r\nclass NgxMatDatetimePickerModule {\r\n}\nNgxMatDatetimePickerModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: NgxMatDatetimePickerModule });\nNgxMatDatetimePickerModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function NgxMatDatetimePickerModule_Factory(t) { return new (t || NgxMatDatetimePickerModule)(); }, providers: [\n MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER\n ], imports: [[\n CommonModule,\n MatDatepickerModule,\n MatDialogModule,\n PortalModule,\n FormsModule,\n MatIconModule,\n MatButtonModule,\n MatInputModule,\n NgxMatTimepickerModule\n ]] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(NgxMatDatetimePickerModule, { declarations: function () { return [NgxMatDatetimePicker,\n NgxMatDatetimeContent,\n NgxMatDatetimeInput,\n NgxMatCalendar,\n NgxMatMonthView,\n NgxMatYearView,\n NgxMatMultiYearView,\n NgxMatCalendarHeader]; }, imports: function () { return [CommonModule,\n MatDatepickerModule,\n MatDialogModule,\n PortalModule,\n FormsModule,\n MatIconModule,\n MatButtonModule,\n MatInputModule,\n NgxMatTimepickerModule]; }, exports: function () { return [NgxMatDatetimePicker,\n NgxMatDatetimeInput,\n NgxMatCalendar,\n NgxMatMonthView,\n NgxMatYearView,\n NgxMatMultiYearView,\n NgxMatCalendarHeader]; } }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(NgxMatDatetimePickerModule, [{\n type: NgModule,\n args: [{\n imports: [\n CommonModule,\n MatDatepickerModule,\n MatDialogModule,\n PortalModule,\n FormsModule,\n MatIconModule,\n MatButtonModule,\n MatInputModule,\n NgxMatTimepickerModule\n ],\n exports: [\n NgxMatDatetimePicker,\n NgxMatDatetimeInput,\n NgxMatCalendar,\n NgxMatMonthView,\n NgxMatYearView,\n NgxMatMultiYearView,\n NgxMatCalendarHeader\n ],\n declarations: [\n NgxMatDatetimePicker,\n NgxMatDatetimeContent,\n NgxMatDatetimeInput,\n NgxMatCalendar,\n NgxMatMonthView,\n NgxMatYearView,\n NgxMatMultiYearView,\n NgxMatCalendarHeader\n ],\n entryComponents: [\n NgxMatDatetimeContent,\n NgxMatCalendarHeader\n ],\n providers: [\n MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER\n ]\n }]\n }], null, null); })();\n\n/**\r\n * @fileoverview added by tsickle\r\n * Generated from: lib/core/native-date-adapter.ts\r\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\r\n */\r\n// TODO(mmalerba): Remove when we no longer support safari 9.\r\n/**\r\n * Whether the browser supports the Intl API.\r\n * @type {?}\r\n */\r\nlet SUPPORTS_INTL_API;\r\n// We need a try/catch around the reference to `Intl`, because accessing it in some cases can\r\n// cause IE to throw. These cases are tied to particular versions of Windows and can happen if\r\n// the consumer is providing a polyfilled `Map`. See:\r\n// https://github.com/Microsoft/ChakraCore/issues/3189\r\n// https://github.com/angular/components/issues/15687\r\ntry {\r\n SUPPORTS_INTL_API = typeof Intl != 'undefined';\r\n}\r\ncatch (_a) {\r\n SUPPORTS_INTL_API = false;\r\n}\r\n/**\r\n * The default month names to use if Intl API is not available.\r\n * @type {?}\r\n */\r\nconst DEFAULT_MONTH_NAMES = {\r\n 'long': [\r\n 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September',\r\n 'October', 'November', 'December'\r\n ],\r\n 'short': ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],\r\n 'narrow': ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D']\r\n};\r\nconst ɵ0 = /**\r\n * @param {?} i\r\n * @return {?}\r\n */\r\ni => String(i + 1);\r\n/**\r\n * The default date names to use if Intl API is not available.\r\n * @type {?}\r\n */\r\nconst DEFAULT_DATE_NAMES = range(31, (ɵ0));\r\n/**\r\n * The default day of the week names to use if Intl API is not available.\r\n * @type {?}\r\n */\r\nconst DEFAULT_DAY_OF_WEEK_NAMES = {\r\n 'long': ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],\r\n 'short': ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],\r\n 'narrow': ['S', 'M', 'T', 'W', 'T', 'F', 'S']\r\n};\r\n/**\r\n * Matches strings that have the form of a valid RFC 3339 string\r\n * (https://tools.ietf.org/html/rfc3339). Note that the string may not actually be a valid date\r\n * because the regex will match strings an with out of bounds month, date, etc.\r\n * @type {?}\r\n */\r\nconst ISO_8601_REGEX = /^\\d{4}-\\d{2}-\\d{2}(?:T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|(?:(?:\\+|-)\\d{2}:\\d{2}))?)?$/;\r\n/**\r\n * Creates an array and fills it with values.\r\n * @template T\r\n * @param {?} length\r\n * @param {?} valueFunction\r\n * @return {?}\r\n */\r\nfunction range(length, valueFunction) {\r\n /** @type {?} */\r\n const valuesArray = Array(length);\r\n for (let i = 0; i < length; i++) {\r\n valuesArray[i] = valueFunction(i);\r\n }\r\n return valuesArray;\r\n}\r\n/**\r\n * Adapts the native JS Date for use with cdk-based components that work with dates.\r\n */\r\nclass NgxMatNativeDateAdapter extends NgxMatDateAdapter {\r\n /**\r\n * @param {?} matDateLocale\r\n * @param {?} platform\r\n */\r\n constructor(matDateLocale, platform) {\r\n super();\r\n /**\r\n * Whether to use `timeZone: 'utc'` with `Intl.DateTimeFormat` when formatting dates.\r\n * Without this `Intl.DateTimeFormat` sometimes chooses the wrong timeZone, which can throw off\r\n * the result. (e.g. in the en-US locale `new Date(1800, 7, 14).toLocaleDateString()`\r\n * will produce `'8/13/1800'`.\r\n *\r\n * TODO(mmalerba): drop this variable. It's not being used in the code right now. We're now\r\n * getting the string representation of a Date object from its utc representation. We're keeping\r\n * it here for sometime, just for precaution, in case we decide to revert some of these changes\r\n * though.\r\n */\r\n this.useUtcForDisplay = true;\r\n super.setLocale(matDateLocale);\r\n // IE does its own time zone correction, so we disable this on IE.\r\n this.useUtcForDisplay = !platform.TRIDENT;\r\n this._clampDate = platform.TRIDENT || platform.EDGE;\r\n }\r\n /**\r\n * @param {?} date\r\n * @return {?}\r\n */\r\n getYear(date) {\r\n return date.getFullYear();\r\n }\r\n /**\r\n * @param {?} date\r\n * @return {?}\r\n */\r\n getMonth(date) {\r\n return date.getMonth();\r\n }\r\n /**\r\n * @param {?} date\r\n * @return {?}\r\n */\r\n getDate(date) {\r\n return date.getDate();\r\n }\r\n /**\r\n * @param {?} date\r\n * @return {?}\r\n */\r\n getDayOfWeek(date) {\r\n return date.getDay();\r\n }\r\n /**\r\n * @param {?} style\r\n * @return {?}\r\n */\r\n getMonthNames(style) {\r\n if (SUPPORTS_INTL_API) {\r\n /** @type {?} */\r\n const dtf = new Intl.DateTimeFormat(this.locale, { month: style, timeZone: 'utc' });\r\n return range(12, (/**\r\n * @param {?} i\r\n * @return {?}\r\n */\r\n i => this._stripDirectionalityCharacters(this._format(dtf, new Date(2017, i, 1)))));\r\n }\r\n return DEFAULT_MONTH_NAMES[style];\r\n }\r\n /**\r\n * @return {?}\r\n */\r\n getDateNames() {\r\n if (SUPPORTS_INTL_API) {\r\n /** @type {?} */\r\n const dtf = new Intl.DateTimeFormat(this.locale, { day: 'numeric', timeZone: 'utc' });\r\n return range(31, (/**\r\n * @param {?} i\r\n * @return {?}\r\n */\r\n i => this._stripDirectionalityCharacters(this._format(dtf, new Date(2017, 0, i + 1)))));\r\n }\r\n return DEFAULT_DATE_NAMES;\r\n }\r\n /**\r\n * @param {?} style\r\n * @return {?}\r\n */\r\n getDayOfWeekNames(style) {\r\n if (SUPPORTS_INTL_API) {\r\n /** @type {?} */\r\n const dtf = new Intl.DateTimeFormat(this.locale, { weekday: style, timeZone: 'utc' });\r\n return range(7, (/**\r\n * @param {?} i\r\n * @return {?}\r\n */\r\n i => this._stripDirectionalityCharacters(this._format(dtf, new Date(2017, 0, i + 1)))));\r\n }\r\n return DEFAULT_DAY_OF_WEEK_NAMES[style];\r\n }\r\n /**\r\n * @param {?} date\r\n * @return {?}\r\n */\r\n getYearName(date) {\r\n if (SUPPORTS_INTL_API) {\r\n /** @type {?} */\r\n const dtf = new Intl.DateTimeFormat(this.locale, { year: 'numeric', timeZone: 'utc' });\r\n return this._stripDirectionalityCharacters(this._format(dtf, date));\r\n }\r\n return String(this.getYear(date));\r\n }\r\n /**\r\n * @return {?}\r\n */\r\n getFirstDayOfWeek() {\r\n // We can't tell using native JS Date what the first day of the week is, we default to Sunday.\r\n return 0;\r\n }\r\n /**\r\n * @param {?} date\r\n * @return {?}\r\n */\r\n getNumDaysInMonth(date) {\r\n return this.getDate(this._createDateWithOverflow(this.getYear(date), this.getMonth(date) + 1, 0));\r\n }\r\n /**\r\n * @param {?} date\r\n * @return {?}\r\n */\r\n clone(date) {\r\n return new Date(date.getTime());\r\n }\r\n /**\r\n * @param {?} year\r\n * @param {?} month\r\n * @param {?} date\r\n * @return {?}\r\n */\r\n createDate(year, month, date) {\r\n // Check for invalid month and date (except upper bound on date which we have to check after\r\n // creating the Date).\r\n if (month < 0 || month > 11) {\r\n throw Error(`Invalid month index \"${month}\". Month index has to be between 0 and 11.`);\r\n }\r\n if (date < 1) {\r\n throw Error(`Invalid date \"${date}\". Date has to be greater than 0.`);\r\n }\r\n /** @type {?} */\r\n let result = this._createDateWithOverflow(year, month, date);\r\n // Check that the date wasn't above the upper bound for the month, causing the month to overflow\r\n if (result.getMonth() != month) {\r\n throw Error(`Invalid date \"${date}\" for month with index \"${month}\".`);\r\n }\r\n return result;\r\n }\r\n /**\r\n * @return {?}\r\n */\r\n today() {\r\n return new Date();\r\n }\r\n /**\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n parse(value) {\r\n // We have no way using the native JS Date to set the parse format or locale, so we ignore these\r\n // parameters.\r\n if (typeof value == 'number') {\r\n return new Date(value);\r\n }\r\n return value ? new Date(Date.parse(value)) : null;\r\n }\r\n /**\r\n * @param {?} date\r\n * @param {?} displayFormat\r\n * @return {?}\r\n */\r\n format(date, displayFormat) {\r\n if (!this.isValid(date)) {\r\n throw Error('NativeDateAdapter: Cannot format invalid date.');\r\n }\r\n if (SUPPORTS_INTL_API) {\r\n // On IE and Edge the i18n API will throw a hard error that can crash the entire app\r\n // if we attempt to format a date whose year is less than 1 or greater than 9999.\r\n if (this._clampDate && (date.getFullYear() < 1 || date.getFullYear() > 9999)) {\r\n date = this.clone(date);\r\n date.setFullYear(Math.max(1, Math.min(9999, date.getFullYear())));\r\n }\r\n displayFormat = Object.assign({}, displayFormat, { timeZone: 'utc' });\r\n /** @type {?} */\r\n const dtf = new Intl.DateTimeFormat(this.locale, displayFormat);\r\n return this._stripDirectionalityCharacters(this._format(dtf, date));\r\n }\r\n return this._stripDirectionalityCharacters(date.toDateString());\r\n }\r\n /**\r\n * @param {?} date\r\n * @param {?} years\r\n * @return {?}\r\n */\r\n addCalendarYears(date, years) {\r\n return this.addCalendarMonths(date, years * 12);\r\n }\r\n /**\r\n * @param {?} date\r\n * @param {?} months\r\n * @return {?}\r\n */\r\n addCalendarMonths(date, months) {\r\n /** @type {?} */\r\n let newDate = this._createDateWithOverflow(this.getYear(date), this.getMonth(date) + months, this.getDate(date));\r\n // It's possible to wind up in the wrong month if the original month has more days than the new\r\n // month. In this case we want to go to the last day of the desired month.\r\n // Note: the additional + 12 % 12 ensures we end up with a positive number, since JS % doesn't\r\n // guarantee this.\r\n if (this.getMonth(newDate) != ((this.getMonth(date) + months) % 12 + 12) % 12) {\r\n newDate = this._createDateWithOverflow(this.getYear(newDate), this.getMonth(newDate), 0);\r\n }\r\n return newDate;\r\n }\r\n /**\r\n * @param {?} date\r\n * @param {?} days\r\n * @return {?}\r\n */\r\n addCalendarDays(date, days) {\r\n return this._createDateWithOverflow(this.getYear(date), this.getMonth(date), this.getDate(date) + days);\r\n }\r\n /**\r\n * @param {?} date\r\n * @return {?}\r\n */\r\n toIso8601(date) {\r\n return [\r\n date.getUTCFullYear(),\r\n this._2digit(date.getUTCMonth() + 1),\r\n this._2digit(date.getUTCDate())\r\n ].join('-');\r\n }\r\n /**\r\n * Returns the given value if given a valid Date or null. Deserializes valid ISO 8601 strings\r\n * (https://www.ietf.org/rfc/rfc3339.txt) into valid Dates and empty string into null. Returns an\r\n * invalid date for all other values.\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n deserialize(value) {\r\n if (typeof value === 'string') {\r\n if (!value) {\r\n return null;\r\n }\r\n // The `Date` constructor accepts formats other than ISO 8601, so we need to make sure the\r\n // string is the right format first.\r\n if (ISO_8601_REGEX.test(value)) {\r\n /** @type {?} */\r\n let date = new Date(value);\r\n if (this.isValid(date)) {\r\n return date;\r\n }\r\n }\r\n }\r\n return super.deserialize(value);\r\n }\r\n /**\r\n * @param {?} obj\r\n * @return {?}\r\n */\r\n isDateInstance(obj) {\r\n return obj instanceof Date;\r\n }\r\n /**\r\n * @param {?} date\r\n * @return {?}\r\n */\r\n isValid(date) {\r\n return !isNaN(date.getTime());\r\n }\r\n /**\r\n * @return {?}\r\n */\r\n invalid() {\r\n return new Date(NaN);\r\n }\r\n /**\r\n * @param {?} date\r\n * @return {?}\r\n */\r\n getHour(date) {\r\n return date.getHours();\r\n }\r\n /**\r\n * @param {?} date\r\n * @return {?}\r\n */\r\n getMinute(date) {\r\n return date.getMinutes();\r\n }\r\n /**\r\n * @param {?} date\r\n * @return {?}\r\n */\r\n getSecond(date) {\r\n return date.getSeconds();\r\n }\r\n /**\r\n * @param {?} date\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n setHour(date, value) {\r\n date.setHours(value);\r\n }\r\n /**\r\n * @param {?} date\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n setMinute(date, value) {\r\n date.setMinutes(value);\r\n }\r\n /**\r\n * @param {?} date\r\n * @param {?} value\r\n * @return {?}\r\n */\r\n setSecond(date, value) {\r\n date.setSeconds(value);\r\n }\r\n /**\r\n * Creates a date but allows the month and date to overflow.\r\n * @private\r\n * @param {?} year\r\n * @param {?} month\r\n * @param {?} date\r\n * @return {?}\r\n */\r\n _createDateWithOverflow(year, month, date) {\r\n /** @type {?} */\r\n const result = new Date(year, month, date);\r\n // We need to correct for the fact that JS native Date treats years in range [0, 99] as\r\n // abbreviations for 19xx.\r\n if (year >= 0 && year < 100) {\r\n result.setFullYear(this.getYear(result) - 1900);\r\n }\r\n return result;\r\n }\r\n /**\r\n * Pads a number to make it two digits.\r\n * @private\r\n * @param {?} n The number to pad.\r\n * @return {?} The padded number.\r\n */\r\n _2digit(n) {\r\n return ('00' + n).slice(-2);\r\n }\r\n /**\r\n * Strip out unicode LTR and RTL characters. Edge and IE insert these into formatted dates while\r\n * other browsers do not. We remove them to make output consistent and because they interfere with\r\n * date parsing.\r\n * @private\r\n * @param {?} str The string to strip direction characters from.\r\n * @return {?} The stripped string.\r\n */\r\n _stripDirectionalityCharacters(str) {\r\n return str.replace(/[\\u200e\\u200f]/g, '');\r\n }\r\n /**\r\n * When converting Date object to string, javascript built-in functions may return wrong\r\n * results because it applies its internal DST rules. The DST rules around the world change\r\n * very frequently, and the current valid rule is not always valid in previous years though.\r\n * We work around this problem building a new Date object which has its internal UTC\r\n * representation with the local date and time.\r\n * @private\r\n * @param {?} dtf Intl.DateTimeFormat object, containg the desired string format. It must have\r\n * timeZone set to 'utc' to work fine.\r\n * @param {?} date Date from which we want to get the string representation according to dtf\r\n * @return {?} A Date object with its UTC representation based on the passed in date info\r\n */\r\n _format(dtf, date) {\r\n /** @type {?} */\r\n const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));\r\n return dtf.format(d);\r\n }\r\n}\nNgxMatNativeDateAdapter.ɵfac = function NgxMatNativeDateAdapter_Factory(t) { return new (t || NgxMatNativeDateAdapter)(ɵngcc0.ɵɵinject(MAT_DATE_LOCALE, 8), ɵngcc0.ɵɵinject(ɵngcc12.Platform)); };\nNgxMatNativeDateAdapter.ɵprov = ɵngcc0.ɵɵdefineInjectable({ token: NgxMatNativeDateAdapter, factory: NgxMatNativeDateAdapter.ɵfac });\r\n/** @nocollapse */\r\nNgxMatNativeDateAdapter.ctorParameters = () => [\r\n { type: String, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_LOCALE,] }] },\r\n { type: Platform }\r\n];\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(NgxMatNativeDateAdapter, [{\n type: Injectable\n }], function () { return [{ type: String, decorators: [{\n type: Optional\n }, {\n type: Inject,\n args: [MAT_DATE_LOCALE]\n }] }, { type: ɵngcc12.Platform }]; }, null); })();\n\n/**\r\n * @fileoverview added by tsickle\r\n * Generated from: lib/core/native-date-formats.ts\r\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\r\n */\r\n/**\r\n * @license\r\n * Copyright Google LLC All Rights Reserved.\r\n *\r\n * Use of this source code is governed by an MIT-style license that can be\r\n * found in the LICENSE file at https://angular.io/license\r\n * @type {?}\r\n */\r\nconst DEFAULT_DATE_INPUT = {\r\n year: 'numeric', month: 'numeric', day: 'numeric',\r\n hour12: false, hour: \"2-digit\", minute: \"2-digit\", second: \"2-digit\"\r\n};\r\n/** @type {?} */\r\nconst NGX_MAT_NATIVE_DATE_FORMATS = {\r\n parse: {\r\n dateInput: DEFAULT_DATE_INPUT,\r\n },\r\n display: {\r\n dateInput: DEFAULT_DATE_INPUT,\r\n monthYearLabel: { year: 'numeric', month: 'short' },\r\n dateA11yLabel: { year: 'numeric', month: 'long', day: 'numeric' },\r\n monthYearA11yLabel: { year: 'numeric', month: 'long' },\r\n }\r\n};\n\n/**\r\n * @fileoverview added by tsickle\r\n * Generated from: lib/core/native-date.module.ts\r\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\r\n */\r\nclass NgxNativeDateModule {\r\n}\nNgxNativeDateModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: NgxNativeDateModule });\nNgxNativeDateModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function NgxNativeDateModule_Factory(t) { return new (t || NgxNativeDateModule)(); }, providers: [\n { provide: NgxMatDateAdapter, useClass: NgxMatNativeDateAdapter },\n ], imports: [[PlatformModule]] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(NgxNativeDateModule, { imports: function () { return [PlatformModule]; } }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(NgxNativeDateModule, [{\n type: NgModule,\n args: [{\n imports: [PlatformModule],\n providers: [\n { provide: NgxMatDateAdapter, useClass: NgxMatNativeDateAdapter },\n ]\n }]\n }], null, null); })();\r\nconst ɵ0$1 = NGX_MAT_NATIVE_DATE_FORMATS;\r\nclass NgxMatNativeDateModule {\r\n}\nNgxMatNativeDateModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: NgxMatNativeDateModule });\nNgxMatNativeDateModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function NgxMatNativeDateModule_Factory(t) { return new (t || NgxMatNativeDateModule)(); }, providers: [{ provide: NGX_MAT_DATE_FORMATS, useValue: ɵ0$1 }], imports: [[NgxNativeDateModule]] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(NgxMatNativeDateModule, { imports: [NgxNativeDateModule] }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(NgxMatNativeDateModule, [{\n type: NgModule,\n args: [{\n imports: [NgxNativeDateModule],\n providers: [{ provide: NGX_MAT_DATE_FORMATS, useValue: ɵ0$1 }]\n }]\n }], null, null); })();\n\n/**\r\n * @fileoverview added by tsickle\r\n * Generated from: public-api.ts\r\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\r\n */\n\n/**\r\n * @fileoverview added by tsickle\r\n * Generated from: angular-material-components-datetime-picker.ts\r\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\r\n */\n\nexport { NgxMatDatetimeContent, NgxMatDatetimePicker, MAT_DATEPICKER_VALUE_ACCESSOR, MAT_DATEPICKER_VALIDATORS, MatDatetimePickerInputEvent, NgxMatDatetimeInput, NgxMatDatetimePickerModule, NgxMatTimepickerComponent, NgxMatTimepickerModule, NgxMatDateAdapter, NgxMatNativeDateAdapter, NGX_MAT_NATIVE_DATE_FORMATS, NGX_MAT_DATE_FORMATS, NgxNativeDateModule, NgxMatNativeDateModule, NgxMatCalendar as ɵb, NgxMatCalendarHeader as ɵa, NgxMatMonthView as ɵc, NgxMatMultiYearView as ɵe, NgxMatYearView as ɵd };\n\n//# sourceMappingURL=angular-material-components-datetime-picker.js.map","/**\n * @license Angular v9.1.13\n * (c) 2010-2020 Google LLC. https://angular.io/\n * License: MIT\n */\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/src/animation_builder.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * An injectable service that produces an animation sequence programmatically within an\n * Angular component or directive.\n * Provided by the `BrowserAnimationsModule` or `NoopAnimationsModule`.\n *\n * \\@usageNotes\n *\n * To use this service, add it to your component or directive as a dependency.\n * The service is instantiated along with your component.\n *\n * Apps do not typically need to create their own animation players, but if you\n * do need to, follow these steps:\n *\n * 1. Use the `build()` method to create a programmatic animation using the\n * `animate()` function. The method returns an `AnimationFactory` instance.\n *\n * 2. Use the factory object to create an `AnimationPlayer` and attach it to a DOM element.\n *\n * 3. Use the player object to control the animation programmatically.\n *\n * For example:\n *\n * ```ts\n * // import the service from BrowserAnimationsModule\n * import {AnimationBuilder} from '\\@angular/animations';\n * // require the service as a dependency\n * class MyCmp {\n * constructor(private _builder: AnimationBuilder) {}\n *\n * makeAnimation(element: any) {\n * // first define a reusable animation\n * const myAnimation = this._builder.build([\n * style({ width: 0 }),\n * animate(1000, style({ width: '100px' }))\n * ]);\n *\n * // use the returned factory object to create a player\n * const player = myAnimation.create(element);\n *\n * player.play();\n * }\n * }\n * ```\n *\n * \\@publicApi\n * @abstract\n */\nclass AnimationBuilder {\n}\nif (false) {\n /**\n * Builds a factory for producing a defined animation.\n * @see `animate()`\n * @abstract\n * @param {?} animation A reusable animation definition.\n * @return {?} A factory object that can create a player for the defined animation.\n */\n AnimationBuilder.prototype.build = function (animation) { };\n}\n/**\n * A factory object returned from the `AnimationBuilder`.`build()` method.\n *\n * \\@publicApi\n * @abstract\n */\nclass AnimationFactory {\n}\nif (false) {\n /**\n * Creates an `AnimationPlayer` instance for the reusable animation defined by\n * the `AnimationBuilder`.`build()` method that created this factory.\n * Attaches the new player a DOM element.\n * @abstract\n * @param {?} element The DOM element to which to attach the animation.\n * @param {?=} options A set of options that can include a time delay and\n * additional developer-defined parameters.\n * @return {?}\n */\n AnimationFactory.prototype.create = function (element, options) { };\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/src/animation_metadata.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. 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 * Represents a set of CSS styles for use in an animation style.\n * @record\n */\nfunction ɵStyleData() { }\n/** @enum {number} */\nconst AnimationMetadataType = {\n /**\n * Associates a named animation state with a set of CSS styles.\n * See `state()`\n */\n State: 0,\n /**\n * Data for a transition from one animation state to another.\n * See `transition()`\n */\n Transition: 1,\n /**\n * Contains a set of animation steps.\n * See `sequence()`\n */\n Sequence: 2,\n /**\n * Contains a set of animation steps.\n * See `{@link animations/group group()}`\n */\n Group: 3,\n /**\n * Contains an animation step.\n * See `animate()`\n */\n Animate: 4,\n /**\n * Contains a set of animation steps.\n * See `keyframes()`\n */\n Keyframes: 5,\n /**\n * Contains a set of CSS property-value pairs into a named style.\n * See `style()`\n */\n Style: 6,\n /**\n * Associates an animation with an entry trigger that can be attached to an element.\n * See `trigger()`\n */\n Trigger: 7,\n /**\n * Contains a re-usable animation.\n * See `animation()`\n */\n Reference: 8,\n /**\n * Contains data to use in executing child animations returned by a query.\n * See `animateChild()`\n */\n AnimateChild: 9,\n /**\n * Contains animation parameters for a re-usable animation.\n * See `useAnimation()`\n */\n AnimateRef: 10,\n /**\n * Contains child-animation query data.\n * See `query()`\n */\n Query: 11,\n /**\n * Contains data for staggering an animation sequence.\n * See `stagger()`\n */\n Stagger: 12,\n};\n/**\n * Specifies automatic styling.\n *\n * \\@publicApi\n * @type {?}\n */\nconst AUTO_STYLE = '*';\n/**\n * Base for animation data structures.\n *\n * \\@publicApi\n * @record\n */\nfunction AnimationMetadata() { }\nif (false) {\n /** @type {?} */\n AnimationMetadata.prototype.type;\n}\n/**\n * Contains an animation trigger. Instantiated and returned by the\n * `trigger()` function.\n *\n * \\@publicApi\n * @record\n */\nfunction AnimationTriggerMetadata() { }\nif (false) {\n /**\n * The trigger name, used to associate it with an element. Unique within the component.\n * @type {?}\n */\n AnimationTriggerMetadata.prototype.name;\n /**\n * An animation definition object, containing an array of state and transition declarations.\n * @type {?}\n */\n AnimationTriggerMetadata.prototype.definitions;\n /**\n * An options object containing a delay and\n * developer-defined parameters that provide styling defaults and\n * can be overridden on invocation. Default delay is 0.\n * @type {?}\n */\n AnimationTriggerMetadata.prototype.options;\n}\n/**\n * Encapsulates an animation state by associating a state name with a set of CSS styles.\n * Instantiated and returned by the `state()` function.\n *\n * \\@publicApi\n * @record\n */\nfunction AnimationStateMetadata() { }\nif (false) {\n /**\n * The state name, unique within the component.\n * @type {?}\n */\n AnimationStateMetadata.prototype.name;\n /**\n * The CSS styles associated with this state.\n * @type {?}\n */\n AnimationStateMetadata.prototype.styles;\n /**\n * An options object containing\n * developer-defined parameters that provide styling defaults and\n * can be overridden on invocation.\n * @type {?|undefined}\n */\n AnimationStateMetadata.prototype.options;\n}\n/**\n * Encapsulates an animation transition. Instantiated and returned by the\n * `transition()` function.\n *\n * \\@publicApi\n * @record\n */\nfunction AnimationTransitionMetadata() { }\nif (false) {\n /**\n * An expression that describes a state change.\n * @type {?}\n */\n AnimationTransitionMetadata.prototype.expr;\n /**\n * One or more animation objects to which this transition applies.\n * @type {?}\n */\n AnimationTransitionMetadata.prototype.animation;\n /**\n * An options object containing a delay and\n * developer-defined parameters that provide styling defaults and\n * can be overridden on invocation. Default delay is 0.\n * @type {?}\n */\n AnimationTransitionMetadata.prototype.options;\n}\n/**\n * Encapsulates a reusable animation, which is a collection of individual animation steps.\n * Instantiated and returned by the `animation()` function, and\n * passed to the `useAnimation()` function.\n *\n * \\@publicApi\n * @record\n */\nfunction AnimationReferenceMetadata() { }\nif (false) {\n /**\n * One or more animation step objects.\n * @type {?}\n */\n AnimationReferenceMetadata.prototype.animation;\n /**\n * An options object containing a delay and\n * developer-defined parameters that provide styling defaults and\n * can be overridden on invocation. Default delay is 0.\n * @type {?}\n */\n AnimationReferenceMetadata.prototype.options;\n}\n/**\n * Encapsulates an animation query. Instantiated and returned by\n * the `query()` function.\n *\n * \\@publicApi\n * @record\n */\nfunction AnimationQueryMetadata() { }\nif (false) {\n /**\n * The CSS selector for this query.\n * @type {?}\n */\n AnimationQueryMetadata.prototype.selector;\n /**\n * One or more animation step objects.\n * @type {?}\n */\n AnimationQueryMetadata.prototype.animation;\n /**\n * A query options object.\n * @type {?}\n */\n AnimationQueryMetadata.prototype.options;\n}\n/**\n * Encapsulates a keyframes sequence. Instantiated and returned by\n * the `keyframes()` function.\n *\n * \\@publicApi\n * @record\n */\nfunction AnimationKeyframesSequenceMetadata() { }\nif (false) {\n /**\n * An array of animation styles.\n * @type {?}\n */\n AnimationKeyframesSequenceMetadata.prototype.steps;\n}\n/**\n * Encapsulates an animation style. Instantiated and returned by\n * the `style()` function.\n *\n * \\@publicApi\n * @record\n */\nfunction AnimationStyleMetadata() { }\nif (false) {\n /**\n * A set of CSS style properties.\n * @type {?}\n */\n AnimationStyleMetadata.prototype.styles;\n /**\n * A percentage of the total animate time at which the style is to be applied.\n * @type {?}\n */\n AnimationStyleMetadata.prototype.offset;\n}\n/**\n * Encapsulates an animation step. Instantiated and returned by\n * the `animate()` function.\n *\n * \\@publicApi\n * @record\n */\nfunction AnimationAnimateMetadata() { }\nif (false) {\n /**\n * The timing data for the step.\n * @type {?}\n */\n AnimationAnimateMetadata.prototype.timings;\n /**\n * A set of styles used in the step.\n * @type {?}\n */\n AnimationAnimateMetadata.prototype.styles;\n}\n/**\n * Encapsulates a child animation, that can be run explicitly when the parent is run.\n * Instantiated and returned by the `animateChild` function.\n *\n * \\@publicApi\n * @record\n */\nfunction AnimationAnimateChildMetadata() { }\nif (false) {\n /**\n * An options object containing a delay and\n * developer-defined parameters that provide styling defaults and\n * can be overridden on invocation. Default delay is 0.\n * @type {?}\n */\n AnimationAnimateChildMetadata.prototype.options;\n}\n/**\n * Encapsulates a reusable animation.\n * Instantiated and returned by the `useAnimation()` function.\n *\n * \\@publicApi\n * @record\n */\nfunction AnimationAnimateRefMetadata() { }\nif (false) {\n /**\n * An animation reference object.\n * @type {?}\n */\n AnimationAnimateRefMetadata.prototype.animation;\n /**\n * An options object containing a delay and\n * developer-defined parameters that provide styling defaults and\n * can be overridden on invocation. Default delay is 0.\n * @type {?}\n */\n AnimationAnimateRefMetadata.prototype.options;\n}\n/**\n * Encapsulates an animation sequence.\n * Instantiated and returned by the `sequence()` function.\n *\n * \\@publicApi\n * @record\n */\nfunction AnimationSequenceMetadata() { }\nif (false) {\n /**\n * An array of animation step objects.\n * @type {?}\n */\n AnimationSequenceMetadata.prototype.steps;\n /**\n * An options object containing a delay and\n * developer-defined parameters that provide styling defaults and\n * can be overridden on invocation. Default delay is 0.\n * @type {?}\n */\n AnimationSequenceMetadata.prototype.options;\n}\n/**\n * Encapsulates an animation group.\n * Instantiated and returned by the `{\\@link animations/group group()}` function.\n *\n * \\@publicApi\n * @record\n */\nfunction AnimationGroupMetadata() { }\nif (false) {\n /**\n * One or more animation or style steps that form this group.\n * @type {?}\n */\n AnimationGroupMetadata.prototype.steps;\n /**\n * An options object containing a delay and\n * developer-defined parameters that provide styling defaults and\n * can be overridden on invocation. Default delay is 0.\n * @type {?}\n */\n AnimationGroupMetadata.prototype.options;\n}\n/**\n * Encapsulates parameters for staggering the start times of a set of animation steps.\n * Instantiated and returned by the `stagger()` function.\n *\n * \\@publicApi\n *\n * @record\n */\nfunction AnimationStaggerMetadata() { }\nif (false) {\n /**\n * The timing data for the steps.\n * @type {?}\n */\n AnimationStaggerMetadata.prototype.timings;\n /**\n * One or more animation steps.\n * @type {?}\n */\n AnimationStaggerMetadata.prototype.animation;\n}\n/**\n * Creates a named animation trigger, containing a list of `state()`\n * and `transition()` entries to be evaluated when the expression\n * bound to the trigger changes.\n *\n * \\@usageNotes\n * Define an animation trigger in the `animations` section of `\\@Component` metadata.\n * In the template, reference the trigger by name and bind it to a trigger expression that\n * evaluates to a defined animation state, using the following format:\n *\n * `[\\@triggerName]=\"expression\"`\n *\n * Animation trigger bindings convert all values to strings, and then match the\n * previous and current values against any linked transitions.\n * Booleans can be specified as `1` or `true` and `0` or `false`.\n *\n * ### Usage Example\n *\n * The following example creates an animation trigger reference based on the provided\n * name value.\n * The provided animation value is expected to be an array consisting of state and\n * transition declarations.\n *\n * ```typescript\n * \\@Component({\n * selector: \"my-component\",\n * templateUrl: \"my-component-tpl.html\",\n * animations: [\n * trigger(\"myAnimationTrigger\", [\n * state(...),\n * state(...),\n * transition(...),\n * transition(...)\n * ])\n * ]\n * })\n * class MyComponent {\n * myStatusExp = \"something\";\n * }\n * ```\n *\n * The template associated with this component makes use of the defined trigger\n * by binding to an element within its template code.\n *\n * ```html\n * \n *
...
\n * ```\n *\n * ### Using an inline function\n * The `transition` animation method also supports reading an inline function which can decide\n * if its associated animation should be run.\n *\n * ```typescript\n * // this method is run each time the `myAnimationTrigger` trigger value changes.\n * function myInlineMatcherFn(fromState: string, toState: string, element: any, params: {[key:\n * string]: any}): boolean {\n * // notice that `element` and `params` are also available here\n * return toState == 'yes-please-animate';\n * }\n * /\n * selector: 'my-component',\n * templateUrl: 'my-component-tpl.html',\n * animations: [\n * trigger('myAnimationTrigger', [\n * transition(myInlineMatcherFn, [\n * // the animation sequence code\n * ]),\n * ])\n * ]\n * })\n * class MyComponent {\n * myStatusExp = \"yes-please-animate\";\n * }\n * ```\n *\n * ### Disabling Animations\n * When true, the special animation control binding `\\@.disabled` binding prevents\n * all animations from rendering.\n * Place the `\\@.disabled` binding on an element to disable\n * animations on the element itself, as well as any inner animation triggers\n * within the element.\n *\n * The following example shows how to use this feature:\n *\n * ```typescript /\n * selector: 'my-component',\n * template: `\n *
\n * \n *
\n * `,\n * animations: [\n * trigger(\"childAnimation\", [\n * // ...\n * ])\n * ]\n * })\n * class MyComponent {\n * isDisabled = true;\n * exp = '...';\n * }\n * ```\n *\n * When `\\@.disabled` is true, it prevents the `\\@childAnimation` trigger from animating,\n * along with any inner animations.\n *\n * ### Disable animations application-wide\n * When an area of the template is set to have animations disabled,\n * **all** inner components have their animations disabled as well.\n * This means that you can disable all animations for an app\n * by placing a host binding set on `\\@.disabled` on the topmost Angular component.\n *\n * ```typescript\n * import {Component, HostBinding} from '\\@angular/core';\n * /\n * selector: 'app-component',\n * templateUrl: 'app.component.html',\n * })\n * class AppComponent {\n * \\@HostBinding('@.disabled')\n * public animationsDisabled = true;\n * }\n * ```\n *\n * ### Overriding disablement of inner animations\n * Despite inner animations being disabled, a parent animation can `query()`\n * for inner elements located in disabled areas of the template and still animate\n * them if needed. This is also the case for when a sub animation is\n * queried by a parent and then later animated using `animateChild()`.\n *\n * ### Detecting when an animation is disabled\n * If a region of the DOM (or the entire application) has its animations disabled, the animation\n * trigger callbacks still fire, but for zero seconds. When the callback fires, it provides\n * an instance of an `AnimationEvent`. If animations are disabled,\n * the `.disabled` flag on the event is true.\n *\n * \\@publicApi\n * @param {?} name An identifying string.\n * @param {?} definitions An animation definition object, containing an array of `state()`\n * and `transition()` declarations.\n *\n * @return {?} An object that encapsulates the trigger data.\n *\n */\nfunction trigger(name, definitions) {\n return { type: 7 /* Trigger */, name, definitions, options: {} };\n}\n/**\n * Defines an animation step that combines styling information with timing information.\n *\n * \\@usageNotes\n * Call within an animation `sequence()`, `{\\@link animations/group group()}`, or\n * `transition()` call to specify an animation step\n * that applies given style data to the parent animation for a given amount of time.\n *\n * ### Syntax Examples\n * **Timing examples**\n *\n * The following examples show various `timings` specifications.\n * - `animate(500)` : Duration is 500 milliseconds.\n * - `animate(\"1s\")` : Duration is 1000 milliseconds.\n * - `animate(\"100ms 0.5s\")` : Duration is 100 milliseconds, delay is 500 milliseconds.\n * - `animate(\"5s ease-in\")` : Duration is 5000 milliseconds, easing in.\n * - `animate(\"5s 10ms cubic-bezier(.17,.67,.88,.1)\")` : Duration is 5000 milliseconds, delay is 10\n * milliseconds, easing according to a bezier curve.\n *\n * **Style examples**\n *\n * The following example calls `style()` to set a single CSS style.\n * ```typescript\n * animate(500, style({ background: \"red\" }))\n * ```\n * The following example calls `keyframes()` to set a CSS style\n * to different values for successive keyframes.\n * ```typescript\n * animate(500, keyframes(\n * [\n * style({ background: \"blue\" })),\n * style({ background: \"red\" }))\n * ])\n * ```\n *\n * \\@publicApi\n * @param {?} timings Sets `AnimateTimings` for the parent animation.\n * A string in the format \"duration [delay] [easing]\".\n * - Duration and delay are expressed as a number and optional time unit,\n * such as \"1s\" or \"10ms\" for one second and 10 milliseconds, respectively.\n * The default unit is milliseconds.\n * - The easing value controls how the animation accelerates and decelerates\n * during its runtime. Value is one of `ease`, `ease-in`, `ease-out`,\n * `ease-in-out`, or a `cubic-bezier()` function call.\n * If not supplied, no easing is applied.\n *\n * For example, the string \"1s 100ms ease-out\" specifies a duration of\n * 1000 milliseconds, and delay of 100 ms, and the \"ease-out\" easing style,\n * which decelerates near the end of the duration.\n * @param {?=} styles Sets AnimationStyles for the parent animation.\n * A function call to either `style()` or `keyframes()`\n * that returns a collection of CSS style entries to be applied to the parent animation.\n * When null, uses the styles from the destination state.\n * This is useful when describing an animation step that will complete an animation;\n * see \"Animating to the final state\" in `transitions()`.\n * @return {?} An object that encapsulates the animation step.\n *\n */\nfunction animate(timings, styles = null) {\n return { type: 4 /* Animate */, styles, timings };\n}\n/**\n * \\@description Defines a list of animation steps to be run in parallel.\n *\n * \\@usageNotes\n * Grouped animations are useful when a series of styles must be\n * animated at different starting times and closed off at different ending times.\n *\n * When called within a `sequence()` or a\n * `transition()` call, does not continue to the next\n * instruction until all of the inner animation steps have completed.\n *\n * \\@publicApi\n * @param {?} steps An array of animation step objects.\n * - When steps are defined by `style()` or `animate()`\n * function calls, each call within the group is executed instantly.\n * - To specify offset styles to be applied at a later time, define steps with\n * `keyframes()`, or use `animate()` calls with a delay value.\n * For example:\n *\n * ```typescript\n * group([\n * animate(\"1s\", style({ background: \"black\" })),\n * animate(\"2s\", style({ color: \"white\" }))\n * ])\n * ```\n *\n * @param {?=} options An options object containing a delay and\n * developer-defined parameters that provide styling defaults and\n * can be overridden on invocation.\n *\n * @return {?} An object that encapsulates the group data.\n *\n */\nfunction group(steps, options = null) {\n return { type: 3 /* Group */, steps, options };\n}\n/**\n * Defines a list of animation steps to be run sequentially, one by one.\n *\n * \\@usageNotes\n * When you pass an array of steps to a\n * `transition()` call, the steps run sequentially by default.\n * Compare this to the `{\\@link animations/group group()}` call, which runs animation steps in\n * parallel.\n *\n * When a sequence is used within a `{\\@link animations/group group()}` or a `transition()` call,\n * execution continues to the next instruction only after each of the inner animation\n * steps have completed.\n *\n * \\@publicApi\n *\n * @param {?} steps An array of animation step objects.\n * - Steps defined by `style()` calls apply the styling data immediately.\n * - Steps defined by `animate()` calls apply the styling data over time\n * as specified by the timing data.\n *\n * ```typescript\n * sequence([\n * style({ opacity: 0 }),\n * animate(\"1s\", style({ opacity: 1 }))\n * ])\n * ```\n *\n * @param {?=} options An options object containing a delay and\n * developer-defined parameters that provide styling defaults and\n * can be overridden on invocation.\n *\n * @return {?} An object that encapsulates the sequence data.\n *\n */\nfunction sequence(steps, options = null) {\n return { type: 2 /* Sequence */, steps, options };\n}\n/**\n * Declares a key/value object containing CSS properties/styles that\n * can then be used for an animation `state`, within an animation `sequence`,\n * or as styling data for calls to `animate()` and `keyframes()`.\n *\n * \\@usageNotes\n * The following examples create animation styles that collect a set of\n * CSS property values:\n *\n * ```typescript\n * // string values for CSS properties\n * style({ background: \"red\", color: \"blue\" })\n *\n * // numerical pixel values\n * style({ width: 100, height: 0 })\n * ```\n *\n * The following example uses auto-styling to allow a component to animate from\n * a height of 0 up to the height of the parent element:\n *\n * ```\n * style({ height: 0 }),\n * animate(\"1s\", style({ height: \"*\" }))\n * ```\n *\n * \\@publicApi\n *\n * @param {?} tokens A set of CSS styles or HTML styles associated with an animation state.\n * The value can be any of the following:\n * - A key-value style pair associating a CSS property with a value.\n * - An array of key-value style pairs.\n * - An asterisk (*), to use auto-styling, where styles are derived from the element\n * being animated and applied to the animation when it starts.\n *\n * Auto-styling can be used to define a state that depends on layout or other\n * environmental factors.\n *\n * @return {?} An object that encapsulates the style data.\n *\n */\nfunction style(tokens) {\n return { type: 6 /* Style */, styles: tokens, offset: null };\n}\n/**\n * Declares an animation state within a trigger attached to an element.\n *\n * \\@usageNotes\n * Use the `trigger()` function to register states to an animation trigger.\n * Use the `transition()` function to animate between states.\n * When a state is active within a component, its associated styles persist on the element,\n * even when the animation ends.\n *\n * \\@publicApi\n *\n * @param {?} name One or more names for the defined state in a comma-separated string.\n * The following reserved state names can be supplied to define a style for specific use\n * cases:\n *\n * - `void` You can associate styles with this name to be used when\n * the element is detached from the application. For example, when an `ngIf` evaluates\n * to false, the state of the associated element is void.\n * - `*` (asterisk) Indicates the default state. You can associate styles with this name\n * to be used as the fallback when the state that is being animated is not declared\n * within the trigger.\n *\n * @param {?} styles A set of CSS styles associated with this state, created using the\n * `style()` function.\n * This set of styles persists on the element once the state has been reached.\n * @param {?=} options Parameters that can be passed to the state when it is invoked.\n * 0 or more key-value pairs.\n * @return {?} An object that encapsulates the new state data.\n *\n */\nfunction state(name, styles, options) {\n return { type: 0 /* State */, name, styles, options };\n}\n/**\n * Defines a set of animation styles, associating each style with an optional `offset` value.\n *\n * \\@usageNotes\n * Use with the `animate()` call. Instead of applying animations\n * from the current state\n * to the destination state, keyframes describe how each style entry is applied and at what point\n * within the animation arc.\n * Compare [CSS Keyframe Animations](https://www.w3schools.com/css/css3_animations.asp).\n *\n * ### Usage\n *\n * In the following example, the offset values describe\n * when each `backgroundColor` value is applied. The color is red at the start, and changes to\n * blue when 20% of the total time has elapsed.\n *\n * ```typescript\n * // the provided offset values\n * animate(\"5s\", keyframes([\n * style({ backgroundColor: \"red\", offset: 0 }),\n * style({ backgroundColor: \"blue\", offset: 0.2 }),\n * style({ backgroundColor: \"orange\", offset: 0.3 }),\n * style({ backgroundColor: \"black\", offset: 1 })\n * ]))\n * ```\n *\n * If there are no `offset` values specified in the style entries, the offsets\n * are calculated automatically.\n *\n * ```typescript\n * animate(\"5s\", keyframes([\n * style({ backgroundColor: \"red\" }) // offset = 0\n * style({ backgroundColor: \"blue\" }) // offset = 0.33\n * style({ backgroundColor: \"orange\" }) // offset = 0.66\n * style({ backgroundColor: \"black\" }) // offset = 1\n * ]))\n * ```\n * \\@publicApi\n * @param {?} steps A set of animation styles with optional offset data.\n * The optional `offset` value for a style specifies a percentage of the total animation\n * time at which that style is applied.\n * @return {?} An object that encapsulates the keyframes data.\n *\n */\nfunction keyframes(steps) {\n return { type: 5 /* Keyframes */, steps };\n}\n/**\n * Declares an animation transition as a sequence of animation steps to run when a given\n * condition is satisfied. The condition is a Boolean expression or function that compares\n * the previous and current animation states, and returns true if this transition should occur.\n * When the state criteria of a defined transition are met, the associated animation is\n * triggered.\n *\n * \\@usageNotes\n * The template associated with a component binds an animation trigger to an element.\n *\n * ```HTML\n * \n *
...
\n * ```\n *\n * All transitions are defined within an animation trigger,\n * along with named states that the transitions change to and from.\n *\n * ```typescript\n * trigger(\"myAnimationTrigger\", [\n * // define states\n * state(\"on\", style({ background: \"green\" })),\n * state(\"off\", style({ background: \"grey\" })),\n * ...]\n * ```\n *\n * Note that when you call the `sequence()` function within a `{\\@link animations/group group()}`\n * or a `transition()` call, execution does not continue to the next instruction\n * until each of the inner animation steps have completed.\n *\n * ### Syntax examples\n *\n * The following examples define transitions between the two defined states (and default states),\n * using various options:\n *\n * ```typescript\n * // Transition occurs when the state value\n * // bound to \"myAnimationTrigger\" changes from \"on\" to \"off\"\n * transition(\"on => off\", animate(500))\n * // Run the same animation for both directions\n * transition(\"on <=> off\", animate(500))\n * // Define multiple state-change pairs separated by commas\n * transition(\"on => off, off => void\", animate(500))\n * ```\n *\n * ### Special values for state-change expressions\n *\n * - Catch-all state change for when an element is inserted into the page and the\n * destination state is unknown:\n *\n * ```typescript\n * transition(\"void => *\", [\n * style({ opacity: 0 }),\n * animate(500)\n * ])\n * ```\n *\n * - Capture a state change between any states:\n *\n * `transition(\"* => *\", animate(\"1s 0s\"))`\n *\n * - Entry and exit transitions:\n *\n * ```typescript\n * transition(\":enter\", [\n * style({ opacity: 0 }),\n * animate(500, style({ opacity: 1 }))\n * ]),\n * transition(\":leave\", [\n * animate(500, style({ opacity: 0 }))\n * ])\n * ```\n *\n * - Use `:increment` and `:decrement` to initiate transitions:\n *\n * ```typescript\n * transition(\":increment\", group([\n * query(':enter', [\n * style({ left: '100%' }),\n * animate('0.5s ease-out', style('*'))\n * ]),\n * query(':leave', [\n * animate('0.5s ease-out', style({ left: '-100%' }))\n * ])\n * ]))\n *\n * transition(\":decrement\", group([\n * query(':enter', [\n * style({ left: '100%' }),\n * animate('0.5s ease-out', style('*'))\n * ]),\n * query(':leave', [\n * animate('0.5s ease-out', style({ left: '-100%' }))\n * ])\n * ]))\n * ```\n *\n * ### State-change functions\n *\n * Here is an example of a `fromState` specified as a state-change function that invokes an\n * animation when true:\n *\n * ```typescript\n * transition((fromState, toState) =>\n * {\n * return fromState == \"off\" && toState == \"on\";\n * },\n * animate(\"1s 0s\"))\n * ```\n *\n * ### Animating to the final state\n *\n * If the final step in a transition is a call to `animate()` that uses a timing value\n * with no style data, that step is automatically considered the final animation arc,\n * for the element to reach the final state. Angular automatically adds or removes\n * CSS styles to ensure that the element is in the correct final state.\n *\n * The following example defines a transition that starts by hiding the element,\n * then makes sure that it animates properly to whatever state is currently active for trigger:\n *\n * ```typescript\n * transition(\"void => *\", [\n * style({ opacity: 0 }),\n * animate(500)\n * ])\n * ```\n * ### Boolean value matching\n * If a trigger binding value is a Boolean, it can be matched using a transition expression\n * that compares true and false or 1 and 0. For example:\n *\n * ```\n * // in the template\n *
...
\n * // in the component metadata\n * trigger('openClose', [\n * state('true', style({ height: '*' })),\n * state('false', style({ height: '0px' })),\n * transition('false <=> true', animate(500))\n * ])\n * ```\n *\n * \\@publicApi\n *\n * @param {?} stateChangeExpr A Boolean expression or function that compares the previous and current\n * animation states, and returns true if this transition should occur. Note that \"true\" and \"false\"\n * match 1 and 0, respectively. An expression is evaluated each time a state change occurs in the\n * animation trigger element.\n * The animation steps run when the expression evaluates to true.\n *\n * - A state-change string takes the form \"state1 => state2\", where each side is a defined animation\n * state, or an asterix (*) to refer to a dynamic start or end state.\n * - The expression string can contain multiple comma-separated statements;\n * for example \"state1 => state2, state3 => state4\".\n * - Special values `:enter` and `:leave` initiate a transition on the entry and exit states,\n * equivalent to \"void => *\" and \"* => void\".\n * - Special values `:increment` and `:decrement` initiate a transition when a numeric value has\n * increased or decreased in value.\n * - A function is executed each time a state change occurs in the animation trigger element.\n * The animation steps run when the function returns true.\n *\n * @param {?} steps One or more animation objects, as returned by the `animate()` or\n * `sequence()` function, that form a transformation from one state to another.\n * A sequence is used by default when you pass an array.\n * @param {?=} options An options object that can contain a delay value for the start of the animation,\n * and additional developer-defined parameters. Provided values for additional parameters are used\n * as defaults, and override values can be passed to the caller on invocation.\n * @return {?} An object that encapsulates the transition data.\n *\n */\nfunction transition(stateChangeExpr, steps, options = null) {\n return { type: 1 /* Transition */, expr: stateChangeExpr, animation: steps, options };\n}\n/**\n * Produces a reusable animation that can be invoked in another animation or sequence,\n * by calling the `useAnimation()` function.\n *\n * \\@usageNotes\n * The following example defines a reusable animation, providing some default parameter\n * values.\n *\n * ```typescript\n * var fadeAnimation = animation([\n * style({ opacity: '{{ start }}' }),\n * animate('{{ time }}',\n * style({ opacity: '{{ end }}'}))\n * ],\n * { params: { time: '1000ms', start: 0, end: 1 }});\n * ```\n *\n * The following invokes the defined animation with a call to `useAnimation()`,\n * passing in override parameter values.\n *\n * ```js\n * useAnimation(fadeAnimation, {\n * params: {\n * time: '2s',\n * start: 1,\n * end: 0\n * }\n * })\n * ```\n *\n * If any of the passed-in parameter values are missing from this call,\n * the default values are used. If one or more parameter values are missing before a step is\n * animated, `useAnimation()` throws an error.\n *\n * \\@publicApi\n * @param {?} steps One or more animation objects, as returned by the `animate()`\n * or `sequence()` function, that form a transformation from one state to another.\n * A sequence is used by default when you pass an array.\n * @param {?=} options An options object that can contain a delay value for the start of the\n * animation, and additional developer-defined parameters.\n * Provided values for additional parameters are used as defaults,\n * and override values can be passed to the caller on invocation.\n * @return {?} An object that encapsulates the animation data.\n *\n */\nfunction animation(steps, options = null) {\n return { type: 8 /* Reference */, animation: steps, options };\n}\n/**\n * Executes a queried inner animation element within an animation sequence.\n *\n * \\@usageNotes\n * Each time an animation is triggered in Angular, the parent animation\n * has priority and any child animations are blocked. In order\n * for a child animation to run, the parent animation must query each of the elements\n * containing child animations, and run them using this function.\n *\n * Note that this feature is designed to be used with `query()` and it will only work\n * with animations that are assigned using the Angular animation library. CSS keyframes\n * and transitions are not handled by this API.\n *\n * \\@publicApi\n * @param {?=} options An options object that can contain a delay value for the start of the\n * animation, and additional override values for developer-defined parameters.\n * @return {?} An object that encapsulates the child animation data.\n *\n */\nfunction animateChild(options = null) {\n return { type: 9 /* AnimateChild */, options };\n}\n/**\n * Starts a reusable animation that is created using the `animation()` function.\n *\n * \\@publicApi\n * @param {?} animation The reusable animation to start.\n * @param {?=} options An options object that can contain a delay value for the start of\n * the animation, and additional override values for developer-defined parameters.\n * @return {?} An object that contains the animation parameters.\n *\n */\nfunction useAnimation(animation, options = null) {\n return { type: 10 /* AnimateRef */, animation, options };\n}\n/**\n * Finds one or more inner elements within the current element that is\n * being animated within a sequence. Use with `animate()`.\n *\n * \\@usageNotes\n * Tokens can be merged into a combined query selector string. For example:\n *\n * ```typescript\n * query(':self, .record:enter, .record:leave, \\@subTrigger', [...])\n * ```\n *\n * The `query()` function collects multiple elements and works internally by using\n * `element.querySelectorAll`. Use the `limit` field of an options object to limit\n * the total number of items to be collected. For example:\n *\n * ```js\n * query('div', [\n * animate(...),\n * animate(...)\n * ], { limit: 1 })\n * ```\n *\n * By default, throws an error when zero items are found. Set the\n * `optional` flag to ignore this error. For example:\n *\n * ```js\n * query('.some-element-that-may-not-be-there', [\n * animate(...),\n * animate(...)\n * ], { optional: true })\n * ```\n *\n * ### Usage Example\n *\n * The following example queries for inner elements and animates them\n * individually using `animate()`.\n *\n * ```typescript\n * \\@Component({\n * selector: 'inner',\n * template: `\n *
\n *
Title
\n *
\n * Blah blah blah\n *
\n *
\n * `,\n * animations: [\n * trigger('queryAnimation', [\n * transition('* => goAnimate', [\n * // hide the inner elements\n * query('h1', style({ opacity: 0 })),\n * query('.content', style({ opacity: 0 })),\n *\n * // animate the inner elements in, one by one\n * query('h1', animate(1000, style({ opacity: 1 }))),\n * query('.content', animate(1000, style({ opacity: 1 }))),\n * ])\n * ])\n * ]\n * })\n * class Cmp {\n * exp = '';\n *\n * goAnimate() {\n * this.exp = 'goAnimate';\n * }\n * }\n * ```\n *\n * \\@publicApi\n * @param {?} selector The element to query, or a set of elements that contain Angular-specific\n * characteristics, specified with one or more of the following tokens.\n * - `query(\":enter\")` or `query(\":leave\")` : Query for newly inserted/removed elements.\n * - `query(\":animating\")` : Query all currently animating elements.\n * - `query(\"\\@triggerName\")` : Query elements that contain an animation trigger.\n * - `query(\"\\@*\")` : Query all elements that contain an animation triggers.\n * - `query(\":self\")` : Include the current element into the animation sequence.\n *\n * @param {?} animation One or more animation steps to apply to the queried element or elements.\n * An array is treated as an animation sequence.\n * @param {?=} options An options object. Use the 'limit' field to limit the total number of\n * items to collect.\n * @return {?} An object that encapsulates the query data.\n *\n */\nfunction query(selector, animation, options = null) {\n return { type: 11 /* Query */, selector, animation, options };\n}\n/**\n * Use within an animation `query()` call to issue a timing gap after\n * each queried item is animated.\n *\n * \\@usageNotes\n * In the following example, a container element wraps a list of items stamped out\n * by an `ngFor`. The container element contains an animation trigger that will later be set\n * to query for each of the inner items.\n *\n * Each time items are added, the opacity fade-in animation runs,\n * and each removed item is faded out.\n * When either of these animations occur, the stagger effect is\n * applied after each item's animation is started.\n *\n * ```html\n * \n * \n * \n *
\n *
\n * {{ item }}\n *
\n *
\n * ```\n *\n * Here is the component code:\n *\n * ```typescript\n * import {trigger, transition, style, animate, query, stagger} from '\\@angular/animations';\n * \\@Component({\n * templateUrl: 'list.component.html',\n * animations: [\n * trigger('listAnimation', [\n * ...\n * ])\n * ]\n * })\n * class ListComponent {\n * items = [];\n *\n * showItems() {\n * this.items = [0,1,2,3,4];\n * }\n *\n * hideItems() {\n * this.items = [];\n * }\n *\n * toggle() {\n * this.items.length ? this.hideItems() : this.showItems();\n * }\n * }\n * ```\n *\n * Here is the animation trigger code:\n *\n * ```typescript\n * trigger('listAnimation', [\n * transition('* => *', [ // each time the binding value changes\n * query(':leave', [\n * stagger(100, [\n * animate('0.5s', style({ opacity: 0 }))\n * ])\n * ]),\n * query(':enter', [\n * style({ opacity: 0 }),\n * stagger(100, [\n * animate('0.5s', style({ opacity: 1 }))\n * ])\n * ])\n * ])\n * ])\n * ```\n *\n * \\@publicApi\n * @param {?} timings A delay value.\n * @param {?} animation One ore more animation steps.\n * @return {?} An object that encapsulates the stagger data.\n *\n */\nfunction stagger(timings, animation) {\n return { type: 12 /* Stagger */, timings, animation };\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/src/util.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. 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 * @param {?} cb\n * @return {?}\n */\nfunction scheduleMicroTask(cb) {\n Promise.resolve(null).then(cb);\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/src/players/animation_player.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Provides programmatic control of a reusable animation sequence,\n * built using the `build()` method of `AnimationBuilder`. The `build()` method\n * returns a factory, whose `create()` method instantiates and initializes this interface.\n *\n * @see `AnimationBuilder`\n * @see `AnimationFactory`\n * @see `animate()`\n *\n * \\@publicApi\n * @record\n */\nfunction AnimationPlayer() { }\nif (false) {\n /**\n * The parent of this player, if any.\n * @type {?}\n */\n AnimationPlayer.prototype.parentPlayer;\n /**\n * The total run time of the animation, in milliseconds.\n * @type {?}\n */\n AnimationPlayer.prototype.totalTime;\n /**\n * Provides a callback to invoke before the animation is destroyed.\n * @type {?|undefined}\n */\n AnimationPlayer.prototype.beforeDestroy;\n /**\n * \\@internal\n * Internal\n * @type {?|undefined}\n */\n AnimationPlayer.prototype.triggerCallback;\n /**\n * \\@internal\n * Internal\n * @type {?|undefined}\n */\n AnimationPlayer.prototype.disabled;\n /**\n * Provides a callback to invoke when the animation finishes.\n * @see `finish()`\n * @param {?} fn The callback function.\n * @return {?}\n */\n AnimationPlayer.prototype.onDone = function (fn) { };\n /**\n * Provides a callback to invoke when the animation starts.\n * @see `run()`\n * @param {?} fn The callback function.\n * @return {?}\n */\n AnimationPlayer.prototype.onStart = function (fn) { };\n /**\n * Provides a callback to invoke after the animation is destroyed.\n * @see `destroy()` / `beforeDestroy()`\n * @param {?} fn The callback function.\n * @return {?}\n */\n AnimationPlayer.prototype.onDestroy = function (fn) { };\n /**\n * Initializes the animation.\n * @return {?}\n */\n AnimationPlayer.prototype.init = function () { };\n /**\n * Reports whether the animation has started.\n * @return {?} True if the animation has started, false otherwise.\n */\n AnimationPlayer.prototype.hasStarted = function () { };\n /**\n * Runs the animation, invoking the `onStart()` callback.\n * @return {?}\n */\n AnimationPlayer.prototype.play = function () { };\n /**\n * Pauses the animation.\n * @return {?}\n */\n AnimationPlayer.prototype.pause = function () { };\n /**\n * Restarts the paused animation.\n * @return {?}\n */\n AnimationPlayer.prototype.restart = function () { };\n /**\n * Ends the animation, invoking the `onDone()` callback.\n * @return {?}\n */\n AnimationPlayer.prototype.finish = function () { };\n /**\n * Destroys the animation, after invoking the `beforeDestroy()` callback.\n * Calls the `onDestroy()` callback when destruction is completed.\n * @return {?}\n */\n AnimationPlayer.prototype.destroy = function () { };\n /**\n * Resets the animation to its initial state.\n * @return {?}\n */\n AnimationPlayer.prototype.reset = function () { };\n /**\n * Sets the position of the animation.\n * @param {?} position A 0-based offset into the duration, in milliseconds.\n * @return {?}\n */\n AnimationPlayer.prototype.setPosition = function (position) { };\n /**\n * Reports the current position of the animation.\n * @return {?} A 0-based offset into the duration, in milliseconds.\n */\n AnimationPlayer.prototype.getPosition = function () { };\n}\n/**\n * An empty programmatic controller for reusable animations.\n * Used internally when animations are disabled, to avoid\n * checking for the null case when an animation player is expected.\n *\n * @see `animate()`\n * @see `AnimationPlayer`\n * @see `GroupPlayer`\n *\n * \\@publicApi\n */\nclass NoopAnimationPlayer {\n /**\n * @param {?=} duration\n * @param {?=} delay\n */\n constructor(duration = 0, delay = 0) {\n this._onDoneFns = [];\n this._onStartFns = [];\n this._onDestroyFns = [];\n this._started = false;\n this._destroyed = false;\n this._finished = false;\n this.parentPlayer = null;\n this.totalTime = duration + delay;\n }\n /**\n * @private\n * @return {?}\n */\n _onFinish() {\n if (!this._finished) {\n this._finished = true;\n this._onDoneFns.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n this._onDoneFns = [];\n }\n }\n /**\n * @param {?} fn\n * @return {?}\n */\n onStart(fn) {\n this._onStartFns.push(fn);\n }\n /**\n * @param {?} fn\n * @return {?}\n */\n onDone(fn) {\n this._onDoneFns.push(fn);\n }\n /**\n * @param {?} fn\n * @return {?}\n */\n onDestroy(fn) {\n this._onDestroyFns.push(fn);\n }\n /**\n * @return {?}\n */\n hasStarted() {\n return this._started;\n }\n /**\n * @return {?}\n */\n init() { }\n /**\n * @return {?}\n */\n play() {\n if (!this.hasStarted()) {\n this._onStart();\n this.triggerMicrotask();\n }\n this._started = true;\n }\n /**\n * \\@internal\n * @return {?}\n */\n triggerMicrotask() {\n scheduleMicroTask((/**\n * @return {?}\n */\n () => this._onFinish()));\n }\n /**\n * @private\n * @return {?}\n */\n _onStart() {\n this._onStartFns.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n this._onStartFns = [];\n }\n /**\n * @return {?}\n */\n pause() { }\n /**\n * @return {?}\n */\n restart() { }\n /**\n * @return {?}\n */\n finish() {\n this._onFinish();\n }\n /**\n * @return {?}\n */\n destroy() {\n if (!this._destroyed) {\n this._destroyed = true;\n if (!this.hasStarted()) {\n this._onStart();\n }\n this.finish();\n this._onDestroyFns.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n this._onDestroyFns = [];\n }\n }\n /**\n * @return {?}\n */\n reset() { }\n /**\n * @param {?} position\n * @return {?}\n */\n setPosition(position) { }\n /**\n * @return {?}\n */\n getPosition() {\n return 0;\n }\n /**\n * \\@internal\n * @param {?} phaseName\n * @return {?}\n */\n triggerCallback(phaseName) {\n /** @type {?} */\n const methods = phaseName == 'start' ? this._onStartFns : this._onDoneFns;\n methods.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n methods.length = 0;\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n NoopAnimationPlayer.prototype._onDoneFns;\n /**\n * @type {?}\n * @private\n */\n NoopAnimationPlayer.prototype._onStartFns;\n /**\n * @type {?}\n * @private\n */\n NoopAnimationPlayer.prototype._onDestroyFns;\n /**\n * @type {?}\n * @private\n */\n NoopAnimationPlayer.prototype._started;\n /**\n * @type {?}\n * @private\n */\n NoopAnimationPlayer.prototype._destroyed;\n /**\n * @type {?}\n * @private\n */\n NoopAnimationPlayer.prototype._finished;\n /** @type {?} */\n NoopAnimationPlayer.prototype.parentPlayer;\n /** @type {?} */\n NoopAnimationPlayer.prototype.totalTime;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/src/players/animation_group_player.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * A programmatic controller for a group of reusable animations.\n * Used internally to control animations.\n *\n * @see `AnimationPlayer`\n * @see `{\\@link animations/group group()}`\n *\n */\nclass AnimationGroupPlayer {\n /**\n * @param {?} _players\n */\n constructor(_players) {\n this._onDoneFns = [];\n this._onStartFns = [];\n this._finished = false;\n this._started = false;\n this._destroyed = false;\n this._onDestroyFns = [];\n this.parentPlayer = null;\n this.totalTime = 0;\n this.players = _players;\n /** @type {?} */\n let doneCount = 0;\n /** @type {?} */\n let destroyCount = 0;\n /** @type {?} */\n let startCount = 0;\n /** @type {?} */\n const total = this.players.length;\n if (total == 0) {\n scheduleMicroTask((/**\n * @return {?}\n */\n () => this._onFinish()));\n }\n else {\n this.players.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n player.onDone((/**\n * @return {?}\n */\n () => {\n if (++doneCount == total) {\n this._onFinish();\n }\n }));\n player.onDestroy((/**\n * @return {?}\n */\n () => {\n if (++destroyCount == total) {\n this._onDestroy();\n }\n }));\n player.onStart((/**\n * @return {?}\n */\n () => {\n if (++startCount == total) {\n this._onStart();\n }\n }));\n }));\n }\n this.totalTime = this.players.reduce((/**\n * @param {?} time\n * @param {?} player\n * @return {?}\n */\n (time, player) => Math.max(time, player.totalTime)), 0);\n }\n /**\n * @private\n * @return {?}\n */\n _onFinish() {\n if (!this._finished) {\n this._finished = true;\n this._onDoneFns.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n this._onDoneFns = [];\n }\n }\n /**\n * @return {?}\n */\n init() {\n this.players.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => player.init()));\n }\n /**\n * @param {?} fn\n * @return {?}\n */\n onStart(fn) {\n this._onStartFns.push(fn);\n }\n /**\n * @private\n * @return {?}\n */\n _onStart() {\n if (!this.hasStarted()) {\n this._started = true;\n this._onStartFns.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n this._onStartFns = [];\n }\n }\n /**\n * @param {?} fn\n * @return {?}\n */\n onDone(fn) {\n this._onDoneFns.push(fn);\n }\n /**\n * @param {?} fn\n * @return {?}\n */\n onDestroy(fn) {\n this._onDestroyFns.push(fn);\n }\n /**\n * @return {?}\n */\n hasStarted() {\n return this._started;\n }\n /**\n * @return {?}\n */\n play() {\n if (!this.parentPlayer) {\n this.init();\n }\n this._onStart();\n this.players.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => player.play()));\n }\n /**\n * @return {?}\n */\n pause() {\n this.players.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => player.pause()));\n }\n /**\n * @return {?}\n */\n restart() {\n this.players.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => player.restart()));\n }\n /**\n * @return {?}\n */\n finish() {\n this._onFinish();\n this.players.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => player.finish()));\n }\n /**\n * @return {?}\n */\n destroy() {\n this._onDestroy();\n }\n /**\n * @private\n * @return {?}\n */\n _onDestroy() {\n if (!this._destroyed) {\n this._destroyed = true;\n this._onFinish();\n this.players.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => player.destroy()));\n this._onDestroyFns.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n this._onDestroyFns = [];\n }\n }\n /**\n * @return {?}\n */\n reset() {\n this.players.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => player.reset()));\n this._destroyed = false;\n this._finished = false;\n this._started = false;\n }\n /**\n * @param {?} p\n * @return {?}\n */\n setPosition(p) {\n /** @type {?} */\n const timeAtPosition = p * this.totalTime;\n this.players.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n /** @type {?} */\n const position = player.totalTime ? Math.min(1, timeAtPosition / player.totalTime) : 1;\n player.setPosition(position);\n }));\n }\n /**\n * @return {?}\n */\n getPosition() {\n /** @type {?} */\n let min = 0;\n this.players.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n /** @type {?} */\n const p = player.getPosition();\n min = Math.min(p, min);\n }));\n return min;\n }\n /**\n * @return {?}\n */\n beforeDestroy() {\n this.players.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n if (player.beforeDestroy) {\n player.beforeDestroy();\n }\n }));\n }\n /**\n * \\@internal\n * @param {?} phaseName\n * @return {?}\n */\n triggerCallback(phaseName) {\n /** @type {?} */\n const methods = phaseName == 'start' ? this._onStartFns : this._onDoneFns;\n methods.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n methods.length = 0;\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n AnimationGroupPlayer.prototype._onDoneFns;\n /**\n * @type {?}\n * @private\n */\n AnimationGroupPlayer.prototype._onStartFns;\n /**\n * @type {?}\n * @private\n */\n AnimationGroupPlayer.prototype._finished;\n /**\n * @type {?}\n * @private\n */\n AnimationGroupPlayer.prototype._started;\n /**\n * @type {?}\n * @private\n */\n AnimationGroupPlayer.prototype._destroyed;\n /**\n * @type {?}\n * @private\n */\n AnimationGroupPlayer.prototype._onDestroyFns;\n /** @type {?} */\n AnimationGroupPlayer.prototype.parentPlayer;\n /** @type {?} */\n AnimationGroupPlayer.prototype.totalTime;\n /** @type {?} */\n AnimationGroupPlayer.prototype.players;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/src/private_export.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst ɵPRE_STYLE = '!';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/src/animations.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/public_api.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/index.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { AUTO_STYLE, AnimationBuilder, AnimationFactory, NoopAnimationPlayer, animate, animateChild, animation, group, keyframes, query, sequence, stagger, state, style, transition, trigger, useAnimation, AnimationGroupPlayer as ɵAnimationGroupPlayer, ɵPRE_STYLE };\n\n//# sourceMappingURL=animations.js.map","/**\n * @license Angular v9.1.13\n * (c) 2010-2020 Google LLC. https://angular.io/\n * License: MIT\n */\n\nimport { ɵAnimationGroupPlayer, NoopAnimationPlayer, AUTO_STYLE, ɵPRE_STYLE, sequence, style } from '@angular/animations';\nimport { Injectable } from '@angular/core';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/render/shared.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @return {?}\n */\nimport * as ɵngcc0 from '@angular/core';\nfunction isBrowser() {\n return (typeof window !== 'undefined' && typeof window.document !== 'undefined');\n}\n/**\n * @return {?}\n */\nfunction isNode() {\n // Checking only for `process` isn't enough to identify whether or not we're in a Node\n // environment, because Webpack by default will polyfill the `process`. While we can discern\n // that Webpack polyfilled it by looking at `process.browser`, it's very Webpack-specific and\n // might not be future-proof. Instead we look at the stringified version of `process` which\n // is `[object process]` in Node and `[object Object]` when polyfilled.\n return typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';\n}\n/**\n * @param {?} players\n * @return {?}\n */\nfunction optimizeGroupPlayer(players) {\n switch (players.length) {\n case 0:\n return new NoopAnimationPlayer();\n case 1:\n return players[0];\n default:\n return new ɵAnimationGroupPlayer(players);\n }\n}\n/**\n * @param {?} driver\n * @param {?} normalizer\n * @param {?} element\n * @param {?} keyframes\n * @param {?=} preStyles\n * @param {?=} postStyles\n * @return {?}\n */\nfunction normalizeKeyframes(driver, normalizer, element, keyframes, preStyles = {}, postStyles = {}) {\n /** @type {?} */\n const errors = [];\n /** @type {?} */\n const normalizedKeyframes = [];\n /** @type {?} */\n let previousOffset = -1;\n /** @type {?} */\n let previousKeyframe = null;\n keyframes.forEach((/**\n * @param {?} kf\n * @return {?}\n */\n kf => {\n /** @type {?} */\n const offset = (/** @type {?} */ (kf['offset']));\n /** @type {?} */\n const isSameOffset = offset == previousOffset;\n /** @type {?} */\n const normalizedKeyframe = (isSameOffset && previousKeyframe) || {};\n Object.keys(kf).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n /** @type {?} */\n let normalizedProp = prop;\n /** @type {?} */\n let normalizedValue = kf[prop];\n if (prop !== 'offset') {\n normalizedProp = normalizer.normalizePropertyName(normalizedProp, errors);\n switch (normalizedValue) {\n case ɵPRE_STYLE:\n normalizedValue = preStyles[prop];\n break;\n case AUTO_STYLE:\n normalizedValue = postStyles[prop];\n break;\n default:\n normalizedValue =\n normalizer.normalizeStyleValue(prop, normalizedProp, normalizedValue, errors);\n break;\n }\n }\n normalizedKeyframe[normalizedProp] = normalizedValue;\n }));\n if (!isSameOffset) {\n normalizedKeyframes.push(normalizedKeyframe);\n }\n previousKeyframe = normalizedKeyframe;\n previousOffset = offset;\n }));\n if (errors.length) {\n /** @type {?} */\n const LINE_START = '\\n - ';\n throw new Error(`Unable to animate due to the following errors:${LINE_START}${errors.join(LINE_START)}`);\n }\n return normalizedKeyframes;\n}\n/**\n * @param {?} player\n * @param {?} eventName\n * @param {?} event\n * @param {?} callback\n * @return {?}\n */\nfunction listenOnPlayer(player, eventName, event, callback) {\n switch (eventName) {\n case 'start':\n player.onStart((/**\n * @return {?}\n */\n () => callback(event && copyAnimationEvent(event, 'start', player))));\n break;\n case 'done':\n player.onDone((/**\n * @return {?}\n */\n () => callback(event && copyAnimationEvent(event, 'done', player))));\n break;\n case 'destroy':\n player.onDestroy((/**\n * @return {?}\n */\n () => callback(event && copyAnimationEvent(event, 'destroy', player))));\n break;\n }\n}\n/**\n * @param {?} e\n * @param {?} phaseName\n * @param {?} player\n * @return {?}\n */\nfunction copyAnimationEvent(e, phaseName, player) {\n /** @type {?} */\n const totalTime = player.totalTime;\n /** @type {?} */\n const disabled = ((/** @type {?} */ (player))).disabled ? true : false;\n /** @type {?} */\n const event = makeAnimationEvent(e.element, e.triggerName, e.fromState, e.toState, phaseName || e.phaseName, totalTime == undefined ? e.totalTime : totalTime, disabled);\n /** @type {?} */\n const data = ((/** @type {?} */ (e)))['_data'];\n if (data != null) {\n ((/** @type {?} */ (event)))['_data'] = data;\n }\n return event;\n}\n/**\n * @param {?} element\n * @param {?} triggerName\n * @param {?} fromState\n * @param {?} toState\n * @param {?=} phaseName\n * @param {?=} totalTime\n * @param {?=} disabled\n * @return {?}\n */\nfunction makeAnimationEvent(element, triggerName, fromState, toState, phaseName = '', totalTime = 0, disabled) {\n return { element, triggerName, fromState, toState, phaseName, totalTime, disabled: !!disabled };\n}\n/**\n * @param {?} map\n * @param {?} key\n * @param {?} defaultValue\n * @return {?}\n */\nfunction getOrSetAsInMap(map, key, defaultValue) {\n /** @type {?} */\n let value;\n if (map instanceof Map) {\n value = map.get(key);\n if (!value) {\n map.set(key, value = defaultValue);\n }\n }\n else {\n value = map[key];\n if (!value) {\n value = map[key] = defaultValue;\n }\n }\n return value;\n}\n/**\n * @param {?} command\n * @return {?}\n */\nfunction parseTimelineCommand(command) {\n /** @type {?} */\n const separatorPos = command.indexOf(':');\n /** @type {?} */\n const id = command.substring(1, separatorPos);\n /** @type {?} */\n const action = command.substr(separatorPos + 1);\n return [id, action];\n}\n/** @type {?} */\nlet _contains = (/**\n * @param {?} elm1\n * @param {?} elm2\n * @return {?}\n */\n(elm1, elm2) => false);\nconst ɵ0 = _contains;\n/** @type {?} */\nlet _matches = (/**\n * @param {?} element\n * @param {?} selector\n * @return {?}\n */\n(element, selector) => false);\nconst ɵ1 = _matches;\n/** @type {?} */\nlet _query = (/**\n * @param {?} element\n * @param {?} selector\n * @param {?} multi\n * @return {?}\n */\n(element, selector, multi) => {\n return [];\n});\nconst ɵ2 = _query;\n// Define utility methods for browsers and platform-server(domino) where Element\n// and utility methods exist.\n/** @type {?} */\nconst _isNode = isNode();\nif (_isNode || typeof Element !== 'undefined') {\n // this is well supported in all browsers\n _contains = (/**\n * @param {?} elm1\n * @param {?} elm2\n * @return {?}\n */\n (elm1, elm2) => {\n return (/** @type {?} */ (elm1.contains(elm2)));\n });\n _matches = ((/**\n * @return {?}\n */\n () => {\n if (_isNode || Element.prototype.matches) {\n return (/**\n * @param {?} element\n * @param {?} selector\n * @return {?}\n */\n (element, selector) => element.matches(selector));\n }\n else {\n /** @type {?} */\n const proto = (/** @type {?} */ (Element.prototype));\n /** @type {?} */\n const fn = proto.matchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector ||\n proto.oMatchesSelector || proto.webkitMatchesSelector;\n if (fn) {\n return (/**\n * @param {?} element\n * @param {?} selector\n * @return {?}\n */\n (element, selector) => fn.apply(element, [selector]));\n }\n else {\n return _matches;\n }\n }\n }))();\n _query = (/**\n * @param {?} element\n * @param {?} selector\n * @param {?} multi\n * @return {?}\n */\n (element, selector, multi) => {\n /** @type {?} */\n let results = [];\n if (multi) {\n results.push(...element.querySelectorAll(selector));\n }\n else {\n /** @type {?} */\n const elm = element.querySelector(selector);\n if (elm) {\n results.push(elm);\n }\n }\n return results;\n });\n}\n/**\n * @param {?} prop\n * @return {?}\n */\nfunction containsVendorPrefix(prop) {\n // Webkit is the only real popular vendor prefix nowadays\n // cc: http://shouldiprefix.com/\n return prop.substring(1, 6) == 'ebkit'; // webkit or Webkit\n}\n/** @type {?} */\nlet _CACHED_BODY = null;\n/** @type {?} */\nlet _IS_WEBKIT = false;\n/**\n * @param {?} prop\n * @return {?}\n */\nfunction validateStyleProperty(prop) {\n if (!_CACHED_BODY) {\n _CACHED_BODY = getBodyNode() || {};\n _IS_WEBKIT = (/** @type {?} */ (_CACHED_BODY)).style ? ('WebkitAppearance' in (/** @type {?} */ (_CACHED_BODY)).style) : false;\n }\n /** @type {?} */\n let result = true;\n if ((/** @type {?} */ (_CACHED_BODY)).style && !containsVendorPrefix(prop)) {\n result = prop in (/** @type {?} */ (_CACHED_BODY)).style;\n if (!result && _IS_WEBKIT) {\n /** @type {?} */\n const camelProp = 'Webkit' + prop.charAt(0).toUpperCase() + prop.substr(1);\n result = camelProp in (/** @type {?} */ (_CACHED_BODY)).style;\n }\n }\n return result;\n}\n/**\n * @return {?}\n */\nfunction getBodyNode() {\n if (typeof document != 'undefined') {\n return document.body;\n }\n return null;\n}\n/** @type {?} */\nconst matchesElement = _matches;\n/** @type {?} */\nconst containsElement = _contains;\n/** @type {?} */\nconst invokeQuery = _query;\n/**\n * @param {?} object\n * @return {?}\n */\nfunction hypenatePropsObject(object) {\n /** @type {?} */\n const newObj = {};\n Object.keys(object).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n /** @type {?} */\n const newProp = prop.replace(/([a-z])([A-Z])/g, '$1-$2');\n newObj[newProp] = object[prop];\n }));\n return newObj;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/render/animation_driver.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * \\@publicApi\n */\nclass NoopAnimationDriver {\n /**\n * @param {?} prop\n * @return {?}\n */\n validateStyleProperty(prop) {\n return validateStyleProperty(prop);\n }\n /**\n * @param {?} element\n * @param {?} selector\n * @return {?}\n */\n matchesElement(element, selector) {\n return matchesElement(element, selector);\n }\n /**\n * @param {?} elm1\n * @param {?} elm2\n * @return {?}\n */\n containsElement(elm1, elm2) {\n return containsElement(elm1, elm2);\n }\n /**\n * @param {?} element\n * @param {?} selector\n * @param {?} multi\n * @return {?}\n */\n query(element, selector, multi) {\n return invokeQuery(element, selector, multi);\n }\n /**\n * @param {?} element\n * @param {?} prop\n * @param {?=} defaultValue\n * @return {?}\n */\n computeStyle(element, prop, defaultValue) {\n return defaultValue || '';\n }\n /**\n * @param {?} element\n * @param {?} keyframes\n * @param {?} duration\n * @param {?} delay\n * @param {?} easing\n * @param {?=} previousPlayers\n * @param {?=} scrubberAccessRequested\n * @return {?}\n */\n animate(element, keyframes, duration, delay, easing, previousPlayers = [], scrubberAccessRequested) {\n return new NoopAnimationPlayer(duration, delay);\n }\n}\nNoopAnimationDriver.ɵfac = function NoopAnimationDriver_Factory(t) { return new (t || NoopAnimationDriver)(); };\nNoopAnimationDriver.ɵprov = ɵngcc0.ɵɵdefineInjectable({ token: NoopAnimationDriver, factory: NoopAnimationDriver.ɵfac });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(NoopAnimationDriver, [{\n type: Injectable\n }], null, null); })();\n/**\n * \\@publicApi\n * @abstract\n */\nclass AnimationDriver {\n}\nAnimationDriver.NOOP = new NoopAnimationDriver();\nif (false) {\n /** @type {?} */\n AnimationDriver.NOOP;\n /**\n * @abstract\n * @param {?} prop\n * @return {?}\n */\n AnimationDriver.prototype.validateStyleProperty = function (prop) { };\n /**\n * @abstract\n * @param {?} element\n * @param {?} selector\n * @return {?}\n */\n AnimationDriver.prototype.matchesElement = function (element, selector) { };\n /**\n * @abstract\n * @param {?} elm1\n * @param {?} elm2\n * @return {?}\n */\n AnimationDriver.prototype.containsElement = function (elm1, elm2) { };\n /**\n * @abstract\n * @param {?} element\n * @param {?} selector\n * @param {?} multi\n * @return {?}\n */\n AnimationDriver.prototype.query = function (element, selector, multi) { };\n /**\n * @abstract\n * @param {?} element\n * @param {?} prop\n * @param {?=} defaultValue\n * @return {?}\n */\n AnimationDriver.prototype.computeStyle = function (element, prop, defaultValue) { };\n /**\n * @abstract\n * @param {?} element\n * @param {?} keyframes\n * @param {?} duration\n * @param {?} delay\n * @param {?=} easing\n * @param {?=} previousPlayers\n * @param {?=} scrubberAccessRequested\n * @return {?}\n */\n AnimationDriver.prototype.animate = function (element, keyframes, duration, delay, easing, previousPlayers, scrubberAccessRequested) { };\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/util.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst ONE_SECOND = 1000;\n/** @type {?} */\nconst SUBSTITUTION_EXPR_START = '{{';\n/** @type {?} */\nconst SUBSTITUTION_EXPR_END = '}}';\n/** @type {?} */\nconst ENTER_CLASSNAME = 'ng-enter';\n/** @type {?} */\nconst LEAVE_CLASSNAME = 'ng-leave';\n/** @type {?} */\nconst ENTER_SELECTOR = '.ng-enter';\n/** @type {?} */\nconst LEAVE_SELECTOR = '.ng-leave';\n/** @type {?} */\nconst NG_TRIGGER_CLASSNAME = 'ng-trigger';\n/** @type {?} */\nconst NG_TRIGGER_SELECTOR = '.ng-trigger';\n/** @type {?} */\nconst NG_ANIMATING_CLASSNAME = 'ng-animating';\n/** @type {?} */\nconst NG_ANIMATING_SELECTOR = '.ng-animating';\n/**\n * @param {?} value\n * @return {?}\n */\nfunction resolveTimingValue(value) {\n if (typeof value == 'number')\n return value;\n /** @type {?} */\n const matches = value.match(/^(-?[\\.\\d]+)(m?s)/);\n if (!matches || matches.length < 2)\n return 0;\n return _convertTimeValueToMS(parseFloat(matches[1]), matches[2]);\n}\n/**\n * @param {?} value\n * @param {?} unit\n * @return {?}\n */\nfunction _convertTimeValueToMS(value, unit) {\n switch (unit) {\n case 's':\n return value * ONE_SECOND;\n default: // ms or something else\n return value;\n }\n}\n/**\n * @param {?} timings\n * @param {?} errors\n * @param {?=} allowNegativeValues\n * @return {?}\n */\nfunction resolveTiming(timings, errors, allowNegativeValues) {\n return timings.hasOwnProperty('duration') ?\n (/** @type {?} */ (timings)) :\n parseTimeExpression((/** @type {?} */ (timings)), errors, allowNegativeValues);\n}\n/**\n * @param {?} exp\n * @param {?} errors\n * @param {?=} allowNegativeValues\n * @return {?}\n */\nfunction parseTimeExpression(exp, errors, allowNegativeValues) {\n /** @type {?} */\n const regex = /^(-?[\\.\\d]+)(m?s)(?:\\s+(-?[\\.\\d]+)(m?s))?(?:\\s+([-a-z]+(?:\\(.+?\\))?))?$/i;\n /** @type {?} */\n let duration;\n /** @type {?} */\n let delay = 0;\n /** @type {?} */\n let easing = '';\n if (typeof exp === 'string') {\n /** @type {?} */\n const matches = exp.match(regex);\n if (matches === null) {\n errors.push(`The provided timing value \"${exp}\" is invalid.`);\n return { duration: 0, delay: 0, easing: '' };\n }\n duration = _convertTimeValueToMS(parseFloat(matches[1]), matches[2]);\n /** @type {?} */\n const delayMatch = matches[3];\n if (delayMatch != null) {\n delay = _convertTimeValueToMS(parseFloat(delayMatch), matches[4]);\n }\n /** @type {?} */\n const easingVal = matches[5];\n if (easingVal) {\n easing = easingVal;\n }\n }\n else {\n duration = exp;\n }\n if (!allowNegativeValues) {\n /** @type {?} */\n let containsErrors = false;\n /** @type {?} */\n let startIndex = errors.length;\n if (duration < 0) {\n errors.push(`Duration values below 0 are not allowed for this animation step.`);\n containsErrors = true;\n }\n if (delay < 0) {\n errors.push(`Delay values below 0 are not allowed for this animation step.`);\n containsErrors = true;\n }\n if (containsErrors) {\n errors.splice(startIndex, 0, `The provided timing value \"${exp}\" is invalid.`);\n }\n }\n return { duration, delay, easing };\n}\n/**\n * @param {?} obj\n * @param {?=} destination\n * @return {?}\n */\nfunction copyObj(obj, destination = {}) {\n Object.keys(obj).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n destination[prop] = obj[prop];\n }));\n return destination;\n}\n/**\n * @param {?} styles\n * @return {?}\n */\nfunction normalizeStyles(styles) {\n /** @type {?} */\n const normalizedStyles = {};\n if (Array.isArray(styles)) {\n styles.forEach((/**\n * @param {?} data\n * @return {?}\n */\n data => copyStyles(data, false, normalizedStyles)));\n }\n else {\n copyStyles(styles, false, normalizedStyles);\n }\n return normalizedStyles;\n}\n/**\n * @param {?} styles\n * @param {?} readPrototype\n * @param {?=} destination\n * @return {?}\n */\nfunction copyStyles(styles, readPrototype, destination = {}) {\n if (readPrototype) {\n // we make use of a for-in loop so that the\n // prototypically inherited properties are\n // revealed from the backFill map\n for (let prop in styles) {\n destination[prop] = styles[prop];\n }\n }\n else {\n copyObj(styles, destination);\n }\n return destination;\n}\n/**\n * @param {?} element\n * @param {?} key\n * @param {?} value\n * @return {?}\n */\nfunction getStyleAttributeString(element, key, value) {\n // Return the key-value pair string to be added to the style attribute for the\n // given CSS style key.\n if (value) {\n return key + ':' + value + ';';\n }\n else {\n return '';\n }\n}\n/**\n * @param {?} element\n * @return {?}\n */\nfunction writeStyleAttribute(element) {\n // Read the style property of the element and manually reflect it to the\n // style attribute. This is needed because Domino on platform-server doesn't\n // understand the full set of allowed CSS properties and doesn't reflect some\n // of them automatically.\n /** @type {?} */\n let styleAttrValue = '';\n for (let i = 0; i < element.style.length; i++) {\n /** @type {?} */\n const key = element.style.item(i);\n styleAttrValue += getStyleAttributeString(element, key, element.style.getPropertyValue(key));\n }\n for (const key in element.style) {\n // Skip internal Domino properties that don't need to be reflected.\n if (!element.style.hasOwnProperty(key) || key.startsWith('_')) {\n continue;\n }\n /** @type {?} */\n const dashKey = camelCaseToDashCase(key);\n styleAttrValue += getStyleAttributeString(element, dashKey, element.style[key]);\n }\n element.setAttribute('style', styleAttrValue);\n}\n/**\n * @param {?} element\n * @param {?} styles\n * @param {?=} formerStyles\n * @return {?}\n */\nfunction setStyles(element, styles, formerStyles) {\n if (element['style']) {\n Object.keys(styles).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n /** @type {?} */\n const camelProp = dashCaseToCamelCase(prop);\n if (formerStyles && !formerStyles.hasOwnProperty(prop)) {\n formerStyles[prop] = element.style[camelProp];\n }\n element.style[camelProp] = styles[prop];\n }));\n // On the server set the 'style' attribute since it's not automatically reflected.\n if (isNode()) {\n writeStyleAttribute(element);\n }\n }\n}\n/**\n * @param {?} element\n * @param {?} styles\n * @return {?}\n */\nfunction eraseStyles(element, styles) {\n if (element['style']) {\n Object.keys(styles).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n /** @type {?} */\n const camelProp = dashCaseToCamelCase(prop);\n element.style[camelProp] = '';\n }));\n // On the server set the 'style' attribute since it's not automatically reflected.\n if (isNode()) {\n writeStyleAttribute(element);\n }\n }\n}\n/**\n * @param {?} steps\n * @return {?}\n */\nfunction normalizeAnimationEntry(steps) {\n if (Array.isArray(steps)) {\n if (steps.length == 1)\n return steps[0];\n return sequence(steps);\n }\n return (/** @type {?} */ (steps));\n}\n/**\n * @param {?} value\n * @param {?} options\n * @param {?} errors\n * @return {?}\n */\nfunction validateStyleParams(value, options, errors) {\n /** @type {?} */\n const params = options.params || {};\n /** @type {?} */\n const matches = extractStyleParams(value);\n if (matches.length) {\n matches.forEach((/**\n * @param {?} varName\n * @return {?}\n */\n varName => {\n if (!params.hasOwnProperty(varName)) {\n errors.push(`Unable to resolve the local animation param ${varName} in the given list of values`);\n }\n }));\n }\n}\n/** @type {?} */\nconst PARAM_REGEX = new RegExp(`${SUBSTITUTION_EXPR_START}\\\\s*(.+?)\\\\s*${SUBSTITUTION_EXPR_END}`, 'g');\n/**\n * @param {?} value\n * @return {?}\n */\nfunction extractStyleParams(value) {\n /** @type {?} */\n let params = [];\n if (typeof value === 'string') {\n /** @type {?} */\n let match;\n while (match = PARAM_REGEX.exec(value)) {\n params.push((/** @type {?} */ (match[1])));\n }\n PARAM_REGEX.lastIndex = 0;\n }\n return params;\n}\n/**\n * @param {?} value\n * @param {?} params\n * @param {?} errors\n * @return {?}\n */\nfunction interpolateParams(value, params, errors) {\n /** @type {?} */\n const original = value.toString();\n /** @type {?} */\n const str = original.replace(PARAM_REGEX, (/**\n * @param {?} _\n * @param {?} varName\n * @return {?}\n */\n (_, varName) => {\n /** @type {?} */\n let localVal = params[varName];\n // this means that the value was never overridden by the data passed in by the user\n if (!params.hasOwnProperty(varName)) {\n errors.push(`Please provide a value for the animation param ${varName}`);\n localVal = '';\n }\n return localVal.toString();\n }));\n // we do this to assert that numeric values stay as they are\n return str == original ? value : str;\n}\n/**\n * @param {?} iterator\n * @return {?}\n */\nfunction iteratorToArray(iterator) {\n /** @type {?} */\n const arr = [];\n /** @type {?} */\n let item = iterator.next();\n while (!item.done) {\n arr.push(item.value);\n item = iterator.next();\n }\n return arr;\n}\n/**\n * @param {?} source\n * @param {?} destination\n * @return {?}\n */\nfunction mergeAnimationOptions(source, destination) {\n if (source.params) {\n /** @type {?} */\n const p0 = source.params;\n if (!destination.params) {\n destination.params = {};\n }\n /** @type {?} */\n const p1 = destination.params;\n Object.keys(p0).forEach((/**\n * @param {?} param\n * @return {?}\n */\n param => {\n if (!p1.hasOwnProperty(param)) {\n p1[param] = p0[param];\n }\n }));\n }\n return destination;\n}\n/** @type {?} */\nconst DASH_CASE_REGEXP = /-+([a-z0-9])/g;\n/**\n * @param {?} input\n * @return {?}\n */\nfunction dashCaseToCamelCase(input) {\n return input.replace(DASH_CASE_REGEXP, (/**\n * @param {...?} m\n * @return {?}\n */\n (...m) => m[1].toUpperCase()));\n}\n/**\n * @param {?} input\n * @return {?}\n */\nfunction camelCaseToDashCase(input) {\n return input.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();\n}\n/**\n * @param {?} duration\n * @param {?} delay\n * @return {?}\n */\nfunction allowPreviousPlayerStylesMerge(duration, delay) {\n return duration === 0 || delay === 0;\n}\n/**\n * @param {?} element\n * @param {?} keyframes\n * @param {?} previousStyles\n * @return {?}\n */\nfunction balancePreviousStylesIntoKeyframes(element, keyframes, previousStyles) {\n /** @type {?} */\n const previousStyleProps = Object.keys(previousStyles);\n if (previousStyleProps.length && keyframes.length) {\n /** @type {?} */\n let startingKeyframe = keyframes[0];\n /** @type {?} */\n let missingStyleProps = [];\n previousStyleProps.forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n if (!startingKeyframe.hasOwnProperty(prop)) {\n missingStyleProps.push(prop);\n }\n startingKeyframe[prop] = previousStyles[prop];\n }));\n if (missingStyleProps.length) {\n // tslint:disable-next-line\n for (var i = 1; i < keyframes.length; i++) {\n /** @type {?} */\n let kf = keyframes[i];\n missingStyleProps.forEach((/**\n * @param {?} prop\n * @return {?}\n */\n function (prop) {\n kf[prop] = computeStyle(element, prop);\n }));\n }\n }\n }\n return keyframes;\n}\n/**\n * @param {?} visitor\n * @param {?} node\n * @param {?} context\n * @return {?}\n */\nfunction visitDslNode(visitor, node, context) {\n switch (node.type) {\n case 7 /* Trigger */:\n return visitor.visitTrigger(node, context);\n case 0 /* State */:\n return visitor.visitState(node, context);\n case 1 /* Transition */:\n return visitor.visitTransition(node, context);\n case 2 /* Sequence */:\n return visitor.visitSequence(node, context);\n case 3 /* Group */:\n return visitor.visitGroup(node, context);\n case 4 /* Animate */:\n return visitor.visitAnimate(node, context);\n case 5 /* Keyframes */:\n return visitor.visitKeyframes(node, context);\n case 6 /* Style */:\n return visitor.visitStyle(node, context);\n case 8 /* Reference */:\n return visitor.visitReference(node, context);\n case 9 /* AnimateChild */:\n return visitor.visitAnimateChild(node, context);\n case 10 /* AnimateRef */:\n return visitor.visitAnimateRef(node, context);\n case 11 /* Query */:\n return visitor.visitQuery(node, context);\n case 12 /* Stagger */:\n return visitor.visitStagger(node, context);\n default:\n throw new Error(`Unable to resolve animation metadata node #${node.type}`);\n }\n}\n/**\n * @param {?} element\n * @param {?} prop\n * @return {?}\n */\nfunction computeStyle(element, prop) {\n return ((/** @type {?} */ (window.getComputedStyle(element))))[prop];\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/dsl/animation_transition_expr.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. 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 * @type {?}\n */\nconst ANY_STATE = '*';\n/**\n * @param {?} transitionValue\n * @param {?} errors\n * @return {?}\n */\nfunction parseTransitionExpr(transitionValue, errors) {\n /** @type {?} */\n const expressions = [];\n if (typeof transitionValue == 'string') {\n transitionValue.split(/\\s*,\\s*/).forEach((/**\n * @param {?} str\n * @return {?}\n */\n str => parseInnerTransitionStr(str, expressions, errors)));\n }\n else {\n expressions.push((/** @type {?} */ (transitionValue)));\n }\n return expressions;\n}\n/**\n * @param {?} eventStr\n * @param {?} expressions\n * @param {?} errors\n * @return {?}\n */\nfunction parseInnerTransitionStr(eventStr, expressions, errors) {\n if (eventStr[0] == ':') {\n /** @type {?} */\n const result = parseAnimationAlias(eventStr, errors);\n if (typeof result == 'function') {\n expressions.push(result);\n return;\n }\n eventStr = result;\n }\n /** @type {?} */\n const match = eventStr.match(/^(\\*|[-\\w]+)\\s*()\\s*(\\*|[-\\w]+)$/);\n if (match == null || match.length < 4) {\n errors.push(`The provided transition expression \"${eventStr}\" is not supported`);\n return expressions;\n }\n /** @type {?} */\n const fromState = match[1];\n /** @type {?} */\n const separator = match[2];\n /** @type {?} */\n const toState = match[3];\n expressions.push(makeLambdaFromStates(fromState, toState));\n /** @type {?} */\n const isFullAnyStateExpr = fromState == ANY_STATE && toState == ANY_STATE;\n if (separator[0] == '<' && !isFullAnyStateExpr) {\n expressions.push(makeLambdaFromStates(toState, fromState));\n }\n}\n/**\n * @param {?} alias\n * @param {?} errors\n * @return {?}\n */\nfunction parseAnimationAlias(alias, errors) {\n switch (alias) {\n case ':enter':\n return 'void => *';\n case ':leave':\n return '* => void';\n case ':increment':\n return (/**\n * @param {?} fromState\n * @param {?} toState\n * @return {?}\n */\n (fromState, toState) => parseFloat(toState) > parseFloat(fromState));\n case ':decrement':\n return (/**\n * @param {?} fromState\n * @param {?} toState\n * @return {?}\n */\n (fromState, toState) => parseFloat(toState) < parseFloat(fromState));\n default:\n errors.push(`The transition alias value \"${alias}\" is not supported`);\n return '* => *';\n }\n}\n// DO NOT REFACTOR ... keep the follow set instantiations\n// with the values intact (closure compiler for some reason\n// removes follow-up lines that add the values outside of\n// the constructor...\n/** @type {?} */\nconst TRUE_BOOLEAN_VALUES = new Set(['true', '1']);\n/** @type {?} */\nconst FALSE_BOOLEAN_VALUES = new Set(['false', '0']);\n/**\n * @param {?} lhs\n * @param {?} rhs\n * @return {?}\n */\nfunction makeLambdaFromStates(lhs, rhs) {\n /** @type {?} */\n const LHS_MATCH_BOOLEAN = TRUE_BOOLEAN_VALUES.has(lhs) || FALSE_BOOLEAN_VALUES.has(lhs);\n /** @type {?} */\n const RHS_MATCH_BOOLEAN = TRUE_BOOLEAN_VALUES.has(rhs) || FALSE_BOOLEAN_VALUES.has(rhs);\n return (/**\n * @param {?} fromState\n * @param {?} toState\n * @return {?}\n */\n (fromState, toState) => {\n /** @type {?} */\n let lhsMatch = lhs == ANY_STATE || lhs == fromState;\n /** @type {?} */\n let rhsMatch = rhs == ANY_STATE || rhs == toState;\n if (!lhsMatch && LHS_MATCH_BOOLEAN && typeof fromState === 'boolean') {\n lhsMatch = fromState ? TRUE_BOOLEAN_VALUES.has(lhs) : FALSE_BOOLEAN_VALUES.has(lhs);\n }\n if (!rhsMatch && RHS_MATCH_BOOLEAN && typeof toState === 'boolean') {\n rhsMatch = toState ? TRUE_BOOLEAN_VALUES.has(rhs) : FALSE_BOOLEAN_VALUES.has(rhs);\n }\n return lhsMatch && rhsMatch;\n });\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/dsl/animation_ast_builder.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst SELF_TOKEN = ':self';\n/** @type {?} */\nconst SELF_TOKEN_REGEX = new RegExp(`\\s*${SELF_TOKEN}\\s*,?`, 'g');\n/*\n * [Validation]\n * The visitor code below will traverse the animation AST generated by the animation verb functions\n * (the output is a tree of objects) and attempt to perform a series of validations on the data. The\n * following corner-cases will be validated:\n *\n * 1. Overlap of animations\n * Given that a CSS property cannot be animated in more than one place at the same time, it's\n * important that this behavior is detected and validated. The way in which this occurs is that\n * each time a style property is examined, a string-map containing the property will be updated with\n * the start and end times for when the property is used within an animation step.\n *\n * If there are two or more parallel animations that are currently running (these are invoked by the\n * group()) on the same element then the validator will throw an error. Since the start/end timing\n * values are collected for each property then if the current animation step is animating the same\n * property and its timing values fall anywhere into the window of time that the property is\n * currently being animated within then this is what causes an error.\n *\n * 2. Timing values\n * The validator will validate to see if a timing value of `duration delay easing` or\n * `durationNumber` is valid or not.\n *\n * (note that upon validation the code below will replace the timing data with an object containing\n * {duration,delay,easing}.\n *\n * 3. Offset Validation\n * Each of the style() calls are allowed to have an offset value when placed inside of keyframes().\n * Offsets within keyframes() are considered valid when:\n *\n * - No offsets are used at all\n * - Each style() entry contains an offset value\n * - Each offset is between 0 and 1\n * - Each offset is greater to or equal than the previous one\n *\n * Otherwise an error will be thrown.\n */\n/**\n * @param {?} driver\n * @param {?} metadata\n * @param {?} errors\n * @return {?}\n */\nfunction buildAnimationAst(driver, metadata, errors) {\n return new AnimationAstBuilderVisitor(driver).build(metadata, errors);\n}\n/** @type {?} */\nconst ROOT_SELECTOR = '';\nclass AnimationAstBuilderVisitor {\n /**\n * @param {?} _driver\n */\n constructor(_driver) {\n this._driver = _driver;\n }\n /**\n * @param {?} metadata\n * @param {?} errors\n * @return {?}\n */\n build(metadata, errors) {\n /** @type {?} */\n const context = new AnimationAstBuilderContext(errors);\n this._resetContextStyleTimingState(context);\n return (/** @type {?} */ (visitDslNode(this, normalizeAnimationEntry(metadata), context)));\n }\n /**\n * @private\n * @param {?} context\n * @return {?}\n */\n _resetContextStyleTimingState(context) {\n context.currentQuerySelector = ROOT_SELECTOR;\n context.collectedStyles = {};\n context.collectedStyles[ROOT_SELECTOR] = {};\n context.currentTime = 0;\n }\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n visitTrigger(metadata, context) {\n /** @type {?} */\n let queryCount = context.queryCount = 0;\n /** @type {?} */\n let depCount = context.depCount = 0;\n /** @type {?} */\n const states = [];\n /** @type {?} */\n const transitions = [];\n if (metadata.name.charAt(0) == '@') {\n context.errors.push('animation triggers cannot be prefixed with an `@` sign (e.g. trigger(\\'@foo\\', [...]))');\n }\n metadata.definitions.forEach((/**\n * @param {?} def\n * @return {?}\n */\n def => {\n this._resetContextStyleTimingState(context);\n if (def.type == 0 /* State */) {\n /** @type {?} */\n const stateDef = (/** @type {?} */ (def));\n /** @type {?} */\n const name = stateDef.name;\n name.toString().split(/\\s*,\\s*/).forEach((/**\n * @param {?} n\n * @return {?}\n */\n n => {\n stateDef.name = n;\n states.push(this.visitState(stateDef, context));\n }));\n stateDef.name = name;\n }\n else if (def.type == 1 /* Transition */) {\n /** @type {?} */\n const transition = this.visitTransition((/** @type {?} */ (def)), context);\n queryCount += transition.queryCount;\n depCount += transition.depCount;\n transitions.push(transition);\n }\n else {\n context.errors.push('only state() and transition() definitions can sit inside of a trigger()');\n }\n }));\n return {\n type: 7 /* Trigger */,\n name: metadata.name,\n states,\n transitions,\n queryCount,\n depCount,\n options: null\n };\n }\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n visitState(metadata, context) {\n /** @type {?} */\n const styleAst = this.visitStyle(metadata.styles, context);\n /** @type {?} */\n const astParams = (metadata.options && metadata.options.params) || null;\n if (styleAst.containsDynamicStyles) {\n /** @type {?} */\n const missingSubs = new Set();\n /** @type {?} */\n const params = astParams || {};\n styleAst.styles.forEach((/**\n * @param {?} value\n * @return {?}\n */\n value => {\n if (isObject(value)) {\n /** @type {?} */\n const stylesObj = (/** @type {?} */ (value));\n Object.keys(stylesObj).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n extractStyleParams(stylesObj[prop]).forEach((/**\n * @param {?} sub\n * @return {?}\n */\n sub => {\n if (!params.hasOwnProperty(sub)) {\n missingSubs.add(sub);\n }\n }));\n }));\n }\n }));\n if (missingSubs.size) {\n /** @type {?} */\n const missingSubsArr = iteratorToArray(missingSubs.values());\n context.errors.push(`state(\"${metadata\n .name}\", ...) must define default values for all the following style substitutions: ${missingSubsArr.join(', ')}`);\n }\n }\n return {\n type: 0 /* State */,\n name: metadata.name,\n style: styleAst,\n options: astParams ? { params: astParams } : null\n };\n }\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n visitTransition(metadata, context) {\n context.queryCount = 0;\n context.depCount = 0;\n /** @type {?} */\n const animation = visitDslNode(this, normalizeAnimationEntry(metadata.animation), context);\n /** @type {?} */\n const matchers = parseTransitionExpr(metadata.expr, context.errors);\n return {\n type: 1 /* Transition */,\n matchers,\n animation,\n queryCount: context.queryCount,\n depCount: context.depCount,\n options: normalizeAnimationOptions(metadata.options)\n };\n }\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n visitSequence(metadata, context) {\n return {\n type: 2 /* Sequence */,\n steps: metadata.steps.map((/**\n * @param {?} s\n * @return {?}\n */\n s => visitDslNode(this, s, context))),\n options: normalizeAnimationOptions(metadata.options)\n };\n }\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n visitGroup(metadata, context) {\n /** @type {?} */\n const currentTime = context.currentTime;\n /** @type {?} */\n let furthestTime = 0;\n /** @type {?} */\n const steps = metadata.steps.map((/**\n * @param {?} step\n * @return {?}\n */\n step => {\n context.currentTime = currentTime;\n /** @type {?} */\n const innerAst = visitDslNode(this, step, context);\n furthestTime = Math.max(furthestTime, context.currentTime);\n return innerAst;\n }));\n context.currentTime = furthestTime;\n return {\n type: 3 /* Group */,\n steps,\n options: normalizeAnimationOptions(metadata.options)\n };\n }\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n visitAnimate(metadata, context) {\n /** @type {?} */\n const timingAst = constructTimingAst(metadata.timings, context.errors);\n context.currentAnimateTimings = timingAst;\n /** @type {?} */\n let styleAst;\n /** @type {?} */\n let styleMetadata = metadata.styles ? metadata.styles : style({});\n if (styleMetadata.type == 5 /* Keyframes */) {\n styleAst = this.visitKeyframes((/** @type {?} */ (styleMetadata)), context);\n }\n else {\n /** @type {?} */\n let styleMetadata = (/** @type {?} */ (metadata.styles));\n /** @type {?} */\n let isEmpty = false;\n if (!styleMetadata) {\n isEmpty = true;\n /** @type {?} */\n const newStyleData = {};\n if (timingAst.easing) {\n newStyleData['easing'] = timingAst.easing;\n }\n styleMetadata = style(newStyleData);\n }\n context.currentTime += timingAst.duration + timingAst.delay;\n /** @type {?} */\n const _styleAst = this.visitStyle(styleMetadata, context);\n _styleAst.isEmptyStep = isEmpty;\n styleAst = _styleAst;\n }\n context.currentAnimateTimings = null;\n return {\n type: 4 /* Animate */,\n timings: timingAst,\n style: styleAst,\n options: null\n };\n }\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n visitStyle(metadata, context) {\n /** @type {?} */\n const ast = this._makeStyleAst(metadata, context);\n this._validateStyleAst(ast, context);\n return ast;\n }\n /**\n * @private\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n _makeStyleAst(metadata, context) {\n /** @type {?} */\n const styles = [];\n if (Array.isArray(metadata.styles)) {\n ((/** @type {?} */ (metadata.styles))).forEach((/**\n * @param {?} styleTuple\n * @return {?}\n */\n styleTuple => {\n if (typeof styleTuple == 'string') {\n if (styleTuple == AUTO_STYLE) {\n styles.push(styleTuple);\n }\n else {\n context.errors.push(`The provided style string value ${styleTuple} is not allowed.`);\n }\n }\n else {\n styles.push(styleTuple);\n }\n }));\n }\n else {\n styles.push(metadata.styles);\n }\n /** @type {?} */\n let containsDynamicStyles = false;\n /** @type {?} */\n let collectedEasing = null;\n styles.forEach((/**\n * @param {?} styleData\n * @return {?}\n */\n styleData => {\n if (isObject(styleData)) {\n /** @type {?} */\n const styleMap = (/** @type {?} */ (styleData));\n /** @type {?} */\n const easing = styleMap['easing'];\n if (easing) {\n collectedEasing = (/** @type {?} */ (easing));\n delete styleMap['easing'];\n }\n if (!containsDynamicStyles) {\n for (let prop in styleMap) {\n /** @type {?} */\n const value = styleMap[prop];\n if (value.toString().indexOf(SUBSTITUTION_EXPR_START) >= 0) {\n containsDynamicStyles = true;\n break;\n }\n }\n }\n }\n }));\n return {\n type: 6 /* Style */,\n styles,\n easing: collectedEasing,\n offset: metadata.offset,\n containsDynamicStyles,\n options: null\n };\n }\n /**\n * @private\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n _validateStyleAst(ast, context) {\n /** @type {?} */\n const timings = context.currentAnimateTimings;\n /** @type {?} */\n let endTime = context.currentTime;\n /** @type {?} */\n let startTime = context.currentTime;\n if (timings && startTime > 0) {\n startTime -= timings.duration + timings.delay;\n }\n ast.styles.forEach((/**\n * @param {?} tuple\n * @return {?}\n */\n tuple => {\n if (typeof tuple == 'string')\n return;\n Object.keys(tuple).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n if (!this._driver.validateStyleProperty(prop)) {\n context.errors.push(`The provided animation property \"${prop}\" is not a supported CSS property for animations`);\n return;\n }\n /** @type {?} */\n const collectedStyles = context.collectedStyles[(/** @type {?} */ (context.currentQuerySelector))];\n /** @type {?} */\n const collectedEntry = collectedStyles[prop];\n /** @type {?} */\n let updateCollectedStyle = true;\n if (collectedEntry) {\n if (startTime != endTime && startTime >= collectedEntry.startTime &&\n endTime <= collectedEntry.endTime) {\n context.errors.push(`The CSS property \"${prop}\" that exists between the times of \"${collectedEntry.startTime}ms\" and \"${collectedEntry\n .endTime}ms\" is also being animated in a parallel animation between the times of \"${startTime}ms\" and \"${endTime}ms\"`);\n updateCollectedStyle = false;\n }\n // we always choose the smaller start time value since we\n // want to have a record of the entire animation window where\n // the style property is being animated in between\n startTime = collectedEntry.startTime;\n }\n if (updateCollectedStyle) {\n collectedStyles[prop] = { startTime, endTime };\n }\n if (context.options) {\n validateStyleParams(tuple[prop], context.options, context.errors);\n }\n }));\n }));\n }\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n visitKeyframes(metadata, context) {\n /** @type {?} */\n const ast = { type: 5 /* Keyframes */, styles: [], options: null };\n if (!context.currentAnimateTimings) {\n context.errors.push(`keyframes() must be placed inside of a call to animate()`);\n return ast;\n }\n /** @type {?} */\n const MAX_KEYFRAME_OFFSET = 1;\n /** @type {?} */\n let totalKeyframesWithOffsets = 0;\n /** @type {?} */\n const offsets = [];\n /** @type {?} */\n let offsetsOutOfOrder = false;\n /** @type {?} */\n let keyframesOutOfRange = false;\n /** @type {?} */\n let previousOffset = 0;\n /** @type {?} */\n const keyframes = metadata.steps.map((/**\n * @param {?} styles\n * @return {?}\n */\n styles => {\n /** @type {?} */\n const style = this._makeStyleAst(styles, context);\n /** @type {?} */\n let offsetVal = style.offset != null ? style.offset : consumeOffset(style.styles);\n /** @type {?} */\n let offset = 0;\n if (offsetVal != null) {\n totalKeyframesWithOffsets++;\n offset = style.offset = offsetVal;\n }\n keyframesOutOfRange = keyframesOutOfRange || offset < 0 || offset > 1;\n offsetsOutOfOrder = offsetsOutOfOrder || offset < previousOffset;\n previousOffset = offset;\n offsets.push(offset);\n return style;\n }));\n if (keyframesOutOfRange) {\n context.errors.push(`Please ensure that all keyframe offsets are between 0 and 1`);\n }\n if (offsetsOutOfOrder) {\n context.errors.push(`Please ensure that all keyframe offsets are in order`);\n }\n /** @type {?} */\n const length = metadata.steps.length;\n /** @type {?} */\n let generatedOffset = 0;\n if (totalKeyframesWithOffsets > 0 && totalKeyframesWithOffsets < length) {\n context.errors.push(`Not all style() steps within the declared keyframes() contain offsets`);\n }\n else if (totalKeyframesWithOffsets == 0) {\n generatedOffset = MAX_KEYFRAME_OFFSET / (length - 1);\n }\n /** @type {?} */\n const limit = length - 1;\n /** @type {?} */\n const currentTime = context.currentTime;\n /** @type {?} */\n const currentAnimateTimings = (/** @type {?} */ (context.currentAnimateTimings));\n /** @type {?} */\n const animateDuration = currentAnimateTimings.duration;\n keyframes.forEach((/**\n * @param {?} kf\n * @param {?} i\n * @return {?}\n */\n (kf, i) => {\n /** @type {?} */\n const offset = generatedOffset > 0 ? (i == limit ? 1 : (generatedOffset * i)) : offsets[i];\n /** @type {?} */\n const durationUpToThisFrame = offset * animateDuration;\n context.currentTime = currentTime + currentAnimateTimings.delay + durationUpToThisFrame;\n currentAnimateTimings.duration = durationUpToThisFrame;\n this._validateStyleAst(kf, context);\n kf.offset = offset;\n ast.styles.push(kf);\n }));\n return ast;\n }\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n visitReference(metadata, context) {\n return {\n type: 8 /* Reference */,\n animation: visitDslNode(this, normalizeAnimationEntry(metadata.animation), context),\n options: normalizeAnimationOptions(metadata.options)\n };\n }\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n visitAnimateChild(metadata, context) {\n context.depCount++;\n return {\n type: 9 /* AnimateChild */,\n options: normalizeAnimationOptions(metadata.options)\n };\n }\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n visitAnimateRef(metadata, context) {\n return {\n type: 10 /* AnimateRef */,\n animation: this.visitReference(metadata.animation, context),\n options: normalizeAnimationOptions(metadata.options)\n };\n }\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n visitQuery(metadata, context) {\n /** @type {?} */\n const parentSelector = (/** @type {?} */ (context.currentQuerySelector));\n /** @type {?} */\n const options = (/** @type {?} */ ((metadata.options || {})));\n context.queryCount++;\n context.currentQuery = metadata;\n const [selector, includeSelf] = normalizeSelector(metadata.selector);\n context.currentQuerySelector =\n parentSelector.length ? (parentSelector + ' ' + selector) : selector;\n getOrSetAsInMap(context.collectedStyles, context.currentQuerySelector, {});\n /** @type {?} */\n const animation = visitDslNode(this, normalizeAnimationEntry(metadata.animation), context);\n context.currentQuery = null;\n context.currentQuerySelector = parentSelector;\n return {\n type: 11 /* Query */,\n selector,\n limit: options.limit || 0,\n optional: !!options.optional,\n includeSelf,\n animation,\n originalSelector: metadata.selector,\n options: normalizeAnimationOptions(metadata.options)\n };\n }\n /**\n * @param {?} metadata\n * @param {?} context\n * @return {?}\n */\n visitStagger(metadata, context) {\n if (!context.currentQuery) {\n context.errors.push(`stagger() can only be used inside of query()`);\n }\n /** @type {?} */\n const timings = metadata.timings === 'full' ?\n { duration: 0, delay: 0, easing: 'full' } :\n resolveTiming(metadata.timings, context.errors, true);\n return {\n type: 12 /* Stagger */,\n animation: visitDslNode(this, normalizeAnimationEntry(metadata.animation), context),\n timings,\n options: null\n };\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n AnimationAstBuilderVisitor.prototype._driver;\n}\n/**\n * @param {?} selector\n * @return {?}\n */\nfunction normalizeSelector(selector) {\n /** @type {?} */\n const hasAmpersand = selector.split(/\\s*,\\s*/).find((/**\n * @param {?} token\n * @return {?}\n */\n token => token == SELF_TOKEN)) ? true : false;\n if (hasAmpersand) {\n selector = selector.replace(SELF_TOKEN_REGEX, '');\n }\n // the :enter and :leave selectors are filled in at runtime during timeline building\n selector = selector.replace(/@\\*/g, NG_TRIGGER_SELECTOR)\n .replace(/@\\w+/g, (/**\n * @param {?} match\n * @return {?}\n */\n match => NG_TRIGGER_SELECTOR + '-' + match.substr(1)))\n .replace(/:animating/g, NG_ANIMATING_SELECTOR);\n return [selector, hasAmpersand];\n}\n/**\n * @param {?} obj\n * @return {?}\n */\nfunction normalizeParams(obj) {\n return obj ? copyObj(obj) : null;\n}\nclass AnimationAstBuilderContext {\n /**\n * @param {?} errors\n */\n constructor(errors) {\n this.errors = errors;\n this.queryCount = 0;\n this.depCount = 0;\n this.currentTransition = null;\n this.currentQuery = null;\n this.currentQuerySelector = null;\n this.currentAnimateTimings = null;\n this.currentTime = 0;\n this.collectedStyles = {};\n this.options = null;\n }\n}\nif (false) {\n /** @type {?} */\n AnimationAstBuilderContext.prototype.queryCount;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.depCount;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.currentTransition;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.currentQuery;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.currentQuerySelector;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.currentAnimateTimings;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.currentTime;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.collectedStyles;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.options;\n /** @type {?} */\n AnimationAstBuilderContext.prototype.errors;\n}\n/**\n * @param {?} styles\n * @return {?}\n */\nfunction consumeOffset(styles) {\n if (typeof styles == 'string')\n return null;\n /** @type {?} */\n let offset = null;\n if (Array.isArray(styles)) {\n styles.forEach((/**\n * @param {?} styleTuple\n * @return {?}\n */\n styleTuple => {\n if (isObject(styleTuple) && styleTuple.hasOwnProperty('offset')) {\n /** @type {?} */\n const obj = (/** @type {?} */ (styleTuple));\n offset = parseFloat((/** @type {?} */ (obj['offset'])));\n delete obj['offset'];\n }\n }));\n }\n else if (isObject(styles) && styles.hasOwnProperty('offset')) {\n /** @type {?} */\n const obj = styles;\n offset = parseFloat((/** @type {?} */ (obj['offset'])));\n delete obj['offset'];\n }\n return offset;\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction isObject(value) {\n return !Array.isArray(value) && typeof value == 'object';\n}\n/**\n * @param {?} value\n * @param {?} errors\n * @return {?}\n */\nfunction constructTimingAst(value, errors) {\n /** @type {?} */\n let timings = null;\n if (value.hasOwnProperty('duration')) {\n timings = (/** @type {?} */ (value));\n }\n else if (typeof value == 'number') {\n /** @type {?} */\n const duration = resolveTiming(value, errors).duration;\n return makeTimingAst(duration, 0, '');\n }\n /** @type {?} */\n const strValue = (/** @type {?} */ (value));\n /** @type {?} */\n const isDynamic = strValue.split(/\\s+/).some((/**\n * @param {?} v\n * @return {?}\n */\n v => v.charAt(0) == '{' && v.charAt(1) == '{'));\n if (isDynamic) {\n /** @type {?} */\n const ast = (/** @type {?} */ (makeTimingAst(0, 0, '')));\n ast.dynamic = true;\n ast.strValue = strValue;\n return (/** @type {?} */ (ast));\n }\n timings = timings || resolveTiming(strValue, errors);\n return makeTimingAst(timings.duration, timings.delay, timings.easing);\n}\n/**\n * @param {?} options\n * @return {?}\n */\nfunction normalizeAnimationOptions(options) {\n if (options) {\n options = copyObj(options);\n if (options['params']) {\n options['params'] = (/** @type {?} */ (normalizeParams(options['params'])));\n }\n }\n else {\n options = {};\n }\n return options;\n}\n/**\n * @param {?} duration\n * @param {?} delay\n * @param {?} easing\n * @return {?}\n */\nfunction makeTimingAst(duration, delay, easing) {\n return { duration, delay, easing };\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/dsl/animation_timeline_instruction.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @record\n */\nfunction AnimationTimelineInstruction() { }\nif (false) {\n /** @type {?} */\n AnimationTimelineInstruction.prototype.element;\n /** @type {?} */\n AnimationTimelineInstruction.prototype.keyframes;\n /** @type {?} */\n AnimationTimelineInstruction.prototype.preStyleProps;\n /** @type {?} */\n AnimationTimelineInstruction.prototype.postStyleProps;\n /** @type {?} */\n AnimationTimelineInstruction.prototype.duration;\n /** @type {?} */\n AnimationTimelineInstruction.prototype.delay;\n /** @type {?} */\n AnimationTimelineInstruction.prototype.totalTime;\n /** @type {?} */\n AnimationTimelineInstruction.prototype.easing;\n /** @type {?|undefined} */\n AnimationTimelineInstruction.prototype.stretchStartingKeyframe;\n /** @type {?} */\n AnimationTimelineInstruction.prototype.subTimeline;\n}\n/**\n * @param {?} element\n * @param {?} keyframes\n * @param {?} preStyleProps\n * @param {?} postStyleProps\n * @param {?} duration\n * @param {?} delay\n * @param {?=} easing\n * @param {?=} subTimeline\n * @return {?}\n */\nfunction createTimelineInstruction(element, keyframes, preStyleProps, postStyleProps, duration, delay, easing = null, subTimeline = false) {\n return {\n type: 1 /* TimelineAnimation */,\n element,\n keyframes,\n preStyleProps,\n postStyleProps,\n duration,\n delay,\n totalTime: duration + delay,\n easing,\n subTimeline\n };\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/dsl/element_instruction_map.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass ElementInstructionMap {\n constructor() {\n this._map = new Map();\n }\n /**\n * @param {?} element\n * @return {?}\n */\n consume(element) {\n /** @type {?} */\n let instructions = this._map.get(element);\n if (instructions) {\n this._map.delete(element);\n }\n else {\n instructions = [];\n }\n return instructions;\n }\n /**\n * @param {?} element\n * @param {?} instructions\n * @return {?}\n */\n append(element, instructions) {\n /** @type {?} */\n let existingInstructions = this._map.get(element);\n if (!existingInstructions) {\n this._map.set(element, existingInstructions = []);\n }\n existingInstructions.push(...instructions);\n }\n /**\n * @param {?} element\n * @return {?}\n */\n has(element) {\n return this._map.has(element);\n }\n /**\n * @return {?}\n */\n clear() {\n this._map.clear();\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n ElementInstructionMap.prototype._map;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/dsl/animation_timeline_builder.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst ONE_FRAME_IN_MILLISECONDS = 1;\n/** @type {?} */\nconst ENTER_TOKEN = ':enter';\n/** @type {?} */\nconst ENTER_TOKEN_REGEX = new RegExp(ENTER_TOKEN, 'g');\n/** @type {?} */\nconst LEAVE_TOKEN = ':leave';\n/** @type {?} */\nconst LEAVE_TOKEN_REGEX = new RegExp(LEAVE_TOKEN, 'g');\n/*\n * The code within this file aims to generate web-animations-compatible keyframes from Angular's\n * animation DSL code.\n *\n * The code below will be converted from:\n *\n * ```\n * sequence([\n * style({ opacity: 0 }),\n * animate(1000, style({ opacity: 0 }))\n * ])\n * ```\n *\n * To:\n * ```\n * keyframes = [{ opacity: 0, offset: 0 }, { opacity: 1, offset: 1 }]\n * duration = 1000\n * delay = 0\n * easing = ''\n * ```\n *\n * For this operation to cover the combination of animation verbs (style, animate, group, etc...) a\n * combination of prototypical inheritance, AST traversal and merge-sort-like algorithms are used.\n *\n * [AST Traversal]\n * Each of the animation verbs, when executed, will return an string-map object representing what\n * type of action it is (style, animate, group, etc...) and the data associated with it. This means\n * that when functional composition mix of these functions is evaluated (like in the example above)\n * then it will end up producing a tree of objects representing the animation itself.\n *\n * When this animation object tree is processed by the visitor code below it will visit each of the\n * verb statements within the visitor. And during each visit it will build the context of the\n * animation keyframes by interacting with the `TimelineBuilder`.\n *\n * [TimelineBuilder]\n * This class is responsible for tracking the styles and building a series of keyframe objects for a\n * timeline between a start and end time. The builder starts off with an initial timeline and each\n * time the AST comes across a `group()`, `keyframes()` or a combination of the two wihtin a\n * `sequence()` then it will generate a sub timeline for each step as well as a new one after\n * they are complete.\n *\n * As the AST is traversed, the timing state on each of the timelines will be incremented. If a sub\n * timeline was created (based on one of the cases above) then the parent timeline will attempt to\n * merge the styles used within the sub timelines into itself (only with group() this will happen).\n * This happens with a merge operation (much like how the merge works in mergesort) and it will only\n * copy the most recently used styles from the sub timelines into the parent timeline. This ensures\n * that if the styles are used later on in another phase of the animation then they will be the most\n * up-to-date values.\n *\n * [How Missing Styles Are Updated]\n * Each timeline has a `backFill` property which is responsible for filling in new styles into\n * already processed keyframes if a new style shows up later within the animation sequence.\n *\n * ```\n * sequence([\n * style({ width: 0 }),\n * animate(1000, style({ width: 100 })),\n * animate(1000, style({ width: 200 })),\n * animate(1000, style({ width: 300 }))\n * animate(1000, style({ width: 400, height: 400 })) // notice how `height` doesn't exist anywhere\n * else\n * ])\n * ```\n *\n * What is happening here is that the `height` value is added later in the sequence, but is missing\n * from all previous animation steps. Therefore when a keyframe is created it would also be missing\n * from all previous keyframes up until where it is first used. For the timeline keyframe generation\n * to properly fill in the style it will place the previous value (the value from the parent\n * timeline) or a default value of `*` into the backFill object. Given that each of the keyframe\n * styles are objects that prototypically inhert from the backFill object, this means that if a\n * value is added into the backFill then it will automatically propagate any missing values to all\n * keyframes. Therefore the missing `height` value will be properly filled into the already\n * processed keyframes.\n *\n * When a sub-timeline is created it will have its own backFill property. This is done so that\n * styles present within the sub-timeline do not accidentally seep into the previous/future timeline\n * keyframes\n *\n * (For prototypically-inherited contents to be detected a `for(i in obj)` loop must be used.)\n *\n * [Validation]\n * The code in this file is not responsible for validation. That functionality happens with within\n * the `AnimationValidatorVisitor` code.\n */\n/**\n * @param {?} driver\n * @param {?} rootElement\n * @param {?} ast\n * @param {?} enterClassName\n * @param {?} leaveClassName\n * @param {?=} startingStyles\n * @param {?=} finalStyles\n * @param {?=} options\n * @param {?=} subInstructions\n * @param {?=} errors\n * @return {?}\n */\nfunction buildAnimationTimelines(driver, rootElement, ast, enterClassName, leaveClassName, startingStyles = {}, finalStyles = {}, options, subInstructions, errors = []) {\n return new AnimationTimelineBuilderVisitor().buildKeyframes(driver, rootElement, ast, enterClassName, leaveClassName, startingStyles, finalStyles, options, subInstructions, errors);\n}\nclass AnimationTimelineBuilderVisitor {\n /**\n * @param {?} driver\n * @param {?} rootElement\n * @param {?} ast\n * @param {?} enterClassName\n * @param {?} leaveClassName\n * @param {?} startingStyles\n * @param {?} finalStyles\n * @param {?} options\n * @param {?=} subInstructions\n * @param {?=} errors\n * @return {?}\n */\n buildKeyframes(driver, rootElement, ast, enterClassName, leaveClassName, startingStyles, finalStyles, options, subInstructions, errors = []) {\n subInstructions = subInstructions || new ElementInstructionMap();\n /** @type {?} */\n const context = new AnimationTimelineContext(driver, rootElement, subInstructions, enterClassName, leaveClassName, errors, []);\n context.options = options;\n context.currentTimeline.setStyles([startingStyles], null, context.errors, options);\n visitDslNode(this, ast, context);\n // this checks to see if an actual animation happened\n /** @type {?} */\n const timelines = context.timelines.filter((/**\n * @param {?} timeline\n * @return {?}\n */\n timeline => timeline.containsAnimation()));\n if (timelines.length && Object.keys(finalStyles).length) {\n /** @type {?} */\n const tl = timelines[timelines.length - 1];\n if (!tl.allowOnlyTimelineStyles()) {\n tl.setStyles([finalStyles], null, context.errors, options);\n }\n }\n return timelines.length ? timelines.map((/**\n * @param {?} timeline\n * @return {?}\n */\n timeline => timeline.buildKeyframes())) :\n [createTimelineInstruction(rootElement, [], [], [], 0, 0, '', false)];\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n visitTrigger(ast, context) {\n // these values are not visited in this AST\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n visitState(ast, context) {\n // these values are not visited in this AST\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n visitTransition(ast, context) {\n // these values are not visited in this AST\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n visitAnimateChild(ast, context) {\n /** @type {?} */\n const elementInstructions = context.subInstructions.consume(context.element);\n if (elementInstructions) {\n /** @type {?} */\n const innerContext = context.createSubContext(ast.options);\n /** @type {?} */\n const startTime = context.currentTimeline.currentTime;\n /** @type {?} */\n const endTime = this._visitSubInstructions(elementInstructions, innerContext, (/** @type {?} */ (innerContext.options)));\n if (startTime != endTime) {\n // we do this on the upper context because we created a sub context for\n // the sub child animations\n context.transformIntoNewTimeline(endTime);\n }\n }\n context.previousNode = ast;\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n visitAnimateRef(ast, context) {\n /** @type {?} */\n const innerContext = context.createSubContext(ast.options);\n innerContext.transformIntoNewTimeline();\n this.visitReference(ast.animation, innerContext);\n context.transformIntoNewTimeline(innerContext.currentTimeline.currentTime);\n context.previousNode = ast;\n }\n /**\n * @private\n * @param {?} instructions\n * @param {?} context\n * @param {?} options\n * @return {?}\n */\n _visitSubInstructions(instructions, context, options) {\n /** @type {?} */\n const startTime = context.currentTimeline.currentTime;\n /** @type {?} */\n let furthestTime = startTime;\n // this is a special-case for when a user wants to skip a sub\n // animation from being fired entirely.\n /** @type {?} */\n const duration = options.duration != null ? resolveTimingValue(options.duration) : null;\n /** @type {?} */\n const delay = options.delay != null ? resolveTimingValue(options.delay) : null;\n if (duration !== 0) {\n instructions.forEach((/**\n * @param {?} instruction\n * @return {?}\n */\n instruction => {\n /** @type {?} */\n const instructionTimings = context.appendInstructionToTimeline(instruction, duration, delay);\n furthestTime =\n Math.max(furthestTime, instructionTimings.duration + instructionTimings.delay);\n }));\n }\n return furthestTime;\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n visitReference(ast, context) {\n context.updateOptions(ast.options, true);\n visitDslNode(this, ast.animation, context);\n context.previousNode = ast;\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n visitSequence(ast, context) {\n /** @type {?} */\n const subContextCount = context.subContextCount;\n /** @type {?} */\n let ctx = context;\n /** @type {?} */\n const options = ast.options;\n if (options && (options.params || options.delay)) {\n ctx = context.createSubContext(options);\n ctx.transformIntoNewTimeline();\n if (options.delay != null) {\n if (ctx.previousNode.type == 6 /* Style */) {\n ctx.currentTimeline.snapshotCurrentStyles();\n ctx.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;\n }\n /** @type {?} */\n const delay = resolveTimingValue(options.delay);\n ctx.delayNextStep(delay);\n }\n }\n if (ast.steps.length) {\n ast.steps.forEach((/**\n * @param {?} s\n * @return {?}\n */\n s => visitDslNode(this, s, ctx)));\n // this is here just incase the inner steps only contain or end with a style() call\n ctx.currentTimeline.applyStylesToKeyframe();\n // this means that some animation function within the sequence\n // ended up creating a sub timeline (which means the current\n // timeline cannot overlap with the contents of the sequence)\n if (ctx.subContextCount > subContextCount) {\n ctx.transformIntoNewTimeline();\n }\n }\n context.previousNode = ast;\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n visitGroup(ast, context) {\n /** @type {?} */\n const innerTimelines = [];\n /** @type {?} */\n let furthestTime = context.currentTimeline.currentTime;\n /** @type {?} */\n const delay = ast.options && ast.options.delay ? resolveTimingValue(ast.options.delay) : 0;\n ast.steps.forEach((/**\n * @param {?} s\n * @return {?}\n */\n s => {\n /** @type {?} */\n const innerContext = context.createSubContext(ast.options);\n if (delay) {\n innerContext.delayNextStep(delay);\n }\n visitDslNode(this, s, innerContext);\n furthestTime = Math.max(furthestTime, innerContext.currentTimeline.currentTime);\n innerTimelines.push(innerContext.currentTimeline);\n }));\n // this operation is run after the AST loop because otherwise\n // if the parent timeline's collected styles were updated then\n // it would pass in invalid data into the new-to-be forked items\n innerTimelines.forEach((/**\n * @param {?} timeline\n * @return {?}\n */\n timeline => context.currentTimeline.mergeTimelineCollectedStyles(timeline)));\n context.transformIntoNewTimeline(furthestTime);\n context.previousNode = ast;\n }\n /**\n * @private\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n _visitTiming(ast, context) {\n if (((/** @type {?} */ (ast))).dynamic) {\n /** @type {?} */\n const strValue = ((/** @type {?} */ (ast))).strValue;\n /** @type {?} */\n const timingValue = context.params ? interpolateParams(strValue, context.params, context.errors) : strValue;\n return resolveTiming(timingValue, context.errors);\n }\n else {\n return { duration: ast.duration, delay: ast.delay, easing: ast.easing };\n }\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n visitAnimate(ast, context) {\n /** @type {?} */\n const timings = context.currentAnimateTimings = this._visitTiming(ast.timings, context);\n /** @type {?} */\n const timeline = context.currentTimeline;\n if (timings.delay) {\n context.incrementTime(timings.delay);\n timeline.snapshotCurrentStyles();\n }\n /** @type {?} */\n const style = ast.style;\n if (style.type == 5 /* Keyframes */) {\n this.visitKeyframes(style, context);\n }\n else {\n context.incrementTime(timings.duration);\n this.visitStyle((/** @type {?} */ (style)), context);\n timeline.applyStylesToKeyframe();\n }\n context.currentAnimateTimings = null;\n context.previousNode = ast;\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n visitStyle(ast, context) {\n /** @type {?} */\n const timeline = context.currentTimeline;\n /** @type {?} */\n const timings = (/** @type {?} */ (context.currentAnimateTimings));\n // this is a special case for when a style() call\n // directly follows an animate() call (but not inside of an animate() call)\n if (!timings && timeline.getCurrentStyleProperties().length) {\n timeline.forwardFrame();\n }\n /** @type {?} */\n const easing = (timings && timings.easing) || ast.easing;\n if (ast.isEmptyStep) {\n timeline.applyEmptyStep(easing);\n }\n else {\n timeline.setStyles(ast.styles, easing, context.errors, context.options);\n }\n context.previousNode = ast;\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n visitKeyframes(ast, context) {\n /** @type {?} */\n const currentAnimateTimings = (/** @type {?} */ (context.currentAnimateTimings));\n /** @type {?} */\n const startTime = ((/** @type {?} */ (context.currentTimeline))).duration;\n /** @type {?} */\n const duration = currentAnimateTimings.duration;\n /** @type {?} */\n const innerContext = context.createSubContext();\n /** @type {?} */\n const innerTimeline = innerContext.currentTimeline;\n innerTimeline.easing = currentAnimateTimings.easing;\n ast.styles.forEach((/**\n * @param {?} step\n * @return {?}\n */\n step => {\n /** @type {?} */\n const offset = step.offset || 0;\n innerTimeline.forwardTime(offset * duration);\n innerTimeline.setStyles(step.styles, step.easing, context.errors, context.options);\n innerTimeline.applyStylesToKeyframe();\n }));\n // this will ensure that the parent timeline gets all the styles from\n // the child even if the new timeline below is not used\n context.currentTimeline.mergeTimelineCollectedStyles(innerTimeline);\n // we do this because the window between this timeline and the sub timeline\n // should ensure that the styles within are exactly the same as they were before\n context.transformIntoNewTimeline(startTime + duration);\n context.previousNode = ast;\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n visitQuery(ast, context) {\n // in the event that the first step before this is a style step we need\n // to ensure the styles are applied before the children are animated\n /** @type {?} */\n const startTime = context.currentTimeline.currentTime;\n /** @type {?} */\n const options = (/** @type {?} */ ((ast.options || {})));\n /** @type {?} */\n const delay = options.delay ? resolveTimingValue(options.delay) : 0;\n if (delay &&\n (context.previousNode.type === 6 /* Style */ ||\n (startTime == 0 && context.currentTimeline.getCurrentStyleProperties().length))) {\n context.currentTimeline.snapshotCurrentStyles();\n context.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;\n }\n /** @type {?} */\n let furthestTime = startTime;\n /** @type {?} */\n const elms = context.invokeQuery(ast.selector, ast.originalSelector, ast.limit, ast.includeSelf, options.optional ? true : false, context.errors);\n context.currentQueryTotal = elms.length;\n /** @type {?} */\n let sameElementTimeline = null;\n elms.forEach((/**\n * @param {?} element\n * @param {?} i\n * @return {?}\n */\n (element, i) => {\n context.currentQueryIndex = i;\n /** @type {?} */\n const innerContext = context.createSubContext(ast.options, element);\n if (delay) {\n innerContext.delayNextStep(delay);\n }\n if (element === context.element) {\n sameElementTimeline = innerContext.currentTimeline;\n }\n visitDslNode(this, ast.animation, innerContext);\n // this is here just incase the inner steps only contain or end\n // with a style() call (which is here to signal that this is a preparatory\n // call to style an element before it is animated again)\n innerContext.currentTimeline.applyStylesToKeyframe();\n /** @type {?} */\n const endTime = innerContext.currentTimeline.currentTime;\n furthestTime = Math.max(furthestTime, endTime);\n }));\n context.currentQueryIndex = 0;\n context.currentQueryTotal = 0;\n context.transformIntoNewTimeline(furthestTime);\n if (sameElementTimeline) {\n context.currentTimeline.mergeTimelineCollectedStyles(sameElementTimeline);\n context.currentTimeline.snapshotCurrentStyles();\n }\n context.previousNode = ast;\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n visitStagger(ast, context) {\n /** @type {?} */\n const parentContext = (/** @type {?} */ (context.parentContext));\n /** @type {?} */\n const tl = context.currentTimeline;\n /** @type {?} */\n const timings = ast.timings;\n /** @type {?} */\n const duration = Math.abs(timings.duration);\n /** @type {?} */\n const maxTime = duration * (context.currentQueryTotal - 1);\n /** @type {?} */\n let delay = duration * context.currentQueryIndex;\n /** @type {?} */\n let staggerTransformer = timings.duration < 0 ? 'reverse' : timings.easing;\n switch (staggerTransformer) {\n case 'reverse':\n delay = maxTime - delay;\n break;\n case 'full':\n delay = parentContext.currentStaggerTime;\n break;\n }\n /** @type {?} */\n const timeline = context.currentTimeline;\n if (delay) {\n timeline.delayNextStep(delay);\n }\n /** @type {?} */\n const startingTime = timeline.currentTime;\n visitDslNode(this, ast.animation, context);\n context.previousNode = ast;\n // time = duration + delay\n // the reason why this computation is so complex is because\n // the inner timeline may either have a delay value or a stretched\n // keyframe depending on if a subtimeline is not used or is used.\n parentContext.currentStaggerTime =\n (tl.currentTime - startingTime) + (tl.startTime - parentContext.currentTimeline.startTime);\n }\n}\n/** @type {?} */\nconst DEFAULT_NOOP_PREVIOUS_NODE = (/** @type {?} */ ({}));\nclass AnimationTimelineContext {\n /**\n * @param {?} _driver\n * @param {?} element\n * @param {?} subInstructions\n * @param {?} _enterClassName\n * @param {?} _leaveClassName\n * @param {?} errors\n * @param {?} timelines\n * @param {?=} initialTimeline\n */\n constructor(_driver, element, subInstructions, _enterClassName, _leaveClassName, errors, timelines, initialTimeline) {\n this._driver = _driver;\n this.element = element;\n this.subInstructions = subInstructions;\n this._enterClassName = _enterClassName;\n this._leaveClassName = _leaveClassName;\n this.errors = errors;\n this.timelines = timelines;\n this.parentContext = null;\n this.currentAnimateTimings = null;\n this.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;\n this.subContextCount = 0;\n this.options = {};\n this.currentQueryIndex = 0;\n this.currentQueryTotal = 0;\n this.currentStaggerTime = 0;\n this.currentTimeline = initialTimeline || new TimelineBuilder(this._driver, element, 0);\n timelines.push(this.currentTimeline);\n }\n /**\n * @return {?}\n */\n get params() {\n return this.options.params;\n }\n /**\n * @param {?} options\n * @param {?=} skipIfExists\n * @return {?}\n */\n updateOptions(options, skipIfExists) {\n if (!options)\n return;\n /** @type {?} */\n const newOptions = (/** @type {?} */ (options));\n /** @type {?} */\n let optionsToUpdate = this.options;\n // NOTE: this will get patched up when other animation methods support duration overrides\n if (newOptions.duration != null) {\n ((/** @type {?} */ (optionsToUpdate))).duration = resolveTimingValue(newOptions.duration);\n }\n if (newOptions.delay != null) {\n optionsToUpdate.delay = resolveTimingValue(newOptions.delay);\n }\n /** @type {?} */\n const newParams = newOptions.params;\n if (newParams) {\n /** @type {?} */\n let paramsToUpdate = (/** @type {?} */ (optionsToUpdate.params));\n if (!paramsToUpdate) {\n paramsToUpdate = this.options.params = {};\n }\n Object.keys(newParams).forEach((/**\n * @param {?} name\n * @return {?}\n */\n name => {\n if (!skipIfExists || !paramsToUpdate.hasOwnProperty(name)) {\n paramsToUpdate[name] = interpolateParams(newParams[name], paramsToUpdate, this.errors);\n }\n }));\n }\n }\n /**\n * @private\n * @return {?}\n */\n _copyOptions() {\n /** @type {?} */\n const options = {};\n if (this.options) {\n /** @type {?} */\n const oldParams = this.options.params;\n if (oldParams) {\n /** @type {?} */\n const params = options['params'] = {};\n Object.keys(oldParams).forEach((/**\n * @param {?} name\n * @return {?}\n */\n name => {\n params[name] = oldParams[name];\n }));\n }\n }\n return options;\n }\n /**\n * @param {?=} options\n * @param {?=} element\n * @param {?=} newTime\n * @return {?}\n */\n createSubContext(options = null, element, newTime) {\n /** @type {?} */\n const target = element || this.element;\n /** @type {?} */\n const context = new AnimationTimelineContext(this._driver, target, this.subInstructions, this._enterClassName, this._leaveClassName, this.errors, this.timelines, this.currentTimeline.fork(target, newTime || 0));\n context.previousNode = this.previousNode;\n context.currentAnimateTimings = this.currentAnimateTimings;\n context.options = this._copyOptions();\n context.updateOptions(options);\n context.currentQueryIndex = this.currentQueryIndex;\n context.currentQueryTotal = this.currentQueryTotal;\n context.parentContext = this;\n this.subContextCount++;\n return context;\n }\n /**\n * @param {?=} newTime\n * @return {?}\n */\n transformIntoNewTimeline(newTime) {\n this.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;\n this.currentTimeline = this.currentTimeline.fork(this.element, newTime);\n this.timelines.push(this.currentTimeline);\n return this.currentTimeline;\n }\n /**\n * @param {?} instruction\n * @param {?} duration\n * @param {?} delay\n * @return {?}\n */\n appendInstructionToTimeline(instruction, duration, delay) {\n /** @type {?} */\n const updatedTimings = {\n duration: duration != null ? duration : instruction.duration,\n delay: this.currentTimeline.currentTime + (delay != null ? delay : 0) + instruction.delay,\n easing: ''\n };\n /** @type {?} */\n const builder = new SubTimelineBuilder(this._driver, instruction.element, instruction.keyframes, instruction.preStyleProps, instruction.postStyleProps, updatedTimings, instruction.stretchStartingKeyframe);\n this.timelines.push(builder);\n return updatedTimings;\n }\n /**\n * @param {?} time\n * @return {?}\n */\n incrementTime(time) {\n this.currentTimeline.forwardTime(this.currentTimeline.duration + time);\n }\n /**\n * @param {?} delay\n * @return {?}\n */\n delayNextStep(delay) {\n // negative delays are not yet supported\n if (delay > 0) {\n this.currentTimeline.delayNextStep(delay);\n }\n }\n /**\n * @param {?} selector\n * @param {?} originalSelector\n * @param {?} limit\n * @param {?} includeSelf\n * @param {?} optional\n * @param {?} errors\n * @return {?}\n */\n invokeQuery(selector, originalSelector, limit, includeSelf, optional, errors) {\n /** @type {?} */\n let results = [];\n if (includeSelf) {\n results.push(this.element);\n }\n if (selector.length > 0) { // if :self is only used then the selector is empty\n selector = selector.replace(ENTER_TOKEN_REGEX, '.' + this._enterClassName);\n selector = selector.replace(LEAVE_TOKEN_REGEX, '.' + this._leaveClassName);\n /** @type {?} */\n const multi = limit != 1;\n /** @type {?} */\n let elements = this._driver.query(this.element, selector, multi);\n if (limit !== 0) {\n elements = limit < 0 ? elements.slice(elements.length + limit, elements.length) :\n elements.slice(0, limit);\n }\n results.push(...elements);\n }\n if (!optional && results.length == 0) {\n errors.push(`\\`query(\"${originalSelector}\")\\` returned zero elements. (Use \\`query(\"${originalSelector}\", { optional: true })\\` if you wish to allow this.)`);\n }\n return results;\n }\n}\nif (false) {\n /** @type {?} */\n AnimationTimelineContext.prototype.parentContext;\n /** @type {?} */\n AnimationTimelineContext.prototype.currentTimeline;\n /** @type {?} */\n AnimationTimelineContext.prototype.currentAnimateTimings;\n /** @type {?} */\n AnimationTimelineContext.prototype.previousNode;\n /** @type {?} */\n AnimationTimelineContext.prototype.subContextCount;\n /** @type {?} */\n AnimationTimelineContext.prototype.options;\n /** @type {?} */\n AnimationTimelineContext.prototype.currentQueryIndex;\n /** @type {?} */\n AnimationTimelineContext.prototype.currentQueryTotal;\n /** @type {?} */\n AnimationTimelineContext.prototype.currentStaggerTime;\n /**\n * @type {?}\n * @private\n */\n AnimationTimelineContext.prototype._driver;\n /** @type {?} */\n AnimationTimelineContext.prototype.element;\n /** @type {?} */\n AnimationTimelineContext.prototype.subInstructions;\n /**\n * @type {?}\n * @private\n */\n AnimationTimelineContext.prototype._enterClassName;\n /**\n * @type {?}\n * @private\n */\n AnimationTimelineContext.prototype._leaveClassName;\n /** @type {?} */\n AnimationTimelineContext.prototype.errors;\n /** @type {?} */\n AnimationTimelineContext.prototype.timelines;\n}\nclass TimelineBuilder {\n /**\n * @param {?} _driver\n * @param {?} element\n * @param {?} startTime\n * @param {?=} _elementTimelineStylesLookup\n */\n constructor(_driver, element, startTime, _elementTimelineStylesLookup) {\n this._driver = _driver;\n this.element = element;\n this.startTime = startTime;\n this._elementTimelineStylesLookup = _elementTimelineStylesLookup;\n this.duration = 0;\n this._previousKeyframe = {};\n this._currentKeyframe = {};\n this._keyframes = new Map();\n this._styleSummary = {};\n this._pendingStyles = {};\n this._backFill = {};\n this._currentEmptyStepKeyframe = null;\n if (!this._elementTimelineStylesLookup) {\n this._elementTimelineStylesLookup = new Map();\n }\n this._localTimelineStyles = Object.create(this._backFill, {});\n this._globalTimelineStyles = (/** @type {?} */ (this._elementTimelineStylesLookup.get(element)));\n if (!this._globalTimelineStyles) {\n this._globalTimelineStyles = this._localTimelineStyles;\n this._elementTimelineStylesLookup.set(element, this._localTimelineStyles);\n }\n this._loadKeyframe();\n }\n /**\n * @return {?}\n */\n containsAnimation() {\n switch (this._keyframes.size) {\n case 0:\n return false;\n case 1:\n return this.getCurrentStyleProperties().length > 0;\n default:\n return true;\n }\n }\n /**\n * @return {?}\n */\n getCurrentStyleProperties() {\n return Object.keys(this._currentKeyframe);\n }\n /**\n * @return {?}\n */\n get currentTime() {\n return this.startTime + this.duration;\n }\n /**\n * @param {?} delay\n * @return {?}\n */\n delayNextStep(delay) {\n // in the event that a style() step is placed right before a stagger()\n // and that style() step is the very first style() value in the animation\n // then we need to make a copy of the keyframe [0, copy, 1] so that the delay\n // properly applies the style() values to work with the stagger...\n /** @type {?} */\n const hasPreStyleStep = this._keyframes.size == 1 && Object.keys(this._pendingStyles).length;\n if (this.duration || hasPreStyleStep) {\n this.forwardTime(this.currentTime + delay);\n if (hasPreStyleStep) {\n this.snapshotCurrentStyles();\n }\n }\n else {\n this.startTime += delay;\n }\n }\n /**\n * @param {?} element\n * @param {?=} currentTime\n * @return {?}\n */\n fork(element, currentTime) {\n this.applyStylesToKeyframe();\n return new TimelineBuilder(this._driver, element, currentTime || this.currentTime, this._elementTimelineStylesLookup);\n }\n /**\n * @private\n * @return {?}\n */\n _loadKeyframe() {\n if (this._currentKeyframe) {\n this._previousKeyframe = this._currentKeyframe;\n }\n this._currentKeyframe = (/** @type {?} */ (this._keyframes.get(this.duration)));\n if (!this._currentKeyframe) {\n this._currentKeyframe = Object.create(this._backFill, {});\n this._keyframes.set(this.duration, this._currentKeyframe);\n }\n }\n /**\n * @return {?}\n */\n forwardFrame() {\n this.duration += ONE_FRAME_IN_MILLISECONDS;\n this._loadKeyframe();\n }\n /**\n * @param {?} time\n * @return {?}\n */\n forwardTime(time) {\n this.applyStylesToKeyframe();\n this.duration = time;\n this._loadKeyframe();\n }\n /**\n * @private\n * @param {?} prop\n * @param {?} value\n * @return {?}\n */\n _updateStyle(prop, value) {\n this._localTimelineStyles[prop] = value;\n this._globalTimelineStyles[prop] = value;\n this._styleSummary[prop] = { time: this.currentTime, value };\n }\n /**\n * @return {?}\n */\n allowOnlyTimelineStyles() {\n return this._currentEmptyStepKeyframe !== this._currentKeyframe;\n }\n /**\n * @param {?} easing\n * @return {?}\n */\n applyEmptyStep(easing) {\n if (easing) {\n this._previousKeyframe['easing'] = easing;\n }\n // special case for animate(duration):\n // all missing styles are filled with a `*` value then\n // if any destination styles are filled in later on the same\n // keyframe then they will override the overridden styles\n // We use `_globalTimelineStyles` here because there may be\n // styles in previous keyframes that are not present in this timeline\n Object.keys(this._globalTimelineStyles).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n this._backFill[prop] = this._globalTimelineStyles[prop] || AUTO_STYLE;\n this._currentKeyframe[prop] = AUTO_STYLE;\n }));\n this._currentEmptyStepKeyframe = this._currentKeyframe;\n }\n /**\n * @param {?} input\n * @param {?} easing\n * @param {?} errors\n * @param {?=} options\n * @return {?}\n */\n setStyles(input, easing, errors, options) {\n if (easing) {\n this._previousKeyframe['easing'] = easing;\n }\n /** @type {?} */\n const params = (options && options.params) || {};\n /** @type {?} */\n const styles = flattenStyles(input, this._globalTimelineStyles);\n Object.keys(styles).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n /** @type {?} */\n const val = interpolateParams(styles[prop], params, errors);\n this._pendingStyles[prop] = val;\n if (!this._localTimelineStyles.hasOwnProperty(prop)) {\n this._backFill[prop] = this._globalTimelineStyles.hasOwnProperty(prop) ?\n this._globalTimelineStyles[prop] :\n AUTO_STYLE;\n }\n this._updateStyle(prop, val);\n }));\n }\n /**\n * @return {?}\n */\n applyStylesToKeyframe() {\n /** @type {?} */\n const styles = this._pendingStyles;\n /** @type {?} */\n const props = Object.keys(styles);\n if (props.length == 0)\n return;\n this._pendingStyles = {};\n props.forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n /** @type {?} */\n const val = styles[prop];\n this._currentKeyframe[prop] = val;\n }));\n Object.keys(this._localTimelineStyles).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n if (!this._currentKeyframe.hasOwnProperty(prop)) {\n this._currentKeyframe[prop] = this._localTimelineStyles[prop];\n }\n }));\n }\n /**\n * @return {?}\n */\n snapshotCurrentStyles() {\n Object.keys(this._localTimelineStyles).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n /** @type {?} */\n const val = this._localTimelineStyles[prop];\n this._pendingStyles[prop] = val;\n this._updateStyle(prop, val);\n }));\n }\n /**\n * @return {?}\n */\n getFinalKeyframe() {\n return this._keyframes.get(this.duration);\n }\n /**\n * @return {?}\n */\n get properties() {\n /** @type {?} */\n const properties = [];\n for (let prop in this._currentKeyframe) {\n properties.push(prop);\n }\n return properties;\n }\n /**\n * @param {?} timeline\n * @return {?}\n */\n mergeTimelineCollectedStyles(timeline) {\n Object.keys(timeline._styleSummary).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n /** @type {?} */\n const details0 = this._styleSummary[prop];\n /** @type {?} */\n const details1 = timeline._styleSummary[prop];\n if (!details0 || details1.time > details0.time) {\n this._updateStyle(prop, details1.value);\n }\n }));\n }\n /**\n * @return {?}\n */\n buildKeyframes() {\n this.applyStylesToKeyframe();\n /** @type {?} */\n const preStyleProps = new Set();\n /** @type {?} */\n const postStyleProps = new Set();\n /** @type {?} */\n const isEmpty = this._keyframes.size === 1 && this.duration === 0;\n /** @type {?} */\n let finalKeyframes = [];\n this._keyframes.forEach((/**\n * @param {?} keyframe\n * @param {?} time\n * @return {?}\n */\n (keyframe, time) => {\n /** @type {?} */\n const finalKeyframe = copyStyles(keyframe, true);\n Object.keys(finalKeyframe).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n /** @type {?} */\n const value = finalKeyframe[prop];\n if (value == ɵPRE_STYLE) {\n preStyleProps.add(prop);\n }\n else if (value == AUTO_STYLE) {\n postStyleProps.add(prop);\n }\n }));\n if (!isEmpty) {\n finalKeyframe['offset'] = time / this.duration;\n }\n finalKeyframes.push(finalKeyframe);\n }));\n /** @type {?} */\n const preProps = preStyleProps.size ? iteratorToArray(preStyleProps.values()) : [];\n /** @type {?} */\n const postProps = postStyleProps.size ? iteratorToArray(postStyleProps.values()) : [];\n // special case for a 0-second animation (which is designed just to place styles onscreen)\n if (isEmpty) {\n /** @type {?} */\n const kf0 = finalKeyframes[0];\n /** @type {?} */\n const kf1 = copyObj(kf0);\n kf0['offset'] = 0;\n kf1['offset'] = 1;\n finalKeyframes = [kf0, kf1];\n }\n return createTimelineInstruction(this.element, finalKeyframes, preProps, postProps, this.duration, this.startTime, this.easing, false);\n }\n}\nif (false) {\n /** @type {?} */\n TimelineBuilder.prototype.duration;\n /** @type {?} */\n TimelineBuilder.prototype.easing;\n /**\n * @type {?}\n * @private\n */\n TimelineBuilder.prototype._previousKeyframe;\n /**\n * @type {?}\n * @private\n */\n TimelineBuilder.prototype._currentKeyframe;\n /**\n * @type {?}\n * @private\n */\n TimelineBuilder.prototype._keyframes;\n /**\n * @type {?}\n * @private\n */\n TimelineBuilder.prototype._styleSummary;\n /**\n * @type {?}\n * @private\n */\n TimelineBuilder.prototype._localTimelineStyles;\n /**\n * @type {?}\n * @private\n */\n TimelineBuilder.prototype._globalTimelineStyles;\n /**\n * @type {?}\n * @private\n */\n TimelineBuilder.prototype._pendingStyles;\n /**\n * @type {?}\n * @private\n */\n TimelineBuilder.prototype._backFill;\n /**\n * @type {?}\n * @private\n */\n TimelineBuilder.prototype._currentEmptyStepKeyframe;\n /**\n * @type {?}\n * @private\n */\n TimelineBuilder.prototype._driver;\n /** @type {?} */\n TimelineBuilder.prototype.element;\n /** @type {?} */\n TimelineBuilder.prototype.startTime;\n /**\n * @type {?}\n * @private\n */\n TimelineBuilder.prototype._elementTimelineStylesLookup;\n}\nclass SubTimelineBuilder extends TimelineBuilder {\n /**\n * @param {?} driver\n * @param {?} element\n * @param {?} keyframes\n * @param {?} preStyleProps\n * @param {?} postStyleProps\n * @param {?} timings\n * @param {?=} _stretchStartingKeyframe\n */\n constructor(driver, element, keyframes, preStyleProps, postStyleProps, timings, _stretchStartingKeyframe = false) {\n super(driver, element, timings.delay);\n this.element = element;\n this.keyframes = keyframes;\n this.preStyleProps = preStyleProps;\n this.postStyleProps = postStyleProps;\n this._stretchStartingKeyframe = _stretchStartingKeyframe;\n this.timings = { duration: timings.duration, delay: timings.delay, easing: timings.easing };\n }\n /**\n * @return {?}\n */\n containsAnimation() {\n return this.keyframes.length > 1;\n }\n /**\n * @return {?}\n */\n buildKeyframes() {\n /** @type {?} */\n let keyframes = this.keyframes;\n let { delay, duration, easing } = this.timings;\n if (this._stretchStartingKeyframe && delay) {\n /** @type {?} */\n const newKeyframes = [];\n /** @type {?} */\n const totalTime = duration + delay;\n /** @type {?} */\n const startingGap = delay / totalTime;\n // the original starting keyframe now starts once the delay is done\n /** @type {?} */\n const newFirstKeyframe = copyStyles(keyframes[0], false);\n newFirstKeyframe['offset'] = 0;\n newKeyframes.push(newFirstKeyframe);\n /** @type {?} */\n const oldFirstKeyframe = copyStyles(keyframes[0], false);\n oldFirstKeyframe['offset'] = roundOffset(startingGap);\n newKeyframes.push(oldFirstKeyframe);\n /*\n When the keyframe is stretched then it means that the delay before the animation\n starts is gone. Instead the first keyframe is placed at the start of the animation\n and it is then copied to where it starts when the original delay is over. This basically\n means nothing animates during that delay, but the styles are still renderered. For this\n to work the original offset values that exist in the original keyframes must be \"warped\"\n so that they can take the new keyframe + delay into account.\n \n delay=1000, duration=1000, keyframes = 0 .5 1\n \n turns into\n \n delay=0, duration=2000, keyframes = 0 .33 .66 1\n */\n // offsets between 1 ... n -1 are all warped by the keyframe stretch\n /** @type {?} */\n const limit = keyframes.length - 1;\n for (let i = 1; i <= limit; i++) {\n /** @type {?} */\n let kf = copyStyles(keyframes[i], false);\n /** @type {?} */\n const oldOffset = (/** @type {?} */ (kf['offset']));\n /** @type {?} */\n const timeAtKeyframe = delay + oldOffset * duration;\n kf['offset'] = roundOffset(timeAtKeyframe / totalTime);\n newKeyframes.push(kf);\n }\n // the new starting keyframe should be added at the start\n duration = totalTime;\n delay = 0;\n easing = '';\n keyframes = newKeyframes;\n }\n return createTimelineInstruction(this.element, keyframes, this.preStyleProps, this.postStyleProps, duration, delay, easing, true);\n }\n}\nif (false) {\n /** @type {?} */\n SubTimelineBuilder.prototype.timings;\n /** @type {?} */\n SubTimelineBuilder.prototype.element;\n /** @type {?} */\n SubTimelineBuilder.prototype.keyframes;\n /** @type {?} */\n SubTimelineBuilder.prototype.preStyleProps;\n /** @type {?} */\n SubTimelineBuilder.prototype.postStyleProps;\n /**\n * @type {?}\n * @private\n */\n SubTimelineBuilder.prototype._stretchStartingKeyframe;\n}\n/**\n * @param {?} offset\n * @param {?=} decimalPoints\n * @return {?}\n */\nfunction roundOffset(offset, decimalPoints = 3) {\n /** @type {?} */\n const mult = Math.pow(10, decimalPoints - 1);\n return Math.round(offset * mult) / mult;\n}\n/**\n * @param {?} input\n * @param {?} allStyles\n * @return {?}\n */\nfunction flattenStyles(input, allStyles) {\n /** @type {?} */\n const styles = {};\n /** @type {?} */\n let allProperties;\n input.forEach((/**\n * @param {?} token\n * @return {?}\n */\n token => {\n if (token === '*') {\n allProperties = allProperties || Object.keys(allStyles);\n allProperties.forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n styles[prop] = AUTO_STYLE;\n }));\n }\n else {\n copyStyles((/** @type {?} */ (token)), false, styles);\n }\n }));\n return styles;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/dsl/animation.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass Animation {\n /**\n * @param {?} _driver\n * @param {?} input\n */\n constructor(_driver, input) {\n this._driver = _driver;\n /** @type {?} */\n const errors = [];\n /** @type {?} */\n const ast = buildAnimationAst(_driver, input, errors);\n if (errors.length) {\n /** @type {?} */\n const errorMessage = `animation validation failed:\\n${errors.join('\\n')}`;\n throw new Error(errorMessage);\n }\n this._animationAst = ast;\n }\n /**\n * @param {?} element\n * @param {?} startingStyles\n * @param {?} destinationStyles\n * @param {?} options\n * @param {?=} subInstructions\n * @return {?}\n */\n buildTimelines(element, startingStyles, destinationStyles, options, subInstructions) {\n /** @type {?} */\n const start = Array.isArray(startingStyles) ? normalizeStyles(startingStyles) :\n (/** @type {?} */ (startingStyles));\n /** @type {?} */\n const dest = Array.isArray(destinationStyles) ? normalizeStyles(destinationStyles) :\n (/** @type {?} */ (destinationStyles));\n /** @type {?} */\n const errors = [];\n subInstructions = subInstructions || new ElementInstructionMap();\n /** @type {?} */\n const result = buildAnimationTimelines(this._driver, element, this._animationAst, ENTER_CLASSNAME, LEAVE_CLASSNAME, start, dest, options, subInstructions, errors);\n if (errors.length) {\n /** @type {?} */\n const errorMessage = `animation building failed:\\n${errors.join('\\n')}`;\n throw new Error(errorMessage);\n }\n return result;\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n Animation.prototype._animationAst;\n /**\n * @type {?}\n * @private\n */\n Animation.prototype._driver;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/dsl/style_normalization/animation_style_normalizer.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. 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 * \\@publicApi\n * @abstract\n */\nclass AnimationStyleNormalizer {\n}\nif (false) {\n /**\n * @abstract\n * @param {?} propertyName\n * @param {?} errors\n * @return {?}\n */\n AnimationStyleNormalizer.prototype.normalizePropertyName = function (propertyName, errors) { };\n /**\n * @abstract\n * @param {?} userProvidedProperty\n * @param {?} normalizedProperty\n * @param {?} value\n * @param {?} errors\n * @return {?}\n */\n AnimationStyleNormalizer.prototype.normalizeStyleValue = function (userProvidedProperty, normalizedProperty, value, errors) { };\n}\n/**\n * \\@publicApi\n */\nclass NoopAnimationStyleNormalizer {\n /**\n * @param {?} propertyName\n * @param {?} errors\n * @return {?}\n */\n normalizePropertyName(propertyName, errors) {\n return propertyName;\n }\n /**\n * @param {?} userProvidedProperty\n * @param {?} normalizedProperty\n * @param {?} value\n * @param {?} errors\n * @return {?}\n */\n normalizeStyleValue(userProvidedProperty, normalizedProperty, value, errors) {\n return (/** @type {?} */ (value));\n }\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/dsl/style_normalization/web_animations_style_normalizer.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass WebAnimationsStyleNormalizer extends AnimationStyleNormalizer {\n /**\n * @param {?} propertyName\n * @param {?} errors\n * @return {?}\n */\n normalizePropertyName(propertyName, errors) {\n return dashCaseToCamelCase(propertyName);\n }\n /**\n * @param {?} userProvidedProperty\n * @param {?} normalizedProperty\n * @param {?} value\n * @param {?} errors\n * @return {?}\n */\n normalizeStyleValue(userProvidedProperty, normalizedProperty, value, errors) {\n /** @type {?} */\n let unit = '';\n /** @type {?} */\n const strVal = value.toString().trim();\n if (DIMENSIONAL_PROP_MAP[normalizedProperty] && value !== 0 && value !== '0') {\n if (typeof value === 'number') {\n unit = 'px';\n }\n else {\n /** @type {?} */\n const valAndSuffixMatch = value.match(/^[+-]?[\\d\\.]+([a-z]*)$/);\n if (valAndSuffixMatch && valAndSuffixMatch[1].length == 0) {\n errors.push(`Please provide a CSS unit value for ${userProvidedProperty}:${value}`);\n }\n }\n }\n return strVal + unit;\n }\n}\nconst ɵ0$1 = /**\n * @return {?}\n */\n() => makeBooleanMap('width,height,minWidth,minHeight,maxWidth,maxHeight,left,top,bottom,right,fontSize,outlineWidth,outlineOffset,paddingTop,paddingLeft,paddingBottom,paddingRight,marginTop,marginLeft,marginBottom,marginRight,borderRadius,borderWidth,borderTopWidth,borderLeftWidth,borderRightWidth,borderBottomWidth,textIndent,perspective'\n .split(','));\n/** @type {?} */\nconst DIMENSIONAL_PROP_MAP = ((ɵ0$1))();\n/**\n * @param {?} keys\n * @return {?}\n */\nfunction makeBooleanMap(keys) {\n /** @type {?} */\n const map = {};\n keys.forEach((/**\n * @param {?} key\n * @return {?}\n */\n key => map[key] = true));\n return map;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/dsl/animation_transition_instruction.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @record\n */\nfunction AnimationTransitionInstruction() { }\nif (false) {\n /** @type {?} */\n AnimationTransitionInstruction.prototype.element;\n /** @type {?} */\n AnimationTransitionInstruction.prototype.triggerName;\n /** @type {?} */\n AnimationTransitionInstruction.prototype.isRemovalTransition;\n /** @type {?} */\n AnimationTransitionInstruction.prototype.fromState;\n /** @type {?} */\n AnimationTransitionInstruction.prototype.fromStyles;\n /** @type {?} */\n AnimationTransitionInstruction.prototype.toState;\n /** @type {?} */\n AnimationTransitionInstruction.prototype.toStyles;\n /** @type {?} */\n AnimationTransitionInstruction.prototype.timelines;\n /** @type {?} */\n AnimationTransitionInstruction.prototype.queriedElements;\n /** @type {?} */\n AnimationTransitionInstruction.prototype.preStyleProps;\n /** @type {?} */\n AnimationTransitionInstruction.prototype.postStyleProps;\n /** @type {?} */\n AnimationTransitionInstruction.prototype.totalTime;\n /** @type {?|undefined} */\n AnimationTransitionInstruction.prototype.errors;\n}\n/**\n * @param {?} element\n * @param {?} triggerName\n * @param {?} fromState\n * @param {?} toState\n * @param {?} isRemovalTransition\n * @param {?} fromStyles\n * @param {?} toStyles\n * @param {?} timelines\n * @param {?} queriedElements\n * @param {?} preStyleProps\n * @param {?} postStyleProps\n * @param {?} totalTime\n * @param {?=} errors\n * @return {?}\n */\nfunction createTransitionInstruction(element, triggerName, fromState, toState, isRemovalTransition, fromStyles, toStyles, timelines, queriedElements, preStyleProps, postStyleProps, totalTime, errors) {\n return {\n type: 0 /* TransitionAnimation */,\n element,\n triggerName,\n isRemovalTransition,\n fromState,\n fromStyles,\n toState,\n toStyles,\n timelines,\n queriedElements,\n preStyleProps,\n postStyleProps,\n totalTime,\n errors\n };\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/dsl/animation_transition_factory.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst EMPTY_OBJECT = {};\nclass AnimationTransitionFactory {\n /**\n * @param {?} _triggerName\n * @param {?} ast\n * @param {?} _stateStyles\n */\n constructor(_triggerName, ast, _stateStyles) {\n this._triggerName = _triggerName;\n this.ast = ast;\n this._stateStyles = _stateStyles;\n }\n /**\n * @param {?} currentState\n * @param {?} nextState\n * @param {?} element\n * @param {?} params\n * @return {?}\n */\n match(currentState, nextState, element, params) {\n return oneOrMoreTransitionsMatch(this.ast.matchers, currentState, nextState, element, params);\n }\n /**\n * @param {?} stateName\n * @param {?} params\n * @param {?} errors\n * @return {?}\n */\n buildStyles(stateName, params, errors) {\n /** @type {?} */\n const backupStateStyler = this._stateStyles['*'];\n /** @type {?} */\n const stateStyler = this._stateStyles[stateName];\n /** @type {?} */\n const backupStyles = backupStateStyler ? backupStateStyler.buildStyles(params, errors) : {};\n return stateStyler ? stateStyler.buildStyles(params, errors) : backupStyles;\n }\n /**\n * @param {?} driver\n * @param {?} element\n * @param {?} currentState\n * @param {?} nextState\n * @param {?} enterClassName\n * @param {?} leaveClassName\n * @param {?=} currentOptions\n * @param {?=} nextOptions\n * @param {?=} subInstructions\n * @param {?=} skipAstBuild\n * @return {?}\n */\n build(driver, element, currentState, nextState, enterClassName, leaveClassName, currentOptions, nextOptions, subInstructions, skipAstBuild) {\n /** @type {?} */\n const errors = [];\n /** @type {?} */\n const transitionAnimationParams = this.ast.options && this.ast.options.params || EMPTY_OBJECT;\n /** @type {?} */\n const currentAnimationParams = currentOptions && currentOptions.params || EMPTY_OBJECT;\n /** @type {?} */\n const currentStateStyles = this.buildStyles(currentState, currentAnimationParams, errors);\n /** @type {?} */\n const nextAnimationParams = nextOptions && nextOptions.params || EMPTY_OBJECT;\n /** @type {?} */\n const nextStateStyles = this.buildStyles(nextState, nextAnimationParams, errors);\n /** @type {?} */\n const queriedElements = new Set();\n /** @type {?} */\n const preStyleMap = new Map();\n /** @type {?} */\n const postStyleMap = new Map();\n /** @type {?} */\n const isRemoval = nextState === 'void';\n /** @type {?} */\n const animationOptions = { params: Object.assign(Object.assign({}, transitionAnimationParams), nextAnimationParams) };\n /** @type {?} */\n const timelines = skipAstBuild ?\n [] :\n buildAnimationTimelines(driver, element, this.ast.animation, enterClassName, leaveClassName, currentStateStyles, nextStateStyles, animationOptions, subInstructions, errors);\n /** @type {?} */\n let totalTime = 0;\n timelines.forEach((/**\n * @param {?} tl\n * @return {?}\n */\n tl => {\n totalTime = Math.max(tl.duration + tl.delay, totalTime);\n }));\n if (errors.length) {\n return createTransitionInstruction(element, this._triggerName, currentState, nextState, isRemoval, currentStateStyles, nextStateStyles, [], [], preStyleMap, postStyleMap, totalTime, errors);\n }\n timelines.forEach((/**\n * @param {?} tl\n * @return {?}\n */\n tl => {\n /** @type {?} */\n const elm = tl.element;\n /** @type {?} */\n const preProps = getOrSetAsInMap(preStyleMap, elm, {});\n tl.preStyleProps.forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => preProps[prop] = true));\n /** @type {?} */\n const postProps = getOrSetAsInMap(postStyleMap, elm, {});\n tl.postStyleProps.forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => postProps[prop] = true));\n if (elm !== element) {\n queriedElements.add(elm);\n }\n }));\n /** @type {?} */\n const queriedElementsList = iteratorToArray(queriedElements.values());\n return createTransitionInstruction(element, this._triggerName, currentState, nextState, isRemoval, currentStateStyles, nextStateStyles, timelines, queriedElementsList, preStyleMap, postStyleMap, totalTime);\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n AnimationTransitionFactory.prototype._triggerName;\n /** @type {?} */\n AnimationTransitionFactory.prototype.ast;\n /**\n * @type {?}\n * @private\n */\n AnimationTransitionFactory.prototype._stateStyles;\n}\n/**\n * @param {?} matchFns\n * @param {?} currentState\n * @param {?} nextState\n * @param {?} element\n * @param {?} params\n * @return {?}\n */\nfunction oneOrMoreTransitionsMatch(matchFns, currentState, nextState, element, params) {\n return matchFns.some((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn(currentState, nextState, element, params)));\n}\nclass AnimationStateStyles {\n /**\n * @param {?} styles\n * @param {?} defaultParams\n */\n constructor(styles, defaultParams) {\n this.styles = styles;\n this.defaultParams = defaultParams;\n }\n /**\n * @param {?} params\n * @param {?} errors\n * @return {?}\n */\n buildStyles(params, errors) {\n /** @type {?} */\n const finalStyles = {};\n /** @type {?} */\n const combinedParams = copyObj(this.defaultParams);\n Object.keys(params).forEach((/**\n * @param {?} key\n * @return {?}\n */\n key => {\n /** @type {?} */\n const value = params[key];\n if (value != null) {\n combinedParams[key] = value;\n }\n }));\n this.styles.styles.forEach((/**\n * @param {?} value\n * @return {?}\n */\n value => {\n if (typeof value !== 'string') {\n /** @type {?} */\n const styleObj = (/** @type {?} */ (value));\n Object.keys(styleObj).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n /** @type {?} */\n let val = styleObj[prop];\n if (val.length > 1) {\n val = interpolateParams(val, combinedParams, errors);\n }\n finalStyles[prop] = val;\n }));\n }\n }));\n return finalStyles;\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n AnimationStateStyles.prototype.styles;\n /**\n * @type {?}\n * @private\n */\n AnimationStateStyles.prototype.defaultParams;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/dsl/animation_trigger.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * \\@publicApi\n * @param {?} name\n * @param {?} ast\n * @return {?}\n */\nfunction buildTrigger(name, ast) {\n return new AnimationTrigger(name, ast);\n}\n/**\n * \\@publicApi\n */\nclass AnimationTrigger {\n /**\n * @param {?} name\n * @param {?} ast\n */\n constructor(name, ast) {\n this.name = name;\n this.ast = ast;\n this.transitionFactories = [];\n this.states = {};\n ast.states.forEach((/**\n * @param {?} ast\n * @return {?}\n */\n ast => {\n /** @type {?} */\n const defaultParams = (ast.options && ast.options.params) || {};\n this.states[ast.name] = new AnimationStateStyles(ast.style, defaultParams);\n }));\n balanceProperties(this.states, 'true', '1');\n balanceProperties(this.states, 'false', '0');\n ast.transitions.forEach((/**\n * @param {?} ast\n * @return {?}\n */\n ast => {\n this.transitionFactories.push(new AnimationTransitionFactory(name, ast, this.states));\n }));\n this.fallbackTransition = createFallbackTransition(name, this.states);\n }\n /**\n * @return {?}\n */\n get containsQueries() {\n return this.ast.queryCount > 0;\n }\n /**\n * @param {?} currentState\n * @param {?} nextState\n * @param {?} element\n * @param {?} params\n * @return {?}\n */\n matchTransition(currentState, nextState, element, params) {\n /** @type {?} */\n const entry = this.transitionFactories.find((/**\n * @param {?} f\n * @return {?}\n */\n f => f.match(currentState, nextState, element, params)));\n return entry || null;\n }\n /**\n * @param {?} currentState\n * @param {?} params\n * @param {?} errors\n * @return {?}\n */\n matchStyles(currentState, params, errors) {\n return this.fallbackTransition.buildStyles(currentState, params, errors);\n }\n}\nif (false) {\n /** @type {?} */\n AnimationTrigger.prototype.transitionFactories;\n /** @type {?} */\n AnimationTrigger.prototype.fallbackTransition;\n /** @type {?} */\n AnimationTrigger.prototype.states;\n /** @type {?} */\n AnimationTrigger.prototype.name;\n /** @type {?} */\n AnimationTrigger.prototype.ast;\n}\n/**\n * @param {?} triggerName\n * @param {?} states\n * @return {?}\n */\nfunction createFallbackTransition(triggerName, states) {\n /** @type {?} */\n const matchers = [(/**\n * @param {?} fromState\n * @param {?} toState\n * @return {?}\n */\n (fromState, toState) => true)];\n /** @type {?} */\n const animation = { type: 2 /* Sequence */, steps: [], options: null };\n /** @type {?} */\n const transition = {\n type: 1 /* Transition */,\n animation,\n matchers,\n options: null,\n queryCount: 0,\n depCount: 0\n };\n return new AnimationTransitionFactory(triggerName, transition, states);\n}\n/**\n * @param {?} obj\n * @param {?} key1\n * @param {?} key2\n * @return {?}\n */\nfunction balanceProperties(obj, key1, key2) {\n if (obj.hasOwnProperty(key1)) {\n if (!obj.hasOwnProperty(key2)) {\n obj[key2] = obj[key1];\n }\n }\n else if (obj.hasOwnProperty(key2)) {\n obj[key1] = obj[key2];\n }\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/render/timeline_animation_engine.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst EMPTY_INSTRUCTION_MAP = new ElementInstructionMap();\nclass TimelineAnimationEngine {\n /**\n * @param {?} bodyNode\n * @param {?} _driver\n * @param {?} _normalizer\n */\n constructor(bodyNode, _driver, _normalizer) {\n this.bodyNode = bodyNode;\n this._driver = _driver;\n this._normalizer = _normalizer;\n this._animations = {};\n this._playersById = {};\n this.players = [];\n }\n /**\n * @param {?} id\n * @param {?} metadata\n * @return {?}\n */\n register(id, metadata) {\n /** @type {?} */\n const errors = [];\n /** @type {?} */\n const ast = buildAnimationAst(this._driver, metadata, errors);\n if (errors.length) {\n throw new Error(`Unable to build the animation due to the following errors: ${errors.join('\\n')}`);\n }\n else {\n this._animations[id] = ast;\n }\n }\n /**\n * @private\n * @param {?} i\n * @param {?} preStyles\n * @param {?=} postStyles\n * @return {?}\n */\n _buildPlayer(i, preStyles, postStyles) {\n /** @type {?} */\n const element = i.element;\n /** @type {?} */\n const keyframes = normalizeKeyframes(this._driver, this._normalizer, element, i.keyframes, preStyles, postStyles);\n return this._driver.animate(element, keyframes, i.duration, i.delay, i.easing, [], true);\n }\n /**\n * @param {?} id\n * @param {?} element\n * @param {?=} options\n * @return {?}\n */\n create(id, element, options = {}) {\n /** @type {?} */\n const errors = [];\n /** @type {?} */\n const ast = this._animations[id];\n /** @type {?} */\n let instructions;\n /** @type {?} */\n const autoStylesMap = new Map();\n if (ast) {\n instructions = buildAnimationTimelines(this._driver, element, ast, ENTER_CLASSNAME, LEAVE_CLASSNAME, {}, {}, options, EMPTY_INSTRUCTION_MAP, errors);\n instructions.forEach((/**\n * @param {?} inst\n * @return {?}\n */\n inst => {\n /** @type {?} */\n const styles = getOrSetAsInMap(autoStylesMap, inst.element, {});\n inst.postStyleProps.forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => styles[prop] = null));\n }));\n }\n else {\n errors.push('The requested animation doesn\\'t exist or has already been destroyed');\n instructions = [];\n }\n if (errors.length) {\n throw new Error(`Unable to create the animation due to the following errors: ${errors.join('\\n')}`);\n }\n autoStylesMap.forEach((/**\n * @param {?} styles\n * @param {?} element\n * @return {?}\n */\n (styles, element) => {\n Object.keys(styles).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n styles[prop] = this._driver.computeStyle(element, prop, AUTO_STYLE);\n }));\n }));\n /** @type {?} */\n const players = instructions.map((/**\n * @param {?} i\n * @return {?}\n */\n i => {\n /** @type {?} */\n const styles = autoStylesMap.get(i.element);\n return this._buildPlayer(i, {}, styles);\n }));\n /** @type {?} */\n const player = optimizeGroupPlayer(players);\n this._playersById[id] = player;\n player.onDestroy((/**\n * @return {?}\n */\n () => this.destroy(id)));\n this.players.push(player);\n return player;\n }\n /**\n * @param {?} id\n * @return {?}\n */\n destroy(id) {\n /** @type {?} */\n const player = this._getPlayer(id);\n player.destroy();\n delete this._playersById[id];\n /** @type {?} */\n const index = this.players.indexOf(player);\n if (index >= 0) {\n this.players.splice(index, 1);\n }\n }\n /**\n * @private\n * @param {?} id\n * @return {?}\n */\n _getPlayer(id) {\n /** @type {?} */\n const player = this._playersById[id];\n if (!player) {\n throw new Error(`Unable to find the timeline player referenced by ${id}`);\n }\n return player;\n }\n /**\n * @param {?} id\n * @param {?} element\n * @param {?} eventName\n * @param {?} callback\n * @return {?}\n */\n listen(id, element, eventName, callback) {\n // triggerName, fromState, toState are all ignored for timeline animations\n /** @type {?} */\n const baseEvent = makeAnimationEvent(element, '', '', '');\n listenOnPlayer(this._getPlayer(id), eventName, baseEvent, callback);\n return (/**\n * @return {?}\n */\n () => { });\n }\n /**\n * @param {?} id\n * @param {?} element\n * @param {?} command\n * @param {?} args\n * @return {?}\n */\n command(id, element, command, args) {\n if (command == 'register') {\n this.register(id, (/** @type {?} */ (args[0])));\n return;\n }\n if (command == 'create') {\n /** @type {?} */\n const options = (/** @type {?} */ ((args[0] || {})));\n this.create(id, element, options);\n return;\n }\n /** @type {?} */\n const player = this._getPlayer(id);\n switch (command) {\n case 'play':\n player.play();\n break;\n case 'pause':\n player.pause();\n break;\n case 'reset':\n player.reset();\n break;\n case 'restart':\n player.restart();\n break;\n case 'finish':\n player.finish();\n break;\n case 'init':\n player.init();\n break;\n case 'setPosition':\n player.setPosition(parseFloat((/** @type {?} */ (args[0]))));\n break;\n case 'destroy':\n this.destroy(id);\n break;\n }\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n TimelineAnimationEngine.prototype._animations;\n /**\n * @type {?}\n * @private\n */\n TimelineAnimationEngine.prototype._playersById;\n /** @type {?} */\n TimelineAnimationEngine.prototype.players;\n /** @type {?} */\n TimelineAnimationEngine.prototype.bodyNode;\n /**\n * @type {?}\n * @private\n */\n TimelineAnimationEngine.prototype._driver;\n /**\n * @type {?}\n * @private\n */\n TimelineAnimationEngine.prototype._normalizer;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/render/transition_animation_engine.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst QUEUED_CLASSNAME = 'ng-animate-queued';\n/** @type {?} */\nconst QUEUED_SELECTOR = '.ng-animate-queued';\n/** @type {?} */\nconst DISABLED_CLASSNAME = 'ng-animate-disabled';\n/** @type {?} */\nconst DISABLED_SELECTOR = '.ng-animate-disabled';\n/** @type {?} */\nconst STAR_CLASSNAME = 'ng-star-inserted';\n/** @type {?} */\nconst STAR_SELECTOR = '.ng-star-inserted';\n/** @type {?} */\nconst EMPTY_PLAYER_ARRAY = [];\n/** @type {?} */\nconst NULL_REMOVAL_STATE = {\n namespaceId: '',\n setForRemoval: false,\n setForMove: false,\n hasAnimation: false,\n removedBeforeQueried: false\n};\n/** @type {?} */\nconst NULL_REMOVED_QUERIED_STATE = {\n namespaceId: '',\n setForMove: false,\n setForRemoval: false,\n hasAnimation: false,\n removedBeforeQueried: true\n};\n/**\n * @record\n */\nfunction TriggerListener() { }\nif (false) {\n /** @type {?} */\n TriggerListener.prototype.name;\n /** @type {?} */\n TriggerListener.prototype.phase;\n /** @type {?} */\n TriggerListener.prototype.callback;\n}\n/**\n * @record\n */\nfunction QueueInstruction() { }\nif (false) {\n /** @type {?} */\n QueueInstruction.prototype.element;\n /** @type {?} */\n QueueInstruction.prototype.triggerName;\n /** @type {?} */\n QueueInstruction.prototype.fromState;\n /** @type {?} */\n QueueInstruction.prototype.toState;\n /** @type {?} */\n QueueInstruction.prototype.transition;\n /** @type {?} */\n QueueInstruction.prototype.player;\n /** @type {?} */\n QueueInstruction.prototype.isFallbackTransition;\n}\n/** @type {?} */\nconst REMOVAL_FLAG = '__ng_removed';\n/**\n * @record\n */\nfunction ElementAnimationState() { }\nif (false) {\n /** @type {?} */\n ElementAnimationState.prototype.setForRemoval;\n /** @type {?} */\n ElementAnimationState.prototype.setForMove;\n /** @type {?} */\n ElementAnimationState.prototype.hasAnimation;\n /** @type {?} */\n ElementAnimationState.prototype.namespaceId;\n /** @type {?} */\n ElementAnimationState.prototype.removedBeforeQueried;\n}\nclass StateValue {\n /**\n * @param {?} input\n * @param {?=} namespaceId\n */\n constructor(input, namespaceId = '') {\n this.namespaceId = namespaceId;\n /** @type {?} */\n const isObj = input && input.hasOwnProperty('value');\n /** @type {?} */\n const value = isObj ? input['value'] : input;\n this.value = normalizeTriggerValue(value);\n if (isObj) {\n /** @type {?} */\n const options = copyObj((/** @type {?} */ (input)));\n delete options['value'];\n this.options = (/** @type {?} */ (options));\n }\n else {\n this.options = {};\n }\n if (!this.options.params) {\n this.options.params = {};\n }\n }\n /**\n * @return {?}\n */\n get params() {\n return (/** @type {?} */ (this.options.params));\n }\n /**\n * @param {?} options\n * @return {?}\n */\n absorbOptions(options) {\n /** @type {?} */\n const newParams = options.params;\n if (newParams) {\n /** @type {?} */\n const oldParams = (/** @type {?} */ (this.options.params));\n Object.keys(newParams).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n if (oldParams[prop] == null) {\n oldParams[prop] = newParams[prop];\n }\n }));\n }\n }\n}\nif (false) {\n /** @type {?} */\n StateValue.prototype.value;\n /** @type {?} */\n StateValue.prototype.options;\n /** @type {?} */\n StateValue.prototype.namespaceId;\n}\n/** @type {?} */\nconst VOID_VALUE = 'void';\n/** @type {?} */\nconst DEFAULT_STATE_VALUE = new StateValue(VOID_VALUE);\nclass AnimationTransitionNamespace {\n /**\n * @param {?} id\n * @param {?} hostElement\n * @param {?} _engine\n */\n constructor(id, hostElement, _engine) {\n this.id = id;\n this.hostElement = hostElement;\n this._engine = _engine;\n this.players = [];\n this._triggers = {};\n this._queue = [];\n this._elementListeners = new Map();\n this._hostClassName = 'ng-tns-' + id;\n addClass(hostElement, this._hostClassName);\n }\n /**\n * @param {?} element\n * @param {?} name\n * @param {?} phase\n * @param {?} callback\n * @return {?}\n */\n listen(element, name, phase, callback) {\n if (!this._triggers.hasOwnProperty(name)) {\n throw new Error(`Unable to listen on the animation trigger event \"${phase}\" because the animation trigger \"${name}\" doesn\\'t exist!`);\n }\n if (phase == null || phase.length == 0) {\n throw new Error(`Unable to listen on the animation trigger \"${name}\" because the provided event is undefined!`);\n }\n if (!isTriggerEventValid(phase)) {\n throw new Error(`The provided animation trigger event \"${phase}\" for the animation trigger \"${name}\" is not supported!`);\n }\n /** @type {?} */\n const listeners = getOrSetAsInMap(this._elementListeners, element, []);\n /** @type {?} */\n const data = { name, phase, callback };\n listeners.push(data);\n /** @type {?} */\n const triggersWithStates = getOrSetAsInMap(this._engine.statesByElement, element, {});\n if (!triggersWithStates.hasOwnProperty(name)) {\n addClass(element, NG_TRIGGER_CLASSNAME);\n addClass(element, NG_TRIGGER_CLASSNAME + '-' + name);\n triggersWithStates[name] = DEFAULT_STATE_VALUE;\n }\n return (/**\n * @return {?}\n */\n () => {\n // the event listener is removed AFTER the flush has occurred such\n // that leave animations callbacks can fire (otherwise if the node\n // is removed in between then the listeners would be deregistered)\n this._engine.afterFlush((/**\n * @return {?}\n */\n () => {\n /** @type {?} */\n const index = listeners.indexOf(data);\n if (index >= 0) {\n listeners.splice(index, 1);\n }\n if (!this._triggers[name]) {\n delete triggersWithStates[name];\n }\n }));\n });\n }\n /**\n * @param {?} name\n * @param {?} ast\n * @return {?}\n */\n register(name, ast) {\n if (this._triggers[name]) {\n // throw\n return false;\n }\n else {\n this._triggers[name] = ast;\n return true;\n }\n }\n /**\n * @private\n * @param {?} name\n * @return {?}\n */\n _getTrigger(name) {\n /** @type {?} */\n const trigger = this._triggers[name];\n if (!trigger) {\n throw new Error(`The provided animation trigger \"${name}\" has not been registered!`);\n }\n return trigger;\n }\n /**\n * @param {?} element\n * @param {?} triggerName\n * @param {?} value\n * @param {?=} defaultToFallback\n * @return {?}\n */\n trigger(element, triggerName, value, defaultToFallback = true) {\n /** @type {?} */\n const trigger = this._getTrigger(triggerName);\n /** @type {?} */\n const player = new TransitionAnimationPlayer(this.id, triggerName, element);\n /** @type {?} */\n let triggersWithStates = this._engine.statesByElement.get(element);\n if (!triggersWithStates) {\n addClass(element, NG_TRIGGER_CLASSNAME);\n addClass(element, NG_TRIGGER_CLASSNAME + '-' + triggerName);\n this._engine.statesByElement.set(element, triggersWithStates = {});\n }\n /** @type {?} */\n let fromState = triggersWithStates[triggerName];\n /** @type {?} */\n const toState = new StateValue(value, this.id);\n /** @type {?} */\n const isObj = value && value.hasOwnProperty('value');\n if (!isObj && fromState) {\n toState.absorbOptions(fromState.options);\n }\n triggersWithStates[triggerName] = toState;\n if (!fromState) {\n fromState = DEFAULT_STATE_VALUE;\n }\n /** @type {?} */\n const isRemoval = toState.value === VOID_VALUE;\n // normally this isn't reached by here, however, if an object expression\n // is passed in then it may be a new object each time. Comparing the value\n // is important since that will stay the same despite there being a new object.\n // The removal arc here is special cased because the same element is triggered\n // twice in the event that it contains animations on the outer/inner portions\n // of the host container\n if (!isRemoval && fromState.value === toState.value) {\n // this means that despite the value not changing, some inner params\n // have changed which means that the animation final styles need to be applied\n if (!objEquals(fromState.params, toState.params)) {\n /** @type {?} */\n const errors = [];\n /** @type {?} */\n const fromStyles = trigger.matchStyles(fromState.value, fromState.params, errors);\n /** @type {?} */\n const toStyles = trigger.matchStyles(toState.value, toState.params, errors);\n if (errors.length) {\n this._engine.reportError(errors);\n }\n else {\n this._engine.afterFlush((/**\n * @return {?}\n */\n () => {\n eraseStyles(element, fromStyles);\n setStyles(element, toStyles);\n }));\n }\n }\n return;\n }\n /** @type {?} */\n const playersOnElement = getOrSetAsInMap(this._engine.playersByElement, element, []);\n playersOnElement.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n // only remove the player if it is queued on the EXACT same trigger/namespace\n // we only also deal with queued players here because if the animation has\n // started then we want to keep the player alive until the flush happens\n // (which is where the previousPlayers are passed into the new palyer)\n if (player.namespaceId == this.id && player.triggerName == triggerName && player.queued) {\n player.destroy();\n }\n }));\n /** @type {?} */\n let transition = trigger.matchTransition(fromState.value, toState.value, element, toState.params);\n /** @type {?} */\n let isFallbackTransition = false;\n if (!transition) {\n if (!defaultToFallback)\n return;\n transition = trigger.fallbackTransition;\n isFallbackTransition = true;\n }\n this._engine.totalQueuedPlayers++;\n this._queue.push({ element, triggerName, transition, fromState, toState, player, isFallbackTransition });\n if (!isFallbackTransition) {\n addClass(element, QUEUED_CLASSNAME);\n player.onStart((/**\n * @return {?}\n */\n () => {\n removeClass(element, QUEUED_CLASSNAME);\n }));\n }\n player.onDone((/**\n * @return {?}\n */\n () => {\n /** @type {?} */\n let index = this.players.indexOf(player);\n if (index >= 0) {\n this.players.splice(index, 1);\n }\n /** @type {?} */\n const players = this._engine.playersByElement.get(element);\n if (players) {\n /** @type {?} */\n let index = players.indexOf(player);\n if (index >= 0) {\n players.splice(index, 1);\n }\n }\n }));\n this.players.push(player);\n playersOnElement.push(player);\n return player;\n }\n /**\n * @param {?} name\n * @return {?}\n */\n deregister(name) {\n delete this._triggers[name];\n this._engine.statesByElement.forEach((/**\n * @param {?} stateMap\n * @param {?} element\n * @return {?}\n */\n (stateMap, element) => {\n delete stateMap[name];\n }));\n this._elementListeners.forEach((/**\n * @param {?} listeners\n * @param {?} element\n * @return {?}\n */\n (listeners, element) => {\n this._elementListeners.set(element, listeners.filter((/**\n * @param {?} entry\n * @return {?}\n */\n entry => {\n return entry.name != name;\n })));\n }));\n }\n /**\n * @param {?} element\n * @return {?}\n */\n clearElementCache(element) {\n this._engine.statesByElement.delete(element);\n this._elementListeners.delete(element);\n /** @type {?} */\n const elementPlayers = this._engine.playersByElement.get(element);\n if (elementPlayers) {\n elementPlayers.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => player.destroy()));\n this._engine.playersByElement.delete(element);\n }\n }\n /**\n * @private\n * @param {?} rootElement\n * @param {?} context\n * @return {?}\n */\n _signalRemovalForInnerTriggers(rootElement, context) {\n /** @type {?} */\n const elements = this._engine.driver.query(rootElement, NG_TRIGGER_SELECTOR, true);\n // emulate a leave animation for all inner nodes within this node.\n // If there are no animations found for any of the nodes then clear the cache\n // for the element.\n elements.forEach((/**\n * @param {?} elm\n * @return {?}\n */\n elm => {\n // this means that an inner remove() operation has already kicked off\n // the animation on this element...\n if (elm[REMOVAL_FLAG])\n return;\n /** @type {?} */\n const namespaces = this._engine.fetchNamespacesByElement(elm);\n if (namespaces.size) {\n namespaces.forEach((/**\n * @param {?} ns\n * @return {?}\n */\n ns => ns.triggerLeaveAnimation(elm, context, false, true)));\n }\n else {\n this.clearElementCache(elm);\n }\n }));\n // If the child elements were removed along with the parent, their animations might not\n // have completed. Clear all the elements from the cache so we don't end up with a memory leak.\n this._engine.afterFlushAnimationsDone((/**\n * @return {?}\n */\n () => elements.forEach((/**\n * @param {?} elm\n * @return {?}\n */\n elm => this.clearElementCache(elm)))));\n }\n /**\n * @param {?} element\n * @param {?} context\n * @param {?=} destroyAfterComplete\n * @param {?=} defaultToFallback\n * @return {?}\n */\n triggerLeaveAnimation(element, context, destroyAfterComplete, defaultToFallback) {\n /** @type {?} */\n const triggerStates = this._engine.statesByElement.get(element);\n if (triggerStates) {\n /** @type {?} */\n const players = [];\n Object.keys(triggerStates).forEach((/**\n * @param {?} triggerName\n * @return {?}\n */\n triggerName => {\n // this check is here in the event that an element is removed\n // twice (both on the host level and the component level)\n if (this._triggers[triggerName]) {\n /** @type {?} */\n const player = this.trigger(element, triggerName, VOID_VALUE, defaultToFallback);\n if (player) {\n players.push(player);\n }\n }\n }));\n if (players.length) {\n this._engine.markElementAsRemoved(this.id, element, true, context);\n if (destroyAfterComplete) {\n optimizeGroupPlayer(players).onDone((/**\n * @return {?}\n */\n () => this._engine.processLeaveNode(element)));\n }\n return true;\n }\n }\n return false;\n }\n /**\n * @param {?} element\n * @return {?}\n */\n prepareLeaveAnimationListeners(element) {\n /** @type {?} */\n const listeners = this._elementListeners.get(element);\n if (listeners) {\n /** @type {?} */\n const visitedTriggers = new Set();\n listeners.forEach((/**\n * @param {?} listener\n * @return {?}\n */\n listener => {\n /** @type {?} */\n const triggerName = listener.name;\n if (visitedTriggers.has(triggerName))\n return;\n visitedTriggers.add(triggerName);\n /** @type {?} */\n const trigger = this._triggers[triggerName];\n /** @type {?} */\n const transition = trigger.fallbackTransition;\n /** @type {?} */\n const elementStates = (/** @type {?} */ (this._engine.statesByElement.get(element)));\n /** @type {?} */\n const fromState = elementStates[triggerName] || DEFAULT_STATE_VALUE;\n /** @type {?} */\n const toState = new StateValue(VOID_VALUE);\n /** @type {?} */\n const player = new TransitionAnimationPlayer(this.id, triggerName, element);\n this._engine.totalQueuedPlayers++;\n this._queue.push({\n element,\n triggerName,\n transition,\n fromState,\n toState,\n player,\n isFallbackTransition: true\n });\n }));\n }\n }\n /**\n * @param {?} element\n * @param {?} context\n * @return {?}\n */\n removeNode(element, context) {\n /** @type {?} */\n const engine = this._engine;\n if (element.childElementCount) {\n this._signalRemovalForInnerTriggers(element, context);\n }\n // this means that a * => VOID animation was detected and kicked off\n if (this.triggerLeaveAnimation(element, context, true))\n return;\n // find the player that is animating and make sure that the\n // removal is delayed until that player has completed\n /** @type {?} */\n let containsPotentialParentTransition = false;\n if (engine.totalAnimations) {\n /** @type {?} */\n const currentPlayers = engine.players.length ? engine.playersByQueriedElement.get(element) : [];\n // when this `if statement` does not continue forward it means that\n // a previous animation query has selected the current element and\n // is animating it. In this situation want to continue forwards and\n // allow the element to be queued up for animation later.\n if (currentPlayers && currentPlayers.length) {\n containsPotentialParentTransition = true;\n }\n else {\n /** @type {?} */\n let parent = element;\n while (parent = parent.parentNode) {\n /** @type {?} */\n const triggers = engine.statesByElement.get(parent);\n if (triggers) {\n containsPotentialParentTransition = true;\n break;\n }\n }\n }\n }\n // at this stage we know that the element will either get removed\n // during flush or will be picked up by a parent query. Either way\n // we need to fire the listeners for this element when it DOES get\n // removed (once the query parent animation is done or after flush)\n this.prepareLeaveAnimationListeners(element);\n // whether or not a parent has an animation we need to delay the deferral of the leave\n // operation until we have more information (which we do after flush() has been called)\n if (containsPotentialParentTransition) {\n engine.markElementAsRemoved(this.id, element, false, context);\n }\n else {\n /** @type {?} */\n const removalFlag = element[REMOVAL_FLAG];\n if (!removalFlag || removalFlag === NULL_REMOVAL_STATE) {\n // we do this after the flush has occurred such\n // that the callbacks can be fired\n engine.afterFlush((/**\n * @return {?}\n */\n () => this.clearElementCache(element)));\n engine.destroyInnerAnimations(element);\n engine._onRemovalComplete(element, context);\n }\n }\n }\n /**\n * @param {?} element\n * @param {?} parent\n * @return {?}\n */\n insertNode(element, parent) {\n addClass(element, this._hostClassName);\n }\n /**\n * @param {?} microtaskId\n * @return {?}\n */\n drainQueuedTransitions(microtaskId) {\n /** @type {?} */\n const instructions = [];\n this._queue.forEach((/**\n * @param {?} entry\n * @return {?}\n */\n entry => {\n /** @type {?} */\n const player = entry.player;\n if (player.destroyed)\n return;\n /** @type {?} */\n const element = entry.element;\n /** @type {?} */\n const listeners = this._elementListeners.get(element);\n if (listeners) {\n listeners.forEach((/**\n * @param {?} listener\n * @return {?}\n */\n (listener) => {\n if (listener.name == entry.triggerName) {\n /** @type {?} */\n const baseEvent = makeAnimationEvent(element, entry.triggerName, entry.fromState.value, entry.toState.value);\n ((/** @type {?} */ (baseEvent)))['_data'] = microtaskId;\n listenOnPlayer(entry.player, listener.phase, baseEvent, listener.callback);\n }\n }));\n }\n if (player.markedForDestroy) {\n this._engine.afterFlush((/**\n * @return {?}\n */\n () => {\n // now we can destroy the element properly since the event listeners have\n // been bound to the player\n player.destroy();\n }));\n }\n else {\n instructions.push(entry);\n }\n }));\n this._queue = [];\n return instructions.sort((/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\n (a, b) => {\n // if depCount == 0 them move to front\n // otherwise if a contains b then move back\n /** @type {?} */\n const d0 = a.transition.ast.depCount;\n /** @type {?} */\n const d1 = b.transition.ast.depCount;\n if (d0 == 0 || d1 == 0) {\n return d0 - d1;\n }\n return this._engine.driver.containsElement(a.element, b.element) ? 1 : -1;\n }));\n }\n /**\n * @param {?} context\n * @return {?}\n */\n destroy(context) {\n this.players.forEach((/**\n * @param {?} p\n * @return {?}\n */\n p => p.destroy()));\n this._signalRemovalForInnerTriggers(this.hostElement, context);\n }\n /**\n * @param {?} element\n * @return {?}\n */\n elementContainsData(element) {\n /** @type {?} */\n let containsData = false;\n if (this._elementListeners.has(element))\n containsData = true;\n containsData =\n (this._queue.find((/**\n * @param {?} entry\n * @return {?}\n */\n entry => entry.element === element)) ? true : false) || containsData;\n return containsData;\n }\n}\nif (false) {\n /** @type {?} */\n AnimationTransitionNamespace.prototype.players;\n /**\n * @type {?}\n * @private\n */\n AnimationTransitionNamespace.prototype._triggers;\n /**\n * @type {?}\n * @private\n */\n AnimationTransitionNamespace.prototype._queue;\n /**\n * @type {?}\n * @private\n */\n AnimationTransitionNamespace.prototype._elementListeners;\n /**\n * @type {?}\n * @private\n */\n AnimationTransitionNamespace.prototype._hostClassName;\n /** @type {?} */\n AnimationTransitionNamespace.prototype.id;\n /** @type {?} */\n AnimationTransitionNamespace.prototype.hostElement;\n /**\n * @type {?}\n * @private\n */\n AnimationTransitionNamespace.prototype._engine;\n}\n/**\n * @record\n */\nfunction QueuedTransition() { }\nif (false) {\n /** @type {?} */\n QueuedTransition.prototype.element;\n /** @type {?} */\n QueuedTransition.prototype.instruction;\n /** @type {?} */\n QueuedTransition.prototype.player;\n}\nclass TransitionAnimationEngine {\n /**\n * @param {?} bodyNode\n * @param {?} driver\n * @param {?} _normalizer\n */\n constructor(bodyNode, driver, _normalizer) {\n this.bodyNode = bodyNode;\n this.driver = driver;\n this._normalizer = _normalizer;\n this.players = [];\n this.newHostElements = new Map();\n this.playersByElement = new Map();\n this.playersByQueriedElement = new Map();\n this.statesByElement = new Map();\n this.disabledNodes = new Set();\n this.totalAnimations = 0;\n this.totalQueuedPlayers = 0;\n this._namespaceLookup = {};\n this._namespaceList = [];\n this._flushFns = [];\n this._whenQuietFns = [];\n this.namespacesByHostElement = new Map();\n this.collectedEnterElements = [];\n this.collectedLeaveElements = [];\n // this method is designed to be overridden by the code that uses this engine\n this.onRemovalComplete = (/**\n * @param {?} element\n * @param {?} context\n * @return {?}\n */\n (element, context) => { });\n }\n /**\n * \\@internal\n * @param {?} element\n * @param {?} context\n * @return {?}\n */\n _onRemovalComplete(element, context) {\n this.onRemovalComplete(element, context);\n }\n /**\n * @return {?}\n */\n get queuedPlayers() {\n /** @type {?} */\n const players = [];\n this._namespaceList.forEach((/**\n * @param {?} ns\n * @return {?}\n */\n ns => {\n ns.players.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n if (player.queued) {\n players.push(player);\n }\n }));\n }));\n return players;\n }\n /**\n * @param {?} namespaceId\n * @param {?} hostElement\n * @return {?}\n */\n createNamespace(namespaceId, hostElement) {\n /** @type {?} */\n const ns = new AnimationTransitionNamespace(namespaceId, hostElement, this);\n if (hostElement.parentNode) {\n this._balanceNamespaceList(ns, hostElement);\n }\n else {\n // defer this later until flush during when the host element has\n // been inserted so that we know exactly where to place it in\n // the namespace list\n this.newHostElements.set(hostElement, ns);\n // given that this host element is apart of the animation code, it\n // may or may not be inserted by a parent node that is an of an\n // animation renderer type. If this happens then we can still have\n // access to this item when we query for :enter nodes. If the parent\n // is a renderer then the set data-structure will normalize the entry\n this.collectEnterElement(hostElement);\n }\n return this._namespaceLookup[namespaceId] = ns;\n }\n /**\n * @private\n * @param {?} ns\n * @param {?} hostElement\n * @return {?}\n */\n _balanceNamespaceList(ns, hostElement) {\n /** @type {?} */\n const limit = this._namespaceList.length - 1;\n if (limit >= 0) {\n /** @type {?} */\n let found = false;\n for (let i = limit; i >= 0; i--) {\n /** @type {?} */\n const nextNamespace = this._namespaceList[i];\n if (this.driver.containsElement(nextNamespace.hostElement, hostElement)) {\n this._namespaceList.splice(i + 1, 0, ns);\n found = true;\n break;\n }\n }\n if (!found) {\n this._namespaceList.splice(0, 0, ns);\n }\n }\n else {\n this._namespaceList.push(ns);\n }\n this.namespacesByHostElement.set(hostElement, ns);\n return ns;\n }\n /**\n * @param {?} namespaceId\n * @param {?} hostElement\n * @return {?}\n */\n register(namespaceId, hostElement) {\n /** @type {?} */\n let ns = this._namespaceLookup[namespaceId];\n if (!ns) {\n ns = this.createNamespace(namespaceId, hostElement);\n }\n return ns;\n }\n /**\n * @param {?} namespaceId\n * @param {?} name\n * @param {?} trigger\n * @return {?}\n */\n registerTrigger(namespaceId, name, trigger) {\n /** @type {?} */\n let ns = this._namespaceLookup[namespaceId];\n if (ns && ns.register(name, trigger)) {\n this.totalAnimations++;\n }\n }\n /**\n * @param {?} namespaceId\n * @param {?} context\n * @return {?}\n */\n destroy(namespaceId, context) {\n if (!namespaceId)\n return;\n /** @type {?} */\n const ns = this._fetchNamespace(namespaceId);\n this.afterFlush((/**\n * @return {?}\n */\n () => {\n this.namespacesByHostElement.delete(ns.hostElement);\n delete this._namespaceLookup[namespaceId];\n /** @type {?} */\n const index = this._namespaceList.indexOf(ns);\n if (index >= 0) {\n this._namespaceList.splice(index, 1);\n }\n }));\n this.afterFlushAnimationsDone((/**\n * @return {?}\n */\n () => ns.destroy(context)));\n }\n /**\n * @private\n * @param {?} id\n * @return {?}\n */\n _fetchNamespace(id) {\n return this._namespaceLookup[id];\n }\n /**\n * @param {?} element\n * @return {?}\n */\n fetchNamespacesByElement(element) {\n // normally there should only be one namespace per element, however\n // if @triggers are placed on both the component element and then\n // its host element (within the component code) then there will be\n // two namespaces returned. We use a set here to simply the dedupe\n // of namespaces incase there are multiple triggers both the elm and host\n /** @type {?} */\n const namespaces = new Set();\n /** @type {?} */\n const elementStates = this.statesByElement.get(element);\n if (elementStates) {\n /** @type {?} */\n const keys = Object.keys(elementStates);\n for (let i = 0; i < keys.length; i++) {\n /** @type {?} */\n const nsId = elementStates[keys[i]].namespaceId;\n if (nsId) {\n /** @type {?} */\n const ns = this._fetchNamespace(nsId);\n if (ns) {\n namespaces.add(ns);\n }\n }\n }\n }\n return namespaces;\n }\n /**\n * @param {?} namespaceId\n * @param {?} element\n * @param {?} name\n * @param {?} value\n * @return {?}\n */\n trigger(namespaceId, element, name, value) {\n if (isElementNode(element)) {\n /** @type {?} */\n const ns = this._fetchNamespace(namespaceId);\n if (ns) {\n ns.trigger(element, name, value);\n return true;\n }\n }\n return false;\n }\n /**\n * @param {?} namespaceId\n * @param {?} element\n * @param {?} parent\n * @param {?} insertBefore\n * @return {?}\n */\n insertNode(namespaceId, element, parent, insertBefore) {\n if (!isElementNode(element))\n return;\n // special case for when an element is removed and reinserted (move operation)\n // when this occurs we do not want to use the element for deletion later\n /** @type {?} */\n const details = (/** @type {?} */ (element[REMOVAL_FLAG]));\n if (details && details.setForRemoval) {\n details.setForRemoval = false;\n details.setForMove = true;\n /** @type {?} */\n const index = this.collectedLeaveElements.indexOf(element);\n if (index >= 0) {\n this.collectedLeaveElements.splice(index, 1);\n }\n }\n // in the event that the namespaceId is blank then the caller\n // code does not contain any animation code in it, but it is\n // just being called so that the node is marked as being inserted\n if (namespaceId) {\n /** @type {?} */\n const ns = this._fetchNamespace(namespaceId);\n // This if-statement is a workaround for router issue #21947.\n // The router sometimes hits a race condition where while a route\n // is being instantiated a new navigation arrives, triggering leave\n // animation of DOM that has not been fully initialized, until this\n // is resolved, we need to handle the scenario when DOM is not in a\n // consistent state during the animation.\n if (ns) {\n ns.insertNode(element, parent);\n }\n }\n // only *directives and host elements are inserted before\n if (insertBefore) {\n this.collectEnterElement(element);\n }\n }\n /**\n * @param {?} element\n * @return {?}\n */\n collectEnterElement(element) {\n this.collectedEnterElements.push(element);\n }\n /**\n * @param {?} element\n * @param {?} value\n * @return {?}\n */\n markElementAsDisabled(element, value) {\n if (value) {\n if (!this.disabledNodes.has(element)) {\n this.disabledNodes.add(element);\n addClass(element, DISABLED_CLASSNAME);\n }\n }\n else if (this.disabledNodes.has(element)) {\n this.disabledNodes.delete(element);\n removeClass(element, DISABLED_CLASSNAME);\n }\n }\n /**\n * @param {?} namespaceId\n * @param {?} element\n * @param {?} isHostElement\n * @param {?} context\n * @return {?}\n */\n removeNode(namespaceId, element, isHostElement, context) {\n if (isElementNode(element)) {\n /** @type {?} */\n const ns = namespaceId ? this._fetchNamespace(namespaceId) : null;\n if (ns) {\n ns.removeNode(element, context);\n }\n else {\n this.markElementAsRemoved(namespaceId, element, false, context);\n }\n if (isHostElement) {\n /** @type {?} */\n const hostNS = this.namespacesByHostElement.get(element);\n if (hostNS && hostNS.id !== namespaceId) {\n hostNS.removeNode(element, context);\n }\n }\n }\n else {\n this._onRemovalComplete(element, context);\n }\n }\n /**\n * @param {?} namespaceId\n * @param {?} element\n * @param {?=} hasAnimation\n * @param {?=} context\n * @return {?}\n */\n markElementAsRemoved(namespaceId, element, hasAnimation, context) {\n this.collectedLeaveElements.push(element);\n element[REMOVAL_FLAG] =\n { namespaceId, setForRemoval: context, hasAnimation, removedBeforeQueried: false };\n }\n /**\n * @param {?} namespaceId\n * @param {?} element\n * @param {?} name\n * @param {?} phase\n * @param {?} callback\n * @return {?}\n */\n listen(namespaceId, element, name, phase, callback) {\n if (isElementNode(element)) {\n return this._fetchNamespace(namespaceId).listen(element, name, phase, callback);\n }\n return (/**\n * @return {?}\n */\n () => { });\n }\n /**\n * @private\n * @param {?} entry\n * @param {?} subTimelines\n * @param {?} enterClassName\n * @param {?} leaveClassName\n * @param {?=} skipBuildAst\n * @return {?}\n */\n _buildInstruction(entry, subTimelines, enterClassName, leaveClassName, skipBuildAst) {\n return entry.transition.build(this.driver, entry.element, entry.fromState.value, entry.toState.value, enterClassName, leaveClassName, entry.fromState.options, entry.toState.options, subTimelines, skipBuildAst);\n }\n /**\n * @param {?} containerElement\n * @return {?}\n */\n destroyInnerAnimations(containerElement) {\n /** @type {?} */\n let elements = this.driver.query(containerElement, NG_TRIGGER_SELECTOR, true);\n elements.forEach((/**\n * @param {?} element\n * @return {?}\n */\n element => this.destroyActiveAnimationsForElement(element)));\n if (this.playersByQueriedElement.size == 0)\n return;\n elements = this.driver.query(containerElement, NG_ANIMATING_SELECTOR, true);\n elements.forEach((/**\n * @param {?} element\n * @return {?}\n */\n element => this.finishActiveQueriedAnimationOnElement(element)));\n }\n /**\n * @param {?} element\n * @return {?}\n */\n destroyActiveAnimationsForElement(element) {\n /** @type {?} */\n const players = this.playersByElement.get(element);\n if (players) {\n players.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n // special case for when an element is set for destruction, but hasn't started.\n // in this situation we want to delay the destruction until the flush occurs\n // so that any event listeners attached to the player are triggered.\n if (player.queued) {\n player.markedForDestroy = true;\n }\n else {\n player.destroy();\n }\n }));\n }\n }\n /**\n * @param {?} element\n * @return {?}\n */\n finishActiveQueriedAnimationOnElement(element) {\n /** @type {?} */\n const players = this.playersByQueriedElement.get(element);\n if (players) {\n players.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => player.finish()));\n }\n }\n /**\n * @return {?}\n */\n whenRenderingDone() {\n return new Promise((/**\n * @param {?} resolve\n * @return {?}\n */\n resolve => {\n if (this.players.length) {\n return optimizeGroupPlayer(this.players).onDone((/**\n * @return {?}\n */\n () => resolve()));\n }\n else {\n resolve();\n }\n }));\n }\n /**\n * @param {?} element\n * @return {?}\n */\n processLeaveNode(element) {\n /** @type {?} */\n const details = (/** @type {?} */ (element[REMOVAL_FLAG]));\n if (details && details.setForRemoval) {\n // this will prevent it from removing it twice\n element[REMOVAL_FLAG] = NULL_REMOVAL_STATE;\n if (details.namespaceId) {\n this.destroyInnerAnimations(element);\n /** @type {?} */\n const ns = this._fetchNamespace(details.namespaceId);\n if (ns) {\n ns.clearElementCache(element);\n }\n }\n this._onRemovalComplete(element, details.setForRemoval);\n }\n if (this.driver.matchesElement(element, DISABLED_SELECTOR)) {\n this.markElementAsDisabled(element, false);\n }\n this.driver.query(element, DISABLED_SELECTOR, true).forEach((/**\n * @param {?} node\n * @return {?}\n */\n node => {\n this.markElementAsDisabled(node, false);\n }));\n }\n /**\n * @param {?=} microtaskId\n * @return {?}\n */\n flush(microtaskId = -1) {\n /** @type {?} */\n let players = [];\n if (this.newHostElements.size) {\n this.newHostElements.forEach((/**\n * @param {?} ns\n * @param {?} element\n * @return {?}\n */\n (ns, element) => this._balanceNamespaceList(ns, element)));\n this.newHostElements.clear();\n }\n if (this.totalAnimations && this.collectedEnterElements.length) {\n for (let i = 0; i < this.collectedEnterElements.length; i++) {\n /** @type {?} */\n const elm = this.collectedEnterElements[i];\n addClass(elm, STAR_CLASSNAME);\n }\n }\n if (this._namespaceList.length &&\n (this.totalQueuedPlayers || this.collectedLeaveElements.length)) {\n /** @type {?} */\n const cleanupFns = [];\n try {\n players = this._flushAnimations(cleanupFns, microtaskId);\n }\n finally {\n for (let i = 0; i < cleanupFns.length; i++) {\n cleanupFns[i]();\n }\n }\n }\n else {\n for (let i = 0; i < this.collectedLeaveElements.length; i++) {\n /** @type {?} */\n const element = this.collectedLeaveElements[i];\n this.processLeaveNode(element);\n }\n }\n this.totalQueuedPlayers = 0;\n this.collectedEnterElements.length = 0;\n this.collectedLeaveElements.length = 0;\n this._flushFns.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n this._flushFns = [];\n if (this._whenQuietFns.length) {\n // we move these over to a variable so that\n // if any new callbacks are registered in another\n // flush they do not populate the existing set\n /** @type {?} */\n const quietFns = this._whenQuietFns;\n this._whenQuietFns = [];\n if (players.length) {\n optimizeGroupPlayer(players).onDone((/**\n * @return {?}\n */\n () => {\n quietFns.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n }));\n }\n else {\n quietFns.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n }\n }\n }\n /**\n * @param {?} errors\n * @return {?}\n */\n reportError(errors) {\n throw new Error(`Unable to process animations due to the following failed trigger transitions\\n ${errors.join('\\n')}`);\n }\n /**\n * @private\n * @param {?} cleanupFns\n * @param {?} microtaskId\n * @return {?}\n */\n _flushAnimations(cleanupFns, microtaskId) {\n /** @type {?} */\n const subTimelines = new ElementInstructionMap();\n /** @type {?} */\n const skippedPlayers = [];\n /** @type {?} */\n const skippedPlayersMap = new Map();\n /** @type {?} */\n const queuedInstructions = [];\n /** @type {?} */\n const queriedElements = new Map();\n /** @type {?} */\n const allPreStyleElements = new Map();\n /** @type {?} */\n const allPostStyleElements = new Map();\n /** @type {?} */\n const disabledElementsSet = new Set();\n this.disabledNodes.forEach((/**\n * @param {?} node\n * @return {?}\n */\n node => {\n disabledElementsSet.add(node);\n /** @type {?} */\n const nodesThatAreDisabled = this.driver.query(node, QUEUED_SELECTOR, true);\n for (let i = 0; i < nodesThatAreDisabled.length; i++) {\n disabledElementsSet.add(nodesThatAreDisabled[i]);\n }\n }));\n /** @type {?} */\n const bodyNode = this.bodyNode;\n /** @type {?} */\n const allTriggerElements = Array.from(this.statesByElement.keys());\n /** @type {?} */\n const enterNodeMap = buildRootMap(allTriggerElements, this.collectedEnterElements);\n // this must occur before the instructions are built below such that\n // the :enter queries match the elements (since the timeline queries\n // are fired during instruction building).\n /** @type {?} */\n const enterNodeMapIds = new Map();\n /** @type {?} */\n let i = 0;\n enterNodeMap.forEach((/**\n * @param {?} nodes\n * @param {?} root\n * @return {?}\n */\n (nodes, root) => {\n /** @type {?} */\n const className = ENTER_CLASSNAME + i++;\n enterNodeMapIds.set(root, className);\n nodes.forEach((/**\n * @param {?} node\n * @return {?}\n */\n node => addClass(node, className)));\n }));\n /** @type {?} */\n const allLeaveNodes = [];\n /** @type {?} */\n const mergedLeaveNodes = new Set();\n /** @type {?} */\n const leaveNodesWithoutAnimations = new Set();\n for (let i = 0; i < this.collectedLeaveElements.length; i++) {\n /** @type {?} */\n const element = this.collectedLeaveElements[i];\n /** @type {?} */\n const details = (/** @type {?} */ (element[REMOVAL_FLAG]));\n if (details && details.setForRemoval) {\n allLeaveNodes.push(element);\n mergedLeaveNodes.add(element);\n if (details.hasAnimation) {\n this.driver.query(element, STAR_SELECTOR, true).forEach((/**\n * @param {?} elm\n * @return {?}\n */\n elm => mergedLeaveNodes.add(elm)));\n }\n else {\n leaveNodesWithoutAnimations.add(element);\n }\n }\n }\n /** @type {?} */\n const leaveNodeMapIds = new Map();\n /** @type {?} */\n const leaveNodeMap = buildRootMap(allTriggerElements, Array.from(mergedLeaveNodes));\n leaveNodeMap.forEach((/**\n * @param {?} nodes\n * @param {?} root\n * @return {?}\n */\n (nodes, root) => {\n /** @type {?} */\n const className = LEAVE_CLASSNAME + i++;\n leaveNodeMapIds.set(root, className);\n nodes.forEach((/**\n * @param {?} node\n * @return {?}\n */\n node => addClass(node, className)));\n }));\n cleanupFns.push((/**\n * @return {?}\n */\n () => {\n enterNodeMap.forEach((/**\n * @param {?} nodes\n * @param {?} root\n * @return {?}\n */\n (nodes, root) => {\n /** @type {?} */\n const className = (/** @type {?} */ (enterNodeMapIds.get(root)));\n nodes.forEach((/**\n * @param {?} node\n * @return {?}\n */\n node => removeClass(node, className)));\n }));\n leaveNodeMap.forEach((/**\n * @param {?} nodes\n * @param {?} root\n * @return {?}\n */\n (nodes, root) => {\n /** @type {?} */\n const className = (/** @type {?} */ (leaveNodeMapIds.get(root)));\n nodes.forEach((/**\n * @param {?} node\n * @return {?}\n */\n node => removeClass(node, className)));\n }));\n allLeaveNodes.forEach((/**\n * @param {?} element\n * @return {?}\n */\n element => {\n this.processLeaveNode(element);\n }));\n }));\n /** @type {?} */\n const allPlayers = [];\n /** @type {?} */\n const erroneousTransitions = [];\n for (let i = this._namespaceList.length - 1; i >= 0; i--) {\n /** @type {?} */\n const ns = this._namespaceList[i];\n ns.drainQueuedTransitions(microtaskId).forEach((/**\n * @param {?} entry\n * @return {?}\n */\n entry => {\n /** @type {?} */\n const player = entry.player;\n /** @type {?} */\n const element = entry.element;\n allPlayers.push(player);\n if (this.collectedEnterElements.length) {\n /** @type {?} */\n const details = (/** @type {?} */ (element[REMOVAL_FLAG]));\n // move animations are currently not supported...\n if (details && details.setForMove) {\n player.destroy();\n return;\n }\n }\n /** @type {?} */\n const nodeIsOrphaned = !bodyNode || !this.driver.containsElement(bodyNode, element);\n /** @type {?} */\n const leaveClassName = (/** @type {?} */ (leaveNodeMapIds.get(element)));\n /** @type {?} */\n const enterClassName = (/** @type {?} */ (enterNodeMapIds.get(element)));\n /** @type {?} */\n const instruction = (/** @type {?} */ (this._buildInstruction(entry, subTimelines, enterClassName, leaveClassName, nodeIsOrphaned)));\n if (instruction.errors && instruction.errors.length) {\n erroneousTransitions.push(instruction);\n return;\n }\n // even though the element may not be apart of the DOM, it may\n // still be added at a later point (due to the mechanics of content\n // projection and/or dynamic component insertion) therefore it's\n // important we still style the element.\n if (nodeIsOrphaned) {\n player.onStart((/**\n * @return {?}\n */\n () => eraseStyles(element, instruction.fromStyles)));\n player.onDestroy((/**\n * @return {?}\n */\n () => setStyles(element, instruction.toStyles)));\n skippedPlayers.push(player);\n return;\n }\n // if a unmatched transition is queued to go then it SHOULD NOT render\n // an animation and cancel the previously running animations.\n if (entry.isFallbackTransition) {\n player.onStart((/**\n * @return {?}\n */\n () => eraseStyles(element, instruction.fromStyles)));\n player.onDestroy((/**\n * @return {?}\n */\n () => setStyles(element, instruction.toStyles)));\n skippedPlayers.push(player);\n return;\n }\n // this means that if a parent animation uses this animation as a sub trigger\n // then it will instruct the timeline builder to not add a player delay, but\n // instead stretch the first keyframe gap up until the animation starts. The\n // reason this is important is to prevent extra initialization styles from being\n // required by the user in the animation.\n instruction.timelines.forEach((/**\n * @param {?} tl\n * @return {?}\n */\n tl => tl.stretchStartingKeyframe = true));\n subTimelines.append(element, instruction.timelines);\n /** @type {?} */\n const tuple = { instruction, player, element };\n queuedInstructions.push(tuple);\n instruction.queriedElements.forEach((/**\n * @param {?} element\n * @return {?}\n */\n element => getOrSetAsInMap(queriedElements, element, []).push(player)));\n instruction.preStyleProps.forEach((/**\n * @param {?} stringMap\n * @param {?} element\n * @return {?}\n */\n (stringMap, element) => {\n /** @type {?} */\n const props = Object.keys(stringMap);\n if (props.length) {\n /** @type {?} */\n let setVal = (/** @type {?} */ (allPreStyleElements.get(element)));\n if (!setVal) {\n allPreStyleElements.set(element, setVal = new Set());\n }\n props.forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => setVal.add(prop)));\n }\n }));\n instruction.postStyleProps.forEach((/**\n * @param {?} stringMap\n * @param {?} element\n * @return {?}\n */\n (stringMap, element) => {\n /** @type {?} */\n const props = Object.keys(stringMap);\n /** @type {?} */\n let setVal = (/** @type {?} */ (allPostStyleElements.get(element)));\n if (!setVal) {\n allPostStyleElements.set(element, setVal = new Set());\n }\n props.forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => setVal.add(prop)));\n }));\n }));\n }\n if (erroneousTransitions.length) {\n /** @type {?} */\n const errors = [];\n erroneousTransitions.forEach((/**\n * @param {?} instruction\n * @return {?}\n */\n instruction => {\n errors.push(`@${instruction.triggerName} has failed due to:\\n`);\n (/** @type {?} */ (instruction.errors)).forEach((/**\n * @param {?} error\n * @return {?}\n */\n error => errors.push(`- ${error}\\n`)));\n }));\n allPlayers.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => player.destroy()));\n this.reportError(errors);\n }\n /** @type {?} */\n const allPreviousPlayersMap = new Map();\n // this map works to tell which element in the DOM tree is contained by\n // which animation. Further down below this map will get populated once\n // the players are built and in doing so it can efficiently figure out\n // if a sub player is skipped due to a parent player having priority.\n /** @type {?} */\n const animationElementMap = new Map();\n queuedInstructions.forEach((/**\n * @param {?} entry\n * @return {?}\n */\n entry => {\n /** @type {?} */\n const element = entry.element;\n if (subTimelines.has(element)) {\n animationElementMap.set(element, element);\n this._beforeAnimationBuild(entry.player.namespaceId, entry.instruction, allPreviousPlayersMap);\n }\n }));\n skippedPlayers.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n /** @type {?} */\n const element = player.element;\n /** @type {?} */\n const previousPlayers = this._getPreviousPlayers(element, false, player.namespaceId, player.triggerName, null);\n previousPlayers.forEach((/**\n * @param {?} prevPlayer\n * @return {?}\n */\n prevPlayer => {\n getOrSetAsInMap(allPreviousPlayersMap, element, []).push(prevPlayer);\n prevPlayer.destroy();\n }));\n }));\n // this is a special case for nodes that will be removed (either by)\n // having their own leave animations or by being queried in a container\n // that will be removed once a parent animation is complete. The idea\n // here is that * styles must be identical to ! styles because of\n // backwards compatibility (* is also filled in by default in many places).\n // Otherwise * styles will return an empty value or auto since the element\n // that is being getComputedStyle'd will not be visible (since * = destination)\n /** @type {?} */\n const replaceNodes = allLeaveNodes.filter((/**\n * @param {?} node\n * @return {?}\n */\n node => {\n return replacePostStylesAsPre(node, allPreStyleElements, allPostStyleElements);\n }));\n // POST STAGE: fill the * styles\n /** @type {?} */\n const postStylesMap = new Map();\n /** @type {?} */\n const allLeaveQueriedNodes = cloakAndComputeStyles(postStylesMap, this.driver, leaveNodesWithoutAnimations, allPostStyleElements, AUTO_STYLE);\n allLeaveQueriedNodes.forEach((/**\n * @param {?} node\n * @return {?}\n */\n node => {\n if (replacePostStylesAsPre(node, allPreStyleElements, allPostStyleElements)) {\n replaceNodes.push(node);\n }\n }));\n // PRE STAGE: fill the ! styles\n /** @type {?} */\n const preStylesMap = new Map();\n enterNodeMap.forEach((/**\n * @param {?} nodes\n * @param {?} root\n * @return {?}\n */\n (nodes, root) => {\n cloakAndComputeStyles(preStylesMap, this.driver, new Set(nodes), allPreStyleElements, ɵPRE_STYLE);\n }));\n replaceNodes.forEach((/**\n * @param {?} node\n * @return {?}\n */\n node => {\n /** @type {?} */\n const post = postStylesMap.get(node);\n /** @type {?} */\n const pre = preStylesMap.get(node);\n postStylesMap.set(node, (/** @type {?} */ (Object.assign(Object.assign({}, post), pre))));\n }));\n /** @type {?} */\n const rootPlayers = [];\n /** @type {?} */\n const subPlayers = [];\n /** @type {?} */\n const NO_PARENT_ANIMATION_ELEMENT_DETECTED = {};\n queuedInstructions.forEach((/**\n * @param {?} entry\n * @return {?}\n */\n entry => {\n const { element, player, instruction } = entry;\n // this means that it was never consumed by a parent animation which\n // means that it is independent and therefore should be set for animation\n if (subTimelines.has(element)) {\n if (disabledElementsSet.has(element)) {\n player.onDestroy((/**\n * @return {?}\n */\n () => setStyles(element, instruction.toStyles)));\n player.disabled = true;\n player.overrideTotalTime(instruction.totalTime);\n skippedPlayers.push(player);\n return;\n }\n // this will flow up the DOM and query the map to figure out\n // if a parent animation has priority over it. In the situation\n // that a parent is detected then it will cancel the loop. If\n // nothing is detected, or it takes a few hops to find a parent,\n // then it will fill in the missing nodes and signal them as having\n // a detected parent (or a NO_PARENT value via a special constant).\n /** @type {?} */\n let parentWithAnimation = NO_PARENT_ANIMATION_ELEMENT_DETECTED;\n if (animationElementMap.size > 1) {\n /** @type {?} */\n let elm = element;\n /** @type {?} */\n const parentsToAdd = [];\n while (elm = elm.parentNode) {\n /** @type {?} */\n const detectedParent = animationElementMap.get(elm);\n if (detectedParent) {\n parentWithAnimation = detectedParent;\n break;\n }\n parentsToAdd.push(elm);\n }\n parentsToAdd.forEach((/**\n * @param {?} parent\n * @return {?}\n */\n parent => animationElementMap.set(parent, parentWithAnimation)));\n }\n /** @type {?} */\n const innerPlayer = this._buildAnimation(player.namespaceId, instruction, allPreviousPlayersMap, skippedPlayersMap, preStylesMap, postStylesMap);\n player.setRealPlayer(innerPlayer);\n if (parentWithAnimation === NO_PARENT_ANIMATION_ELEMENT_DETECTED) {\n rootPlayers.push(player);\n }\n else {\n /** @type {?} */\n const parentPlayers = this.playersByElement.get(parentWithAnimation);\n if (parentPlayers && parentPlayers.length) {\n player.parentPlayer = optimizeGroupPlayer(parentPlayers);\n }\n skippedPlayers.push(player);\n }\n }\n else {\n eraseStyles(element, instruction.fromStyles);\n player.onDestroy((/**\n * @return {?}\n */\n () => setStyles(element, instruction.toStyles)));\n // there still might be a ancestor player animating this\n // element therefore we will still add it as a sub player\n // even if its animation may be disabled\n subPlayers.push(player);\n if (disabledElementsSet.has(element)) {\n skippedPlayers.push(player);\n }\n }\n }));\n // find all of the sub players' corresponding inner animation player\n subPlayers.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n // even if any players are not found for a sub animation then it\n // will still complete itself after the next tick since it's Noop\n /** @type {?} */\n const playersForElement = skippedPlayersMap.get(player.element);\n if (playersForElement && playersForElement.length) {\n /** @type {?} */\n const innerPlayer = optimizeGroupPlayer(playersForElement);\n player.setRealPlayer(innerPlayer);\n }\n }));\n // the reason why we don't actually play the animation is\n // because all that a skipped player is designed to do is to\n // fire the start/done transition callback events\n skippedPlayers.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n if (player.parentPlayer) {\n player.syncPlayerEvents(player.parentPlayer);\n }\n else {\n player.destroy();\n }\n }));\n // run through all of the queued removals and see if they\n // were picked up by a query. If not then perform the removal\n // operation right away unless a parent animation is ongoing.\n for (let i = 0; i < allLeaveNodes.length; i++) {\n /** @type {?} */\n const element = allLeaveNodes[i];\n /** @type {?} */\n const details = (/** @type {?} */ (element[REMOVAL_FLAG]));\n removeClass(element, LEAVE_CLASSNAME);\n // this means the element has a removal animation that is being\n // taken care of and therefore the inner elements will hang around\n // until that animation is over (or the parent queried animation)\n if (details && details.hasAnimation)\n continue;\n /** @type {?} */\n let players = [];\n // if this element is queried or if it contains queried children\n // then we want for the element not to be removed from the page\n // until the queried animations have finished\n if (queriedElements.size) {\n /** @type {?} */\n let queriedPlayerResults = queriedElements.get(element);\n if (queriedPlayerResults && queriedPlayerResults.length) {\n players.push(...queriedPlayerResults);\n }\n /** @type {?} */\n let queriedInnerElements = this.driver.query(element, NG_ANIMATING_SELECTOR, true);\n for (let j = 0; j < queriedInnerElements.length; j++) {\n /** @type {?} */\n let queriedPlayers = queriedElements.get(queriedInnerElements[j]);\n if (queriedPlayers && queriedPlayers.length) {\n players.push(...queriedPlayers);\n }\n }\n }\n /** @type {?} */\n const activePlayers = players.filter((/**\n * @param {?} p\n * @return {?}\n */\n p => !p.destroyed));\n if (activePlayers.length) {\n removeNodesAfterAnimationDone(this, element, activePlayers);\n }\n else {\n this.processLeaveNode(element);\n }\n }\n // this is required so the cleanup method doesn't remove them\n allLeaveNodes.length = 0;\n rootPlayers.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n this.players.push(player);\n player.onDone((/**\n * @return {?}\n */\n () => {\n player.destroy();\n /** @type {?} */\n const index = this.players.indexOf(player);\n this.players.splice(index, 1);\n }));\n player.play();\n }));\n return rootPlayers;\n }\n /**\n * @param {?} namespaceId\n * @param {?} element\n * @return {?}\n */\n elementContainsData(namespaceId, element) {\n /** @type {?} */\n let containsData = false;\n /** @type {?} */\n const details = (/** @type {?} */ (element[REMOVAL_FLAG]));\n if (details && details.setForRemoval)\n containsData = true;\n if (this.playersByElement.has(element))\n containsData = true;\n if (this.playersByQueriedElement.has(element))\n containsData = true;\n if (this.statesByElement.has(element))\n containsData = true;\n return this._fetchNamespace(namespaceId).elementContainsData(element) || containsData;\n }\n /**\n * @param {?} callback\n * @return {?}\n */\n afterFlush(callback) {\n this._flushFns.push(callback);\n }\n /**\n * @param {?} callback\n * @return {?}\n */\n afterFlushAnimationsDone(callback) {\n this._whenQuietFns.push(callback);\n }\n /**\n * @private\n * @param {?} element\n * @param {?} isQueriedElement\n * @param {?=} namespaceId\n * @param {?=} triggerName\n * @param {?=} toStateValue\n * @return {?}\n */\n _getPreviousPlayers(element, isQueriedElement, namespaceId, triggerName, toStateValue) {\n /** @type {?} */\n let players = [];\n if (isQueriedElement) {\n /** @type {?} */\n const queriedElementPlayers = this.playersByQueriedElement.get(element);\n if (queriedElementPlayers) {\n players = queriedElementPlayers;\n }\n }\n else {\n /** @type {?} */\n const elementPlayers = this.playersByElement.get(element);\n if (elementPlayers) {\n /** @type {?} */\n const isRemovalAnimation = !toStateValue || toStateValue == VOID_VALUE;\n elementPlayers.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n if (player.queued)\n return;\n if (!isRemovalAnimation && player.triggerName != triggerName)\n return;\n players.push(player);\n }));\n }\n }\n if (namespaceId || triggerName) {\n players = players.filter((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n if (namespaceId && namespaceId != player.namespaceId)\n return false;\n if (triggerName && triggerName != player.triggerName)\n return false;\n return true;\n }));\n }\n return players;\n }\n /**\n * @private\n * @param {?} namespaceId\n * @param {?} instruction\n * @param {?} allPreviousPlayersMap\n * @return {?}\n */\n _beforeAnimationBuild(namespaceId, instruction, allPreviousPlayersMap) {\n /** @type {?} */\n const triggerName = instruction.triggerName;\n /** @type {?} */\n const rootElement = instruction.element;\n // when a removal animation occurs, ALL previous players are collected\n // and destroyed (even if they are outside of the current namespace)\n /** @type {?} */\n const targetNameSpaceId = instruction.isRemovalTransition ? undefined : namespaceId;\n /** @type {?} */\n const targetTriggerName = instruction.isRemovalTransition ? undefined : triggerName;\n for (const timelineInstruction of instruction.timelines) {\n /** @type {?} */\n const element = timelineInstruction.element;\n /** @type {?} */\n const isQueriedElement = element !== rootElement;\n /** @type {?} */\n const players = getOrSetAsInMap(allPreviousPlayersMap, element, []);\n /** @type {?} */\n const previousPlayers = this._getPreviousPlayers(element, isQueriedElement, targetNameSpaceId, targetTriggerName, instruction.toState);\n previousPlayers.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n /** @type {?} */\n const realPlayer = (/** @type {?} */ (((/** @type {?} */ (player))).getRealPlayer()));\n if (realPlayer.beforeDestroy) {\n realPlayer.beforeDestroy();\n }\n player.destroy();\n players.push(player);\n }));\n }\n // this needs to be done so that the PRE/POST styles can be\n // computed properly without interfering with the previous animation\n eraseStyles(rootElement, instruction.fromStyles);\n }\n /**\n * @private\n * @param {?} namespaceId\n * @param {?} instruction\n * @param {?} allPreviousPlayersMap\n * @param {?} skippedPlayersMap\n * @param {?} preStylesMap\n * @param {?} postStylesMap\n * @return {?}\n */\n _buildAnimation(namespaceId, instruction, allPreviousPlayersMap, skippedPlayersMap, preStylesMap, postStylesMap) {\n /** @type {?} */\n const triggerName = instruction.triggerName;\n /** @type {?} */\n const rootElement = instruction.element;\n // we first run this so that the previous animation player\n // data can be passed into the successive animation players\n /** @type {?} */\n const allQueriedPlayers = [];\n /** @type {?} */\n const allConsumedElements = new Set();\n /** @type {?} */\n const allSubElements = new Set();\n /** @type {?} */\n const allNewPlayers = instruction.timelines.map((/**\n * @param {?} timelineInstruction\n * @return {?}\n */\n timelineInstruction => {\n /** @type {?} */\n const element = timelineInstruction.element;\n allConsumedElements.add(element);\n // FIXME (matsko): make sure to-be-removed animations are removed properly\n /** @type {?} */\n const details = element[REMOVAL_FLAG];\n if (details && details.removedBeforeQueried)\n return new NoopAnimationPlayer(timelineInstruction.duration, timelineInstruction.delay);\n /** @type {?} */\n const isQueriedElement = element !== rootElement;\n /** @type {?} */\n const previousPlayers = flattenGroupPlayers((allPreviousPlayersMap.get(element) || EMPTY_PLAYER_ARRAY)\n .map((/**\n * @param {?} p\n * @return {?}\n */\n p => p.getRealPlayer())))\n .filter((/**\n * @param {?} p\n * @return {?}\n */\n p => {\n // the `element` is not apart of the AnimationPlayer definition, but\n // Mock/WebAnimations\n // use the element within their implementation. This will be added in Angular5 to\n // AnimationPlayer\n /** @type {?} */\n const pp = (/** @type {?} */ (p));\n return pp.element ? pp.element === element : false;\n }));\n /** @type {?} */\n const preStyles = preStylesMap.get(element);\n /** @type {?} */\n const postStyles = postStylesMap.get(element);\n /** @type {?} */\n const keyframes = normalizeKeyframes(this.driver, this._normalizer, element, timelineInstruction.keyframes, preStyles, postStyles);\n /** @type {?} */\n const player = this._buildPlayer(timelineInstruction, keyframes, previousPlayers);\n // this means that this particular player belongs to a sub trigger. It is\n // important that we match this player up with the corresponding (@trigger.listener)\n if (timelineInstruction.subTimeline && skippedPlayersMap) {\n allSubElements.add(element);\n }\n if (isQueriedElement) {\n /** @type {?} */\n const wrappedPlayer = new TransitionAnimationPlayer(namespaceId, triggerName, element);\n wrappedPlayer.setRealPlayer(player);\n allQueriedPlayers.push(wrappedPlayer);\n }\n return player;\n }));\n allQueriedPlayers.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n getOrSetAsInMap(this.playersByQueriedElement, player.element, []).push(player);\n player.onDone((/**\n * @return {?}\n */\n () => deleteOrUnsetInMap(this.playersByQueriedElement, player.element, player)));\n }));\n allConsumedElements.forEach((/**\n * @param {?} element\n * @return {?}\n */\n element => addClass(element, NG_ANIMATING_CLASSNAME)));\n /** @type {?} */\n const player = optimizeGroupPlayer(allNewPlayers);\n player.onDestroy((/**\n * @return {?}\n */\n () => {\n allConsumedElements.forEach((/**\n * @param {?} element\n * @return {?}\n */\n element => removeClass(element, NG_ANIMATING_CLASSNAME)));\n setStyles(rootElement, instruction.toStyles);\n }));\n // this basically makes all of the callbacks for sub element animations\n // be dependent on the upper players for when they finish\n allSubElements.forEach((/**\n * @param {?} element\n * @return {?}\n */\n element => {\n getOrSetAsInMap(skippedPlayersMap, element, []).push(player);\n }));\n return player;\n }\n /**\n * @private\n * @param {?} instruction\n * @param {?} keyframes\n * @param {?} previousPlayers\n * @return {?}\n */\n _buildPlayer(instruction, keyframes, previousPlayers) {\n if (keyframes.length > 0) {\n return this.driver.animate(instruction.element, keyframes, instruction.duration, instruction.delay, instruction.easing, previousPlayers);\n }\n // special case for when an empty transition|definition is provided\n // ... there is no point in rendering an empty animation\n return new NoopAnimationPlayer(instruction.duration, instruction.delay);\n }\n}\nif (false) {\n /** @type {?} */\n TransitionAnimationEngine.prototype.players;\n /** @type {?} */\n TransitionAnimationEngine.prototype.newHostElements;\n /** @type {?} */\n TransitionAnimationEngine.prototype.playersByElement;\n /** @type {?} */\n TransitionAnimationEngine.prototype.playersByQueriedElement;\n /** @type {?} */\n TransitionAnimationEngine.prototype.statesByElement;\n /** @type {?} */\n TransitionAnimationEngine.prototype.disabledNodes;\n /** @type {?} */\n TransitionAnimationEngine.prototype.totalAnimations;\n /** @type {?} */\n TransitionAnimationEngine.prototype.totalQueuedPlayers;\n /**\n * @type {?}\n * @private\n */\n TransitionAnimationEngine.prototype._namespaceLookup;\n /**\n * @type {?}\n * @private\n */\n TransitionAnimationEngine.prototype._namespaceList;\n /**\n * @type {?}\n * @private\n */\n TransitionAnimationEngine.prototype._flushFns;\n /**\n * @type {?}\n * @private\n */\n TransitionAnimationEngine.prototype._whenQuietFns;\n /** @type {?} */\n TransitionAnimationEngine.prototype.namespacesByHostElement;\n /** @type {?} */\n TransitionAnimationEngine.prototype.collectedEnterElements;\n /** @type {?} */\n TransitionAnimationEngine.prototype.collectedLeaveElements;\n /** @type {?} */\n TransitionAnimationEngine.prototype.onRemovalComplete;\n /** @type {?} */\n TransitionAnimationEngine.prototype.bodyNode;\n /** @type {?} */\n TransitionAnimationEngine.prototype.driver;\n /**\n * @type {?}\n * @private\n */\n TransitionAnimationEngine.prototype._normalizer;\n}\nclass TransitionAnimationPlayer {\n /**\n * @param {?} namespaceId\n * @param {?} triggerName\n * @param {?} element\n */\n constructor(namespaceId, triggerName, element) {\n this.namespaceId = namespaceId;\n this.triggerName = triggerName;\n this.element = element;\n this._player = new NoopAnimationPlayer();\n this._containsRealPlayer = false;\n this._queuedCallbacks = {};\n this.destroyed = false;\n this.markedForDestroy = false;\n this.disabled = false;\n this.queued = true;\n this.totalTime = 0;\n }\n /**\n * @param {?} player\n * @return {?}\n */\n setRealPlayer(player) {\n if (this._containsRealPlayer)\n return;\n this._player = player;\n Object.keys(this._queuedCallbacks).forEach((/**\n * @param {?} phase\n * @return {?}\n */\n phase => {\n this._queuedCallbacks[phase].forEach((/**\n * @param {?} callback\n * @return {?}\n */\n callback => listenOnPlayer(player, phase, undefined, callback)));\n }));\n this._queuedCallbacks = {};\n this._containsRealPlayer = true;\n this.overrideTotalTime(player.totalTime);\n ((/** @type {?} */ (this))).queued = false;\n }\n /**\n * @return {?}\n */\n getRealPlayer() {\n return this._player;\n }\n /**\n * @param {?} totalTime\n * @return {?}\n */\n overrideTotalTime(totalTime) {\n ((/** @type {?} */ (this))).totalTime = totalTime;\n }\n /**\n * @param {?} player\n * @return {?}\n */\n syncPlayerEvents(player) {\n /** @type {?} */\n const p = (/** @type {?} */ (this._player));\n if (p.triggerCallback) {\n player.onStart((/**\n * @return {?}\n */\n () => (/** @type {?} */ (p.triggerCallback))('start')));\n }\n player.onDone((/**\n * @return {?}\n */\n () => this.finish()));\n player.onDestroy((/**\n * @return {?}\n */\n () => this.destroy()));\n }\n /**\n * @private\n * @param {?} name\n * @param {?} callback\n * @return {?}\n */\n _queueEvent(name, callback) {\n getOrSetAsInMap(this._queuedCallbacks, name, []).push(callback);\n }\n /**\n * @param {?} fn\n * @return {?}\n */\n onDone(fn) {\n if (this.queued) {\n this._queueEvent('done', fn);\n }\n this._player.onDone(fn);\n }\n /**\n * @param {?} fn\n * @return {?}\n */\n onStart(fn) {\n if (this.queued) {\n this._queueEvent('start', fn);\n }\n this._player.onStart(fn);\n }\n /**\n * @param {?} fn\n * @return {?}\n */\n onDestroy(fn) {\n if (this.queued) {\n this._queueEvent('destroy', fn);\n }\n this._player.onDestroy(fn);\n }\n /**\n * @return {?}\n */\n init() {\n this._player.init();\n }\n /**\n * @return {?}\n */\n hasStarted() {\n return this.queued ? false : this._player.hasStarted();\n }\n /**\n * @return {?}\n */\n play() {\n !this.queued && this._player.play();\n }\n /**\n * @return {?}\n */\n pause() {\n !this.queued && this._player.pause();\n }\n /**\n * @return {?}\n */\n restart() {\n !this.queued && this._player.restart();\n }\n /**\n * @return {?}\n */\n finish() {\n this._player.finish();\n }\n /**\n * @return {?}\n */\n destroy() {\n ((/** @type {?} */ (this))).destroyed = true;\n this._player.destroy();\n }\n /**\n * @return {?}\n */\n reset() {\n !this.queued && this._player.reset();\n }\n /**\n * @param {?} p\n * @return {?}\n */\n setPosition(p) {\n if (!this.queued) {\n this._player.setPosition(p);\n }\n }\n /**\n * @return {?}\n */\n getPosition() {\n return this.queued ? 0 : this._player.getPosition();\n }\n /**\n * \\@internal\n * @param {?} phaseName\n * @return {?}\n */\n triggerCallback(phaseName) {\n /** @type {?} */\n const p = (/** @type {?} */ (this._player));\n if (p.triggerCallback) {\n p.triggerCallback(phaseName);\n }\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n TransitionAnimationPlayer.prototype._player;\n /**\n * @type {?}\n * @private\n */\n TransitionAnimationPlayer.prototype._containsRealPlayer;\n /**\n * @type {?}\n * @private\n */\n TransitionAnimationPlayer.prototype._queuedCallbacks;\n /** @type {?} */\n TransitionAnimationPlayer.prototype.destroyed;\n /** @type {?} */\n TransitionAnimationPlayer.prototype.parentPlayer;\n /** @type {?} */\n TransitionAnimationPlayer.prototype.markedForDestroy;\n /** @type {?} */\n TransitionAnimationPlayer.prototype.disabled;\n /** @type {?} */\n TransitionAnimationPlayer.prototype.queued;\n /** @type {?} */\n TransitionAnimationPlayer.prototype.totalTime;\n /** @type {?} */\n TransitionAnimationPlayer.prototype.namespaceId;\n /** @type {?} */\n TransitionAnimationPlayer.prototype.triggerName;\n /** @type {?} */\n TransitionAnimationPlayer.prototype.element;\n}\n/**\n * @param {?} map\n * @param {?} key\n * @param {?} value\n * @return {?}\n */\nfunction deleteOrUnsetInMap(map, key, value) {\n /** @type {?} */\n let currentValues;\n if (map instanceof Map) {\n currentValues = map.get(key);\n if (currentValues) {\n if (currentValues.length) {\n /** @type {?} */\n const index = currentValues.indexOf(value);\n currentValues.splice(index, 1);\n }\n if (currentValues.length == 0) {\n map.delete(key);\n }\n }\n }\n else {\n currentValues = map[key];\n if (currentValues) {\n if (currentValues.length) {\n /** @type {?} */\n const index = currentValues.indexOf(value);\n currentValues.splice(index, 1);\n }\n if (currentValues.length == 0) {\n delete map[key];\n }\n }\n }\n return currentValues;\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction normalizeTriggerValue(value) {\n // we use `!= null` here because it's the most simple\n // way to test against a \"falsy\" value without mixing\n // in empty strings or a zero value. DO NOT OPTIMIZE.\n return value != null ? value : null;\n}\n/**\n * @param {?} node\n * @return {?}\n */\nfunction isElementNode(node) {\n return node && node['nodeType'] === 1;\n}\n/**\n * @param {?} eventName\n * @return {?}\n */\nfunction isTriggerEventValid(eventName) {\n return eventName == 'start' || eventName == 'done';\n}\n/**\n * @param {?} element\n * @param {?=} value\n * @return {?}\n */\nfunction cloakElement(element, value) {\n /** @type {?} */\n const oldValue = element.style.display;\n element.style.display = value != null ? value : 'none';\n return oldValue;\n}\n/**\n * @param {?} valuesMap\n * @param {?} driver\n * @param {?} elements\n * @param {?} elementPropsMap\n * @param {?} defaultStyle\n * @return {?}\n */\nfunction cloakAndComputeStyles(valuesMap, driver, elements, elementPropsMap, defaultStyle) {\n /** @type {?} */\n const cloakVals = [];\n elements.forEach((/**\n * @param {?} element\n * @return {?}\n */\n element => cloakVals.push(cloakElement(element))));\n /** @type {?} */\n const failedElements = [];\n elementPropsMap.forEach((/**\n * @param {?} props\n * @param {?} element\n * @return {?}\n */\n (props, element) => {\n /** @type {?} */\n const styles = {};\n props.forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n /** @type {?} */\n const value = styles[prop] = driver.computeStyle(element, prop, defaultStyle);\n // there is no easy way to detect this because a sub element could be removed\n // by a parent animation element being detached.\n if (!value || value.length == 0) {\n element[REMOVAL_FLAG] = NULL_REMOVED_QUERIED_STATE;\n failedElements.push(element);\n }\n }));\n valuesMap.set(element, styles);\n }));\n // we use a index variable here since Set.forEach(a, i) does not return\n // an index value for the closure (but instead just the value)\n /** @type {?} */\n let i = 0;\n elements.forEach((/**\n * @param {?} element\n * @return {?}\n */\n element => cloakElement(element, cloakVals[i++])));\n return failedElements;\n}\n/*\nSince the Angular renderer code will return a collection of inserted\nnodes in all areas of a DOM tree, it's up to this algorithm to figure\nout which nodes are roots for each animation @trigger.\n\nBy placing each inserted node into a Set and traversing upwards, it\nis possible to find the @trigger elements and well any direct *star\ninsertion nodes, if a @trigger root is found then the enter element\nis placed into the Map[@trigger] spot.\n */\n/**\n * @param {?} roots\n * @param {?} nodes\n * @return {?}\n */\nfunction buildRootMap(roots, nodes) {\n /** @type {?} */\n const rootMap = new Map();\n roots.forEach((/**\n * @param {?} root\n * @return {?}\n */\n root => rootMap.set(root, [])));\n if (nodes.length == 0)\n return rootMap;\n /** @type {?} */\n const NULL_NODE = 1;\n /** @type {?} */\n const nodeSet = new Set(nodes);\n /** @type {?} */\n const localRootMap = new Map();\n /**\n * @param {?} node\n * @return {?}\n */\n function getRoot(node) {\n if (!node)\n return NULL_NODE;\n /** @type {?} */\n let root = localRootMap.get(node);\n if (root)\n return root;\n /** @type {?} */\n const parent = node.parentNode;\n if (rootMap.has(parent)) { // ngIf inside @trigger\n root = parent;\n }\n else if (nodeSet.has(parent)) { // ngIf inside ngIf\n root = NULL_NODE;\n }\n else { // recurse upwards\n root = getRoot(parent);\n }\n localRootMap.set(node, root);\n return root;\n }\n nodes.forEach((/**\n * @param {?} node\n * @return {?}\n */\n node => {\n /** @type {?} */\n const root = getRoot(node);\n if (root !== NULL_NODE) {\n (/** @type {?} */ (rootMap.get(root))).push(node);\n }\n }));\n return rootMap;\n}\n/** @type {?} */\nconst CLASSES_CACHE_KEY = '$$classes';\n/**\n * @param {?} element\n * @param {?} className\n * @return {?}\n */\nfunction containsClass(element, className) {\n if (element.classList) {\n return element.classList.contains(className);\n }\n else {\n /** @type {?} */\n const classes = element[CLASSES_CACHE_KEY];\n return classes && classes[className];\n }\n}\n/**\n * @param {?} element\n * @param {?} className\n * @return {?}\n */\nfunction addClass(element, className) {\n if (element.classList) {\n element.classList.add(className);\n }\n else {\n /** @type {?} */\n let classes = element[CLASSES_CACHE_KEY];\n if (!classes) {\n classes = element[CLASSES_CACHE_KEY] = {};\n }\n classes[className] = true;\n }\n}\n/**\n * @param {?} element\n * @param {?} className\n * @return {?}\n */\nfunction removeClass(element, className) {\n if (element.classList) {\n element.classList.remove(className);\n }\n else {\n /** @type {?} */\n let classes = element[CLASSES_CACHE_KEY];\n if (classes) {\n delete classes[className];\n }\n }\n}\n/**\n * @param {?} engine\n * @param {?} element\n * @param {?} players\n * @return {?}\n */\nfunction removeNodesAfterAnimationDone(engine, element, players) {\n optimizeGroupPlayer(players).onDone((/**\n * @return {?}\n */\n () => engine.processLeaveNode(element)));\n}\n/**\n * @param {?} players\n * @return {?}\n */\nfunction flattenGroupPlayers(players) {\n /** @type {?} */\n const finalPlayers = [];\n _flattenGroupPlayersRecur(players, finalPlayers);\n return finalPlayers;\n}\n/**\n * @param {?} players\n * @param {?} finalPlayers\n * @return {?}\n */\nfunction _flattenGroupPlayersRecur(players, finalPlayers) {\n for (let i = 0; i < players.length; i++) {\n /** @type {?} */\n const player = players[i];\n if (player instanceof ɵAnimationGroupPlayer) {\n _flattenGroupPlayersRecur(player.players, finalPlayers);\n }\n else {\n finalPlayers.push(player);\n }\n }\n}\n/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nfunction objEquals(a, b) {\n /** @type {?} */\n const k1 = Object.keys(a);\n /** @type {?} */\n const k2 = Object.keys(b);\n if (k1.length != k2.length)\n return false;\n for (let i = 0; i < k1.length; i++) {\n /** @type {?} */\n const prop = k1[i];\n if (!b.hasOwnProperty(prop) || a[prop] !== b[prop])\n return false;\n }\n return true;\n}\n/**\n * @param {?} element\n * @param {?} allPreStyleElements\n * @param {?} allPostStyleElements\n * @return {?}\n */\nfunction replacePostStylesAsPre(element, allPreStyleElements, allPostStyleElements) {\n /** @type {?} */\n const postEntry = allPostStyleElements.get(element);\n if (!postEntry)\n return false;\n /** @type {?} */\n let preEntry = allPreStyleElements.get(element);\n if (preEntry) {\n postEntry.forEach((/**\n * @param {?} data\n * @return {?}\n */\n data => (/** @type {?} */ (preEntry)).add(data)));\n }\n else {\n allPreStyleElements.set(element, postEntry);\n }\n allPostStyleElements.delete(element);\n return true;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/render/animation_engine_next.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass AnimationEngine {\n /**\n * @param {?} bodyNode\n * @param {?} _driver\n * @param {?} normalizer\n */\n constructor(bodyNode, _driver, normalizer) {\n this.bodyNode = bodyNode;\n this._driver = _driver;\n this._triggerCache = {};\n // this method is designed to be overridden by the code that uses this engine\n this.onRemovalComplete = (/**\n * @param {?} element\n * @param {?} context\n * @return {?}\n */\n (element, context) => { });\n this._transitionEngine = new TransitionAnimationEngine(bodyNode, _driver, normalizer);\n this._timelineEngine = new TimelineAnimationEngine(bodyNode, _driver, normalizer);\n this._transitionEngine.onRemovalComplete = (/**\n * @param {?} element\n * @param {?} context\n * @return {?}\n */\n (element, context) => this.onRemovalComplete(element, context));\n }\n /**\n * @param {?} componentId\n * @param {?} namespaceId\n * @param {?} hostElement\n * @param {?} name\n * @param {?} metadata\n * @return {?}\n */\n registerTrigger(componentId, namespaceId, hostElement, name, metadata) {\n /** @type {?} */\n const cacheKey = componentId + '-' + name;\n /** @type {?} */\n let trigger = this._triggerCache[cacheKey];\n if (!trigger) {\n /** @type {?} */\n const errors = [];\n /** @type {?} */\n const ast = (/** @type {?} */ (buildAnimationAst(this._driver, (/** @type {?} */ (metadata)), errors)));\n if (errors.length) {\n throw new Error(`The animation trigger \"${name}\" has failed to build due to the following errors:\\n - ${errors.join('\\n - ')}`);\n }\n trigger = buildTrigger(name, ast);\n this._triggerCache[cacheKey] = trigger;\n }\n this._transitionEngine.registerTrigger(namespaceId, name, trigger);\n }\n /**\n * @param {?} namespaceId\n * @param {?} hostElement\n * @return {?}\n */\n register(namespaceId, hostElement) {\n this._transitionEngine.register(namespaceId, hostElement);\n }\n /**\n * @param {?} namespaceId\n * @param {?} context\n * @return {?}\n */\n destroy(namespaceId, context) {\n this._transitionEngine.destroy(namespaceId, context);\n }\n /**\n * @param {?} namespaceId\n * @param {?} element\n * @param {?} parent\n * @param {?} insertBefore\n * @return {?}\n */\n onInsert(namespaceId, element, parent, insertBefore) {\n this._transitionEngine.insertNode(namespaceId, element, parent, insertBefore);\n }\n /**\n * @param {?} namespaceId\n * @param {?} element\n * @param {?} context\n * @param {?=} isHostElement\n * @return {?}\n */\n onRemove(namespaceId, element, context, isHostElement) {\n this._transitionEngine.removeNode(namespaceId, element, isHostElement || false, context);\n }\n /**\n * @param {?} element\n * @param {?} disable\n * @return {?}\n */\n disableAnimations(element, disable) {\n this._transitionEngine.markElementAsDisabled(element, disable);\n }\n /**\n * @param {?} namespaceId\n * @param {?} element\n * @param {?} property\n * @param {?} value\n * @return {?}\n */\n process(namespaceId, element, property, value) {\n if (property.charAt(0) == '@') {\n const [id, action] = parseTimelineCommand(property);\n /** @type {?} */\n const args = (/** @type {?} */ (value));\n this._timelineEngine.command(id, element, action, args);\n }\n else {\n this._transitionEngine.trigger(namespaceId, element, property, value);\n }\n }\n /**\n * @param {?} namespaceId\n * @param {?} element\n * @param {?} eventName\n * @param {?} eventPhase\n * @param {?} callback\n * @return {?}\n */\n listen(namespaceId, element, eventName, eventPhase, callback) {\n // @@listen\n if (eventName.charAt(0) == '@') {\n const [id, action] = parseTimelineCommand(eventName);\n return this._timelineEngine.listen(id, element, action, callback);\n }\n return this._transitionEngine.listen(namespaceId, element, eventName, eventPhase, callback);\n }\n /**\n * @param {?=} microtaskId\n * @return {?}\n */\n flush(microtaskId = -1) {\n this._transitionEngine.flush(microtaskId);\n }\n /**\n * @return {?}\n */\n get players() {\n return ((/** @type {?} */ (this._transitionEngine.players)))\n .concat((/** @type {?} */ (this._timelineEngine.players)));\n }\n /**\n * @return {?}\n */\n whenRenderingDone() {\n return this._transitionEngine.whenRenderingDone();\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n AnimationEngine.prototype._transitionEngine;\n /**\n * @type {?}\n * @private\n */\n AnimationEngine.prototype._timelineEngine;\n /**\n * @type {?}\n * @private\n */\n AnimationEngine.prototype._triggerCache;\n /** @type {?} */\n AnimationEngine.prototype.onRemovalComplete;\n /**\n * @type {?}\n * @private\n */\n AnimationEngine.prototype.bodyNode;\n /**\n * @type {?}\n * @private\n */\n AnimationEngine.prototype._driver;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/render/special_cased_styles.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Returns an instance of `SpecialCasedStyles` if and when any special (non animateable) styles are\n * detected.\n *\n * In CSS there exist properties that cannot be animated within a keyframe animation\n * (whether it be via CSS keyframes or web-animations) and the animation implementation\n * will ignore them. This function is designed to detect those special cased styles and\n * return a container that will be executed at the start and end of the animation.\n *\n * @param {?} element\n * @param {?} styles\n * @return {?} an instance of `SpecialCasedStyles` if any special styles are detected otherwise `null`\n */\nfunction packageNonAnimatableStyles(element, styles) {\n /** @type {?} */\n let startStyles = null;\n /** @type {?} */\n let endStyles = null;\n if (Array.isArray(styles) && styles.length) {\n startStyles = filterNonAnimatableStyles(styles[0]);\n if (styles.length > 1) {\n endStyles = filterNonAnimatableStyles(styles[styles.length - 1]);\n }\n }\n else if (styles) {\n startStyles = filterNonAnimatableStyles(styles);\n }\n return (startStyles || endStyles) ? new SpecialCasedStyles(element, startStyles, endStyles) :\n null;\n}\n/**\n * Designed to be executed during a keyframe-based animation to apply any special-cased styles.\n *\n * When started (when the `start()` method is run) then the provided `startStyles`\n * will be applied. When finished (when the `finish()` method is called) the\n * `endStyles` will be applied as well any any starting styles. Finally when\n * `destroy()` is called then all styles will be removed.\n */\nclass SpecialCasedStyles {\n /**\n * @param {?} _element\n * @param {?} _startStyles\n * @param {?} _endStyles\n */\n constructor(_element, _startStyles, _endStyles) {\n this._element = _element;\n this._startStyles = _startStyles;\n this._endStyles = _endStyles;\n this._state = 0 /* Pending */;\n /** @type {?} */\n let initialStyles = SpecialCasedStyles.initialStylesByElement.get(_element);\n if (!initialStyles) {\n SpecialCasedStyles.initialStylesByElement.set(_element, initialStyles = {});\n }\n this._initialStyles = initialStyles;\n }\n /**\n * @return {?}\n */\n start() {\n if (this._state < 1 /* Started */) {\n if (this._startStyles) {\n setStyles(this._element, this._startStyles, this._initialStyles);\n }\n this._state = 1 /* Started */;\n }\n }\n /**\n * @return {?}\n */\n finish() {\n this.start();\n if (this._state < 2 /* Finished */) {\n setStyles(this._element, this._initialStyles);\n if (this._endStyles) {\n setStyles(this._element, this._endStyles);\n this._endStyles = null;\n }\n this._state = 1 /* Started */;\n }\n }\n /**\n * @return {?}\n */\n destroy() {\n this.finish();\n if (this._state < 3 /* Destroyed */) {\n SpecialCasedStyles.initialStylesByElement.delete(this._element);\n if (this._startStyles) {\n eraseStyles(this._element, this._startStyles);\n this._endStyles = null;\n }\n if (this._endStyles) {\n eraseStyles(this._element, this._endStyles);\n this._endStyles = null;\n }\n setStyles(this._element, this._initialStyles);\n this._state = 3 /* Destroyed */;\n }\n }\n}\nSpecialCasedStyles.initialStylesByElement = new WeakMap();\nif (false) {\n /** @type {?} */\n SpecialCasedStyles.initialStylesByElement;\n /**\n * @type {?}\n * @private\n */\n SpecialCasedStyles.prototype._state;\n /**\n * @type {?}\n * @private\n */\n SpecialCasedStyles.prototype._initialStyles;\n /**\n * @type {?}\n * @private\n */\n SpecialCasedStyles.prototype._element;\n /**\n * @type {?}\n * @private\n */\n SpecialCasedStyles.prototype._startStyles;\n /**\n * @type {?}\n * @private\n */\n SpecialCasedStyles.prototype._endStyles;\n}\n/** @enum {number} */\nconst SpecialCasedStylesState = {\n Pending: 0,\n Started: 1,\n Finished: 2,\n Destroyed: 3,\n};\n/**\n * @param {?} styles\n * @return {?}\n */\nfunction filterNonAnimatableStyles(styles) {\n /** @type {?} */\n let result = null;\n /** @type {?} */\n const props = Object.keys(styles);\n for (let i = 0; i < props.length; i++) {\n /** @type {?} */\n const prop = props[i];\n if (isNonAnimatableStyle(prop)) {\n result = result || {};\n result[prop] = styles[prop];\n }\n }\n return result;\n}\n/**\n * @param {?} prop\n * @return {?}\n */\nfunction isNonAnimatableStyle(prop) {\n return prop === 'display' || prop === 'position';\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/render/css_keyframes/element_animation_style_handler.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. 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 * @type {?}\n */\nconst ELAPSED_TIME_MAX_DECIMAL_PLACES = 3;\n/** @type {?} */\nconst ANIMATION_PROP = 'animation';\n/** @type {?} */\nconst ANIMATIONEND_EVENT = 'animationend';\n/** @type {?} */\nconst ONE_SECOND$1 = 1000;\nclass ElementAnimationStyleHandler {\n /**\n * @param {?} _element\n * @param {?} _name\n * @param {?} _duration\n * @param {?} _delay\n * @param {?} _easing\n * @param {?} _fillMode\n * @param {?} _onDoneFn\n */\n constructor(_element, _name, _duration, _delay, _easing, _fillMode, _onDoneFn) {\n this._element = _element;\n this._name = _name;\n this._duration = _duration;\n this._delay = _delay;\n this._easing = _easing;\n this._fillMode = _fillMode;\n this._onDoneFn = _onDoneFn;\n this._finished = false;\n this._destroyed = false;\n this._startTime = 0;\n this._position = 0;\n this._eventFn = (/**\n * @param {?} e\n * @return {?}\n */\n (e) => this._handleCallback(e));\n }\n /**\n * @return {?}\n */\n apply() {\n applyKeyframeAnimation(this._element, `${this._duration}ms ${this._easing} ${this._delay}ms 1 normal ${this._fillMode} ${this._name}`);\n addRemoveAnimationEvent(this._element, this._eventFn, false);\n this._startTime = Date.now();\n }\n /**\n * @return {?}\n */\n pause() {\n playPauseAnimation(this._element, this._name, 'paused');\n }\n /**\n * @return {?}\n */\n resume() {\n playPauseAnimation(this._element, this._name, 'running');\n }\n /**\n * @param {?} position\n * @return {?}\n */\n setPosition(position) {\n /** @type {?} */\n const index = findIndexForAnimation(this._element, this._name);\n this._position = position * this._duration;\n setAnimationStyle(this._element, 'Delay', `-${this._position}ms`, index);\n }\n /**\n * @return {?}\n */\n getPosition() {\n return this._position;\n }\n /**\n * @private\n * @param {?} event\n * @return {?}\n */\n _handleCallback(event) {\n /** @type {?} */\n const timestamp = event._ngTestManualTimestamp || Date.now();\n /** @type {?} */\n const elapsedTime = parseFloat(event.elapsedTime.toFixed(ELAPSED_TIME_MAX_DECIMAL_PLACES)) * ONE_SECOND$1;\n if (event.animationName == this._name &&\n Math.max(timestamp - this._startTime, 0) >= this._delay && elapsedTime >= this._duration) {\n this.finish();\n }\n }\n /**\n * @return {?}\n */\n finish() {\n if (this._finished)\n return;\n this._finished = true;\n this._onDoneFn();\n addRemoveAnimationEvent(this._element, this._eventFn, true);\n }\n /**\n * @return {?}\n */\n destroy() {\n if (this._destroyed)\n return;\n this._destroyed = true;\n this.finish();\n removeKeyframeAnimation(this._element, this._name);\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n ElementAnimationStyleHandler.prototype._eventFn;\n /**\n * @type {?}\n * @private\n */\n ElementAnimationStyleHandler.prototype._finished;\n /**\n * @type {?}\n * @private\n */\n ElementAnimationStyleHandler.prototype._destroyed;\n /**\n * @type {?}\n * @private\n */\n ElementAnimationStyleHandler.prototype._startTime;\n /**\n * @type {?}\n * @private\n */\n ElementAnimationStyleHandler.prototype._position;\n /**\n * @type {?}\n * @private\n */\n ElementAnimationStyleHandler.prototype._element;\n /**\n * @type {?}\n * @private\n */\n ElementAnimationStyleHandler.prototype._name;\n /**\n * @type {?}\n * @private\n */\n ElementAnimationStyleHandler.prototype._duration;\n /**\n * @type {?}\n * @private\n */\n ElementAnimationStyleHandler.prototype._delay;\n /**\n * @type {?}\n * @private\n */\n ElementAnimationStyleHandler.prototype._easing;\n /**\n * @type {?}\n * @private\n */\n ElementAnimationStyleHandler.prototype._fillMode;\n /**\n * @type {?}\n * @private\n */\n ElementAnimationStyleHandler.prototype._onDoneFn;\n}\n/**\n * @param {?} element\n * @param {?} name\n * @param {?} status\n * @return {?}\n */\nfunction playPauseAnimation(element, name, status) {\n /** @type {?} */\n const index = findIndexForAnimation(element, name);\n setAnimationStyle(element, 'PlayState', status, index);\n}\n/**\n * @param {?} element\n * @param {?} value\n * @return {?}\n */\nfunction applyKeyframeAnimation(element, value) {\n /** @type {?} */\n const anim = getAnimationStyle(element, '').trim();\n /** @type {?} */\n let index = 0;\n if (anim.length) {\n index = countChars(anim, ',') + 1;\n value = `${anim}, ${value}`;\n }\n setAnimationStyle(element, '', value);\n return index;\n}\n/**\n * @param {?} element\n * @param {?} name\n * @return {?}\n */\nfunction removeKeyframeAnimation(element, name) {\n /** @type {?} */\n const anim = getAnimationStyle(element, '');\n /** @type {?} */\n const tokens = anim.split(',');\n /** @type {?} */\n const index = findMatchingTokenIndex(tokens, name);\n if (index >= 0) {\n tokens.splice(index, 1);\n /** @type {?} */\n const newValue = tokens.join(',');\n setAnimationStyle(element, '', newValue);\n }\n}\n/**\n * @param {?} element\n * @param {?} value\n * @return {?}\n */\nfunction findIndexForAnimation(element, value) {\n /** @type {?} */\n const anim = getAnimationStyle(element, '');\n if (anim.indexOf(',') > 0) {\n /** @type {?} */\n const tokens = anim.split(',');\n return findMatchingTokenIndex(tokens, value);\n }\n return findMatchingTokenIndex([anim], value);\n}\n/**\n * @param {?} tokens\n * @param {?} searchToken\n * @return {?}\n */\nfunction findMatchingTokenIndex(tokens, searchToken) {\n for (let i = 0; i < tokens.length; i++) {\n if (tokens[i].indexOf(searchToken) >= 0) {\n return i;\n }\n }\n return -1;\n}\n/**\n * @param {?} element\n * @param {?} fn\n * @param {?} doRemove\n * @return {?}\n */\nfunction addRemoveAnimationEvent(element, fn, doRemove) {\n doRemove ? element.removeEventListener(ANIMATIONEND_EVENT, fn) :\n element.addEventListener(ANIMATIONEND_EVENT, fn);\n}\n/**\n * @param {?} element\n * @param {?} name\n * @param {?} value\n * @param {?=} index\n * @return {?}\n */\nfunction setAnimationStyle(element, name, value, index) {\n /** @type {?} */\n const prop = ANIMATION_PROP + name;\n if (index != null) {\n /** @type {?} */\n const oldValue = element.style[prop];\n if (oldValue.length) {\n /** @type {?} */\n const tokens = oldValue.split(',');\n tokens[index] = value;\n value = tokens.join(',');\n }\n }\n element.style[prop] = value;\n}\n/**\n * @param {?} element\n * @param {?} name\n * @return {?}\n */\nfunction getAnimationStyle(element, name) {\n return element.style[ANIMATION_PROP + name];\n}\n/**\n * @param {?} value\n * @param {?} char\n * @return {?}\n */\nfunction countChars(value, char) {\n /** @type {?} */\n let count = 0;\n for (let i = 0; i < value.length; i++) {\n /** @type {?} */\n const c = value.charAt(i);\n if (c === char)\n count++;\n }\n return count;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/render/css_keyframes/css_keyframes_player.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst DEFAULT_FILL_MODE = 'forwards';\n/** @type {?} */\nconst DEFAULT_EASING = 'linear';\n/** @enum {number} */\nconst AnimatorControlState = {\n INITIALIZED: 1,\n STARTED: 2,\n FINISHED: 3,\n DESTROYED: 4,\n};\nclass CssKeyframesPlayer {\n /**\n * @param {?} element\n * @param {?} keyframes\n * @param {?} animationName\n * @param {?} _duration\n * @param {?} _delay\n * @param {?} easing\n * @param {?} _finalStyles\n * @param {?=} _specialStyles\n */\n constructor(element, keyframes, animationName, _duration, _delay, easing, _finalStyles, _specialStyles) {\n this.element = element;\n this.keyframes = keyframes;\n this.animationName = animationName;\n this._duration = _duration;\n this._delay = _delay;\n this._finalStyles = _finalStyles;\n this._specialStyles = _specialStyles;\n this._onDoneFns = [];\n this._onStartFns = [];\n this._onDestroyFns = [];\n this._started = false;\n this.currentSnapshot = {};\n this._state = 0;\n this.easing = easing || DEFAULT_EASING;\n this.totalTime = _duration + _delay;\n this._buildStyler();\n }\n /**\n * @param {?} fn\n * @return {?}\n */\n onStart(fn) {\n this._onStartFns.push(fn);\n }\n /**\n * @param {?} fn\n * @return {?}\n */\n onDone(fn) {\n this._onDoneFns.push(fn);\n }\n /**\n * @param {?} fn\n * @return {?}\n */\n onDestroy(fn) {\n this._onDestroyFns.push(fn);\n }\n /**\n * @return {?}\n */\n destroy() {\n this.init();\n if (this._state >= 4 /* DESTROYED */)\n return;\n this._state = 4 /* DESTROYED */;\n this._styler.destroy();\n this._flushStartFns();\n this._flushDoneFns();\n if (this._specialStyles) {\n this._specialStyles.destroy();\n }\n this._onDestroyFns.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n this._onDestroyFns = [];\n }\n /**\n * @private\n * @return {?}\n */\n _flushDoneFns() {\n this._onDoneFns.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n this._onDoneFns = [];\n }\n /**\n * @private\n * @return {?}\n */\n _flushStartFns() {\n this._onStartFns.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n this._onStartFns = [];\n }\n /**\n * @return {?}\n */\n finish() {\n this.init();\n if (this._state >= 3 /* FINISHED */)\n return;\n this._state = 3 /* FINISHED */;\n this._styler.finish();\n this._flushStartFns();\n if (this._specialStyles) {\n this._specialStyles.finish();\n }\n this._flushDoneFns();\n }\n /**\n * @param {?} value\n * @return {?}\n */\n setPosition(value) {\n this._styler.setPosition(value);\n }\n /**\n * @return {?}\n */\n getPosition() {\n return this._styler.getPosition();\n }\n /**\n * @return {?}\n */\n hasStarted() {\n return this._state >= 2 /* STARTED */;\n }\n /**\n * @return {?}\n */\n init() {\n if (this._state >= 1 /* INITIALIZED */)\n return;\n this._state = 1 /* INITIALIZED */;\n /** @type {?} */\n const elm = this.element;\n this._styler.apply();\n if (this._delay) {\n this._styler.pause();\n }\n }\n /**\n * @return {?}\n */\n play() {\n this.init();\n if (!this.hasStarted()) {\n this._flushStartFns();\n this._state = 2 /* STARTED */;\n if (this._specialStyles) {\n this._specialStyles.start();\n }\n }\n this._styler.resume();\n }\n /**\n * @return {?}\n */\n pause() {\n this.init();\n this._styler.pause();\n }\n /**\n * @return {?}\n */\n restart() {\n this.reset();\n this.play();\n }\n /**\n * @return {?}\n */\n reset() {\n this._styler.destroy();\n this._buildStyler();\n this._styler.apply();\n }\n /**\n * @private\n * @return {?}\n */\n _buildStyler() {\n this._styler = new ElementAnimationStyleHandler(this.element, this.animationName, this._duration, this._delay, this.easing, DEFAULT_FILL_MODE, (/**\n * @return {?}\n */\n () => this.finish()));\n }\n /**\n * \\@internal\n * @param {?} phaseName\n * @return {?}\n */\n triggerCallback(phaseName) {\n /** @type {?} */\n const methods = phaseName == 'start' ? this._onStartFns : this._onDoneFns;\n methods.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n methods.length = 0;\n }\n /**\n * @return {?}\n */\n beforeDestroy() {\n this.init();\n /** @type {?} */\n const styles = {};\n if (this.hasStarted()) {\n /** @type {?} */\n const finished = this._state >= 3 /* FINISHED */;\n Object.keys(this._finalStyles).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n if (prop != 'offset') {\n styles[prop] = finished ? this._finalStyles[prop] : computeStyle(this.element, prop);\n }\n }));\n }\n this.currentSnapshot = styles;\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n CssKeyframesPlayer.prototype._onDoneFns;\n /**\n * @type {?}\n * @private\n */\n CssKeyframesPlayer.prototype._onStartFns;\n /**\n * @type {?}\n * @private\n */\n CssKeyframesPlayer.prototype._onDestroyFns;\n /**\n * @type {?}\n * @private\n */\n CssKeyframesPlayer.prototype._started;\n /**\n * @type {?}\n * @private\n */\n CssKeyframesPlayer.prototype._styler;\n /** @type {?} */\n CssKeyframesPlayer.prototype.parentPlayer;\n /** @type {?} */\n CssKeyframesPlayer.prototype.totalTime;\n /** @type {?} */\n CssKeyframesPlayer.prototype.easing;\n /** @type {?} */\n CssKeyframesPlayer.prototype.currentSnapshot;\n /**\n * @type {?}\n * @private\n */\n CssKeyframesPlayer.prototype._state;\n /** @type {?} */\n CssKeyframesPlayer.prototype.element;\n /** @type {?} */\n CssKeyframesPlayer.prototype.keyframes;\n /** @type {?} */\n CssKeyframesPlayer.prototype.animationName;\n /**\n * @type {?}\n * @private\n */\n CssKeyframesPlayer.prototype._duration;\n /**\n * @type {?}\n * @private\n */\n CssKeyframesPlayer.prototype._delay;\n /**\n * @type {?}\n * @private\n */\n CssKeyframesPlayer.prototype._finalStyles;\n /**\n * @type {?}\n * @private\n */\n CssKeyframesPlayer.prototype._specialStyles;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/render/css_keyframes/direct_style_player.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass DirectStylePlayer extends NoopAnimationPlayer {\n /**\n * @param {?} element\n * @param {?} styles\n */\n constructor(element, styles) {\n super();\n this.element = element;\n this._startingStyles = {};\n this.__initialized = false;\n this._styles = hypenatePropsObject(styles);\n }\n /**\n * @return {?}\n */\n init() {\n if (this.__initialized || !this._startingStyles)\n return;\n this.__initialized = true;\n Object.keys(this._styles).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n (/** @type {?} */ (this._startingStyles))[prop] = this.element.style[prop];\n }));\n super.init();\n }\n /**\n * @return {?}\n */\n play() {\n if (!this._startingStyles)\n return;\n this.init();\n Object.keys(this._styles)\n .forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => this.element.style.setProperty(prop, this._styles[prop])));\n super.play();\n }\n /**\n * @return {?}\n */\n destroy() {\n if (!this._startingStyles)\n return;\n Object.keys(this._startingStyles).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n /** @type {?} */\n const value = (/** @type {?} */ (this._startingStyles))[prop];\n if (value) {\n this.element.style.setProperty(prop, value);\n }\n else {\n this.element.style.removeProperty(prop);\n }\n }));\n this._startingStyles = null;\n super.destroy();\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n DirectStylePlayer.prototype._startingStyles;\n /**\n * @type {?}\n * @private\n */\n DirectStylePlayer.prototype.__initialized;\n /**\n * @type {?}\n * @private\n */\n DirectStylePlayer.prototype._styles;\n /** @type {?} */\n DirectStylePlayer.prototype.element;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/render/css_keyframes/css_keyframes_driver.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst KEYFRAMES_NAME_PREFIX = 'gen_css_kf_';\n/** @type {?} */\nconst TAB_SPACE = ' ';\nclass CssKeyframesDriver {\n constructor() {\n this._count = 0;\n this._head = document.querySelector('head');\n this._warningIssued = false;\n }\n /**\n * @param {?} prop\n * @return {?}\n */\n validateStyleProperty(prop) {\n return validateStyleProperty(prop);\n }\n /**\n * @param {?} element\n * @param {?} selector\n * @return {?}\n */\n matchesElement(element, selector) {\n return matchesElement(element, selector);\n }\n /**\n * @param {?} elm1\n * @param {?} elm2\n * @return {?}\n */\n containsElement(elm1, elm2) {\n return containsElement(elm1, elm2);\n }\n /**\n * @param {?} element\n * @param {?} selector\n * @param {?} multi\n * @return {?}\n */\n query(element, selector, multi) {\n return invokeQuery(element, selector, multi);\n }\n /**\n * @param {?} element\n * @param {?} prop\n * @param {?=} defaultValue\n * @return {?}\n */\n computeStyle(element, prop, defaultValue) {\n return (/** @type {?} */ (((/** @type {?} */ (window.getComputedStyle(element))))[prop]));\n }\n /**\n * @param {?} element\n * @param {?} name\n * @param {?} keyframes\n * @return {?}\n */\n buildKeyframeElement(element, name, keyframes) {\n keyframes = keyframes.map((/**\n * @param {?} kf\n * @return {?}\n */\n kf => hypenatePropsObject(kf)));\n /** @type {?} */\n let keyframeStr = `@keyframes ${name} {\\n`;\n /** @type {?} */\n let tab = '';\n keyframes.forEach((/**\n * @param {?} kf\n * @return {?}\n */\n kf => {\n tab = TAB_SPACE;\n /** @type {?} */\n const offset = parseFloat(kf['offset']);\n keyframeStr += `${tab}${offset * 100}% {\\n`;\n tab += TAB_SPACE;\n Object.keys(kf).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n /** @type {?} */\n const value = kf[prop];\n switch (prop) {\n case 'offset':\n return;\n case 'easing':\n if (value) {\n keyframeStr += `${tab}animation-timing-function: ${value};\\n`;\n }\n return;\n default:\n keyframeStr += `${tab}${prop}: ${value};\\n`;\n return;\n }\n }));\n keyframeStr += `${tab}}\\n`;\n }));\n keyframeStr += `}\\n`;\n /** @type {?} */\n const kfElm = document.createElement('style');\n kfElm.innerHTML = keyframeStr;\n return kfElm;\n }\n /**\n * @param {?} element\n * @param {?} keyframes\n * @param {?} duration\n * @param {?} delay\n * @param {?} easing\n * @param {?=} previousPlayers\n * @param {?=} scrubberAccessRequested\n * @return {?}\n */\n animate(element, keyframes, duration, delay, easing, previousPlayers = [], scrubberAccessRequested) {\n if (scrubberAccessRequested) {\n this._notifyFaultyScrubber();\n }\n /** @type {?} */\n const previousCssKeyframePlayers = (/** @type {?} */ (previousPlayers.filter((/**\n * @param {?} player\n * @return {?}\n */\n player => player instanceof CssKeyframesPlayer))));\n /** @type {?} */\n const previousStyles = {};\n if (allowPreviousPlayerStylesMerge(duration, delay)) {\n previousCssKeyframePlayers.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n /** @type {?} */\n let styles = player.currentSnapshot;\n Object.keys(styles).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => previousStyles[prop] = styles[prop]));\n }));\n }\n keyframes = balancePreviousStylesIntoKeyframes(element, keyframes, previousStyles);\n /** @type {?} */\n const finalStyles = flattenKeyframesIntoStyles(keyframes);\n // if there is no animation then there is no point in applying\n // styles and waiting for an event to get fired. This causes lag.\n // It's better to just directly apply the styles to the element\n // via the direct styling animation player.\n if (duration == 0) {\n return new DirectStylePlayer(element, finalStyles);\n }\n /** @type {?} */\n const animationName = `${KEYFRAMES_NAME_PREFIX}${this._count++}`;\n /** @type {?} */\n const kfElm = this.buildKeyframeElement(element, animationName, keyframes);\n (/** @type {?} */ (document.querySelector('head'))).appendChild(kfElm);\n /** @type {?} */\n const specialStyles = packageNonAnimatableStyles(element, keyframes);\n /** @type {?} */\n const player = new CssKeyframesPlayer(element, keyframes, animationName, duration, delay, easing, finalStyles, specialStyles);\n player.onDestroy((/**\n * @return {?}\n */\n () => removeElement(kfElm)));\n return player;\n }\n /**\n * @private\n * @return {?}\n */\n _notifyFaultyScrubber() {\n if (!this._warningIssued) {\n console.warn('@angular/animations: please load the web-animations.js polyfill to allow programmatic access...\\n', ' visit http://bit.ly/IWukam to learn more about using the web-animation-js polyfill.');\n this._warningIssued = true;\n }\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n CssKeyframesDriver.prototype._count;\n /**\n * @type {?}\n * @private\n */\n CssKeyframesDriver.prototype._head;\n /**\n * @type {?}\n * @private\n */\n CssKeyframesDriver.prototype._warningIssued;\n}\n/**\n * @param {?} keyframes\n * @return {?}\n */\nfunction flattenKeyframesIntoStyles(keyframes) {\n /** @type {?} */\n let flatKeyframes = {};\n if (keyframes) {\n /** @type {?} */\n const kfs = Array.isArray(keyframes) ? keyframes : [keyframes];\n kfs.forEach((/**\n * @param {?} kf\n * @return {?}\n */\n kf => {\n Object.keys(kf).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n if (prop == 'offset' || prop == 'easing')\n return;\n flatKeyframes[prop] = kf[prop];\n }));\n }));\n }\n return flatKeyframes;\n}\n/**\n * @param {?} node\n * @return {?}\n */\nfunction removeElement(node) {\n node.parentNode.removeChild(node);\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/render/web_animations/web_animations_player.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass WebAnimationsPlayer {\n /**\n * @param {?} element\n * @param {?} keyframes\n * @param {?} options\n * @param {?=} _specialStyles\n */\n constructor(element, keyframes, options, _specialStyles) {\n this.element = element;\n this.keyframes = keyframes;\n this.options = options;\n this._specialStyles = _specialStyles;\n this._onDoneFns = [];\n this._onStartFns = [];\n this._onDestroyFns = [];\n this._initialized = false;\n this._finished = false;\n this._started = false;\n this._destroyed = false;\n this.time = 0;\n this.parentPlayer = null;\n this.currentSnapshot = {};\n this._duration = (/** @type {?} */ (options['duration']));\n this._delay = (/** @type {?} */ (options['delay'])) || 0;\n this.time = this._duration + this._delay;\n }\n /**\n * @private\n * @return {?}\n */\n _onFinish() {\n if (!this._finished) {\n this._finished = true;\n this._onDoneFns.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n this._onDoneFns = [];\n }\n }\n /**\n * @return {?}\n */\n init() {\n this._buildPlayer();\n this._preparePlayerBeforeStart();\n }\n /**\n * @private\n * @return {?}\n */\n _buildPlayer() {\n if (this._initialized)\n return;\n this._initialized = true;\n /** @type {?} */\n const keyframes = this.keyframes;\n ((/** @type {?} */ (this))).domPlayer =\n this._triggerWebAnimation(this.element, keyframes, this.options);\n this._finalKeyframe = keyframes.length ? keyframes[keyframes.length - 1] : {};\n this.domPlayer.addEventListener('finish', (/**\n * @return {?}\n */\n () => this._onFinish()));\n }\n /**\n * @private\n * @return {?}\n */\n _preparePlayerBeforeStart() {\n // this is required so that the player doesn't start to animate right away\n if (this._delay) {\n this._resetDomPlayerState();\n }\n else {\n this.domPlayer.pause();\n }\n }\n /**\n * \\@internal\n * @param {?} element\n * @param {?} keyframes\n * @param {?} options\n * @return {?}\n */\n _triggerWebAnimation(element, keyframes, options) {\n // jscompiler doesn't seem to know animate is a native property because it's not fully\n // supported yet across common browsers (we polyfill it for Edge/Safari) [CL #143630929]\n return (/** @type {?} */ (element['animate'](keyframes, options)));\n }\n /**\n * @param {?} fn\n * @return {?}\n */\n onStart(fn) {\n this._onStartFns.push(fn);\n }\n /**\n * @param {?} fn\n * @return {?}\n */\n onDone(fn) {\n this._onDoneFns.push(fn);\n }\n /**\n * @param {?} fn\n * @return {?}\n */\n onDestroy(fn) {\n this._onDestroyFns.push(fn);\n }\n /**\n * @return {?}\n */\n play() {\n this._buildPlayer();\n if (!this.hasStarted()) {\n this._onStartFns.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n this._onStartFns = [];\n this._started = true;\n if (this._specialStyles) {\n this._specialStyles.start();\n }\n }\n this.domPlayer.play();\n }\n /**\n * @return {?}\n */\n pause() {\n this.init();\n this.domPlayer.pause();\n }\n /**\n * @return {?}\n */\n finish() {\n this.init();\n if (this._specialStyles) {\n this._specialStyles.finish();\n }\n this._onFinish();\n this.domPlayer.finish();\n }\n /**\n * @return {?}\n */\n reset() {\n this._resetDomPlayerState();\n this._destroyed = false;\n this._finished = false;\n this._started = false;\n }\n /**\n * @private\n * @return {?}\n */\n _resetDomPlayerState() {\n if (this.domPlayer) {\n this.domPlayer.cancel();\n }\n }\n /**\n * @return {?}\n */\n restart() {\n this.reset();\n this.play();\n }\n /**\n * @return {?}\n */\n hasStarted() {\n return this._started;\n }\n /**\n * @return {?}\n */\n destroy() {\n if (!this._destroyed) {\n this._destroyed = true;\n this._resetDomPlayerState();\n this._onFinish();\n if (this._specialStyles) {\n this._specialStyles.destroy();\n }\n this._onDestroyFns.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n this._onDestroyFns = [];\n }\n }\n /**\n * @param {?} p\n * @return {?}\n */\n setPosition(p) {\n this.domPlayer.currentTime = p * this.time;\n }\n /**\n * @return {?}\n */\n getPosition() {\n return this.domPlayer.currentTime / this.time;\n }\n /**\n * @return {?}\n */\n get totalTime() {\n return this._delay + this._duration;\n }\n /**\n * @return {?}\n */\n beforeDestroy() {\n /** @type {?} */\n const styles = {};\n if (this.hasStarted()) {\n Object.keys(this._finalKeyframe).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => {\n if (prop != 'offset') {\n styles[prop] =\n this._finished ? this._finalKeyframe[prop] : computeStyle(this.element, prop);\n }\n }));\n }\n this.currentSnapshot = styles;\n }\n /**\n * \\@internal\n * @param {?} phaseName\n * @return {?}\n */\n triggerCallback(phaseName) {\n /** @type {?} */\n const methods = phaseName == 'start' ? this._onStartFns : this._onDoneFns;\n methods.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n fn => fn()));\n methods.length = 0;\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n WebAnimationsPlayer.prototype._onDoneFns;\n /**\n * @type {?}\n * @private\n */\n WebAnimationsPlayer.prototype._onStartFns;\n /**\n * @type {?}\n * @private\n */\n WebAnimationsPlayer.prototype._onDestroyFns;\n /**\n * @type {?}\n * @private\n */\n WebAnimationsPlayer.prototype._duration;\n /**\n * @type {?}\n * @private\n */\n WebAnimationsPlayer.prototype._delay;\n /**\n * @type {?}\n * @private\n */\n WebAnimationsPlayer.prototype._initialized;\n /**\n * @type {?}\n * @private\n */\n WebAnimationsPlayer.prototype._finished;\n /**\n * @type {?}\n * @private\n */\n WebAnimationsPlayer.prototype._started;\n /**\n * @type {?}\n * @private\n */\n WebAnimationsPlayer.prototype._destroyed;\n /**\n * @type {?}\n * @private\n */\n WebAnimationsPlayer.prototype._finalKeyframe;\n /** @type {?} */\n WebAnimationsPlayer.prototype.domPlayer;\n /** @type {?} */\n WebAnimationsPlayer.prototype.time;\n /** @type {?} */\n WebAnimationsPlayer.prototype.parentPlayer;\n /** @type {?} */\n WebAnimationsPlayer.prototype.currentSnapshot;\n /** @type {?} */\n WebAnimationsPlayer.prototype.element;\n /** @type {?} */\n WebAnimationsPlayer.prototype.keyframes;\n /** @type {?} */\n WebAnimationsPlayer.prototype.options;\n /**\n * @type {?}\n * @private\n */\n WebAnimationsPlayer.prototype._specialStyles;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/render/web_animations/web_animations_driver.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass WebAnimationsDriver {\n constructor() {\n this._isNativeImpl = /\\{\\s*\\[native\\s+code\\]\\s*\\}/.test(getElementAnimateFn().toString());\n this._cssKeyframesDriver = new CssKeyframesDriver();\n }\n /**\n * @param {?} prop\n * @return {?}\n */\n validateStyleProperty(prop) {\n return validateStyleProperty(prop);\n }\n /**\n * @param {?} element\n * @param {?} selector\n * @return {?}\n */\n matchesElement(element, selector) {\n return matchesElement(element, selector);\n }\n /**\n * @param {?} elm1\n * @param {?} elm2\n * @return {?}\n */\n containsElement(elm1, elm2) {\n return containsElement(elm1, elm2);\n }\n /**\n * @param {?} element\n * @param {?} selector\n * @param {?} multi\n * @return {?}\n */\n query(element, selector, multi) {\n return invokeQuery(element, selector, multi);\n }\n /**\n * @param {?} element\n * @param {?} prop\n * @param {?=} defaultValue\n * @return {?}\n */\n computeStyle(element, prop, defaultValue) {\n return (/** @type {?} */ (((/** @type {?} */ (window.getComputedStyle(element))))[prop]));\n }\n /**\n * @param {?} supported\n * @return {?}\n */\n overrideWebAnimationsSupport(supported) {\n this._isNativeImpl = supported;\n }\n /**\n * @param {?} element\n * @param {?} keyframes\n * @param {?} duration\n * @param {?} delay\n * @param {?} easing\n * @param {?=} previousPlayers\n * @param {?=} scrubberAccessRequested\n * @return {?}\n */\n animate(element, keyframes, duration, delay, easing, previousPlayers = [], scrubberAccessRequested) {\n /** @type {?} */\n const useKeyframes = !scrubberAccessRequested && !this._isNativeImpl;\n if (useKeyframes) {\n return this._cssKeyframesDriver.animate(element, keyframes, duration, delay, easing, previousPlayers);\n }\n /** @type {?} */\n const fill = delay == 0 ? 'both' : 'forwards';\n /** @type {?} */\n const playerOptions = { duration, delay, fill };\n // we check for this to avoid having a null|undefined value be present\n // for the easing (which results in an error for certain browsers #9752)\n if (easing) {\n playerOptions['easing'] = easing;\n }\n /** @type {?} */\n const previousStyles = {};\n /** @type {?} */\n const previousWebAnimationPlayers = (/** @type {?} */ (previousPlayers.filter((/**\n * @param {?} player\n * @return {?}\n */\n player => player instanceof WebAnimationsPlayer))));\n if (allowPreviousPlayerStylesMerge(duration, delay)) {\n previousWebAnimationPlayers.forEach((/**\n * @param {?} player\n * @return {?}\n */\n player => {\n /** @type {?} */\n let styles = player.currentSnapshot;\n Object.keys(styles).forEach((/**\n * @param {?} prop\n * @return {?}\n */\n prop => previousStyles[prop] = styles[prop]));\n }));\n }\n keyframes = keyframes.map((/**\n * @param {?} styles\n * @return {?}\n */\n styles => copyStyles(styles, false)));\n keyframes = balancePreviousStylesIntoKeyframes(element, keyframes, previousStyles);\n /** @type {?} */\n const specialStyles = packageNonAnimatableStyles(element, keyframes);\n return new WebAnimationsPlayer(element, keyframes, playerOptions, specialStyles);\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n WebAnimationsDriver.prototype._isNativeImpl;\n /**\n * @type {?}\n * @private\n */\n WebAnimationsDriver.prototype._cssKeyframesDriver;\n}\n/**\n * @return {?}\n */\nfunction supportsWebAnimations() {\n return typeof getElementAnimateFn() === 'function';\n}\n/**\n * @return {?}\n */\nfunction getElementAnimateFn() {\n return (isBrowser() && ((/** @type {?} */ (Element))).prototype['animate']) || {};\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/private_export.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/src/browser.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/public_api.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n\n/**\n * @fileoverview added by tsickle\n * Generated from: packages/animations/browser/index.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { AnimationDriver, Animation as ɵAnimation, AnimationEngine as ɵAnimationEngine, AnimationStyleNormalizer as ɵAnimationStyleNormalizer, CssKeyframesDriver as ɵCssKeyframesDriver, CssKeyframesPlayer as ɵCssKeyframesPlayer, NoopAnimationDriver as ɵNoopAnimationDriver, NoopAnimationStyleNormalizer as ɵNoopAnimationStyleNormalizer, WebAnimationsDriver as ɵWebAnimationsDriver, WebAnimationsPlayer as ɵWebAnimationsPlayer, WebAnimationsStyleNormalizer as ɵWebAnimationsStyleNormalizer, allowPreviousPlayerStylesMerge as ɵallowPreviousPlayerStylesMerge, SpecialCasedStyles as ɵangular_packages_animations_browser_browser_a, containsElement as ɵcontainsElement, invokeQuery as ɵinvokeQuery, matchesElement as ɵmatchesElement, supportsWebAnimations as ɵsupportsWebAnimations, validateStyleProperty as ɵvalidateStyleProperty };\n\n//# sourceMappingURL=browser.js.map","import { DOCUMENT } from '@angular/common';\nimport { Injectable, Inject, ɵɵdefineInjectable, ɵɵinject, QueryList, isDevMode, NgZone, Directive, ElementRef, Input, InjectionToken, Optional, EventEmitter, Output, NgModule } from '@angular/core';\nimport { Subject, Subscription, of } from 'rxjs';\nimport { hasModifierKey, A, Z, ZERO, NINE, LEFT_ARROW, RIGHT_ARROW, UP_ARROW, DOWN_ARROW, TAB } from '@angular/cdk/keycodes';\nimport { tap, debounceTime, filter, map, take } from 'rxjs/operators';\nimport { coerceBooleanProperty, coerceElement } from '@angular/cdk/coercion';\nimport { Platform, normalizePassiveListenerOptions, _getShadowRoot, PlatformModule } from '@angular/cdk/platform';\nimport { ContentObserver, ObserversModule } from '@angular/cdk/observers';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/aria-describer/aria-reference.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\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 * IDs are delimited by an empty space, as per the spec.\n * @type {?}\n */\nimport * as ɵngcc0 from '@angular/core';\nimport * as ɵngcc1 from '@angular/cdk/platform';\nimport * as ɵngcc2 from '@angular/cdk/observers';\nconst ID_DELIMITER = ' ';\n/**\n * Adds the given ID to the specified ARIA attribute on an element.\n * Used for attributes such as aria-labelledby, aria-owns, etc.\n * @param {?} el\n * @param {?} attr\n * @param {?} id\n * @return {?}\n */\nfunction addAriaReferencedId(el, attr, id) {\n /** @type {?} */\n const ids = getAriaReferenceIds(el, attr);\n if (ids.some((/**\n * @param {?} existingId\n * @return {?}\n */\n existingId => existingId.trim() == id.trim()))) {\n return;\n }\n ids.push(id.trim());\n el.setAttribute(attr, ids.join(ID_DELIMITER));\n}\n/**\n * Removes the given ID from the specified ARIA attribute on an element.\n * Used for attributes such as aria-labelledby, aria-owns, etc.\n * @param {?} el\n * @param {?} attr\n * @param {?} id\n * @return {?}\n */\nfunction removeAriaReferencedId(el, attr, id) {\n /** @type {?} */\n const ids = getAriaReferenceIds(el, attr);\n /** @type {?} */\n const filteredIds = ids.filter((/**\n * @param {?} val\n * @return {?}\n */\n val => val != id.trim()));\n if (filteredIds.length) {\n el.setAttribute(attr, filteredIds.join(ID_DELIMITER));\n }\n else {\n el.removeAttribute(attr);\n }\n}\n/**\n * Gets the list of IDs referenced by the given ARIA attribute on an element.\n * Used for attributes such as aria-labelledby, aria-owns, etc.\n * @param {?} el\n * @param {?} attr\n * @return {?}\n */\nfunction getAriaReferenceIds(el, attr) {\n // Get string array of all individual ids (whitespace delimited) in the attribute value\n return (el.getAttribute(attr) || '').match(/\\S+/g) || [];\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/aria-describer/aria-describer.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Interface used to register message elements and keep a count of how many registrations have\n * the same message and the reference to the message element used for the `aria-describedby`.\n * @record\n */\nfunction RegisteredMessage() { }\nif (false) {\n /**\n * The element containing the message.\n * @type {?}\n */\n RegisteredMessage.prototype.messageElement;\n /**\n * The number of elements that reference this message element via `aria-describedby`.\n * @type {?}\n */\n RegisteredMessage.prototype.referenceCount;\n}\n/**\n * ID used for the body container where all messages are appended.\n * @type {?}\n */\nconst MESSAGES_CONTAINER_ID = 'cdk-describedby-message-container';\n/**\n * ID prefix used for each created message element.\n * @type {?}\n */\nconst CDK_DESCRIBEDBY_ID_PREFIX = 'cdk-describedby-message';\n/**\n * Attribute given to each host element that is described by a message element.\n * @type {?}\n */\nconst CDK_DESCRIBEDBY_HOST_ATTRIBUTE = 'cdk-describedby-host';\n/**\n * Global incremental identifier for each registered message element.\n * @type {?}\n */\nlet nextId = 0;\n/**\n * Global map of all registered message elements that have been placed into the document.\n * @type {?}\n */\nconst messageRegistry = new Map();\n/**\n * Container for all registered messages.\n * @type {?}\n */\nlet messagesContainer = null;\n/**\n * Utility that creates visually hidden elements with a message content. Useful for elements that\n * want to use aria-describedby to further describe themselves without adding additional visual\n * content.\n */\nclass AriaDescriber {\n /**\n * @param {?} _document\n */\n constructor(_document) {\n this._document = _document;\n }\n /**\n * Adds to the host element an aria-describedby reference to a hidden element that contains\n * the message. If the same message has already been registered, then it will reuse the created\n * message element.\n * @param {?} hostElement\n * @param {?} message\n * @return {?}\n */\n describe(hostElement, message) {\n if (!this._canBeDescribed(hostElement, message)) {\n return;\n }\n if (typeof message !== 'string') {\n // We need to ensure that the element has an ID.\n this._setMessageId(message);\n messageRegistry.set(message, { messageElement: message, referenceCount: 0 });\n }\n else if (!messageRegistry.has(message)) {\n this._createMessageElement(message);\n }\n if (!this._isElementDescribedByMessage(hostElement, message)) {\n this._addMessageReference(hostElement, message);\n }\n }\n /**\n * Removes the host element's aria-describedby reference to the message element.\n * @param {?} hostElement\n * @param {?} message\n * @return {?}\n */\n removeDescription(hostElement, message) {\n if (!this._isElementNode(hostElement)) {\n return;\n }\n if (this._isElementDescribedByMessage(hostElement, message)) {\n this._removeMessageReference(hostElement, message);\n }\n // If the message is a string, it means that it's one that we created for the\n // consumer so we can remove it safely, otherwise we should leave it in place.\n if (typeof message === 'string') {\n /** @type {?} */\n const registeredMessage = messageRegistry.get(message);\n if (registeredMessage && registeredMessage.referenceCount === 0) {\n this._deleteMessageElement(message);\n }\n }\n if (messagesContainer && messagesContainer.childNodes.length === 0) {\n this._deleteMessagesContainer();\n }\n }\n /**\n * Unregisters all created message elements and removes the message container.\n * @return {?}\n */\n ngOnDestroy() {\n /** @type {?} */\n const describedElements = this._document.querySelectorAll(`[${CDK_DESCRIBEDBY_HOST_ATTRIBUTE}]`);\n for (let i = 0; i < describedElements.length; i++) {\n this._removeCdkDescribedByReferenceIds(describedElements[i]);\n describedElements[i].removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);\n }\n if (messagesContainer) {\n this._deleteMessagesContainer();\n }\n messageRegistry.clear();\n }\n /**\n * Creates a new element in the visually hidden message container element with the message\n * as its content and adds it to the message registry.\n * @private\n * @param {?} message\n * @return {?}\n */\n _createMessageElement(message) {\n /** @type {?} */\n const messageElement = this._document.createElement('div');\n this._setMessageId(messageElement);\n messageElement.textContent = message;\n this._createMessagesContainer();\n (/** @type {?} */ (messagesContainer)).appendChild(messageElement);\n messageRegistry.set(message, { messageElement, referenceCount: 0 });\n }\n /**\n * Assigns a unique ID to an element, if it doesn't have one already.\n * @private\n * @param {?} element\n * @return {?}\n */\n _setMessageId(element) {\n if (!element.id) {\n element.id = `${CDK_DESCRIBEDBY_ID_PREFIX}-${nextId++}`;\n }\n }\n /**\n * Deletes the message element from the global messages container.\n * @private\n * @param {?} message\n * @return {?}\n */\n _deleteMessageElement(message) {\n /** @type {?} */\n const registeredMessage = messageRegistry.get(message);\n /** @type {?} */\n const messageElement = registeredMessage && registeredMessage.messageElement;\n if (messagesContainer && messageElement) {\n messagesContainer.removeChild(messageElement);\n }\n messageRegistry.delete(message);\n }\n /**\n * Creates the global container for all aria-describedby messages.\n * @private\n * @return {?}\n */\n _createMessagesContainer() {\n if (!messagesContainer) {\n /** @type {?} */\n const preExistingContainer = this._document.getElementById(MESSAGES_CONTAINER_ID);\n // When going from the server to the client, we may end up in a situation where there's\n // already a container on the page, but we don't have a reference to it. Clear the\n // old container so we don't get duplicates. Doing this, instead of emptying the previous\n // container, should be slightly faster.\n if (preExistingContainer) {\n (/** @type {?} */ (preExistingContainer.parentNode)).removeChild(preExistingContainer);\n }\n messagesContainer = this._document.createElement('div');\n messagesContainer.id = MESSAGES_CONTAINER_ID;\n messagesContainer.setAttribute('aria-hidden', 'true');\n messagesContainer.style.display = 'none';\n this._document.body.appendChild(messagesContainer);\n }\n }\n /**\n * Deletes the global messages container.\n * @private\n * @return {?}\n */\n _deleteMessagesContainer() {\n if (messagesContainer && messagesContainer.parentNode) {\n messagesContainer.parentNode.removeChild(messagesContainer);\n messagesContainer = null;\n }\n }\n /**\n * Removes all cdk-describedby messages that are hosted through the element.\n * @private\n * @param {?} element\n * @return {?}\n */\n _removeCdkDescribedByReferenceIds(element) {\n // Remove all aria-describedby reference IDs that are prefixed by CDK_DESCRIBEDBY_ID_PREFIX\n /** @type {?} */\n const originalReferenceIds = getAriaReferenceIds(element, 'aria-describedby')\n .filter((/**\n * @param {?} id\n * @return {?}\n */\n id => id.indexOf(CDK_DESCRIBEDBY_ID_PREFIX) != 0));\n element.setAttribute('aria-describedby', originalReferenceIds.join(' '));\n }\n /**\n * Adds a message reference to the element using aria-describedby and increments the registered\n * message's reference count.\n * @private\n * @param {?} element\n * @param {?} message\n * @return {?}\n */\n _addMessageReference(element, message) {\n /** @type {?} */\n const registeredMessage = (/** @type {?} */ (messageRegistry.get(message)));\n // Add the aria-describedby reference and set the\n // describedby_host attribute to mark the element.\n addAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);\n element.setAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE, '');\n registeredMessage.referenceCount++;\n }\n /**\n * Removes a message reference from the element using aria-describedby\n * and decrements the registered message's reference count.\n * @private\n * @param {?} element\n * @param {?} message\n * @return {?}\n */\n _removeMessageReference(element, message) {\n /** @type {?} */\n const registeredMessage = (/** @type {?} */ (messageRegistry.get(message)));\n registeredMessage.referenceCount--;\n removeAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);\n element.removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);\n }\n /**\n * Returns true if the element has been described by the provided message ID.\n * @private\n * @param {?} element\n * @param {?} message\n * @return {?}\n */\n _isElementDescribedByMessage(element, message) {\n /** @type {?} */\n const referenceIds = getAriaReferenceIds(element, 'aria-describedby');\n /** @type {?} */\n const registeredMessage = messageRegistry.get(message);\n /** @type {?} */\n const messageId = registeredMessage && registeredMessage.messageElement.id;\n return !!messageId && referenceIds.indexOf(messageId) != -1;\n }\n /**\n * Determines whether a message can be described on a particular element.\n * @private\n * @param {?} element\n * @param {?} message\n * @return {?}\n */\n _canBeDescribed(element, message) {\n if (!this._isElementNode(element)) {\n return false;\n }\n if (message && typeof message === 'object') {\n // We'd have to make some assumptions about the description element's text, if the consumer\n // passed in an element. Assume that if an element is passed in, the consumer has verified\n // that it can be used as a description.\n return true;\n }\n /** @type {?} */\n const trimmedMessage = message == null ? '' : `${message}`.trim();\n /** @type {?} */\n const ariaLabel = element.getAttribute('aria-label');\n // We shouldn't set descriptions if they're exactly the same as the `aria-label` of the\n // element, because screen readers will end up reading out the same text twice in a row.\n return trimmedMessage ? (!ariaLabel || ariaLabel.trim() !== trimmedMessage) : false;\n }\n /**\n * Checks whether a node is an Element node.\n * @private\n * @param {?} element\n * @return {?}\n */\n _isElementNode(element) {\n return element.nodeType === this._document.ELEMENT_NODE;\n }\n}\nAriaDescriber.ɵfac = function AriaDescriber_Factory(t) { return new (t || AriaDescriber)(ɵngcc0.ɵɵinject(DOCUMENT)); };\n/** @nocollapse */\nAriaDescriber.ctorParameters = () => [\n { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }\n];\n/** @nocollapse */ AriaDescriber.ɵprov = ɵɵdefineInjectable({ factory: function AriaDescriber_Factory() { return new AriaDescriber(ɵɵinject(DOCUMENT)); }, token: AriaDescriber, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(AriaDescriber, [{\n type: Injectable,\n args: [{ providedIn: 'root' }]\n }], function () { return [{ type: undefined, decorators: [{\n type: Inject,\n args: [DOCUMENT]\n }] }]; }, null); })();\nif (false) {\n /**\n * @type {?}\n * @private\n */\n AriaDescriber.prototype._document;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/key-manager/list-key-manager.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * This interface is for items that can be passed to a ListKeyManager.\n * @record\n */\nfunction ListKeyManagerOption() { }\nif (false) {\n /**\n * Whether the option is disabled.\n * @type {?|undefined}\n */\n ListKeyManagerOption.prototype.disabled;\n /**\n * Gets the label for this option.\n * @return {?}\n */\n ListKeyManagerOption.prototype.getLabel = function () { };\n}\n/**\n * This class manages keyboard events for selectable lists. If you pass it a query list\n * of items, it will set the active item correctly when arrow events occur.\n * @template T\n */\nclass ListKeyManager {\n /**\n * @param {?} _items\n */\n constructor(_items) {\n this._items = _items;\n this._activeItemIndex = -1;\n this._activeItem = null;\n this._wrap = false;\n this._letterKeyStream = new Subject();\n this._typeaheadSubscription = Subscription.EMPTY;\n this._vertical = true;\n this._allowedModifierKeys = [];\n /**\n * Predicate function that can be used to check whether an item should be skipped\n * by the key manager. By default, disabled items are skipped.\n */\n this._skipPredicateFn = (/**\n * @param {?} item\n * @return {?}\n */\n (item) => item.disabled);\n // Buffer for the letters that the user has pressed when the typeahead option is turned on.\n this._pressedLetters = [];\n /**\n * Stream that emits any time the TAB key is pressed, so components can react\n * when focus is shifted off of the list.\n */\n this.tabOut = new Subject();\n /**\n * Stream that emits whenever the active item of the list manager changes.\n */\n this.change = new Subject();\n // We allow for the items to be an array because, in some cases, the consumer may\n // not have access to a QueryList of the items they want to manage (e.g. when the\n // items aren't being collected via `ViewChildren` or `ContentChildren`).\n if (_items instanceof QueryList) {\n _items.changes.subscribe((/**\n * @param {?} newItems\n * @return {?}\n */\n (newItems) => {\n if (this._activeItem) {\n /** @type {?} */\n const itemArray = newItems.toArray();\n /** @type {?} */\n const newIndex = itemArray.indexOf(this._activeItem);\n if (newIndex > -1 && newIndex !== this._activeItemIndex) {\n this._activeItemIndex = newIndex;\n }\n }\n }));\n }\n }\n /**\n * Sets the predicate function that determines which items should be skipped by the\n * list key manager.\n * @template THIS\n * @this {THIS}\n * @param {?} predicate Function that determines whether the given item should be skipped.\n * @return {THIS}\n */\n skipPredicate(predicate) {\n (/** @type {?} */ (this))._skipPredicateFn = predicate;\n return (/** @type {?} */ (this));\n }\n /**\n * Configures wrapping mode, which determines whether the active item will wrap to\n * the other end of list when there are no more items in the given direction.\n * @template THIS\n * @this {THIS}\n * @param {?=} shouldWrap Whether the list should wrap when reaching the end.\n * @return {THIS}\n */\n withWrap(shouldWrap = true) {\n (/** @type {?} */ (this))._wrap = shouldWrap;\n return (/** @type {?} */ (this));\n }\n /**\n * Configures whether the key manager should be able to move the selection vertically.\n * @template THIS\n * @this {THIS}\n * @param {?=} enabled Whether vertical selection should be enabled.\n * @return {THIS}\n */\n withVerticalOrientation(enabled = true) {\n (/** @type {?} */ (this))._vertical = enabled;\n return (/** @type {?} */ (this));\n }\n /**\n * Configures the key manager to move the selection horizontally.\n * Passing in `null` will disable horizontal movement.\n * @template THIS\n * @this {THIS}\n * @param {?} direction Direction in which the selection can be moved.\n * @return {THIS}\n */\n withHorizontalOrientation(direction) {\n (/** @type {?} */ (this))._horizontal = direction;\n return (/** @type {?} */ (this));\n }\n /**\n * Modifier keys which are allowed to be held down and whose default actions will be prevented\n * as the user is pressing the arrow keys. Defaults to not allowing any modifier keys.\n * @template THIS\n * @this {THIS}\n * @param {?} keys\n * @return {THIS}\n */\n withAllowedModifierKeys(keys) {\n (/** @type {?} */ (this))._allowedModifierKeys = keys;\n return (/** @type {?} */ (this));\n }\n /**\n * Turns on typeahead mode which allows users to set the active item by typing.\n * @template THIS\n * @this {THIS}\n * @param {?=} debounceInterval Time to wait after the last keystroke before setting the active item.\n * @return {THIS}\n */\n withTypeAhead(debounceInterval = 200) {\n if ((/** @type {?} */ (this))._items.length && (/** @type {?} */ (this))._items.some((/**\n * @param {?} item\n * @return {?}\n */\n item => typeof item.getLabel !== 'function'))) {\n throw Error('ListKeyManager items in typeahead mode must implement the `getLabel` method.');\n }\n (/** @type {?} */ (this))._typeaheadSubscription.unsubscribe();\n // Debounce the presses of non-navigational keys, collect the ones that correspond to letters\n // and convert those letters back into a string. Afterwards find the first item that starts\n // with that string and select it.\n (/** @type {?} */ (this))._typeaheadSubscription = (/** @type {?} */ (this))._letterKeyStream.pipe(tap((/**\n * @param {?} letter\n * @return {?}\n */\n letter => (/** @type {?} */ (this))._pressedLetters.push(letter))), debounceTime(debounceInterval), filter((/**\n * @return {?}\n */\n () => (/** @type {?} */ (this))._pressedLetters.length > 0)), map((/**\n * @return {?}\n */\n () => (/** @type {?} */ (this))._pressedLetters.join('')))).subscribe((/**\n * @param {?} inputString\n * @return {?}\n */\n inputString => {\n /** @type {?} */\n const items = (/** @type {?} */ (this))._getItemsArray();\n // Start at 1 because we want to start searching at the item immediately\n // following the current active item.\n for (let i = 1; i < items.length + 1; i++) {\n /** @type {?} */\n const index = ((/** @type {?} */ (this))._activeItemIndex + i) % items.length;\n /** @type {?} */\n const item = items[index];\n if (!(/** @type {?} */ (this))._skipPredicateFn(item) &&\n (/** @type {?} */ (item.getLabel))().toUpperCase().trim().indexOf(inputString) === 0) {\n (/** @type {?} */ (this)).setActiveItem(index);\n break;\n }\n }\n (/** @type {?} */ (this))._pressedLetters = [];\n }));\n return (/** @type {?} */ (this));\n }\n /**\n * @param {?} item\n * @return {?}\n */\n setActiveItem(item) {\n /** @type {?} */\n const previousIndex = this._activeItemIndex;\n this.updateActiveItem(item);\n if (this._activeItemIndex !== previousIndex) {\n this.change.next(this._activeItemIndex);\n }\n }\n /**\n * Sets the active item depending on the key event passed in.\n * @param {?} event Keyboard event to be used for determining which element should be active.\n * @return {?}\n */\n onKeydown(event) {\n /** @type {?} */\n const keyCode = event.keyCode;\n /** @type {?} */\n const modifiers = ['altKey', 'ctrlKey', 'metaKey', 'shiftKey'];\n /** @type {?} */\n const isModifierAllowed = modifiers.every((/**\n * @param {?} modifier\n * @return {?}\n */\n modifier => {\n return !event[modifier] || this._allowedModifierKeys.indexOf(modifier) > -1;\n }));\n switch (keyCode) {\n case TAB:\n this.tabOut.next();\n return;\n case DOWN_ARROW:\n if (this._vertical && isModifierAllowed) {\n this.setNextItemActive();\n break;\n }\n else {\n return;\n }\n case UP_ARROW:\n if (this._vertical && isModifierAllowed) {\n this.setPreviousItemActive();\n break;\n }\n else {\n return;\n }\n case RIGHT_ARROW:\n if (this._horizontal && isModifierAllowed) {\n this._horizontal === 'rtl' ? this.setPreviousItemActive() : this.setNextItemActive();\n break;\n }\n else {\n return;\n }\n case LEFT_ARROW:\n if (this._horizontal && isModifierAllowed) {\n this._horizontal === 'rtl' ? this.setNextItemActive() : this.setPreviousItemActive();\n break;\n }\n else {\n return;\n }\n default:\n if (isModifierAllowed || hasModifierKey(event, 'shiftKey')) {\n // Attempt to use the `event.key` which also maps it to the user's keyboard language,\n // otherwise fall back to resolving alphanumeric characters via the keyCode.\n if (event.key && event.key.length === 1) {\n this._letterKeyStream.next(event.key.toLocaleUpperCase());\n }\n else if ((keyCode >= A && keyCode <= Z) || (keyCode >= ZERO && keyCode <= NINE)) {\n this._letterKeyStream.next(String.fromCharCode(keyCode));\n }\n }\n // Note that we return here, in order to avoid preventing\n // the default action of non-navigational keys.\n return;\n }\n this._pressedLetters = [];\n event.preventDefault();\n }\n /**\n * Index of the currently active item.\n * @return {?}\n */\n get activeItemIndex() {\n return this._activeItemIndex;\n }\n /**\n * The active item.\n * @return {?}\n */\n get activeItem() {\n return this._activeItem;\n }\n /**\n * Gets whether the user is currently typing into the manager using the typeahead feature.\n * @return {?}\n */\n isTyping() {\n return this._pressedLetters.length > 0;\n }\n /**\n * Sets the active item to the first enabled item in the list.\n * @return {?}\n */\n setFirstItemActive() {\n this._setActiveItemByIndex(0, 1);\n }\n /**\n * Sets the active item to the last enabled item in the list.\n * @return {?}\n */\n setLastItemActive() {\n this._setActiveItemByIndex(this._items.length - 1, -1);\n }\n /**\n * Sets the active item to the next enabled item in the list.\n * @return {?}\n */\n setNextItemActive() {\n this._activeItemIndex < 0 ? this.setFirstItemActive() : this._setActiveItemByDelta(1);\n }\n /**\n * Sets the active item to a previous enabled item in the list.\n * @return {?}\n */\n setPreviousItemActive() {\n this._activeItemIndex < 0 && this._wrap ? this.setLastItemActive()\n : this._setActiveItemByDelta(-1);\n }\n /**\n * @param {?} item\n * @return {?}\n */\n updateActiveItem(item) {\n /** @type {?} */\n const itemArray = this._getItemsArray();\n /** @type {?} */\n const index = typeof item === 'number' ? item : itemArray.indexOf(item);\n /** @type {?} */\n const activeItem = itemArray[index];\n // Explicitly check for `null` and `undefined` because other falsy values are valid.\n this._activeItem = activeItem == null ? null : activeItem;\n this._activeItemIndex = index;\n }\n /**\n * This method sets the active item, given a list of items and the delta between the\n * currently active item and the new active item. It will calculate differently\n * depending on whether wrap mode is turned on.\n * @private\n * @param {?} delta\n * @return {?}\n */\n _setActiveItemByDelta(delta) {\n this._wrap ? this._setActiveInWrapMode(delta) : this._setActiveInDefaultMode(delta);\n }\n /**\n * Sets the active item properly given \"wrap\" mode. In other words, it will continue to move\n * down the list until it finds an item that is not disabled, and it will wrap if it\n * encounters either end of the list.\n * @private\n * @param {?} delta\n * @return {?}\n */\n _setActiveInWrapMode(delta) {\n /** @type {?} */\n const items = this._getItemsArray();\n for (let i = 1; i <= items.length; i++) {\n /** @type {?} */\n const index = (this._activeItemIndex + (delta * i) + items.length) % items.length;\n /** @type {?} */\n const item = items[index];\n if (!this._skipPredicateFn(item)) {\n this.setActiveItem(index);\n return;\n }\n }\n }\n /**\n * Sets the active item properly given the default mode. In other words, it will\n * continue to move down the list until it finds an item that is not disabled. If\n * it encounters either end of the list, it will stop and not wrap.\n * @private\n * @param {?} delta\n * @return {?}\n */\n _setActiveInDefaultMode(delta) {\n this._setActiveItemByIndex(this._activeItemIndex + delta, delta);\n }\n /**\n * Sets the active item to the first enabled item starting at the index specified. If the\n * item is disabled, it will move in the fallbackDelta direction until it either\n * finds an enabled item or encounters the end of the list.\n * @private\n * @param {?} index\n * @param {?} fallbackDelta\n * @return {?}\n */\n _setActiveItemByIndex(index, fallbackDelta) {\n /** @type {?} */\n const items = this._getItemsArray();\n if (!items[index]) {\n return;\n }\n while (this._skipPredicateFn(items[index])) {\n index += fallbackDelta;\n if (!items[index]) {\n return;\n }\n }\n this.setActiveItem(index);\n }\n /**\n * Returns the items as an array.\n * @private\n * @return {?}\n */\n _getItemsArray() {\n return this._items instanceof QueryList ? this._items.toArray() : this._items;\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n ListKeyManager.prototype._activeItemIndex;\n /**\n * @type {?}\n * @private\n */\n ListKeyManager.prototype._activeItem;\n /**\n * @type {?}\n * @private\n */\n ListKeyManager.prototype._wrap;\n /**\n * @type {?}\n * @private\n */\n ListKeyManager.prototype._letterKeyStream;\n /**\n * @type {?}\n * @private\n */\n ListKeyManager.prototype._typeaheadSubscription;\n /**\n * @type {?}\n * @private\n */\n ListKeyManager.prototype._vertical;\n /**\n * @type {?}\n * @private\n */\n ListKeyManager.prototype._horizontal;\n /**\n * @type {?}\n * @private\n */\n ListKeyManager.prototype._allowedModifierKeys;\n /**\n * Predicate function that can be used to check whether an item should be skipped\n * by the key manager. By default, disabled items are skipped.\n * @type {?}\n * @private\n */\n ListKeyManager.prototype._skipPredicateFn;\n /**\n * @type {?}\n * @private\n */\n ListKeyManager.prototype._pressedLetters;\n /**\n * Stream that emits any time the TAB key is pressed, so components can react\n * when focus is shifted off of the list.\n * @type {?}\n */\n ListKeyManager.prototype.tabOut;\n /**\n * Stream that emits whenever the active item of the list manager changes.\n * @type {?}\n */\n ListKeyManager.prototype.change;\n /**\n * @type {?}\n * @private\n */\n ListKeyManager.prototype._items;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/key-manager/activedescendant-key-manager.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * This is the interface for highlightable items (used by the ActiveDescendantKeyManager).\n * Each item must know how to style itself as active or inactive and whether or not it is\n * currently disabled.\n * @record\n */\nfunction Highlightable() { }\nif (false) {\n /**\n * Applies the styles for an active item to this item.\n * @return {?}\n */\n Highlightable.prototype.setActiveStyles = function () { };\n /**\n * Applies the styles for an inactive item to this item.\n * @return {?}\n */\n Highlightable.prototype.setInactiveStyles = function () { };\n}\n/**\n * @template T\n */\nclass ActiveDescendantKeyManager extends ListKeyManager {\n /**\n * @param {?} index\n * @return {?}\n */\n setActiveItem(index) {\n if (this.activeItem) {\n this.activeItem.setInactiveStyles();\n }\n super.setActiveItem(index);\n if (this.activeItem) {\n this.activeItem.setActiveStyles();\n }\n }\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/key-manager/focus-key-manager.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * This is the interface for focusable items (used by the FocusKeyManager).\n * Each item must know how to focus itself, whether or not it is currently disabled\n * and be able to supply its label.\n * @record\n */\nfunction FocusableOption() { }\nif (false) {\n /**\n * Focuses the `FocusableOption`.\n * @param {?=} origin\n * @return {?}\n */\n FocusableOption.prototype.focus = function (origin) { };\n}\n/**\n * @template T\n */\nclass FocusKeyManager extends ListKeyManager {\n constructor() {\n super(...arguments);\n this._origin = 'program';\n }\n /**\n * Sets the focus origin that will be passed in to the items for any subsequent `focus` calls.\n * @template THIS\n * @this {THIS}\n * @param {?} origin Focus origin to be used when focusing items.\n * @return {THIS}\n */\n setFocusOrigin(origin) {\n (/** @type {?} */ (this))._origin = origin;\n return (/** @type {?} */ (this));\n }\n /**\n * @param {?} item\n * @return {?}\n */\n setActiveItem(item) {\n super.setActiveItem(item);\n if (this.activeItem) {\n this.activeItem.focus(this._origin);\n }\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n FocusKeyManager.prototype._origin;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/interactivity-checker/interactivity-checker.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n// The InteractivityChecker leans heavily on the ally.js accessibility utilities.\n// Methods like `isTabbable` are only covering specific edge-cases for the browsers which are\n// supported.\n/**\n * Utility for checking the interactivity of an element, such as whether is is focusable or\n * tabbable.\n */\nclass InteractivityChecker {\n /**\n * @param {?} _platform\n */\n constructor(_platform) {\n this._platform = _platform;\n }\n /**\n * Gets whether an element is disabled.\n *\n * @param {?} element Element to be checked.\n * @return {?} Whether the element is disabled.\n */\n isDisabled(element) {\n // This does not capture some cases, such as a non-form control with a disabled attribute or\n // a form control inside of a disabled form, but should capture the most common cases.\n return element.hasAttribute('disabled');\n }\n /**\n * Gets whether an element is visible for the purposes of interactivity.\n *\n * This will capture states like `display: none` and `visibility: hidden`, but not things like\n * being clipped by an `overflow: hidden` parent or being outside the viewport.\n *\n * @param {?} element\n * @return {?} Whether the element is visible.\n */\n isVisible(element) {\n return hasGeometry(element) && getComputedStyle(element).visibility === 'visible';\n }\n /**\n * Gets whether an element can be reached via Tab key.\n * Assumes that the element has already been checked with isFocusable.\n *\n * @param {?} element Element to be checked.\n * @return {?} Whether the element is tabbable.\n */\n isTabbable(element) {\n // Nothing is tabbable on the server 😎\n if (!this._platform.isBrowser) {\n return false;\n }\n /** @type {?} */\n const frameElement = getFrameElement(getWindow(element));\n if (frameElement) {\n /** @type {?} */\n const frameType = frameElement && frameElement.nodeName.toLowerCase();\n // Frame elements inherit their tabindex onto all child elements.\n if (getTabIndexValue(frameElement) === -1) {\n return false;\n }\n // Webkit and Blink consider anything inside of an