{"version":3,"sources":["webpack:///D:/a/1/s/src/app/core/components/emphasisText/emphasis-text.shared.module.ts","webpack:///D:/a/1/s/src/app/core/components/emphasisText/index.ts","webpack:///D:/a/1/s/node_modules/@angular/cdk/fesm2015/coercion.js","webpack:///D:/a/1/s/node_modules/@angular/cdk/__ivy_ngcc__/fesm2015/bidi.js","webpack:///D:/a/1/s/node_modules/@angular/material-moment-adapter/__ivy_ngcc__/fesm2015/material-moment-adapter.js","webpack:///D:/a/1/s/src/app/core/modules/material/material.shared.module.ts","webpack:///D:/a/1/s/src/app/core/modules/material/index.ts","webpack:///D:/a/1/s/src/app/core/components/headers/h/h.shared.component.html","webpack:///D:/a/1/s/src/app/core/components/headers/h/h.shared.component.ts","webpack:///D:/a/1/s/src/app/core/components/icon/index.ts","webpack:///D:/a/1/s/src/app/core/components/loaders/loaders.shared.component.ts","webpack:///D:/a/1/s/src/app/core/components/loaders/loadersTypes/forPlaceholder/loaders-placeholder.shared.component.ts","webpack:///D:/a/1/s/src/app/core/components/loaders/loadersTypes/forPlaceholder/loaders-placeholder.shared.component.html","webpack:///D:/a/1/s/src/app/core/components/link/link.shared.module.ts","webpack:///D:/a/1/s/src/app/core/components/link/index.ts","webpack:///D:/a/1/s/node_modules/@angular/cdk/__ivy_ngcc__/fesm2015/observers.js","webpack:///D:/a/1/s/src/app/core/components/headers/h/h.shared.module.ts","webpack:///D:/a/1/s/src/app/core/components/headers/header/header.shared.module.ts","webpack:///D:/a/1/s/src/app/core/components/headers/heroHeader/hero-header.shared.module.ts","webpack:///D:/a/1/s/src/app/core/components/headers/headers.shared.module.ts","webpack:///D:/a/1/s/src/app/core/components/headers/index.ts","webpack:///D:/a/1/s/src/app/core/components/loaders/loadersCheckmark/loaders-checkmark.shared.module.ts","webpack:///D:/a/1/s/src/app/core/components/loaders/loadersError/loaders-error.shared.module.ts","webpack:///D:/a/1/s/src/app/core/components/loaders/loadersTypes/forPlaceholder/loaders-placeholder.shared.module.ts","webpack:///D:/a/1/s/src/app/core/components/loaders/loadersTypes/loaders-types.shared.module.ts","webpack:///D:/a/1/s/src/app/core/components/loaders/loaders.shared.module.ts","webpack:///D:/a/1/s/src/app/core/components/loaders/index.ts","webpack:///D:/a/1/s/node_modules/@angular/material/__ivy_ngcc__/fesm2015/icon.js","webpack:///D:/a/1/s/node_modules/@angular/cdk/__ivy_ngcc__/fesm2015/platform.js","webpack:///D:/a/1/s/src/app/core/components/headers/header/header.shared.component.ts","webpack:///D:/a/1/s/src/app/core/components/headers/header/header.shared.component.html","webpack:///D:/a/1/s/node_modules/@angular/cdk/__ivy_ngcc__/fesm2015/keycodes.js","webpack:///D:/a/1/s/node_modules/rxjs/_esm2015/internal/operators/takeUntil.js","webpack:///D:/a/1/s/node_modules/@angular/cdk/__ivy_ngcc__/fesm2015/scrolling.js","webpack:///D:/a/1/s/node_modules/@angular/cdk/__ivy_ngcc__/fesm2015/portal.js","webpack:///D:/a/1/s/node_modules/@angular/cdk/__ivy_ngcc__/fesm2015/overlay.js","webpack:///D:/a/1/s/node_modules/@angular/material/__ivy_ngcc__/fesm2015/button.js","webpack:///D:/a/1/s/node_modules/@angular/material/__ivy_ngcc__/fesm2015/dialog.js","webpack:///D:/a/1/s/node_modules/@angular/material/__ivy_ngcc__/fesm2015/form-field.js","webpack:///D:/a/1/s/node_modules/@angular/material/__ivy_ngcc__/fesm2015/input.js","webpack:///D:/a/1/s/node_modules/@angular/material/__ivy_ngcc__/fesm2015/datepicker.js","webpack:///D:/a/1/s/node_modules/@angular/cdk/fesm2015/cdk.js","webpack:///D:/a/1/s/node_modules/@angular/material/__ivy_ngcc__/fesm2015/core.js","webpack:///D:/a/1/s/node_modules/rxjs/_esm2015/internal/operators/debounceTime.js","webpack:///D:/a/1/s/src/app/core/components/link/link.shared.component.ts","webpack:///D:/a/1/s/src/app/core/components/link/link.shared.component.html","webpack:///D:/a/1/s/src/app/core/components/loaders/loadersTypes/forSpinner/loaders-spinner.shared.module.ts","webpack:///D:/a/1/s/src/app/core/components/loaders/loadersTypes/forSpinner/index.ts","webpack:///D:/a/1/s/node_modules/@angular/cdk/__ivy_ngcc__/fesm2015/a11y.js","webpack:///D:/a/1/s/src/app/core/components/icon/icon.shared.module.ts","webpack:///D:/a/1/s/src/app/core/components/icon/icon.shared.component.ts","webpack:///D:/a/1/s/src/app/core/components/icon/icon.shared.component.html"],"names":["EmphasisTextModule","coerceBooleanProperty","value","coerceNumberProperty","fallbackValue","isNaN","parseFloat","Number","coerceArray","Array","isArray","coerceCssPixelValue","coerceElement","elementOrRef","nativeElement","DIR_DOCUMENT","providedIn","factory","Directionality","_document","this","change","htmlDir","documentElement","dir","body","complete","ɵfac","t","ɵprov","token","BidiModule","ɵmod","type","ɵinj","MAT_MOMENT_DATE_ADAPTER_OPTIONS","useUtc","range","length","valueFunction","valuesArray","i","MomentDateAdapter","dateLocale","_options","super","setLocale","locale","momentLocaleData","localeData","_localeData","firstDayOfWeek","longMonths","months","shortMonths","monthsShort","dates","createDate","format","longDaysOfWeek","weekdays","shortDaysOfWeek","weekdaysShort","narrowDaysOfWeek","weekdaysMin","date","clone","year","month","day","style","daysInMonth","Error","result","_createMoment","isValid","parseFormat","displayFormat","years","add","days","Date","isDateInstance","ISO_8601","deserialize","obj","isMoment","invalid","strict","utc","MomentDateModule","providers","provide","useClass","deps","ɵ0","parse","dateInput","display","monthYearLabel","dateA11yLabel","monthYearA11yLabel","MatMomentDateModule","useValue","imports","CUSTOM_DATE_FORMATS","toExportModules","MaterialModule","HComponent","loading","inverted","marginTop","marginBottom","paddingTop","paddingBottom","brandAccent","counter","ellipsis","center","headerSizeClass","assignHeaderSizeClass","LoadersComponent","color","thickness","LoadersPlaceholderComponent","LinkModule","MutationObserverFactory","callback","MutationObserver","ContentObserver","_mutationObserverFactory","_observedElements","Map","forEach","_","element","_cleanupObserver","observer","subscription","_observeElement","subscribe","unsubscribe","_unobserveElement","has","get","count","stream","create","mutations","next","observe","characterData","childList","subtree","set","disconnect","delete","CdkObserveContent","_contentObserver","_elementRef","_ngZone","event","_disabled","_currentSubscription","_unsubscribe","_subscribe","_debounce","disabled","runOutsideAngular","debounce","pipe","ɵdir","selectors","inputs","outputs","exportAs","ObserversModule","HModule","HeaderModule","HeroHeaderModule","HeadersModule","LoadersCheckmarkModule","LoadersErrorModule","LoadersPlaceholderModule","LoadersTypesModule","toExport","LoadersModule","_c0","getMatIconNameNotFoundError","iconName","getMatIconFailedToSanitizeUrlError","url","getMatIconFailedToSanitizeLiteralError","literal","SvgIconConfig","data","options","nodeName","svgElement","MatIconRegistry","_httpClient","_sanitizer","document","_errorHandler","_svgIconConfigs","_iconSetConfigs","_cachedIconsByUrl","_inProgressUrlFetches","_fontCssClassesByAlias","_defaultFontSetClass","addSvgIconInNamespace","addSvgIconLiteralInNamespace","namespace","_addSvgIconConfig","sanitizedLiteral","sanitize","HTML","_createSvgElementForSingleIcon","addSvgIconSetInNamespace","addSvgIconSetLiteralInNamespace","_addSvgIconSetConfig","_svgElementFromString","alias","className","safeUrl","RESOURCE_URL","cachedIcon","cloneSvg","_loadSvgIconFromConfig","svg","name","key","iconKey","config","_getSvgFromConfig","iconSetConfigs","_getSvgFromIconSetConfigs","clear","namedIcon","_extractIconWithNameFromAnySet","iconSetFetchRequests","filter","iconSetConfig","map","_loadSvgIconSetFromConfig","err","errorMessage","message","handleError","console","error","foundIcon","_extractSvgIconFromSet","_fetchUrl","svgText","responseText","_setSvgAttributes","iconSet","iconSource","querySelector","iconElement","cloneNode","removeAttribute","toLowerCase","_toSvgElement","appendChild","str","div","createElement","innerHTML","attributes","setAttribute","childNodes","nodeType","ELEMENT_NODE","viewBox","inProgressFetch","req","responseType","configNamespace","push","MatIconBase","_MatIconMixinBase","MAT_ICON_LOCATION","_location","location","getPathname","pathname","search","funcIriAttributes","funcIriAttributeSelector","attr","join","funcIriPattern","MatIcon","elementRef","_iconRegistry","ariaHidden","_inline","inline","_fontSet","_cleanupFontValue","_fontIcon","parts","split","changes","svgIconChanges","svgIcon","_splitIconName","getNamedSvgIcon","_setSvgElement","previousValue","_clearSvgElement","_usingFontIcon","_updateFontIconClasses","cachedElements","_elementsWithExternalReferences","size","newPath","_previousPath","_prependPathToReferences","styleTags","querySelectorAll","textContent","path","_cacheChildrenWithExternalReferences","layoutElement","childCount","child","removeChild","elem","fontSetClass","fontSet","classNameForFontAlias","getDefaultFontSetClass","_previousFontSetClass","classList","remove","fontIcon","_previousFontIconClass","trim","elements","attrs","elementsWithFuncIri","elementWithReference","getAttribute","match","ɵcmp","hostAttrs","hostVars","hostBindings","rf","ctx","features","ngContentSelectors","decls","vars","template","styles","encapsulation","changeDetection","MatIconModule","hasV8BreakIterator","Intl","v8BreakIterator","_a","supportedInputTypes","Platform","_platformId","isBrowser","EDGE","test","navigator","userAgent","TRIDENT","BLINK","chrome","CSS","WEBKIT","IOS","window","FIREFOX","ANDROID","SAFARI","PlatformModule","candidateInputTypes","getSupportedInputTypes","Set","featureTestInput","supportsPassiveEvents","rtlScrollAxisType","shadowDomIsSupported","normalizePassiveListenerOptions","addEventListener","Object","defineProperty","capture","supportsScrollBehavior","getRtlScrollAxisType","scrollContainer","containerStyle","height","width","overflow","visibility","pointerEvents","position","content","contentStyle","scrollLeft","_getShadowRoot","head","createShadowRoot","attachShadow","rootNode","getRootNode","ShadowRoot","HeaderComponent","TAB","ENTER","ESCAPE","SPACE","PAGE_UP","PAGE_DOWN","END","HOME","LEFT_ARROW","UP_ARROW","RIGHT_ARROW","DOWN_ARROW","ZERO","NINE","A","Z","hasModifierKey","modifiers","some","modifier","altKey","shiftKey","ctrlKey","metaKey","notifier","subscriber","source","takeUntilSubscriber","notifierSubscription","subscribeToResult","seenValue","OuterSubscriber","destination","outerValue","innerValue","outerIndex","innerIndex","innerSub","ScrollDispatcher","_platform","_scrolled","Subject","_globalSubscription","_scrolledCount","scrollContainers","scrollable","elementScrolled","scrollableReference","auditTimeInMs","Observable","_addGlobalListener","auditTime","a","_removeGlobalListener","of","container","deregister","ancestors","getAncestorScrollContainers","scrolled","target","indexOf","scrollingContainers","_subscription","_scrollableContainsElement","_getDocument","defaultView","scrollableElement","getElementRef","parentElement","_getWindow","fromEvent","ViewportRuler","ngZone","_change","merge","_invalidateCache","_updateViewportSize","_viewportSize","output","scrollPosition","getViewportScrollPosition","getViewportSize","top","left","bottom","right","documentRect","getBoundingClientRect","scrollTop","scrollY","scrollX","throttleTime","innerWidth","innerHeight","CdkScrollableModule","ScrollingModule","throwPortalAlreadyAttachedError","Portal","host","hasAttached","_attachedHost","attach","detach","ComponentPortal","component","viewContainerRef","injector","componentFactoryResolver","TemplatePortal","context","templateRef","undefined","BasePortalOutlet","_isDisposed","attachDomPortal","_attachedPortal","portal","attachComponentPortal","attachTemplatePortal","setAttachedHost","_invokeDisposeFn","fn","_disposeFn","DomPortalOutlet","outletElement","_componentFactoryResolver","_appRef","_defaultInjector","parentNode","anchorNode","createComment","insertBefore","setDisposeFn","replaceChild","componentFactory","resolveComponentFactory","componentRef","createComponent","destroy","attachView","hostView","detachView","_getComponentRootNode","viewContainer","viewRef","createEmbeddedView","detectChanges","rootNodes","index","dispose","CdkPortalOutlet","_viewContainerRef","_isInitialized","attached","_getRootNode","_attachedRef","ref","emit","PortalModule","_viewportRuler","_previousHTMLStyles","_isEnabled","_canBeEnabled","root","_previousScrollPosition","c","html","htmlStyle","bodyStyle","previousHtmlScrollBehavior","scrollBehavior","previousBodyScrollBehavior","scroll","contains","viewport","scrollHeight","scrollWidth","getMatScrollStrategyAlreadyAttachedError","CloseScrollStrategy","_scrollDispatcher","_config","_scrollSubscription","_detach","disable","_overlayRef","run","overlayRef","threshold","_initialScrollPosition","Math","abs","updatePosition","NoopScrollStrategy","isElementScrolledOutsideView","containerBounds","isElementClippedByScrolling","scrollContainerRect","RepositionScrollStrategy","scrollThrottle","autoClose","overlayRect","overlayElement","ScrollStrategyOptions","noop","close","block","reposition","OverlayConfig","scrollStrategy","panelClass","hasBackdrop","backdropClass","disposeOnNavigation","configKeys","keys","ConnectionPositionPair","origin","overlay","offsetX","offsetY","originX","originY","overlayX","overlayY","ConnectedOverlayPositionChange","connectionPair","scrollableViewProperties","validateVerticalPosition","property","validateHorizontalPosition","OverlayKeyboardDispatcher","_attachedOverlays","_keydownListener","overlays","_keydownEventSubscriptions","_keydownEvents","_isAttached","splice","removeEventListener","isTestEnvironment","__karma__","jasmine","OverlayContainer","_containerElement","_createContainer","oppositePlatformContainers","_portalOutlet","_host","_pane","_keyboardDispatcher","_backdropElement","_backdropClick","_attachments","_detachments","_locationChanges","Subscription","EMPTY","_backdropClickHandler","_keydownEventsObservable","_scrollStrategy","_positionStrategy","positionStrategy","attachResult","_previousHostParent","_updateStackingOrder","_updateElementSize","_updateElementDirection","enable","onStable","asObservable","take","_togglePointerEvents","_attachBackdrop","_toggleClasses","detachBackdrop","detachmentResult","_detachContentWhenStable","isAttached","_disposeScrollStrategy","apply","strategy","sizeConfig","assign","direction","classes","getDirection","minWidth","minHeight","maxWidth","maxHeight","enablePointer","requestAnimationFrame","nextSibling","timeoutId","backdropToDetach","finishDetach","clearTimeout","setTimeout","cssClasses","isAdd","cssClass","lift","children","cssUnitPattern","connectedTo","_overlayContainer","_lastBoundingBoxSize","_isPushed","_canPush","_growAfterOpen","_hasFlexibleDimensions","_positionLocked","_viewportMargin","_scrollables","_preferredPositions","_positionChanges","_resizeSubscription","_offsetX","_offsetY","_appliedPanelClasses","positionChanges","setOrigin","_validatePositions","hostElement","_boundingBox","_isInitialRender","_lastPosition","reapplyLastPosition","_clearPanelClasses","_resetOverlayElementStyles","_resetBoundingBoxStyles","_viewportRect","_getNarrowedViewportRect","_originRect","_getOriginRect","_overlayRect","originRect","viewportRect","flexibleFits","fallback","pos","originPoint","_getOriginPoint","overlayPoint","_getOverlayPoint","overlayFit","_getOverlayFit","isCompletelyWithinViewport","_applyPosition","_canFitWithFlexibleDimensions","boundingBoxRect","_calculateBoundingBoxRect","visibleArea","bestFit","bestScore","fit","score","weight","_previousPushAmount","extendStyles","alignItems","justifyContent","lastPosition","scrollables","positions","margin","flexibleDimensions","growAfterOpen","canPush","isLocked","_origin","offset","selector","_transformOriginSelector","x","y","startX","_isRtl","endX","overlayStartX","overlayStartY","point","_getOffset","topOverflow","bottomOverflow","visibleWidth","_subtractOverflows","visibleHeight","fitsInViewportVertically","fitsInViewportHorizontally","availableHeight","availableWidth","getPixelValue","getConfig","horizontalFit","start","overflowRight","max","overflowBottom","overflowTop","overflowLeft","pushX","pushY","_setTransformOrigin","_setOverlayElementStyles","_setBoundingBoxStyles","_addPanelClasses","observers","_getScrollVisibility","changeEvent","xOrigin","yOrigin","transformOrigin","isRtl","smallestDistanceToViewportEdge","min","previousHeight","previousWidth","_hasExactPosition","transform","hasExactPosition","hasFlexibleDimensions","_getExactOverlayY","_getExactOverlayX","transformString","_pushOverlayOnScreen","virtualKeyboardOffset","getContainerElement","clientHeight","horizontalStyleProperty","clientWidth","originBounds","overlayBounds","scrollContainerBounds","isOriginClipped","isOriginOutsideView","isOverlayClipped","isOverlayOutsideView","overflows","reduce","currentValue","currentOverflow","axis","pair","Element","hasOwnProperty","input","units","ConnectedPositionStrategy","originPos","overlayPos","viewportRuler","platform","overlayContainer","withFlexibleDimensions","withPush","withViewportMargin","withFallbackPosition","_direction","setDirection","withScrollableContainers","withPositions","withDefaultOffsetX","withDefaultOffsetY","withLockedPosition","slice","GlobalPositionStrategy","_cssPosition","_topOffset","_bottomOffset","_leftOffset","_rightOffset","_alignItems","_justifyContent","_width","_height","updateSize","parentStyles","shouldBeFlushHorizontally","shouldBeFlushVertically","marginLeft","marginRight","parent","OverlayPositionBuilder","nextUniqueId","Overlay","scrollStrategies","_positionBuilder","_injector","_directionality","_createHostElement","pane","_createPaneElement","portalOutlet","_createPortalOutlet","overlayConfig","id","CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER","useFactory","OverlayModule","BUTTON_HOST_ATTRIBUTES","MatButtonBase","_MatButtonMixinBase","MatButton","_focusMonitor","_animationMode","isRoundButton","_hasHostAttributes","isIconButton","_getHostElement","monitor","stopMonitoring","focusVia","disableRipple","attribute","hasAttribute","viewQuery","_t","ripple","first","consts","_isRippleDisabled","directives","MatButtonModule","MatDialogContainer_ng_template_0_Template","MatDialogConfig","role","disableClose","ariaDescribedBy","ariaLabelledBy","ariaLabel","autoFocus","restoreFocus","closeOnNavigation","matDialogAnimations","dialogContainer","opacity","throwMatDialogContentAlreadyAttachedError","MatDialogContainer","_focusTrapFactory","_changeDetectorRef","_elementFocusedBeforeDialogWasOpened","_state","_animationStateChanged","_savePreviouslyFocusedElement","_ariaLabelledBy","_containsFocus","_getFocusTrap","focusInitialElement","focus","focusInitialElementWhenReady","toFocus","activeElement","_focusTrap","Promise","resolve","then","toState","_trapFocus","_restoreFocus","markForCheck","$event","_onAnimationStart","_onAnimationDone","_id","animation","uniqueId","_containerInstance","_afterOpened","_afterClosed","_beforeClosed","phaseName","_closeFallbackTimeout","_finishDialogClose","detachments","_result","componentInstance","keydownEvents","keyCode","preventDefault","backdropClick","_recaptureFocus","dialogResult","totalTime","_startExitAnimation","_getPositionStrategy","centerHorizontally","centerVertically","addPanelClass","removePanelClass","MAT_DIALOG_DATA","MAT_DIALOG_DEFAULT_OPTIONS","MAT_DIALOG_SCROLL_STRATEGY","MAT_DIALOG_SCROLL_STRATEGY_PROVIDER","MatDialog","_overlay","_defaultOptions","_parentDialog","_openDialogsAtThisLevel","_afterAllClosedAtThisLevel","_afterOpenedAtThisLevel","_ariaHiddenElements","afterAllClosed","defer","openDialogs","_afterAllClosed","startWith","afterOpened","componentOrTemplateRef","defaultOptions","getDialogById","_createOverlay","_attachDialogContainer","dialogRef","_attachDialogContent","_hideNonDialogContentFromAssistiveTechnology","afterClosed","_removeOpenDialog","_closeDialogs","find","dialog","_getOverlayConfig","dialogConfig","state","global","containerPortal","instance","$implicit","_createInjector","contentRef","userInjector","siblings","sibling","dialogs","MatDialogModule","MAT_FORM_FIELD","MAT_INPUT_VALUE_ACCESSOR","MatCalendarBody_tr_0_Template","ctx_r0","_cellPadding","numCols","label","MatCalendarBody_tr_1_td_1_Template","ctx_r4","_firstRowOffset","labelMinRequiredCells","MatCalendarBody_tr_1_td_2_Template","_r9","item_r6","_cellClicked","colIndex_r7","rowIndex_r3","ctx_r5","_cellWidth","enabled","_isActiveCell","selectedValue","todayValue","displayValue","MatCalendarBody_tr_1_Template","row_r2","ctx_r1","MatMonthView_th_3_Template","day_r1","long","narrow","MatCalendar_ng_template_0_Template","MatCalendar_mat_month_view_2_Template","_r5","activeDate","_dateSelected","_userSelected","selected","dateFilter","maxDate","minDate","dateClass","MatCalendar_mat_year_view_3_Template","_monthSelectedInYearView","_goToDateInView","ctx_r2","MatCalendar_mat_multi_year_view_4_Template","_r13","_yearSelectedInMultiYearView","ctx_r3","MatDatepickerToggle__svg_svg_2_Template","createMissingDateImplError","provider","MatDatepickerIntl","calendarLabel","openCalendarLabel","prevMonthLabel","nextMonthLabel","prevYearLabel","nextYearLabel","prevMultiYearLabel","nextMultiYearLabel","switchToMonthViewLabel","switchToMultiYearViewLabel","end","MatCalendarCell","MatCalendarBody","activeCell","cellAspectRatio","selectedValueChange","cell","columnChanges","rows","rowIndex","colIndex","cellNumber","MatMonthView","_dateFormats","_dateAdapter","_dir","_rerenderSubscription","selectedChange","_userSelection","activeDateChange","_activeDate","today","oldActiveDate","validDate","_getValidDateOrNull","clampDate","_hasSameMonthAndYear","_init","_selected","_selectedDate","_getDateInCurrentMonth","_minDate","_maxDate","localeChanges","selectedYear","getYear","selectedMonth","getMonth","selectedDate","addCalendarDays","getDate","getNumDaysInMonth","addCalendarYears","addCalendarMonths","compareDate","_focusActiveCell","_todayDate","_monthLabel","getMonthNames","toLocaleUpperCase","firstOfMonth","_firstWeekOffset","getDayOfWeek","getFirstDayOfWeek","_initWeekdays","_createWeekCells","_matCalendarBody","narrowWeekdays","getDayOfWeekNames","_weekdays","concat","dateNames","getDateNames","_weeks","_shouldEnableDate","cellClasses","d1","d2","_handleCalendarBodyKeydown","MatMultiYearView","yearSelected","isSameMultiYearView","_selectedYear","_todayYear","minYearOfPage","getActiveOffset","_years","row","_createCellForYear","yearsPerPage","_yearSelected","yearName","getYearName","_shouldEnableYear","_getActiveCell","dateAdapter","date1","date2","year1","year2","startingYear","getStartingYear","floor","MatYearView","monthSelected","_selectedMonth","_getMonthInCurrentYear","normalizedDate","_monthSelected","_todayMonth","_yearLabel","monthNames","_months","_createCellForMonth","monthName","_shouldEnableMonth","activeYear","_isYearAndMonthAfterMaxDate","_isYearAndMonthBeforeMinDate","maxYear","maxMonth","minYear","minMonth","MatCalendarHeader","_intl","calendar","changeDetectorRef","stateChanges","currentView","maxYearOfPage","minYearName","maxYearName","formatYearRange","_isSameView","currentPeriodClicked","previousClicked","nextClicked","periodButtonLabel","periodButtonText","previousEnabled","prevButtonLabel","nextEnabled","nextButtonLabel","MatCalendar","_moveFocusOnNextTick","startView","_intlChanges","_startAt","_clampedActiveDate","_currentView","_calendarHeaderPortal","headerComponent","startAt","focusActiveCell","firstChange","view","_getCurrentViewComponent","monthView","yearView","multiYearView","sameDate","normalizedYear","normalizedMonth","matDatepickerAnimations","transformPanel","fadeInCalendar","datepickerUid","MAT_DATEPICKER_SCROLL_STRATEGY","MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER","MatDatepickerContentBase","_MatDatepickerContentMixinBase","MatDatepickerContent","_animationState","_animationDone","_calendar","datepicker","touchUi","select","_selectYear","_selectMonth","_dateFilter","calendarHeaderComponent","MatDatepicker","_dialog","_touchUi","openedStream","closedStream","_opened","_validSelected","_focusedElementBeforeOpen","_inputSubscription","_disabledChange","_selectedChanged","_datepickerInput","_color","_getThemePalette","newValue","open","_destroyPopup","oldValue","_valueChange","_openAsDialog","_openAsPopup","_popupComponentRef","_popupRef","_dialogRef","completeClose","_createPopup","_createPopupPositionStrategy","flexibleConnectedTo","getConnectedOverlayOrigin","withTransformOriginOn","opened","MAT_DATEPICKER_VALUE_ACCESSOR","useExisting","multi","MAT_DATEPICKER_VALIDATORS","MatDatepickerInputEvent","targetElement","MatDatepickerInput","_formField","dateChange","_onTouched","_cvaOnChange","_validatorOnChange","_datepickerSubscription","_localeSubscription","_parseValidator","_lastValueValid","_minValidator","control","controlValue","_maxValidator","_filterValidator","_validator","compose","_datepicker","_registerInput","_value","oldDate","_formatValue","_min","_max","blur","isDisabled","readOnly","lastValueWasValid","_onInput","_onChange","_onBlur","_onKeydown","toIso8601","matDatepicker","matDatepickerFilter","MatDatepickerToggleIcon","MatDatepickerToggle","defaultTabIndex","_stateChanges","parsedTabIndex","tabIndex","_watchStateChanges","stopPropagation","datepickerDisabled","inputDisabled","datepickerToggled","contentQueries","dirIndex","_customIcon","_button","_open","MatDatepickerModule","VERSION","VERSION$1","MATERIAL_SANITY_CHECKS","MatCommonModule","highContrastModeDetector","sanityChecks","_hasDoneGlobalChecks","_applyBodyHighContrastModeCssClasses","_sanityChecks","_checkDoctypeIsDefined","_checkThemeIsPresent","_checkCdkVersionMatch","doc","win","_isTestEnv","isEnabled","_checksAreEnabled","doctype","warn","theme","getComputedStyle","testElement","computedStyle","version","full","mixinDisabled","base","args","mixinColor","defaultColor","colorPalette","mixinDisableRipple","_disableRipple","mixinErrorState","errorState","oldState","newState","errorStateMatcher","_defaultErrorStateMatcher","isErrorState","ngControl","_parentFormGroup","_parentForm","MAT_DATE_LOCALE","_localeChanges","second","firstValid","secondValid","MAT_DATE_FORMATS","SUPPORTS_INTL_API","ErrorStateMatcher","form","touched","submitted","RippleRef","_renderer","fadeOutRipple","defaultRippleAnimationConfig","enterDuration","exitDuration","passiveEventOptions","passive","pointerDownEvents","pointerUpEvents","_target","elementOrElementRef","_isPointerDown","_activeRipples","_pointerUpEventsRegistered","containerRect","_containerRect","animationConfig","centered","radius","rect","distX","distY","sqrt","duration","backgroundColor","transitionDuration","getPropertyValue","rippleRef","persistent","_mostRecentTransientRipple","_runTimeoutOutsideZone","isMostRecentTransientRipple","fadeOut","wasActive","rippleEl","_triggerElement","_removeTriggerEvents","_registerEvents","_onMousedown","_onTouchStart","_onPointerUp","isFakeMousedown","isSyntheticEvent","_lastTouchStartEvent","now","rippleDisabled","fadeInRipple","clientX","clientY","rippleConfig","touches","changedTouches","terminateOnPointerUp","delay","eventTypes","MAT_RIPPLE_GLOBAL_OPTIONS","MatRipple","globalOptions","_globalOptions","_rippleRenderer","_setupTriggerEventsIfEnabled","_trigger","trigger","fadeOutAll","setupTriggerEvents","configOrX","unbounded","MatRippleModule","MAT_LABEL_GLOBAL_OPTIONS","debounceTime","dueTime","scheduler","DebounceTimeOperator","DebounceTimeSubscriber","debouncedSubscription","lastValue","hasValue","clearDebounce","schedule","dispatchNext","debouncedNext","LinkComponent","mobile","emphasis","isAsync","title","onClick","LoadersForSpinnerModule","InteractivityChecker","offsetWidth","offsetHeight","getClientRects","frameElement","node","ownerDocument","frameType","getTabIndexValue","isVisible","tabIndexValue","inputType","hasValidTabIndex","parseInt","FocusTrap","_element","_checker","deferAnchors","_hasAttached","startAnchorListener","focusLastTabbableElement","endAnchorListener","focusFirstTabbableElement","_enabled","attachAnchors","_startAnchor","_endAnchor","_toggleAnchorTabIndex","startAnchor","endAnchor","_createAnchor","_executeOnStable","bound","markers","_getFirstTabbableElement","_getLastTabbableElement","redirectToElement","isFocusable","_getRegionBoundary","isTabbable","tabbableChild","anchor","isStable","FocusTrapFactory","deferCaptureElements","CdkTrapFocus","_previouslyFocusedElement","focusTrap","_autoCapture","autoCapture","LIVE_ANNOUNCER_ELEMENT_TOKEN","LIVE_ANNOUNCER_DEFAULT_OPTIONS","LiveAnnouncer","elementToken","_liveElement","_createLiveElement","politeness","_previousTimeout","previousElements","getElementsByClassName","liveEl","CdkAriaLive","_liveAnnouncer","_politeness","elementText","_previousAnnouncedText","announce","isFakeMousedownFromScreenReader","buttons","FOCUS_MONITOR_DEFAULT_OPTIONS","captureEventListenerOptions","FocusMonitor","_windowFocused","_elementInfo","_monitoredElementCount","_rootNodeFocusListenerCount","_documentKeydownListener","_lastTouchTarget","_setOriginForCurrentEventQueue","_documentMousedownListener","_documentTouchstartListener","_touchTimeoutId","getTarget","_windowFocusListener","_windowFocusTimeoutId","_rootNodeFocusAndBlurListener","handler","_onFocus","call","_detectionMode","detectionMode","checkChildren","cachedInfo","subject","info","_registerGlobalListeners","elementInfo","_setClasses","_removeGlobalListeners","_info","shouldSet","_lastFocusOrigin","_wasCausedByTouch","_toggleClass","_originTimeoutId","focusTarget","Node","_getFocusOrigin","_emitOrigin","relatedTarget","rootNodeFocusListeners","composedPath","CdkMonitorFocus","cdkFocusChange","_monitorSubscription","HighContrastModeDetector","documentWindow","computedColor","replace","bodyClasses","mode","getHighContrastMode","A11yModule","IconModule","IconComponent"],"mappings":"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","file":"x","sourcesContent":["import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\n\r\nimport { EmphasisTextComponent } from './emphasis-text.shared.component';\r\n\r\n@NgModule({\r\n    declarations: [\r\n        EmphasisTextComponent\r\n    ],\r\n    imports: [CommonModule],\r\n    exports: [\r\n        EmphasisTextComponent\r\n    ],\r\n    providers: [],\r\n})\r\nexport class EmphasisTextModule { }\r\n","export * from './emphasis-text.shared.module';\r\n","import { ElementRef } from '@angular/core';\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/** Coerces a data-bound value (typically a string) to a boolean. */\nfunction coerceBooleanProperty(value) {\n    return value != null && `${value}` !== 'false';\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction coerceNumberProperty(value, fallbackValue = 0) {\n    return _isNumberValue(value) ? Number(value) : fallbackValue;\n}\n/**\n * Whether the provided value is considered a number.\n * @docs-private\n */\nfunction _isNumberValue(value) {\n    // parseFloat(value) handles most of the cases we're interested in (it treats null, empty string,\n    // and other non-number values as NaN, where Number just uses 0) but it considers the string\n    // '123hello' to be a valid number. Therefore we also check if Number(value) is NaN.\n    return !isNaN(parseFloat(value)) && !isNaN(Number(value));\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction coerceArray(value) {\n    return Array.isArray(value) ? value : [value];\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Coerces a value to a CSS pixel value. */\nfunction coerceCssPixelValue(value) {\n    if (value == null) {\n        return '';\n    }\n    return typeof value === 'string' ? value : `${value}px`;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Coerces an ElementRef or an Element into an element.\n * Useful for APIs that can accept either a ref or the native element itself.\n */\nfunction coerceElement(elementOrRef) {\n    return elementOrRef instanceof ElementRef ? elementOrRef.nativeElement : elementOrRef;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nexport { _isNumberValue, coerceArray, coerceBooleanProperty, coerceCssPixelValue, coerceElement, coerceNumberProperty };\n//# sourceMappingURL=coercion.js.map\n","import { InjectionToken, inject, EventEmitter, Injectable, Optional, Inject, ɵɵdefineInjectable, ɵɵinject, Directive, Output, Input, NgModule } from '@angular/core';\nimport { DOCUMENT } from '@angular/common';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/bidi/dir-document-token.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Injection token used to inject the document into Directionality.\n * This is used so that the value can be faked in tests.\n *\n * We can't use the real document in tests because changing the real `dir` causes geometry-based\n * tests in Safari to fail.\n *\n * We also can't re-provide the DOCUMENT token from platform-brower because the unit tests\n * themselves use things like `querySelector` in test code.\n *\n * This token is defined in a separate file from Directionality as a workaround for\n * https://github.com/angular/angular/issues/22559\n *\n * \\@docs-private\n * @type {?}\n */\nimport * as ɵngcc0 from '@angular/core';\nconst DIR_DOCUMENT = new InjectionToken('cdk-dir-doc', {\n    providedIn: 'root',\n    factory: DIR_DOCUMENT_FACTORY,\n});\n/**\n * \\@docs-private\n * @return {?}\n */\nfunction DIR_DOCUMENT_FACTORY() {\n    return inject(DOCUMENT);\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/bidi/directionality.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * The directionality (LTR / RTL) context for the application (or a subtree of it).\n * Exposes the current direction and a stream of direction changes.\n */\nclass Directionality {\n    /**\n     * @param {?=} _document\n     */\n    constructor(_document) {\n        /**\n         * The current 'ltr' or 'rtl' value.\n         */\n        this.value = 'ltr';\n        /**\n         * Stream that emits whenever the 'ltr' / 'rtl' state changes.\n         */\n        this.change = new EventEmitter();\n        if (_document) {\n            // TODO: handle 'auto' value -\n            // We still need to account for dir=\"auto\".\n            // It looks like HTMLElemenet.dir is also \"auto\" when that's set to the attribute,\n            // but getComputedStyle return either \"ltr\" or \"rtl\". avoiding getComputedStyle for now\n            /** @type {?} */\n            const bodyDir = _document.body ? _document.body.dir : null;\n            /** @type {?} */\n            const htmlDir = _document.documentElement ? _document.documentElement.dir : null;\n            /** @type {?} */\n            const value = bodyDir || htmlDir;\n            this.value = (value === 'ltr' || value === 'rtl') ? value : 'ltr';\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this.change.complete();\n    }\n}\nDirectionality.ɵfac = function Directionality_Factory(t) { return new (t || Directionality)(ɵngcc0.ɵɵinject(DIR_DOCUMENT, 8)); };\n/** @nocollapse */\nDirectionality.ctorParameters = () => [\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DIR_DOCUMENT,] }] }\n];\n/** @nocollapse */ Directionality.ɵprov = ɵɵdefineInjectable({ factory: function Directionality_Factory() { return new Directionality(ɵɵinject(DIR_DOCUMENT, 8)); }, token: Directionality, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(Directionality, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [DIR_DOCUMENT]\n            }] }]; }, null); })();\nif (false) {\n    /**\n     * The current 'ltr' or 'rtl' value.\n     * @type {?}\n     */\n    Directionality.prototype.value;\n    /**\n     * Stream that emits whenever the 'ltr' / 'rtl' state changes.\n     * @type {?}\n     */\n    Directionality.prototype.change;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/bidi/dir.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Directive to listen for changes of direction of part of the DOM.\n *\n * Provides itself as Directionality such that descendant directives only need to ever inject\n * Directionality to get the closest direction.\n */\nclass Dir {\n    constructor() {\n        /**\n         * Normalized direction that accounts for invalid/unsupported values.\n         */\n        this._dir = 'ltr';\n        /**\n         * Whether the `value` has been set to its initial value.\n         */\n        this._isInitialized = false;\n        /**\n         * Event emitted when the direction changes.\n         */\n        this.change = new EventEmitter();\n    }\n    /**\n     * \\@docs-private\n     * @return {?}\n     */\n    get dir() { return this._dir; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set dir(value) {\n        /** @type {?} */\n        const old = this._dir;\n        /** @type {?} */\n        const normalizedValue = value ? value.toLowerCase() : value;\n        this._rawDir = value;\n        this._dir = (normalizedValue === 'ltr' || normalizedValue === 'rtl') ? normalizedValue : 'ltr';\n        if (old !== this._dir && this._isInitialized) {\n            this.change.emit(this._dir);\n        }\n    }\n    /**\n     * Current layout direction of the element.\n     * @return {?}\n     */\n    get value() { return this.dir; }\n    /**\n     * Initialize once default value has been set.\n     * @return {?}\n     */\n    ngAfterContentInit() {\n        this._isInitialized = true;\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this.change.complete();\n    }\n}\nDir.ɵfac = function Dir_Factory(t) { return new (t || Dir)(); };\nDir.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: Dir, selectors: [[\"\", \"dir\", \"\"]], hostVars: 1, hostBindings: function Dir_HostBindings(rf, ctx) { if (rf & 2) {\n        ɵngcc0.ɵɵattribute(\"dir\", ctx._rawDir);\n    } }, inputs: { dir: \"dir\" }, outputs: { change: \"dirChange\" }, exportAs: [\"dir\"], features: [ɵngcc0.ɵɵProvidersFeature([{ provide: Directionality, useExisting: Dir }])] });\nDir.propDecorators = {\n    change: [{ type: Output, args: ['dirChange',] }],\n    dir: [{ type: Input }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(Dir, [{\n        type: Directive,\n        args: [{\n                selector: '[dir]',\n                providers: [{ provide: Directionality, useExisting: Dir }],\n                host: { '[attr.dir]': '_rawDir' },\n                exportAs: 'dir'\n            }]\n    }], function () { return []; }, { change: [{\n            type: Output,\n            args: ['dirChange']\n        }], dir: [{\n            type: Input\n        }] }); })();\nif (false) {\n    /**\n     * Normalized direction that accounts for invalid/unsupported values.\n     * @type {?}\n     * @private\n     */\n    Dir.prototype._dir;\n    /**\n     * Whether the `value` has been set to its initial value.\n     * @type {?}\n     * @private\n     */\n    Dir.prototype._isInitialized;\n    /**\n     * Direction as passed in by the consumer.\n     * @type {?}\n     */\n    Dir.prototype._rawDir;\n    /**\n     * Event emitted when the direction changes.\n     * @type {?}\n     */\n    Dir.prototype.change;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/bidi/bidi-module.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass BidiModule {\n}\nBidiModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: BidiModule });\nBidiModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function BidiModule_Factory(t) { return new (t || BidiModule)(); } });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(BidiModule, { declarations: [Dir], exports: [Dir] }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(BidiModule, [{\n        type: NgModule,\n        args: [{\n                exports: [Dir],\n                declarations: [Dir]\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/bidi/public-api.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 { BidiModule, DIR_DOCUMENT, Dir, Directionality, DIR_DOCUMENT_FACTORY as ɵangular_material_src_cdk_bidi_bidi_a };\n\n//# sourceMappingURL=bidi.js.map","import { InjectionToken, Injectable, Optional, Inject, NgModule } from '@angular/core';\nimport { DateAdapter, MAT_DATE_LOCALE, MAT_DATE_FORMATS } from '@angular/material/core';\nimport * as _rollupMoment from 'moment';\nimport _rollupMoment__default, {  } from 'moment';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material-moment-adapter/adapter/moment-date-adapter.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nimport * as ɵngcc0 from '@angular/core';\nconst moment = _rollupMoment__default || _rollupMoment;\n/**\n * Configurable options for {\\@see MomentDateAdapter}.\n * @record\n */\nfunction MatMomentDateAdapterOptions() { }\nif (false) {\n    /**\n     * When enabled, the dates have to match the format exactly.\n     * See https://momentjs.com/guides/#/parsing/strict-mode/.\n     * @type {?|undefined}\n     */\n    MatMomentDateAdapterOptions.prototype.strict;\n    /**\n     * Turns the use of utc dates on or off.\n     * Changing this will change how Angular Material components like DatePicker output dates.\n     * {\\@default false}\n     * @type {?|undefined}\n     */\n    MatMomentDateAdapterOptions.prototype.useUtc;\n}\n/**\n * InjectionToken for moment date adapter to configure options.\n * @type {?}\n */\nconst MAT_MOMENT_DATE_ADAPTER_OPTIONS = new InjectionToken('MAT_MOMENT_DATE_ADAPTER_OPTIONS', {\n    providedIn: 'root',\n    factory: MAT_MOMENT_DATE_ADAPTER_OPTIONS_FACTORY\n});\n/**\n * \\@docs-private\n * @return {?}\n */\nfunction MAT_MOMENT_DATE_ADAPTER_OPTIONS_FACTORY() {\n    return {\n        useUtc: false\n    };\n}\n/**\n * Creates an array and fills it with values.\n * @template T\n * @param {?} length\n * @param {?} valueFunction\n * @return {?}\n */\nfunction range(length, valueFunction) {\n    /** @type {?} */\n    const valuesArray = Array(length);\n    for (let i = 0; i < length; i++) {\n        valuesArray[i] = valueFunction(i);\n    }\n    return valuesArray;\n}\n/**\n * Adapts Moment.js Dates for use with Angular Material.\n */\nclass MomentDateAdapter extends DateAdapter {\n    /**\n     * @param {?} dateLocale\n     * @param {?=} _options\n     */\n    constructor(dateLocale, _options) {\n        super();\n        this._options = _options;\n        this.setLocale(dateLocale || moment.locale());\n    }\n    /**\n     * @param {?} locale\n     * @return {?}\n     */\n    setLocale(locale) {\n        super.setLocale(locale);\n        /** @type {?} */\n        let momentLocaleData = moment.localeData(locale);\n        this._localeData = {\n            firstDayOfWeek: momentLocaleData.firstDayOfWeek(),\n            longMonths: momentLocaleData.months(),\n            shortMonths: momentLocaleData.monthsShort(),\n            dates: range(31, (/**\n             * @param {?} i\n             * @return {?}\n             */\n            (i) => this.createDate(2017, 0, i + 1).format('D'))),\n            longDaysOfWeek: momentLocaleData.weekdays(),\n            shortDaysOfWeek: momentLocaleData.weekdaysShort(),\n            narrowDaysOfWeek: momentLocaleData.weekdaysMin(),\n        };\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    getYear(date) {\n        return this.clone(date).year();\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    getMonth(date) {\n        return this.clone(date).month();\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    getDate(date) {\n        return this.clone(date).date();\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    getDayOfWeek(date) {\n        return this.clone(date).day();\n    }\n    /**\n     * @param {?} style\n     * @return {?}\n     */\n    getMonthNames(style) {\n        // Moment.js doesn't support narrow month names, so we just use short if narrow is requested.\n        return style == 'long' ? this._localeData.longMonths : this._localeData.shortMonths;\n    }\n    /**\n     * @return {?}\n     */\n    getDateNames() {\n        return this._localeData.dates;\n    }\n    /**\n     * @param {?} style\n     * @return {?}\n     */\n    getDayOfWeekNames(style) {\n        if (style == 'long') {\n            return this._localeData.longDaysOfWeek;\n        }\n        if (style == 'short') {\n            return this._localeData.shortDaysOfWeek;\n        }\n        return this._localeData.narrowDaysOfWeek;\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    getYearName(date) {\n        return this.clone(date).format('YYYY');\n    }\n    /**\n     * @return {?}\n     */\n    getFirstDayOfWeek() {\n        return this._localeData.firstDayOfWeek;\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    getNumDaysInMonth(date) {\n        return this.clone(date).daysInMonth();\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    clone(date) {\n        return date.clone().locale(this.locale);\n    }\n    /**\n     * @param {?} year\n     * @param {?} month\n     * @param {?} date\n     * @return {?}\n     */\n    createDate(year, month, date) {\n        // Moment.js will create an invalid date if any of the components are out of bounds, but we\n        // explicitly check each case so we can throw more descriptive errors.\n        if (month < 0 || month > 11) {\n            throw Error(`Invalid month index \"${month}\". Month index has to be between 0 and 11.`);\n        }\n        if (date < 1) {\n            throw Error(`Invalid date \"${date}\". Date has to be greater than 0.`);\n        }\n        /** @type {?} */\n        const result = this._createMoment({ year, month, date }).locale(this.locale);\n        // If the result isn't valid, the date must have been out of bounds for this month.\n        if (!result.isValid()) {\n            throw Error(`Invalid date \"${date}\" for month with index \"${month}\".`);\n        }\n        return result;\n    }\n    /**\n     * @return {?}\n     */\n    today() {\n        return this._createMoment().locale(this.locale);\n    }\n    /**\n     * @param {?} value\n     * @param {?} parseFormat\n     * @return {?}\n     */\n    parse(value, parseFormat) {\n        if (value && typeof value == 'string') {\n            return this._createMoment(value, parseFormat, this.locale);\n        }\n        return value ? this._createMoment(value).locale(this.locale) : null;\n    }\n    /**\n     * @param {?} date\n     * @param {?} displayFormat\n     * @return {?}\n     */\n    format(date, displayFormat) {\n        date = this.clone(date);\n        if (!this.isValid(date)) {\n            throw Error('MomentDateAdapter: Cannot format invalid date.');\n        }\n        return date.format(displayFormat);\n    }\n    /**\n     * @param {?} date\n     * @param {?} years\n     * @return {?}\n     */\n    addCalendarYears(date, years) {\n        return this.clone(date).add({ years });\n    }\n    /**\n     * @param {?} date\n     * @param {?} months\n     * @return {?}\n     */\n    addCalendarMonths(date, months) {\n        return this.clone(date).add({ months });\n    }\n    /**\n     * @param {?} date\n     * @param {?} days\n     * @return {?}\n     */\n    addCalendarDays(date, days) {\n        return this.clone(date).add({ days });\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    toIso8601(date) {\n        return this.clone(date).format();\n    }\n    /**\n     * Returns the given value if given a valid Moment or null. Deserializes valid ISO 8601 strings\n     * (https://www.ietf.org/rfc/rfc3339.txt) and valid Date objects into valid Moments and empty\n     * string into null. Returns an invalid date for all other values.\n     * @param {?} value\n     * @return {?}\n     */\n    deserialize(value) {\n        /** @type {?} */\n        let date;\n        if (value instanceof Date) {\n            date = this._createMoment(value).locale(this.locale);\n        }\n        else if (this.isDateInstance(value)) {\n            // Note: assumes that cloning also sets the correct locale.\n            return this.clone(value);\n        }\n        if (typeof value === 'string') {\n            if (!value) {\n                return null;\n            }\n            date = this._createMoment(value, moment.ISO_8601).locale(this.locale);\n        }\n        if (date && this.isValid(date)) {\n            return this._createMoment(date).locale(this.locale);\n        }\n        return super.deserialize(value);\n    }\n    /**\n     * @param {?} obj\n     * @return {?}\n     */\n    isDateInstance(obj) {\n        return moment.isMoment(obj);\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    isValid(date) {\n        return this.clone(date).isValid();\n    }\n    /**\n     * @return {?}\n     */\n    invalid() {\n        return moment.invalid();\n    }\n    /**\n     * Creates a Moment instance while respecting the current UTC settings.\n     * @private\n     * @param {?} date\n     * @param {?=} format\n     * @param {?=} locale\n     * @return {?}\n     */\n    _createMoment(date, format, locale) {\n        const { strict, useUtc } = this._options || {};\n        return useUtc\n            ? moment.utc(date, format, locale, strict)\n            : moment(date, format, locale, strict);\n    }\n}\nMomentDateAdapter.ɵfac = function MomentDateAdapter_Factory(t) { return new (t || MomentDateAdapter)(ɵngcc0.ɵɵinject(MAT_DATE_LOCALE, 8), ɵngcc0.ɵɵinject(MAT_MOMENT_DATE_ADAPTER_OPTIONS, 8)); };\nMomentDateAdapter.ɵprov = ɵngcc0.ɵɵdefineInjectable({ token: MomentDateAdapter, factory: MomentDateAdapter.ɵfac });\n/** @nocollapse */\nMomentDateAdapter.ctorParameters = () => [\n    { type: String, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_LOCALE,] }] },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_MOMENT_DATE_ADAPTER_OPTIONS,] }] }\n];\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MomentDateAdapter, [{\n        type: Injectable\n    }], function () { return [{ type: String, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MAT_DATE_LOCALE]\n            }] }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MAT_MOMENT_DATE_ADAPTER_OPTIONS]\n            }] }]; }, null); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    MomentDateAdapter.prototype._localeData;\n    /**\n     * @type {?}\n     * @private\n     */\n    MomentDateAdapter.prototype._options;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material-moment-adapter/adapter/moment-date-formats.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/** @type {?} */\nconst MAT_MOMENT_DATE_FORMATS = {\n    parse: {\n        dateInput: 'l',\n    },\n    display: {\n        dateInput: 'l',\n        monthYearLabel: 'MMM YYYY',\n        dateA11yLabel: 'LL',\n        monthYearA11yLabel: 'MMMM YYYY',\n    },\n};\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material-moment-adapter/adapter/index.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass MomentDateModule {\n}\nMomentDateModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: MomentDateModule });\nMomentDateModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function MomentDateModule_Factory(t) { return new (t || MomentDateModule)(); }, providers: [\n        {\n            provide: DateAdapter,\n            useClass: MomentDateAdapter,\n            deps: [MAT_DATE_LOCALE, MAT_MOMENT_DATE_ADAPTER_OPTIONS]\n        }\n    ] });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MomentDateModule, [{\n        type: NgModule,\n        args: [{\n                providers: [\n                    {\n                        provide: DateAdapter,\n                        useClass: MomentDateAdapter,\n                        deps: [MAT_DATE_LOCALE, MAT_MOMENT_DATE_ADAPTER_OPTIONS]\n                    }\n                ]\n            }]\n    }], null, null); })();\nconst ɵ0 = MAT_MOMENT_DATE_FORMATS;\nclass MatMomentDateModule {\n}\nMatMomentDateModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: MatMomentDateModule });\nMatMomentDateModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function MatMomentDateModule_Factory(t) { return new (t || MatMomentDateModule)(); }, providers: [{ provide: MAT_DATE_FORMATS, useValue: ɵ0 }], imports: [[MomentDateModule]] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(MatMomentDateModule, { imports: [MomentDateModule] }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatMomentDateModule, [{\n        type: NgModule,\n        args: [{\n                imports: [MomentDateModule],\n                providers: [{ provide: MAT_DATE_FORMATS, useValue: ɵ0 }]\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material-moment-adapter/public-api.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 { MAT_MOMENT_DATE_ADAPTER_OPTIONS, MAT_MOMENT_DATE_ADAPTER_OPTIONS_FACTORY, MAT_MOMENT_DATE_FORMATS, MatMomentDateModule, MomentDateAdapter, MomentDateModule };\n\n//# sourceMappingURL=material-moment-adapter.js.map","//\r\n//  https://material.angular.io/guide/getting-started\r\n//\r\n\r\nimport { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { MatDatepickerModule } from '@angular/material/datepicker';\r\nimport { MatIconModule } from '@angular/material/icon';\r\nimport { MatMomentDateModule } from '@angular/material-moment-adapter';\r\n\r\n/* Date formats: https://material.angular.io/components/datepicker/overview */\r\nimport { MomentDateAdapter } from '@angular/material-moment-adapter';\r\nimport { DateAdapter, MAT_DATE_FORMATS, MAT_DATE_LOCALE } from '@angular/material/core';\r\n\r\n\r\nexport const CUSTOM_DATE_FORMATS = {\r\n    parse: {\r\n        dateInput: 'DD/MM/YYYY'\r\n    },\r\n    display: {\r\n        dateInput: 'DD/MM/YYYY',\r\n        monthYearLabel: 'MMM YYYY',\r\n        dateA11yLabel: 'LL',\r\n        monthYearA11yLabel: 'MMMM YYYY'\r\n    },\r\n};\r\n\r\n\r\nconst toExportModules: any[] = [\r\n    MatDatepickerModule,\r\n    MatIconModule,\r\n    MatMomentDateModule,\r\n];\r\n\r\n@NgModule({\r\n    declarations: [],\r\n    imports: [\r\n        CommonModule,\r\n        ...toExportModules,\r\n\r\n    ],\r\n    exports: [\r\n        ...toExportModules,\r\n    ],\r\n    providers: [\r\n        { provide: DateAdapter, useClass: MomentDateAdapter, deps: [MAT_DATE_LOCALE] },\r\n        { provide: MAT_DATE_FORMATS, useValue: CUSTOM_DATE_FORMATS },\r\n        // { provide: MAT_DATE_LOCALE, useValue: 'pl' } /* This will enable local lang */\r\n    ],\r\n})\r\nexport class MaterialModule { }\r\n","export * from './material.shared.module';\r\n","<ng-template #content>\r\n    <ng-container *ngIf=\"!loading\">\r\n        <span class=\"h__pre-content\" *ngIf=\"preContent\">{{preContent}}</span>\r\n\r\n        <span class=\"h__counter\" *ngIf=\"counter !== null\">{{counter}}</span>\r\n\r\n        <span class=\"h__label\" [ngClass]=\"{'-ellipsis': ellipsis}\">\r\n            <ng-content></ng-content>\r\n        </span>\r\n\r\n        <span class=\"h__post-content\" *ngIf=\"postContent\">{{postContent}}</span>\r\n    </ng-container>\r\n\r\n    <shared-loader-for-placeholder class=\"h__loader\" [ngClass]=\"{'-center': center}\" *ngIf=\"loading\">\r\n    </shared-loader-for-placeholder>\r\n</ng-template>\r\n\r\n<ng-container *ngIf=\"type; else emptyBlock\">\r\n    <h1 class=\"h {{headerSizeClass}}{{marginTop ? ' -margin-top-'+marginTop : ''}}{{marginBottom ? ' -margin-bottom-'+marginBottom : ''}}{{paddingTop ? ' -padding-top-'+paddingTop : ''}}{{paddingBottom ? ' -padding-bottom-'+paddingBottom : ''}}\"\r\n        [ngClass]=\"{'-inverted': inverted, '-brand-accent': brandAccent, '-center': center}\">\r\n        <ng-container *ngTemplateOutlet=\"content\"></ng-container>\r\n    </h1>\r\n</ng-container>\r\n\r\n<ng-template #emptyBlock></ng-template>\r\n","import { Component, Input, ChangeDetectionStrategy, OnInit } from '@angular/core';\r\n\r\n@Component({\r\n    selector: 'shared-h',\r\n    templateUrl: './h.shared.component.html',\r\n    styleUrls: ['./h.shared.component.scss'],\r\n    changeDetection: ChangeDetectionStrategy.OnPush\r\n})\r\nexport class HComponent implements OnInit {\r\n    @Input() public loading: boolean = false;\r\n    @Input() public type: OLO.Components.HEADER_TYPE = '1';\r\n    @Input() public inverted: boolean = false;\r\n    @Input() public marginTop: OLO.Components.MARGIN_SIZE = null;\r\n    @Input() public marginBottom: OLO.Components.MARGIN_SIZE = null;\r\n    @Input() public paddingTop: OLO.Components.MARGIN_SIZE = null;\r\n    @Input() public paddingBottom: OLO.Components.MARGIN_SIZE = null;\r\n    @Input() public brandAccent: boolean = false;\r\n    @Input() public counter: number = null;\r\n    @Input() public postContent: string | number;\r\n    @Input() public preContent: string | number;\r\n    @Input() public ellipsis: boolean = false;\r\n    @Input() public center: boolean = false;\r\n\r\n    public headerSizeClass: OLO.Components.HEADER_CLASS;\r\n\r\n    ngOnInit() {\r\n        this.headerSizeClass = this.assignHeaderSizeClass();\r\n    }\r\n\r\n    private assignHeaderSizeClass(): OLO.Components.HEADER_CLASS {\r\n        switch (this.type) {\r\n            case '0': return '-h0';\r\n            case '1': return '-h1';\r\n            case '2': return '-h2';\r\n            case '3': return '-h3';\r\n            case '4': return '-h4';\r\n            case '5': return '-h5';\r\n            case '6': return '-h6';\r\n        }\r\n    }\r\n}\r\n","export * from './icon.shared.module';\r\n","import { Component, OnInit, Input, ChangeDetectionStrategy } from '@angular/core';\r\n\r\n@Component({\r\n    template: `<div>This component requires extending</div>`,\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n})\r\nexport class LoadersComponent implements OnInit {\r\n    @Input() public inverted: boolean = false;\r\n    @Input() public color: string = null;\r\n    @Input() public thickness: number = null;\r\n\r\n    constructor() { }\r\n\r\n    ngOnInit(): void { }\r\n}\r\n","import { Component, OnInit, ChangeDetectionStrategy } from '@angular/core';\r\n\r\nimport { LoadersComponent } from '../../loaders.shared.component';\r\n\r\n@Component({\r\n    selector: 'shared-loader-for-placeholder',\r\n    templateUrl: './loaders-placeholder.shared.component.html',\r\n    styleUrls: ['./loaders-placeholder.shared.component.scss'],\r\n    changeDetection: ChangeDetectionStrategy.OnPush\r\n})\r\nexport class LoadersPlaceholderComponent extends LoadersComponent {\r\n    constructor() {\r\n        super();\r\n    }\r\n}\r\n","<div class=\"loader-for-placeholder\">\r\n    <div class=\"loader-for-placeholder__inner\">\r\n        <div class=\"loader-for-placeholder__content\">\r\n            <ng-content></ng-content>\r\n        </div>\r\n    </div>\r\n</div>","import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { RouterModule } from '@angular/router';\r\nimport { FormsModule } from '@angular/forms';\r\n\r\nimport { MaterialModule } from '@shared/core/modules/material';\r\nimport { IconModule } from '@shared/core/components/icon';\r\n\r\nimport { LinkComponent } from './link.shared.component';\r\n\r\n@NgModule({\r\n    declarations: [\r\n        LinkComponent,\r\n    ],\r\n    imports: [\r\n        CommonModule,\r\n        RouterModule,\r\n        FormsModule,\r\n        MaterialModule,\r\n        IconModule,\r\n    ],\r\n    exports: [\r\n        LinkComponent\r\n    ],\r\n    providers: [],\r\n})\r\nexport class LinkModule { }\r\n","export * from './link.shared.module';\r\n","import { coerceElement, coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';\nimport { Injectable, ɵɵdefineInjectable, ɵɵinject, EventEmitter, Directive, ElementRef, NgZone, Output, Input, NgModule } from '@angular/core';\nimport { Observable, Subject } from 'rxjs';\nimport { debounceTime } from 'rxjs/operators';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/observers/observe-content.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Factory that creates a new MutationObserver and allows us to stub it out in unit tests.\n * \\@docs-private\n */\nimport * as ɵngcc0 from '@angular/core';\nclass MutationObserverFactory {\n    /**\n     * @param {?} callback\n     * @return {?}\n     */\n    create(callback) {\n        return typeof MutationObserver === 'undefined' ? null : new MutationObserver(callback);\n    }\n}\nMutationObserverFactory.ɵfac = function MutationObserverFactory_Factory(t) { return new (t || MutationObserverFactory)(); };\n/** @nocollapse */ MutationObserverFactory.ɵprov = ɵɵdefineInjectable({ factory: function MutationObserverFactory_Factory() { return new MutationObserverFactory(); }, token: MutationObserverFactory, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MutationObserverFactory, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], null, null); })();\n/**\n * An injectable service that allows watching elements for changes to their content.\n */\nclass ContentObserver {\n    /**\n     * @param {?} _mutationObserverFactory\n     */\n    constructor(_mutationObserverFactory) {\n        this._mutationObserverFactory = _mutationObserverFactory;\n        /**\n         * Keeps track of the existing MutationObservers so they can be reused.\n         */\n        this._observedElements = new Map();\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._observedElements.forEach((/**\n         * @param {?} _\n         * @param {?} element\n         * @return {?}\n         */\n        (_, element) => this._cleanupObserver(element)));\n    }\n    /**\n     * @param {?} elementOrRef\n     * @return {?}\n     */\n    observe(elementOrRef) {\n        /** @type {?} */\n        const element = coerceElement(elementOrRef);\n        return new Observable((/**\n         * @param {?} observer\n         * @return {?}\n         */\n        (observer) => {\n            /** @type {?} */\n            const stream = this._observeElement(element);\n            /** @type {?} */\n            const subscription = stream.subscribe(observer);\n            return (/**\n             * @return {?}\n             */\n            () => {\n                subscription.unsubscribe();\n                this._unobserveElement(element);\n            });\n        }));\n    }\n    /**\n     * Observes the given element by using the existing MutationObserver if available, or creating a\n     * new one if not.\n     * @private\n     * @param {?} element\n     * @return {?}\n     */\n    _observeElement(element) {\n        if (!this._observedElements.has(element)) {\n            /** @type {?} */\n            const stream = new Subject();\n            /** @type {?} */\n            const observer = this._mutationObserverFactory.create((/**\n             * @param {?} mutations\n             * @return {?}\n             */\n            mutations => stream.next(mutations)));\n            if (observer) {\n                observer.observe(element, {\n                    characterData: true,\n                    childList: true,\n                    subtree: true\n                });\n            }\n            this._observedElements.set(element, { observer, stream, count: 1 });\n        }\n        else {\n            (/** @type {?} */ (this._observedElements.get(element))).count++;\n        }\n        return (/** @type {?} */ (this._observedElements.get(element))).stream;\n    }\n    /**\n     * Un-observes the given element and cleans up the underlying MutationObserver if nobody else is\n     * observing this element.\n     * @private\n     * @param {?} element\n     * @return {?}\n     */\n    _unobserveElement(element) {\n        if (this._observedElements.has(element)) {\n            (/** @type {?} */ (this._observedElements.get(element))).count--;\n            if (!(/** @type {?} */ (this._observedElements.get(element))).count) {\n                this._cleanupObserver(element);\n            }\n        }\n    }\n    /**\n     * Clean up the underlying MutationObserver for the specified element.\n     * @private\n     * @param {?} element\n     * @return {?}\n     */\n    _cleanupObserver(element) {\n        if (this._observedElements.has(element)) {\n            const { observer, stream } = (/** @type {?} */ (this._observedElements.get(element)));\n            if (observer) {\n                observer.disconnect();\n            }\n            stream.complete();\n            this._observedElements.delete(element);\n        }\n    }\n}\nContentObserver.ɵfac = function ContentObserver_Factory(t) { return new (t || ContentObserver)(ɵngcc0.ɵɵinject(MutationObserverFactory)); };\n/** @nocollapse */\nContentObserver.ctorParameters = () => [\n    { type: MutationObserverFactory }\n];\n/** @nocollapse */ ContentObserver.ɵprov = ɵɵdefineInjectable({ factory: function ContentObserver_Factory() { return new ContentObserver(ɵɵinject(MutationObserverFactory)); }, token: ContentObserver, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(ContentObserver, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: MutationObserverFactory }]; }, null); })();\nif (false) {\n    /**\n     * Keeps track of the existing MutationObservers so they can be reused.\n     * @type {?}\n     * @private\n     */\n    ContentObserver.prototype._observedElements;\n    /**\n     * @type {?}\n     * @private\n     */\n    ContentObserver.prototype._mutationObserverFactory;\n}\n/**\n * Directive that triggers a callback whenever the content of\n * its associated element has changed.\n */\nclass CdkObserveContent {\n    /**\n     * @param {?} _contentObserver\n     * @param {?} _elementRef\n     * @param {?} _ngZone\n     */\n    constructor(_contentObserver, _elementRef, _ngZone) {\n        this._contentObserver = _contentObserver;\n        this._elementRef = _elementRef;\n        this._ngZone = _ngZone;\n        /**\n         * Event emitted for each change in the element's content.\n         */\n        this.event = new EventEmitter();\n        this._disabled = false;\n        this._currentSubscription = null;\n    }\n    /**\n     * Whether observing content is disabled. This option can be used\n     * to disconnect the underlying MutationObserver until it is needed.\n     * @return {?}\n     */\n    get disabled() { return this._disabled; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set disabled(value) {\n        this._disabled = coerceBooleanProperty(value);\n        this._disabled ? this._unsubscribe() : this._subscribe();\n    }\n    /**\n     * Debounce interval for emitting the changes.\n     * @return {?}\n     */\n    get debounce() { return this._debounce; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set debounce(value) {\n        this._debounce = coerceNumberProperty(value);\n        this._subscribe();\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterContentInit() {\n        if (!this._currentSubscription && !this.disabled) {\n            this._subscribe();\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._unsubscribe();\n    }\n    /**\n     * @private\n     * @return {?}\n     */\n    _subscribe() {\n        this._unsubscribe();\n        /** @type {?} */\n        const stream = this._contentObserver.observe(this._elementRef);\n        // TODO(mmalerba): We shouldn't be emitting on this @Output() outside the zone.\n        // Consider brining it back inside the zone next time we're making breaking changes.\n        // Bringing it back inside can cause things like infinite change detection loops and changed\n        // after checked errors if people's code isn't handling it properly.\n        this._ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => {\n            this._currentSubscription =\n                (this.debounce ? stream.pipe(debounceTime(this.debounce)) : stream).subscribe(this.event);\n        }));\n    }\n    /**\n     * @private\n     * @return {?}\n     */\n    _unsubscribe() {\n        if (this._currentSubscription) {\n            this._currentSubscription.unsubscribe();\n        }\n    }\n}\nCdkObserveContent.ɵfac = function CdkObserveContent_Factory(t) { return new (t || CdkObserveContent)(ɵngcc0.ɵɵdirectiveInject(ContentObserver), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone)); };\nCdkObserveContent.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: CdkObserveContent, selectors: [[\"\", \"cdkObserveContent\", \"\"]], inputs: { disabled: [\"cdkObserveContentDisabled\", \"disabled\"], debounce: \"debounce\" }, outputs: { event: \"cdkObserveContent\" }, exportAs: [\"cdkObserveContent\"] });\n/** @nocollapse */\nCdkObserveContent.ctorParameters = () => [\n    { type: ContentObserver },\n    { type: ElementRef },\n    { type: NgZone }\n];\nCdkObserveContent.propDecorators = {\n    event: [{ type: Output, args: ['cdkObserveContent',] }],\n    disabled: [{ type: Input, args: ['cdkObserveContentDisabled',] }],\n    debounce: [{ type: Input }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(CdkObserveContent, [{\n        type: Directive,\n        args: [{\n                selector: '[cdkObserveContent]',\n                exportAs: 'cdkObserveContent'\n            }]\n    }], function () { return [{ type: ContentObserver }, { type: ɵngcc0.ElementRef }, { type: ɵngcc0.NgZone }]; }, { event: [{\n            type: Output,\n            args: ['cdkObserveContent']\n        }], disabled: [{\n            type: Input,\n            args: ['cdkObserveContentDisabled']\n        }], debounce: [{\n            type: Input\n        }] }); })();\nif (false) {\n    /** @type {?} */\n    CdkObserveContent.ngAcceptInputType_disabled;\n    /** @type {?} */\n    CdkObserveContent.ngAcceptInputType_debounce;\n    /**\n     * Event emitted for each change in the element's content.\n     * @type {?}\n     */\n    CdkObserveContent.prototype.event;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkObserveContent.prototype._disabled;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkObserveContent.prototype._debounce;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkObserveContent.prototype._currentSubscription;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkObserveContent.prototype._contentObserver;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkObserveContent.prototype._elementRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkObserveContent.prototype._ngZone;\n}\nclass ObserversModule {\n}\nObserversModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: ObserversModule });\nObserversModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function ObserversModule_Factory(t) { return new (t || ObserversModule)(); }, providers: [MutationObserverFactory] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(ObserversModule, { declarations: [CdkObserveContent], exports: [CdkObserveContent] }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(ObserversModule, [{\n        type: NgModule,\n        args: [{\n                exports: [CdkObserveContent],\n                declarations: [CdkObserveContent],\n                providers: [MutationObserverFactory]\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/observers/public-api.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 { CdkObserveContent, ContentObserver, MutationObserverFactory, ObserversModule };\n\n//# sourceMappingURL=observers.js.map","import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\n\r\nimport { LoadersModule } from '@shared/core/components/loaders';\r\n\r\nimport { HComponent } from './h.shared.component';\r\n\r\n@NgModule({\r\n    declarations: [\r\n        HComponent\r\n    ],\r\n    imports: [\r\n        CommonModule,\r\n        LoadersModule,\r\n    ],\r\n    exports: [\r\n        HComponent\r\n    ],\r\n    providers: [],\r\n})\r\nexport class HModule { }\r\n","import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\n\r\nimport { LoadersModule } from '@shared/core/components/loaders';\r\nimport { HModule } from '../h/h.shared.module';\r\n\r\nimport { HeaderComponent } from './header.shared.component';\r\n\r\n@NgModule({\r\n    declarations: [\r\n        HeaderComponent,\r\n    ],\r\n    imports: [\r\n        CommonModule,\r\n        HModule,\r\n        LoadersModule,\r\n    ],\r\n    exports: [\r\n        HeaderComponent,\r\n    ],\r\n    providers: [],\r\n})\r\nexport class HeaderModule { }\r\n","import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\n\r\nimport { HeaderModule } from '../header/header.shared.module';\r\nimport { EmphasisTextModule } from '@shared/core/components/emphasisText';\r\nimport { LinkModule } from '@shared/core/components/link';\r\n\r\nimport { HeroHeaderComponent } from './hero-header.shared.component';\r\n\r\n@NgModule({\r\n    declarations: [\r\n        HeroHeaderComponent\r\n    ],\r\n    imports: [\r\n        CommonModule,\r\n        HeaderModule,\r\n        EmphasisTextModule,\r\n        LinkModule,\r\n    ],\r\n    exports: [\r\n        HeroHeaderComponent\r\n    ],\r\n    providers: [\r\n    ],\r\n})\r\nexport class HeroHeaderModule { }\r\n","import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\n\r\nimport { HModule } from './h/h.shared.module';\r\nimport { HeroHeaderModule } from './heroHeader';\r\nimport { HeaderModule } from './header/header.shared.module';\r\n\r\n@NgModule({\r\n    declarations: [],\r\n    imports: [\r\n        CommonModule,\r\n        HModule,\r\n        HeaderModule,\r\n        HeroHeaderModule,\r\n    ],\r\n    exports: [\r\n        HModule,\r\n        HeaderModule,\r\n        HeroHeaderModule,\r\n    ],\r\n    providers: [],\r\n})\r\nexport class HeadersModule { }\r\n","export * from './headers.shared.module';\r\nexport * from './h/h.shared.component';\r\n","import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\n\r\nimport { LoadersCheckmarkComponent } from './loaders-checkmark.shared.component';\r\n\r\n@NgModule({\r\n    declarations: [\r\n        LoadersCheckmarkComponent,\r\n    ],\r\n    imports: [CommonModule],\r\n    exports: [\r\n        LoadersCheckmarkComponent,\r\n    ],\r\n    providers: [],\r\n})\r\nexport class LoadersCheckmarkModule { }\r\n","import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\n\r\nimport { LoadersErrorComponent } from './loaders-error.shared.component';\r\n\r\n@NgModule({\r\n    declarations: [\r\n        LoadersErrorComponent\r\n    ],\r\n    imports: [CommonModule],\r\n    exports: [\r\n        LoadersErrorComponent\r\n    ],\r\n    providers: [],\r\n})\r\nexport class LoadersErrorModule { }\r\n","import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\n\r\nimport { LoadersPlaceholderComponent } from './loaders-placeholder.shared.component';\r\n\r\n@NgModule({\r\n    declarations: [\r\n        LoadersPlaceholderComponent\r\n    ],\r\n    imports: [CommonModule],\r\n    exports: [\r\n        LoadersPlaceholderComponent\r\n    ],\r\n    providers: [],\r\n})\r\nexport class LoadersPlaceholderModule { }\r\n","import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\n\r\nimport { LoadersPlaceholderModule } from './forPlaceholder';\r\nimport { LoadersForSpinnerModule } from './forSpinner';\r\n\r\n@NgModule({\r\n    declarations: [],\r\n    imports: [\r\n        CommonModule,\r\n        LoadersPlaceholderModule,\r\n        LoadersForSpinnerModule,\r\n    ],\r\n    exports: [\r\n        LoadersPlaceholderModule,\r\n        LoadersForSpinnerModule,\r\n    ],\r\n    providers: [],\r\n})\r\nexport class LoadersTypesModule { }\r\n","import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\n\r\nimport { LoadersCheckmarkModule } from './loadersCheckmark';\r\nimport { LoadersErrorModule } from './loadersError';\r\nimport { LoadersTypesModule } from './loadersTypes';\r\n\r\nimport { LoadersComponent } from './loaders.shared.component';\r\n\r\nconst toExport: any[] = [\r\n    LoadersCheckmarkModule,\r\n    LoadersErrorModule,\r\n    LoadersTypesModule,\r\n];\r\n\r\n@NgModule({\r\n    declarations: [\r\n        LoadersComponent\r\n    ],\r\n    imports: [\r\n        CommonModule,\r\n        ...toExport,\r\n    ],\r\n    exports: [\r\n        LoadersComponent,\r\n        ...toExport,\r\n    ],\r\n    providers: [],\r\n})\r\nexport class LoadersModule { }\r\n","export * from './loaders.shared.module';\r\n","import { SecurityContext, Injectable, Optional, Inject, ErrorHandler, ɵɵdefineInjectable, ɵɵinject, SkipSelf, InjectionToken, inject, Component, ViewEncapsulation, ChangeDetectionStrategy, ElementRef, Attribute, Input, NgModule } from '@angular/core';\nimport { mixinColor, MatCommonModule } from '@angular/material/core';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { DOCUMENT } from '@angular/common';\nimport { tap, map, catchError, finalize, share, take } from 'rxjs/operators';\nimport { HttpClient } from '@angular/common/http';\nimport { DomSanitizer } from '@angular/platform-browser';\nimport { of, throwError, forkJoin } from 'rxjs';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/icon/icon-registry.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Returns an exception to be thrown in the case when attempting to\n * load an icon with a name that cannot be found.\n * \\@docs-private\n * @param {?} iconName\n * @return {?}\n */\nimport * as ɵngcc0 from '@angular/core';\nimport * as ɵngcc1 from '@angular/common/http';\nimport * as ɵngcc2 from '@angular/platform-browser';\n\nconst _c0 = [\"*\"];\nfunction getMatIconNameNotFoundError(iconName) {\n    return Error(`Unable to find icon with the name \"${iconName}\"`);\n}\n/**\n * Returns an exception to be thrown when the consumer attempts to use\n * `<mat-icon>` without including \\@angular/common/http.\n * \\@docs-private\n * @return {?}\n */\nfunction getMatIconNoHttpProviderError() {\n    return Error('Could not find HttpClient provider for use with Angular Material icons. ' +\n        'Please include the HttpClientModule from @angular/common/http in your ' +\n        'app imports.');\n}\n/**\n * Returns an exception to be thrown when a URL couldn't be sanitized.\n * \\@docs-private\n * @param {?} url URL that was attempted to be sanitized.\n * @return {?}\n */\nfunction getMatIconFailedToSanitizeUrlError(url) {\n    return Error(`The URL provided to MatIconRegistry was not trusted as a resource URL ` +\n        `via Angular's DomSanitizer. Attempted URL was \"${url}\".`);\n}\n/**\n * Returns an exception to be thrown when a HTML string couldn't be sanitized.\n * \\@docs-private\n * @param {?} literal HTML that was attempted to be sanitized.\n * @return {?}\n */\nfunction getMatIconFailedToSanitizeLiteralError(literal) {\n    return Error(`The literal provided to MatIconRegistry was not trusted as safe HTML by ` +\n        `Angular's DomSanitizer. Attempted literal was \"${literal}\".`);\n}\n/**\n * Options that can be used to configure how an icon or the icons in an icon set are presented.\n * @record\n */\nfunction IconOptions() { }\nif (false) {\n    /**\n     * View box to set on the icon.\n     * @type {?|undefined}\n     */\n    IconOptions.prototype.viewBox;\n}\n/**\n * Configuration for an icon, including the URL and possibly the cached SVG element.\n * \\@docs-private\n */\nclass SvgIconConfig {\n    /**\n     * @param {?} data\n     * @param {?=} options\n     */\n    constructor(data, options) {\n        this.options = options;\n        // Note that we can't use `instanceof SVGElement` here,\n        // because it'll break during server-side rendering.\n        if (!!((/** @type {?} */ (data))).nodeName) {\n            this.svgElement = (/** @type {?} */ (data));\n        }\n        else {\n            this.url = (/** @type {?} */ (data));\n        }\n    }\n}\nif (false) {\n    /** @type {?} */\n    SvgIconConfig.prototype.url;\n    /** @type {?} */\n    SvgIconConfig.prototype.svgElement;\n    /** @type {?} */\n    SvgIconConfig.prototype.options;\n}\n/**\n * Service to register and display icons used by the `<mat-icon>` component.\n * - Registers icon URLs by namespace and name.\n * - Registers icon set URLs by namespace.\n * - Registers aliases for CSS classes, for use with icon fonts.\n * - Loads icons from URLs and extracts individual icons from icon sets.\n */\nclass MatIconRegistry {\n    /**\n     * @param {?} _httpClient\n     * @param {?} _sanitizer\n     * @param {?} document\n     * @param {?=} _errorHandler\n     */\n    constructor(_httpClient, _sanitizer, document, _errorHandler) {\n        this._httpClient = _httpClient;\n        this._sanitizer = _sanitizer;\n        this._errorHandler = _errorHandler;\n        /**\n         * URLs and cached SVG elements for individual icons. Keys are of the format \"[namespace]:[icon]\".\n         */\n        this._svgIconConfigs = new Map();\n        /**\n         * SvgIconConfig objects and cached SVG elements for icon sets, keyed by namespace.\n         * Multiple icon sets can be registered under the same namespace.\n         */\n        this._iconSetConfigs = new Map();\n        /**\n         * Cache for icons loaded by direct URLs.\n         */\n        this._cachedIconsByUrl = new Map();\n        /**\n         * In-progress icon fetches. Used to coalesce multiple requests to the same URL.\n         */\n        this._inProgressUrlFetches = new Map();\n        /**\n         * Map from font identifiers to their CSS class names. Used for icon fonts.\n         */\n        this._fontCssClassesByAlias = new Map();\n        /**\n         * The CSS class to apply when an `<mat-icon>` component has no icon name, url, or font specified.\n         * The default 'material-icons' value assumes that the material icon font has been loaded as\n         * described at http://google.github.io/material-design-icons/#icon-font-for-the-web\n         */\n        this._defaultFontSetClass = 'material-icons';\n        this._document = document;\n    }\n    /**\n     * Registers an icon by URL in the default namespace.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} iconName Name under which the icon should be registered.\n     * @param {?} url\n     * @param {?=} options\n     * @return {THIS}\n     */\n    addSvgIcon(iconName, url, options) {\n        return (/** @type {?} */ (this)).addSvgIconInNamespace('', iconName, url, options);\n    }\n    /**\n     * Registers an icon using an HTML string in the default namespace.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} iconName Name under which the icon should be registered.\n     * @param {?} literal SVG source of the icon.\n     * @param {?=} options\n     * @return {THIS}\n     */\n    addSvgIconLiteral(iconName, literal, options) {\n        return (/** @type {?} */ (this)).addSvgIconLiteralInNamespace('', iconName, literal, options);\n    }\n    /**\n     * Registers an icon by URL in the specified namespace.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} namespace Namespace in which the icon should be registered.\n     * @param {?} iconName Name under which the icon should be registered.\n     * @param {?} url\n     * @param {?=} options\n     * @return {THIS}\n     */\n    addSvgIconInNamespace(namespace, iconName, url, options) {\n        return (/** @type {?} */ (this))._addSvgIconConfig(namespace, iconName, new SvgIconConfig(url, options));\n    }\n    /**\n     * Registers an icon using an HTML string in the specified namespace.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} namespace Namespace in which the icon should be registered.\n     * @param {?} iconName Name under which the icon should be registered.\n     * @param {?} literal SVG source of the icon.\n     * @param {?=} options\n     * @return {THIS}\n     */\n    addSvgIconLiteralInNamespace(namespace, iconName, literal, options) {\n        /** @type {?} */\n        const sanitizedLiteral = (/** @type {?} */ (this))._sanitizer.sanitize(SecurityContext.HTML, literal);\n        if (!sanitizedLiteral) {\n            throw getMatIconFailedToSanitizeLiteralError(literal);\n        }\n        /** @type {?} */\n        const svgElement = (/** @type {?} */ (this))._createSvgElementForSingleIcon(sanitizedLiteral, options);\n        return (/** @type {?} */ (this))._addSvgIconConfig(namespace, iconName, new SvgIconConfig(svgElement, options));\n    }\n    /**\n     * Registers an icon set by URL in the default namespace.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} url\n     * @param {?=} options\n     * @return {THIS}\n     */\n    addSvgIconSet(url, options) {\n        return (/** @type {?} */ (this)).addSvgIconSetInNamespace('', url, options);\n    }\n    /**\n     * Registers an icon set using an HTML string in the default namespace.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} literal SVG source of the icon set.\n     * @param {?=} options\n     * @return {THIS}\n     */\n    addSvgIconSetLiteral(literal, options) {\n        return (/** @type {?} */ (this)).addSvgIconSetLiteralInNamespace('', literal, options);\n    }\n    /**\n     * Registers an icon set by URL in the specified namespace.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} namespace Namespace in which to register the icon set.\n     * @param {?} url\n     * @param {?=} options\n     * @return {THIS}\n     */\n    addSvgIconSetInNamespace(namespace, url, options) {\n        return (/** @type {?} */ (this))._addSvgIconSetConfig(namespace, new SvgIconConfig(url, options));\n    }\n    /**\n     * Registers an icon set using an HTML string in the specified namespace.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} namespace Namespace in which to register the icon set.\n     * @param {?} literal SVG source of the icon set.\n     * @param {?=} options\n     * @return {THIS}\n     */\n    addSvgIconSetLiteralInNamespace(namespace, literal, options) {\n        /** @type {?} */\n        const sanitizedLiteral = (/** @type {?} */ (this))._sanitizer.sanitize(SecurityContext.HTML, literal);\n        if (!sanitizedLiteral) {\n            throw getMatIconFailedToSanitizeLiteralError(literal);\n        }\n        /** @type {?} */\n        const svgElement = (/** @type {?} */ (this))._svgElementFromString(sanitizedLiteral);\n        return (/** @type {?} */ (this))._addSvgIconSetConfig(namespace, new SvgIconConfig(svgElement, options));\n    }\n    /**\n     * Defines an alias for a CSS class name to be used for icon fonts. Creating an matIcon\n     * component with the alias as the fontSet input will cause the class name to be applied\n     * to the `<mat-icon>` element.\n     *\n     * @template THIS\n     * @this {THIS}\n     * @param {?} alias Alias for the font.\n     * @param {?=} className Class name override to be used instead of the alias.\n     * @return {THIS}\n     */\n    registerFontClassAlias(alias, className = alias) {\n        (/** @type {?} */ (this))._fontCssClassesByAlias.set(alias, className);\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Returns the CSS class name associated with the alias by a previous call to\n     * registerFontClassAlias. If no CSS class has been associated, returns the alias unmodified.\n     * @param {?} alias\n     * @return {?}\n     */\n    classNameForFontAlias(alias) {\n        return this._fontCssClassesByAlias.get(alias) || alias;\n    }\n    /**\n     * Sets the CSS class name to be used for icon fonts when an `<mat-icon>` component does not\n     * have a fontSet input value, and is not loading an icon by name or URL.\n     *\n     * @template THIS\n     * @this {THIS}\n     * @param {?} className\n     * @return {THIS}\n     */\n    setDefaultFontSetClass(className) {\n        (/** @type {?} */ (this))._defaultFontSetClass = className;\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Returns the CSS class name to be used for icon fonts when an `<mat-icon>` component does not\n     * have a fontSet input value, and is not loading an icon by name or URL.\n     * @return {?}\n     */\n    getDefaultFontSetClass() {\n        return this._defaultFontSetClass;\n    }\n    /**\n     * Returns an Observable that produces the icon (as an `<svg>` DOM element) from the given URL.\n     * The response from the URL may be cached so this will not always cause an HTTP request, but\n     * the produced element will always be a new copy of the originally fetched icon. (That is,\n     * it will not contain any modifications made to elements previously returned).\n     *\n     * @param {?} safeUrl URL from which to fetch the SVG icon.\n     * @return {?}\n     */\n    getSvgIconFromUrl(safeUrl) {\n        /** @type {?} */\n        const url = this._sanitizer.sanitize(SecurityContext.RESOURCE_URL, safeUrl);\n        if (!url) {\n            throw getMatIconFailedToSanitizeUrlError(safeUrl);\n        }\n        /** @type {?} */\n        const cachedIcon = this._cachedIconsByUrl.get(url);\n        if (cachedIcon) {\n            return of(cloneSvg(cachedIcon));\n        }\n        return this._loadSvgIconFromConfig(new SvgIconConfig(safeUrl)).pipe(tap((/**\n         * @param {?} svg\n         * @return {?}\n         */\n        svg => this._cachedIconsByUrl.set((/** @type {?} */ (url)), svg))), map((/**\n         * @param {?} svg\n         * @return {?}\n         */\n        svg => cloneSvg(svg))));\n    }\n    /**\n     * Returns an Observable that produces the icon (as an `<svg>` DOM element) with the given name\n     * and namespace. The icon must have been previously registered with addIcon or addIconSet;\n     * if not, the Observable will throw an error.\n     *\n     * @param {?} name Name of the icon to be retrieved.\n     * @param {?=} namespace Namespace in which to look for the icon.\n     * @return {?}\n     */\n    getNamedSvgIcon(name, namespace = '') {\n        // Return (copy of) cached icon if possible.\n        /** @type {?} */\n        const key = iconKey(namespace, name);\n        /** @type {?} */\n        const config = this._svgIconConfigs.get(key);\n        if (config) {\n            return this._getSvgFromConfig(config);\n        }\n        // See if we have any icon sets registered for the namespace.\n        /** @type {?} */\n        const iconSetConfigs = this._iconSetConfigs.get(namespace);\n        if (iconSetConfigs) {\n            return this._getSvgFromIconSetConfigs(name, iconSetConfigs);\n        }\n        return throwError(getMatIconNameNotFoundError(key));\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._svgIconConfigs.clear();\n        this._iconSetConfigs.clear();\n        this._cachedIconsByUrl.clear();\n    }\n    /**\n     * Returns the cached icon for a SvgIconConfig if available, or fetches it from its URL if not.\n     * @private\n     * @param {?} config\n     * @return {?}\n     */\n    _getSvgFromConfig(config) {\n        if (config.svgElement) {\n            // We already have the SVG element for this icon, return a copy.\n            return of(cloneSvg(config.svgElement));\n        }\n        else {\n            // Fetch the icon from the config's URL, cache it, and return a copy.\n            return this._loadSvgIconFromConfig(config).pipe(tap((/**\n             * @param {?} svg\n             * @return {?}\n             */\n            svg => config.svgElement = svg)), map((/**\n             * @param {?} svg\n             * @return {?}\n             */\n            svg => cloneSvg(svg))));\n        }\n    }\n    /**\n     * Attempts to find an icon with the specified name in any of the SVG icon sets.\n     * First searches the available cached icons for a nested element with a matching name, and\n     * if found copies the element to a new `<svg>` element. If not found, fetches all icon sets\n     * that have not been cached, and searches again after all fetches are completed.\n     * The returned Observable produces the SVG element if possible, and throws\n     * an error if no icon with the specified name can be found.\n     * @private\n     * @param {?} name\n     * @param {?} iconSetConfigs\n     * @return {?}\n     */\n    _getSvgFromIconSetConfigs(name, iconSetConfigs) {\n        // For all the icon set SVG elements we've fetched, see if any contain an icon with the\n        // requested name.\n        /** @type {?} */\n        const namedIcon = this._extractIconWithNameFromAnySet(name, iconSetConfigs);\n        if (namedIcon) {\n            // We could cache namedIcon in _svgIconConfigs, but since we have to make a copy every\n            // time anyway, there's probably not much advantage compared to just always extracting\n            // it from the icon set.\n            return of(namedIcon);\n        }\n        // Not found in any cached icon sets. If there are icon sets with URLs that we haven't\n        // fetched, fetch them now and look for iconName in the results.\n        /** @type {?} */\n        const iconSetFetchRequests = iconSetConfigs\n            .filter((/**\n         * @param {?} iconSetConfig\n         * @return {?}\n         */\n        iconSetConfig => !iconSetConfig.svgElement))\n            .map((/**\n         * @param {?} iconSetConfig\n         * @return {?}\n         */\n        iconSetConfig => {\n            return this._loadSvgIconSetFromConfig(iconSetConfig).pipe(catchError((/**\n             * @param {?} err\n             * @return {?}\n             */\n            (err) => {\n                /** @type {?} */\n                const url = this._sanitizer.sanitize(SecurityContext.RESOURCE_URL, iconSetConfig.url);\n                // Swallow errors fetching individual URLs so the\n                // combined Observable won't necessarily fail.\n                /** @type {?} */\n                const errorMessage = `Loading icon set URL: ${url} failed: ${err.message}`;\n                // @breaking-change 9.0.0 _errorHandler parameter to be made required\n                if (this._errorHandler) {\n                    this._errorHandler.handleError(new Error(errorMessage));\n                }\n                else {\n                    console.error(errorMessage);\n                }\n                return of(null);\n            })));\n        }));\n        // Fetch all the icon set URLs. When the requests complete, every IconSet should have a\n        // cached SVG element (unless the request failed), and we can check again for the icon.\n        return forkJoin(iconSetFetchRequests).pipe(map((/**\n         * @return {?}\n         */\n        () => {\n            /** @type {?} */\n            const foundIcon = this._extractIconWithNameFromAnySet(name, iconSetConfigs);\n            if (!foundIcon) {\n                throw getMatIconNameNotFoundError(name);\n            }\n            return foundIcon;\n        })));\n    }\n    /**\n     * Searches the cached SVG elements for the given icon sets for a nested icon element whose \"id\"\n     * tag matches the specified name. If found, copies the nested element to a new SVG element and\n     * returns it. Returns null if no matching element is found.\n     * @private\n     * @param {?} iconName\n     * @param {?} iconSetConfigs\n     * @return {?}\n     */\n    _extractIconWithNameFromAnySet(iconName, iconSetConfigs) {\n        // Iterate backwards, so icon sets added later have precedence.\n        for (let i = iconSetConfigs.length - 1; i >= 0; i--) {\n            /** @type {?} */\n            const config = iconSetConfigs[i];\n            if (config.svgElement) {\n                /** @type {?} */\n                const foundIcon = this._extractSvgIconFromSet(config.svgElement, iconName, config.options);\n                if (foundIcon) {\n                    return foundIcon;\n                }\n            }\n        }\n        return null;\n    }\n    /**\n     * Loads the content of the icon URL specified in the SvgIconConfig and creates an SVG element\n     * from it.\n     * @private\n     * @param {?} config\n     * @return {?}\n     */\n    _loadSvgIconFromConfig(config) {\n        return this._fetchUrl(config.url)\n            .pipe(map((/**\n         * @param {?} svgText\n         * @return {?}\n         */\n        svgText => this._createSvgElementForSingleIcon(svgText, config.options))));\n    }\n    /**\n     * Loads the content of the icon set URL specified in the SvgIconConfig and creates an SVG element\n     * from it.\n     * @private\n     * @param {?} config\n     * @return {?}\n     */\n    _loadSvgIconSetFromConfig(config) {\n        // If the SVG for this icon set has already been parsed, do nothing.\n        if (config.svgElement) {\n            return of(config.svgElement);\n        }\n        return this._fetchUrl(config.url).pipe(map((/**\n         * @param {?} svgText\n         * @return {?}\n         */\n        svgText => {\n            // It is possible that the icon set was parsed and cached by an earlier request, so parsing\n            // only needs to occur if the cache is yet unset.\n            if (!config.svgElement) {\n                config.svgElement = this._svgElementFromString(svgText);\n            }\n            return config.svgElement;\n        })));\n    }\n    /**\n     * Creates a DOM element from the given SVG string, and adds default attributes.\n     * @private\n     * @param {?} responseText\n     * @param {?=} options\n     * @return {?}\n     */\n    _createSvgElementForSingleIcon(responseText, options) {\n        /** @type {?} */\n        const svg = this._svgElementFromString(responseText);\n        this._setSvgAttributes(svg, options);\n        return svg;\n    }\n    /**\n     * Searches the cached element of the given SvgIconConfig for a nested icon element whose \"id\"\n     * tag matches the specified name. If found, copies the nested element to a new SVG element and\n     * returns it. Returns null if no matching element is found.\n     * @private\n     * @param {?} iconSet\n     * @param {?} iconName\n     * @param {?=} options\n     * @return {?}\n     */\n    _extractSvgIconFromSet(iconSet, iconName, options) {\n        // Use the `id=\"iconName\"` syntax in order to escape special\n        // characters in the ID (versus using the #iconName syntax).\n        /** @type {?} */\n        const iconSource = iconSet.querySelector(`[id=\"${iconName}\"]`);\n        if (!iconSource) {\n            return null;\n        }\n        // Clone the element and remove the ID to prevent multiple elements from being added\n        // to the page with the same ID.\n        /** @type {?} */\n        const iconElement = (/** @type {?} */ (iconSource.cloneNode(true)));\n        iconElement.removeAttribute('id');\n        // If the icon node is itself an <svg> node, clone and return it directly. If not, set it as\n        // the content of a new <svg> node.\n        if (iconElement.nodeName.toLowerCase() === 'svg') {\n            return this._setSvgAttributes((/** @type {?} */ (iconElement)), options);\n        }\n        // If the node is a <symbol>, it won't be rendered so we have to convert it into <svg>. Note\n        // that the same could be achieved by referring to it via <use href=\"#id\">, however the <use>\n        // tag is problematic on Firefox, because it needs to include the current page path.\n        if (iconElement.nodeName.toLowerCase() === 'symbol') {\n            return this._setSvgAttributes(this._toSvgElement(iconElement), options);\n        }\n        // createElement('SVG') doesn't work as expected; the DOM ends up with\n        // the correct nodes, but the SVG content doesn't render. Instead we\n        // have to create an empty SVG node using innerHTML and append its content.\n        // Elements created using DOMParser.parseFromString have the same problem.\n        // http://stackoverflow.com/questions/23003278/svg-innerhtml-in-firefox-can-not-display\n        /** @type {?} */\n        const svg = this._svgElementFromString('<svg></svg>');\n        // Clone the node so we don't remove it from the parent icon set element.\n        svg.appendChild(iconElement);\n        return this._setSvgAttributes(svg, options);\n    }\n    /**\n     * Creates a DOM element from the given SVG string.\n     * @private\n     * @param {?} str\n     * @return {?}\n     */\n    _svgElementFromString(str) {\n        /** @type {?} */\n        const div = this._document.createElement('DIV');\n        div.innerHTML = str;\n        /** @type {?} */\n        const svg = (/** @type {?} */ (div.querySelector('svg')));\n        if (!svg) {\n            throw Error('<svg> tag not found');\n        }\n        return svg;\n    }\n    /**\n     * Converts an element into an SVG node by cloning all of its children.\n     * @private\n     * @param {?} element\n     * @return {?}\n     */\n    _toSvgElement(element) {\n        /** @type {?} */\n        const svg = this._svgElementFromString('<svg></svg>');\n        /** @type {?} */\n        const attributes = element.attributes;\n        // Copy over all the attributes from the `symbol` to the new SVG, except the id.\n        for (let i = 0; i < attributes.length; i++) {\n            const { name, value } = attributes[i];\n            if (name !== 'id') {\n                svg.setAttribute(name, value);\n            }\n        }\n        for (let i = 0; i < element.childNodes.length; i++) {\n            if (element.childNodes[i].nodeType === this._document.ELEMENT_NODE) {\n                svg.appendChild(element.childNodes[i].cloneNode(true));\n            }\n        }\n        return svg;\n    }\n    /**\n     * Sets the default attributes for an SVG element to be used as an icon.\n     * @private\n     * @param {?} svg\n     * @param {?=} options\n     * @return {?}\n     */\n    _setSvgAttributes(svg, options) {\n        svg.setAttribute('fit', '');\n        svg.setAttribute('height', '100%');\n        svg.setAttribute('width', '100%');\n        svg.setAttribute('preserveAspectRatio', 'xMidYMid meet');\n        svg.setAttribute('focusable', 'false'); // Disable IE11 default behavior to make SVGs focusable.\n        if (options && options.viewBox) {\n            svg.setAttribute('viewBox', options.viewBox);\n        }\n        return svg;\n    }\n    /**\n     * Returns an Observable which produces the string contents of the given URL. Results may be\n     * cached, so future calls with the same URL may not cause another HTTP request.\n     * @private\n     * @param {?} safeUrl\n     * @return {?}\n     */\n    _fetchUrl(safeUrl) {\n        if (!this._httpClient) {\n            throw getMatIconNoHttpProviderError();\n        }\n        if (safeUrl == null) {\n            throw Error(`Cannot fetch icon from URL \"${safeUrl}\".`);\n        }\n        /** @type {?} */\n        const url = this._sanitizer.sanitize(SecurityContext.RESOURCE_URL, safeUrl);\n        if (!url) {\n            throw getMatIconFailedToSanitizeUrlError(safeUrl);\n        }\n        // Store in-progress fetches to avoid sending a duplicate request for a URL when there is\n        // already a request in progress for that URL. It's necessary to call share() on the\n        // Observable returned by http.get() so that multiple subscribers don't cause multiple XHRs.\n        /** @type {?} */\n        const inProgressFetch = this._inProgressUrlFetches.get(url);\n        if (inProgressFetch) {\n            return inProgressFetch;\n        }\n        // TODO(jelbourn): for some reason, the `finalize` operator \"loses\" the generic type on the\n        // Observable. Figure out why and fix it.\n        /** @type {?} */\n        const req = this._httpClient.get(url, { responseType: 'text' }).pipe(finalize((/**\n         * @return {?}\n         */\n        () => this._inProgressUrlFetches.delete(url))), share());\n        this._inProgressUrlFetches.set(url, req);\n        return req;\n    }\n    /**\n     * Registers an icon config by name in the specified namespace.\n     * @private\n     * @template THIS\n     * @this {THIS}\n     * @param {?} namespace Namespace in which to register the icon config.\n     * @param {?} iconName Name under which to register the config.\n     * @param {?} config Config to be registered.\n     * @return {THIS}\n     */\n    _addSvgIconConfig(namespace, iconName, config) {\n        (/** @type {?} */ (this))._svgIconConfigs.set(iconKey(namespace, iconName), config);\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Registers an icon set config in the specified namespace.\n     * @private\n     * @template THIS\n     * @this {THIS}\n     * @param {?} namespace Namespace in which to register the icon config.\n     * @param {?} config Config to be registered.\n     * @return {THIS}\n     */\n    _addSvgIconSetConfig(namespace, config) {\n        /** @type {?} */\n        const configNamespace = (/** @type {?} */ (this))._iconSetConfigs.get(namespace);\n        if (configNamespace) {\n            configNamespace.push(config);\n        }\n        else {\n            (/** @type {?} */ (this))._iconSetConfigs.set(namespace, [config]);\n        }\n        return (/** @type {?} */ (this));\n    }\n}\nMatIconRegistry.ɵfac = function MatIconRegistry_Factory(t) { return new (t || MatIconRegistry)(ɵngcc0.ɵɵinject(ɵngcc1.HttpClient, 8), ɵngcc0.ɵɵinject(ɵngcc2.DomSanitizer), ɵngcc0.ɵɵinject(DOCUMENT, 8), ɵngcc0.ɵɵinject(ɵngcc0.ErrorHandler, 8)); };\n/** @nocollapse */\nMatIconRegistry.ctorParameters = () => [\n    { type: HttpClient, decorators: [{ type: Optional }] },\n    { type: DomSanitizer },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] },\n    { type: ErrorHandler, decorators: [{ type: Optional }] }\n];\n/** @nocollapse */ MatIconRegistry.ɵprov = ɵɵdefineInjectable({ factory: function MatIconRegistry_Factory() { return new MatIconRegistry(ɵɵinject(HttpClient, 8), ɵɵinject(DomSanitizer), ɵɵinject(DOCUMENT, 8), ɵɵinject(ErrorHandler, 8)); }, token: MatIconRegistry, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatIconRegistry, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: ɵngcc1.HttpClient, decorators: [{\n                type: Optional\n            }] }, { type: ɵngcc2.DomSanitizer }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [DOCUMENT]\n            }] }, { type: ɵngcc0.ErrorHandler, decorators: [{\n                type: Optional\n            }] }]; }, null); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    MatIconRegistry.prototype._document;\n    /**\n     * URLs and cached SVG elements for individual icons. Keys are of the format \"[namespace]:[icon]\".\n     * @type {?}\n     * @private\n     */\n    MatIconRegistry.prototype._svgIconConfigs;\n    /**\n     * SvgIconConfig objects and cached SVG elements for icon sets, keyed by namespace.\n     * Multiple icon sets can be registered under the same namespace.\n     * @type {?}\n     * @private\n     */\n    MatIconRegistry.prototype._iconSetConfigs;\n    /**\n     * Cache for icons loaded by direct URLs.\n     * @type {?}\n     * @private\n     */\n    MatIconRegistry.prototype._cachedIconsByUrl;\n    /**\n     * In-progress icon fetches. Used to coalesce multiple requests to the same URL.\n     * @type {?}\n     * @private\n     */\n    MatIconRegistry.prototype._inProgressUrlFetches;\n    /**\n     * Map from font identifiers to their CSS class names. Used for icon fonts.\n     * @type {?}\n     * @private\n     */\n    MatIconRegistry.prototype._fontCssClassesByAlias;\n    /**\n     * The CSS class to apply when an `<mat-icon>` component has no icon name, url, or font specified.\n     * The default 'material-icons' value assumes that the material icon font has been loaded as\n     * described at http://google.github.io/material-design-icons/#icon-font-for-the-web\n     * @type {?}\n     * @private\n     */\n    MatIconRegistry.prototype._defaultFontSetClass;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatIconRegistry.prototype._httpClient;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatIconRegistry.prototype._sanitizer;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatIconRegistry.prototype._errorHandler;\n}\n/**\n * \\@docs-private\n * @param {?} parentRegistry\n * @param {?} httpClient\n * @param {?} sanitizer\n * @param {?=} document\n * @param {?=} errorHandler\n * @return {?}\n */\nfunction ICON_REGISTRY_PROVIDER_FACTORY(parentRegistry, httpClient, sanitizer, document, errorHandler) {\n    return parentRegistry || new MatIconRegistry(httpClient, sanitizer, document, errorHandler);\n}\n/**\n * \\@docs-private\n * @type {?}\n */\nconst ICON_REGISTRY_PROVIDER = {\n    // If there is already an MatIconRegistry available, use that. Otherwise, provide a new one.\n    provide: MatIconRegistry,\n    deps: [\n        [new Optional(), new SkipSelf(), MatIconRegistry],\n        [new Optional(), HttpClient],\n        DomSanitizer,\n        [new Optional(), ErrorHandler],\n        [new Optional(), (/** @type {?} */ (DOCUMENT))],\n    ],\n    useFactory: ICON_REGISTRY_PROVIDER_FACTORY,\n};\n/**\n * Clones an SVGElement while preserving type information.\n * @param {?} svg\n * @return {?}\n */\nfunction cloneSvg(svg) {\n    return (/** @type {?} */ (svg.cloneNode(true)));\n}\n/**\n * Returns the cache key to use for an icon namespace and name.\n * @param {?} namespace\n * @param {?} name\n * @return {?}\n */\nfunction iconKey(namespace, name) {\n    return namespace + ':' + name;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/icon/icon.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n// Boilerplate for applying mixins to MatIcon.\n/**\n * \\@docs-private\n */\nclass MatIconBase {\n    /**\n     * @param {?} _elementRef\n     */\n    constructor(_elementRef) {\n        this._elementRef = _elementRef;\n    }\n}\nif (false) {\n    /** @type {?} */\n    MatIconBase.prototype._elementRef;\n}\n/** @type {?} */\nconst _MatIconMixinBase = mixinColor(MatIconBase);\n/**\n * Injection token used to provide the current location to `MatIcon`.\n * Used to handle server-side rendering and to stub out during unit tests.\n * \\@docs-private\n * @type {?}\n */\nconst MAT_ICON_LOCATION = new InjectionToken('mat-icon-location', {\n    providedIn: 'root',\n    factory: MAT_ICON_LOCATION_FACTORY\n});\n/**\n * Stubbed out location for `MatIcon`.\n * \\@docs-private\n * @record\n */\nfunction MatIconLocation() { }\nif (false) {\n    /** @type {?} */\n    MatIconLocation.prototype.getPathname;\n}\n/**\n * \\@docs-private\n * @return {?}\n */\nfunction MAT_ICON_LOCATION_FACTORY() {\n    /** @type {?} */\n    const _document = inject(DOCUMENT);\n    /** @type {?} */\n    const _location = _document ? _document.location : null;\n    return {\n        // Note that this needs to be a function, rather than a property, because Angular\n        // will only resolve it once, but we want the current path on each call.\n        getPathname: (/**\n         * @return {?}\n         */\n        () => _location ? (_location.pathname + _location.search) : '')\n    };\n}\n/**\n * SVG attributes that accept a FuncIRI (e.g. `url(<something>)`).\n * @type {?}\n */\nconst funcIriAttributes = [\n    'clip-path',\n    'color-profile',\n    'src',\n    'cursor',\n    'fill',\n    'filter',\n    'marker',\n    'marker-start',\n    'marker-mid',\n    'marker-end',\n    'mask',\n    'stroke'\n];\nconst ɵ0 = /**\n * @param {?} attr\n * @return {?}\n */\nattr => `[${attr}]`;\n/**\n * Selector that can be used to find all elements that are using a `FuncIRI`.\n * @type {?}\n */\nconst funcIriAttributeSelector = funcIriAttributes.map((ɵ0)).join(', ');\n/**\n * Regex that can be used to extract the id out of a FuncIRI.\n * @type {?}\n */\nconst funcIriPattern = /^url\\(['\"]?#(.*?)['\"]?\\)$/;\n/**\n * Component to display an icon. It can be used in the following ways:\n *\n * - Specify the svgIcon input to load an SVG icon from a URL previously registered with the\n *   addSvgIcon, addSvgIconInNamespace, addSvgIconSet, or addSvgIconSetInNamespace methods of\n *   MatIconRegistry. If the svgIcon value contains a colon it is assumed to be in the format\n *   \"[namespace]:[name]\", if not the value will be the name of an icon in the default namespace.\n *   Examples:\n *     `<mat-icon svgIcon=\"left-arrow\"></mat-icon>\n *     <mat-icon svgIcon=\"animals:cat\"></mat-icon>`\n *\n * - Use a font ligature as an icon by putting the ligature text in the content of the `<mat-icon>`\n *   component. By default the Material icons font is used as described at\n *   http://google.github.io/material-design-icons/#icon-font-for-the-web. You can specify an\n *   alternate font by setting the fontSet input to either the CSS class to apply to use the\n *   desired font, or to an alias previously registered with MatIconRegistry.registerFontClassAlias.\n *   Examples:\n *     `<mat-icon>home</mat-icon>\n *     <mat-icon fontSet=\"myfont\">sun</mat-icon>`\n *\n * - Specify a font glyph to be included via CSS rules by setting the fontSet input to specify the\n *   font, and the fontIcon input to specify the icon. Typically the fontIcon will specify a\n *   CSS class which causes the glyph to be displayed via a :before selector, as in\n *   https://fortawesome.github.io/Font-Awesome/examples/\n *   Example:\n *     `<mat-icon fontSet=\"fa\" fontIcon=\"alarm\"></mat-icon>`\n */\nclass MatIcon extends _MatIconMixinBase {\n    /**\n     * @param {?} elementRef\n     * @param {?} _iconRegistry\n     * @param {?} ariaHidden\n     * @param {?=} _location\n     * @param {?=} _errorHandler\n     */\n    constructor(elementRef, _iconRegistry, ariaHidden, _location, _errorHandler) {\n        super(elementRef);\n        this._iconRegistry = _iconRegistry;\n        this._location = _location;\n        this._errorHandler = _errorHandler;\n        this._inline = false;\n        // If the user has not explicitly set aria-hidden, mark the icon as hidden, as this is\n        // the right thing to do for the majority of icon use-cases.\n        if (!ariaHidden) {\n            elementRef.nativeElement.setAttribute('aria-hidden', 'true');\n        }\n    }\n    /**\n     * Whether the icon should be inlined, automatically sizing the icon to match the font size of\n     * the element the icon is contained in.\n     * @return {?}\n     */\n    get inline() {\n        return this._inline;\n    }\n    /**\n     * @param {?} inline\n     * @return {?}\n     */\n    set inline(inline) {\n        this._inline = coerceBooleanProperty(inline);\n    }\n    /**\n     * Font set that the icon is a part of.\n     * @return {?}\n     */\n    get fontSet() { return this._fontSet; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set fontSet(value) {\n        this._fontSet = this._cleanupFontValue(value);\n    }\n    /**\n     * Name of an icon within a font set.\n     * @return {?}\n     */\n    get fontIcon() { return this._fontIcon; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set fontIcon(value) {\n        this._fontIcon = this._cleanupFontValue(value);\n    }\n    /**\n     * Splits an svgIcon binding value into its icon set and icon name components.\n     * Returns a 2-element array of [(icon set), (icon name)].\n     * The separator for the two fields is ':'. If there is no separator, an empty\n     * string is returned for the icon set and the entire value is returned for\n     * the icon name. If the argument is falsy, returns an array of two empty strings.\n     * Throws an error if the name contains two or more ':' separators.\n     * Examples:\n     *   `'social:cake' -> ['social', 'cake']\n     *   'penguin' -> ['', 'penguin']\n     *   null -> ['', '']\n     *   'a:b:c' -> (throws Error)`\n     * @private\n     * @param {?} iconName\n     * @return {?}\n     */\n    _splitIconName(iconName) {\n        if (!iconName) {\n            return ['', ''];\n        }\n        /** @type {?} */\n        const parts = iconName.split(':');\n        switch (parts.length) {\n            case 1: return ['', parts[0]]; // Use default namespace.\n            case 2: return (/** @type {?} */ (parts));\n            default: throw Error(`Invalid icon name: \"${iconName}\"`);\n        }\n    }\n    /**\n     * @param {?} changes\n     * @return {?}\n     */\n    ngOnChanges(changes) {\n        // Only update the inline SVG icon if the inputs changed, to avoid unnecessary DOM operations.\n        /** @type {?} */\n        const svgIconChanges = changes['svgIcon'];\n        if (svgIconChanges) {\n            if (this.svgIcon) {\n                const [namespace, iconName] = this._splitIconName(this.svgIcon);\n                this._iconRegistry.getNamedSvgIcon(iconName, namespace)\n                    .pipe(take(1))\n                    .subscribe((/**\n                 * @param {?} svg\n                 * @return {?}\n                 */\n                svg => this._setSvgElement(svg)), (/**\n                 * @param {?} err\n                 * @return {?}\n                 */\n                (err) => {\n                    /** @type {?} */\n                    const errorMessage = `Error retrieving icon ${namespace}:${iconName}! ${err.message}`;\n                    // @breaking-change 9.0.0 _errorHandler parameter to be made required.\n                    if (this._errorHandler) {\n                        this._errorHandler.handleError(new Error(errorMessage));\n                    }\n                    else {\n                        console.error(errorMessage);\n                    }\n                }));\n            }\n            else if (svgIconChanges.previousValue) {\n                this._clearSvgElement();\n            }\n        }\n        if (this._usingFontIcon()) {\n            this._updateFontIconClasses();\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngOnInit() {\n        // Update font classes because ngOnChanges won't be called if none of the inputs are present,\n        // e.g. <mat-icon>arrow</mat-icon> In this case we need to add a CSS class for the default font.\n        if (this._usingFontIcon()) {\n            this._updateFontIconClasses();\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterViewChecked() {\n        /** @type {?} */\n        const cachedElements = this._elementsWithExternalReferences;\n        if (cachedElements && this._location && cachedElements.size) {\n            /** @type {?} */\n            const newPath = this._location.getPathname();\n            // We need to check whether the URL has changed on each change detection since\n            // the browser doesn't have an API that will let us react on link clicks and\n            // we can't depend on the Angular router. The references need to be updated,\n            // because while most browsers don't care whether the URL is correct after\n            // the first render, Safari will break if the user navigates to a different\n            // page and the SVG isn't re-rendered.\n            if (newPath !== this._previousPath) {\n                this._previousPath = newPath;\n                this._prependPathToReferences(newPath);\n            }\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        if (this._elementsWithExternalReferences) {\n            this._elementsWithExternalReferences.clear();\n        }\n    }\n    /**\n     * @private\n     * @return {?}\n     */\n    _usingFontIcon() {\n        return !this.svgIcon;\n    }\n    /**\n     * @private\n     * @param {?} svg\n     * @return {?}\n     */\n    _setSvgElement(svg) {\n        this._clearSvgElement();\n        // Workaround for IE11 and Edge ignoring `style` tags inside dynamically-created SVGs.\n        // See: https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/10898469/\n        // Do this before inserting the element into the DOM, in order to avoid a style recalculation.\n        /** @type {?} */\n        const styleTags = (/** @type {?} */ (svg.querySelectorAll('style')));\n        for (let i = 0; i < styleTags.length; i++) {\n            styleTags[i].textContent += ' ';\n        }\n        // Note: we do this fix here, rather than the icon registry, because the\n        // references have to point to the URL at the time that the icon was created.\n        if (this._location) {\n            /** @type {?} */\n            const path = this._location.getPathname();\n            this._previousPath = path;\n            this._cacheChildrenWithExternalReferences(svg);\n            this._prependPathToReferences(path);\n        }\n        this._elementRef.nativeElement.appendChild(svg);\n    }\n    /**\n     * @private\n     * @return {?}\n     */\n    _clearSvgElement() {\n        /** @type {?} */\n        const layoutElement = this._elementRef.nativeElement;\n        /** @type {?} */\n        let childCount = layoutElement.childNodes.length;\n        if (this._elementsWithExternalReferences) {\n            this._elementsWithExternalReferences.clear();\n        }\n        // Remove existing non-element child nodes and SVGs, and add the new SVG element. Note that\n        // we can't use innerHTML, because IE will throw if the element has a data binding.\n        while (childCount--) {\n            /** @type {?} */\n            const child = layoutElement.childNodes[childCount];\n            // 1 corresponds to Node.ELEMENT_NODE. We remove all non-element nodes in order to get rid\n            // of any loose text nodes, as well as any SVG elements in order to remove any old icons.\n            if (child.nodeType !== 1 || child.nodeName.toLowerCase() === 'svg') {\n                layoutElement.removeChild(child);\n            }\n        }\n    }\n    /**\n     * @private\n     * @return {?}\n     */\n    _updateFontIconClasses() {\n        if (!this._usingFontIcon()) {\n            return;\n        }\n        /** @type {?} */\n        const elem = this._elementRef.nativeElement;\n        /** @type {?} */\n        const fontSetClass = this.fontSet ?\n            this._iconRegistry.classNameForFontAlias(this.fontSet) :\n            this._iconRegistry.getDefaultFontSetClass();\n        if (fontSetClass != this._previousFontSetClass) {\n            if (this._previousFontSetClass) {\n                elem.classList.remove(this._previousFontSetClass);\n            }\n            if (fontSetClass) {\n                elem.classList.add(fontSetClass);\n            }\n            this._previousFontSetClass = fontSetClass;\n        }\n        if (this.fontIcon != this._previousFontIconClass) {\n            if (this._previousFontIconClass) {\n                elem.classList.remove(this._previousFontIconClass);\n            }\n            if (this.fontIcon) {\n                elem.classList.add(this.fontIcon);\n            }\n            this._previousFontIconClass = this.fontIcon;\n        }\n    }\n    /**\n     * Cleans up a value to be used as a fontIcon or fontSet.\n     * Since the value ends up being assigned as a CSS class, we\n     * have to trim the value and omit space-separated values.\n     * @private\n     * @param {?} value\n     * @return {?}\n     */\n    _cleanupFontValue(value) {\n        return typeof value === 'string' ? value.trim().split(' ')[0] : value;\n    }\n    /**\n     * Prepends the current path to all elements that have an attribute pointing to a `FuncIRI`\n     * reference. This is required because WebKit browsers require references to be prefixed with\n     * the current path, if the page has a `base` tag.\n     * @private\n     * @param {?} path\n     * @return {?}\n     */\n    _prependPathToReferences(path) {\n        /** @type {?} */\n        const elements = this._elementsWithExternalReferences;\n        if (elements) {\n            elements.forEach((/**\n             * @param {?} attrs\n             * @param {?} element\n             * @return {?}\n             */\n            (attrs, element) => {\n                attrs.forEach((/**\n                 * @param {?} attr\n                 * @return {?}\n                 */\n                attr => {\n                    element.setAttribute(attr.name, `url('${path}#${attr.value}')`);\n                }));\n            }));\n        }\n    }\n    /**\n     * Caches the children of an SVG element that have `url()`\n     * references that we need to prefix with the current path.\n     * @private\n     * @param {?} element\n     * @return {?}\n     */\n    _cacheChildrenWithExternalReferences(element) {\n        /** @type {?} */\n        const elementsWithFuncIri = element.querySelectorAll(funcIriAttributeSelector);\n        /** @type {?} */\n        const elements = this._elementsWithExternalReferences =\n            this._elementsWithExternalReferences || new Map();\n        for (let i = 0; i < elementsWithFuncIri.length; i++) {\n            funcIriAttributes.forEach((/**\n             * @param {?} attr\n             * @return {?}\n             */\n            attr => {\n                /** @type {?} */\n                const elementWithReference = elementsWithFuncIri[i];\n                /** @type {?} */\n                const value = elementWithReference.getAttribute(attr);\n                /** @type {?} */\n                const match = value ? value.match(funcIriPattern) : null;\n                if (match) {\n                    /** @type {?} */\n                    let attributes = elements.get(elementWithReference);\n                    if (!attributes) {\n                        attributes = [];\n                        elements.set(elementWithReference, attributes);\n                    }\n                    (/** @type {?} */ (attributes)).push({ name: attr, value: match[1] });\n                }\n            }));\n        }\n    }\n}\nMatIcon.ɵfac = function MatIcon_Factory(t) { return new (t || MatIcon)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(MatIconRegistry), ɵngcc0.ɵɵinjectAttribute('aria-hidden'), ɵngcc0.ɵɵdirectiveInject(MAT_ICON_LOCATION, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ErrorHandler, 8)); };\nMatIcon.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatIcon, selectors: [[\"mat-icon\"]], hostAttrs: [\"role\", \"img\", 1, \"mat-icon\", \"notranslate\"], hostVars: 4, hostBindings: function MatIcon_HostBindings(rf, ctx) { if (rf & 2) {\n        ɵngcc0.ɵɵclassProp(\"mat-icon-inline\", ctx.inline)(\"mat-icon-no-color\", ctx.color !== \"primary\" && ctx.color !== \"accent\" && ctx.color !== \"warn\");\n    } }, inputs: { color: \"color\", inline: \"inline\", fontSet: \"fontSet\", fontIcon: \"fontIcon\", svgIcon: \"svgIcon\" }, exportAs: [\"matIcon\"], features: [ɵngcc0.ɵɵInheritDefinitionFeature, ɵngcc0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function MatIcon_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵprojectionDef();\n        ɵngcc0.ɵɵprojection(0);\n    } }, styles: [\".mat-icon{background-repeat:no-repeat;display:inline-block;fill:currentColor;height:24px;width:24px}.mat-icon.mat-icon-inline{font-size:inherit;height:inherit;line-height:inherit;width:inherit}[dir=rtl] .mat-icon-rtl-mirror{transform:scale(-1, 1)}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon{display:block}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button .mat-icon{margin:auto}\\n\"], encapsulation: 2, changeDetection: 0 });\n/** @nocollapse */\nMatIcon.ctorParameters = () => [\n    { type: ElementRef },\n    { type: MatIconRegistry },\n    { type: String, decorators: [{ type: Attribute, args: ['aria-hidden',] }] },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_ICON_LOCATION,] }] },\n    { type: ErrorHandler, decorators: [{ type: Optional }] }\n];\nMatIcon.propDecorators = {\n    inline: [{ type: Input }],\n    svgIcon: [{ type: Input }],\n    fontSet: [{ type: Input }],\n    fontIcon: [{ type: Input }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatIcon, [{\n        type: Component,\n        args: [{\n                template: '<ng-content></ng-content>',\n                selector: 'mat-icon',\n                exportAs: 'matIcon',\n                inputs: ['color'],\n                host: {\n                    'role': 'img',\n                    'class': 'mat-icon notranslate',\n                    '[class.mat-icon-inline]': 'inline',\n                    '[class.mat-icon-no-color]': 'color !== \"primary\" && color !== \"accent\" && color !== \"warn\"'\n                },\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush,\n                styles: [\".mat-icon{background-repeat:no-repeat;display:inline-block;fill:currentColor;height:24px;width:24px}.mat-icon.mat-icon-inline{font-size:inherit;height:inherit;line-height:inherit;width:inherit}[dir=rtl] .mat-icon-rtl-mirror{transform:scale(-1, 1)}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon{display:block}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button .mat-icon{margin:auto}\\n\"]\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: MatIconRegistry }, { type: String, decorators: [{\n                type: Attribute,\n                args: ['aria-hidden']\n            }] }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MAT_ICON_LOCATION]\n            }] }, { type: ɵngcc0.ErrorHandler, decorators: [{\n                type: Optional\n            }] }]; }, { inline: [{\n            type: Input\n        }], fontSet: [{\n            type: Input\n        }], fontIcon: [{\n            type: Input\n        }], svgIcon: [{\n            type: Input\n        }] }); })();\nif (false) {\n    /** @type {?} */\n    MatIcon.ngAcceptInputType_inline;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatIcon.prototype._inline;\n    /**\n     * Name of the icon in the SVG icon set.\n     * @type {?}\n     */\n    MatIcon.prototype.svgIcon;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatIcon.prototype._fontSet;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatIcon.prototype._fontIcon;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatIcon.prototype._previousFontSetClass;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatIcon.prototype._previousFontIconClass;\n    /**\n     * Keeps track of the current page path.\n     * @type {?}\n     * @private\n     */\n    MatIcon.prototype._previousPath;\n    /**\n     * Keeps track of the elements and attributes that we've prefixed with the current path.\n     * @type {?}\n     * @private\n     */\n    MatIcon.prototype._elementsWithExternalReferences;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatIcon.prototype._iconRegistry;\n    /**\n     * @deprecated `location` parameter to be made required.\n     * \\@breaking-change 8.0.0\n     * @type {?}\n     * @private\n     */\n    MatIcon.prototype._location;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatIcon.prototype._errorHandler;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/icon/icon-module.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass MatIconModule {\n}\nMatIconModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: MatIconModule });\nMatIconModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function MatIconModule_Factory(t) { return new (t || MatIconModule)(); }, imports: [[MatCommonModule],\n        MatCommonModule] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(MatIconModule, { declarations: function () { return [MatIcon]; }, imports: function () { return [MatCommonModule]; }, exports: function () { return [MatIcon,\n        MatCommonModule]; } }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatIconModule, [{\n        type: NgModule,\n        args: [{\n                imports: [MatCommonModule],\n                exports: [MatIcon, MatCommonModule],\n                declarations: [MatIcon]\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/icon/public-api.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 { ICON_REGISTRY_PROVIDER, ICON_REGISTRY_PROVIDER_FACTORY, MAT_ICON_LOCATION, MAT_ICON_LOCATION_FACTORY, MatIcon, MatIconModule, MatIconRegistry, getMatIconFailedToSanitizeLiteralError, getMatIconFailedToSanitizeUrlError, getMatIconNameNotFoundError, getMatIconNoHttpProviderError };\n\n//# sourceMappingURL=icon.js.map","import { Injectable, Optional, Inject, PLATFORM_ID, ɵɵdefineInjectable, ɵɵinject, NgModule } from '@angular/core';\nimport { isPlatformBrowser } from '@angular/common';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/platform/platform.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n// Whether the current platform supports the V8 Break Iterator. The V8 check\n// is necessary to detect all Blink based browsers.\n/** @type {?} */\nimport * as ɵngcc0 from '@angular/core';\nlet hasV8BreakIterator;\n// We need a try/catch around the reference to `Intl`, because accessing it in some cases can\n// cause IE to throw. These cases are tied to particular versions of Windows and can happen if\n// the consumer is providing a polyfilled `Map`. See:\n// https://github.com/Microsoft/ChakraCore/issues/3189\n// https://github.com/angular/components/issues/15687\ntry {\n    hasV8BreakIterator = (typeof Intl !== 'undefined' && ((/** @type {?} */ (Intl))).v8BreakIterator);\n}\ncatch (_a) {\n    hasV8BreakIterator = false;\n}\n/**\n * Service to detect the current platform by comparing the userAgent strings and\n * checking browser-specific global properties.\n */\nclass Platform {\n    /**\n     * \\@breaking-change 8.0.0 remove optional decorator\n     * @param {?=} _platformId\n     */\n    constructor(_platformId) {\n        this._platformId = _platformId;\n        // We want to use the Angular platform check because if the Document is shimmed\n        // without the navigator, the following checks will fail. This is preferred because\n        // sometimes the Document may be shimmed without the user's knowledge or intention\n        /**\n         * Whether the Angular application is being rendered in the browser.\n         */\n        this.isBrowser = this._platformId ?\n            isPlatformBrowser(this._platformId) : typeof document === 'object' && !!document;\n        /**\n         * Whether the current browser is Microsoft Edge.\n         */\n        this.EDGE = this.isBrowser && /(edge)/i.test(navigator.userAgent);\n        /**\n         * Whether the current rendering engine is Microsoft Trident.\n         */\n        this.TRIDENT = this.isBrowser && /(msie|trident)/i.test(navigator.userAgent);\n        // EdgeHTML and Trident mock Blink specific things and need to be excluded from this check.\n        /**\n         * Whether the current rendering engine is Blink.\n         */\n        this.BLINK = this.isBrowser && (!!(((/** @type {?} */ (window))).chrome || hasV8BreakIterator) &&\n            typeof CSS !== 'undefined' && !this.EDGE && !this.TRIDENT);\n        // Webkit is part of the userAgent in EdgeHTML, Blink and Trident. Therefore we need to\n        // ensure that Webkit runs standalone and is not used as another engine's base.\n        /**\n         * Whether the current rendering engine is WebKit.\n         */\n        this.WEBKIT = this.isBrowser &&\n            /AppleWebKit/i.test(navigator.userAgent) && !this.BLINK && !this.EDGE && !this.TRIDENT;\n        /**\n         * Whether the current platform is Apple iOS.\n         */\n        this.IOS = this.isBrowser && /iPad|iPhone|iPod/.test(navigator.userAgent) &&\n            !('MSStream' in window);\n        // It's difficult to detect the plain Gecko engine, because most of the browsers identify\n        // them self as Gecko-like browsers and modify the userAgent's according to that.\n        // Since we only cover one explicit Firefox case, we can simply check for Firefox\n        // instead of having an unstable check for Gecko.\n        /**\n         * Whether the current browser is Firefox.\n         */\n        this.FIREFOX = this.isBrowser && /(firefox|minefield)/i.test(navigator.userAgent);\n        /**\n         * Whether the current platform is Android.\n         */\n        // Trident on mobile adds the android platform to the userAgent to trick detections.\n        this.ANDROID = this.isBrowser && /android/i.test(navigator.userAgent) && !this.TRIDENT;\n        // Safari browsers will include the Safari keyword in their userAgent. Some browsers may fake\n        // this and just place the Safari keyword in the userAgent. To be more safe about Safari every\n        // Safari browser should also use Webkit as its layout engine.\n        /**\n         * Whether the current browser is Safari.\n         */\n        this.SAFARI = this.isBrowser && /safari/i.test(navigator.userAgent) && this.WEBKIT;\n    }\n}\nPlatform.ɵfac = function Platform_Factory(t) { return new (t || Platform)(ɵngcc0.ɵɵinject(PLATFORM_ID, 8)); };\n/** @nocollapse */\nPlatform.ctorParameters = () => [\n    { type: Object, decorators: [{ type: Optional }, { type: Inject, args: [PLATFORM_ID,] }] }\n];\n/** @nocollapse */ Platform.ɵprov = ɵɵdefineInjectable({ factory: function Platform_Factory() { return new Platform(ɵɵinject(PLATFORM_ID, 8)); }, token: Platform, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(Platform, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: Object, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [PLATFORM_ID]\n            }] }]; }, null); })();\nif (false) {\n    /**\n     * Whether the Angular application is being rendered in the browser.\n     * @type {?}\n     */\n    Platform.prototype.isBrowser;\n    /**\n     * Whether the current browser is Microsoft Edge.\n     * @type {?}\n     */\n    Platform.prototype.EDGE;\n    /**\n     * Whether the current rendering engine is Microsoft Trident.\n     * @type {?}\n     */\n    Platform.prototype.TRIDENT;\n    /**\n     * Whether the current rendering engine is Blink.\n     * @type {?}\n     */\n    Platform.prototype.BLINK;\n    /**\n     * Whether the current rendering engine is WebKit.\n     * @type {?}\n     */\n    Platform.prototype.WEBKIT;\n    /**\n     * Whether the current platform is Apple iOS.\n     * @type {?}\n     */\n    Platform.prototype.IOS;\n    /**\n     * Whether the current browser is Firefox.\n     * @type {?}\n     */\n    Platform.prototype.FIREFOX;\n    /**\n     * Whether the current platform is Android.\n     * @type {?}\n     */\n    Platform.prototype.ANDROID;\n    /**\n     * Whether the current browser is Safari.\n     * @type {?}\n     */\n    Platform.prototype.SAFARI;\n    /**\n     * @type {?}\n     * @private\n     */\n    Platform.prototype._platformId;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/platform/platform-module.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass PlatformModule {\n}\nPlatformModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: PlatformModule });\nPlatformModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function PlatformModule_Factory(t) { return new (t || PlatformModule)(); } });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(PlatformModule, [{\n        type: NgModule,\n        args: [{}]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/platform/features/input-types.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 * Cached result Set of input types support by the current browser.\n * @type {?}\n */\nlet supportedInputTypes;\n/**\n * Types of `<input>` that *might* be supported.\n * @type {?}\n */\nconst candidateInputTypes = [\n    // `color` must come first. Chrome 56 shows a warning if we change the type to `color` after\n    // first changing it to something else:\n    // The specified value \"\" does not conform to the required format.\n    // The format is \"#rrggbb\" where rr, gg, bb are two-digit hexadecimal numbers.\n    'color',\n    'button',\n    'checkbox',\n    'date',\n    'datetime-local',\n    'email',\n    'file',\n    'hidden',\n    'image',\n    'month',\n    'number',\n    'password',\n    'radio',\n    'range',\n    'reset',\n    'search',\n    'submit',\n    'tel',\n    'text',\n    'time',\n    'url',\n    'week',\n];\n/**\n * @return {?} The input types supported by this browser.\n */\nfunction getSupportedInputTypes() {\n    // Result is cached.\n    if (supportedInputTypes) {\n        return supportedInputTypes;\n    }\n    // We can't check if an input type is not supported until we're on the browser, so say that\n    // everything is supported when not on the browser. We don't use `Platform` here since it's\n    // just a helper function and can't inject it.\n    if (typeof document !== 'object' || !document) {\n        supportedInputTypes = new Set(candidateInputTypes);\n        return supportedInputTypes;\n    }\n    /** @type {?} */\n    let featureTestInput = document.createElement('input');\n    supportedInputTypes = new Set(candidateInputTypes.filter((/**\n     * @param {?} value\n     * @return {?}\n     */\n    value => {\n        featureTestInput.setAttribute('type', value);\n        return featureTestInput.type === value;\n    })));\n    return supportedInputTypes;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/platform/features/passive-listeners.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 * Cached result of whether the user's browser supports passive event listeners.\n * @type {?}\n */\nlet supportsPassiveEvents;\n/**\n * Checks whether the user's browser supports passive event listeners.\n * See: https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md\n * @return {?}\n */\nfunction supportsPassiveEventListeners() {\n    if (supportsPassiveEvents == null && typeof window !== 'undefined') {\n        try {\n            window.addEventListener('test', (/** @type {?} */ (null)), Object.defineProperty({}, 'passive', {\n                get: (/**\n                 * @return {?}\n                 */\n                () => supportsPassiveEvents = true)\n            }));\n        }\n        finally {\n            supportsPassiveEvents = supportsPassiveEvents || false;\n        }\n    }\n    return supportsPassiveEvents;\n}\n/**\n * Normalizes an `AddEventListener` object to something that can be passed\n * to `addEventListener` on any browser, no matter whether it supports the\n * `options` parameter.\n * @param {?} options Object to be normalized.\n * @return {?}\n */\nfunction normalizePassiveListenerOptions(options) {\n    return supportsPassiveEventListeners() ? options : !!options.capture;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/platform/features/scrolling.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/** @enum {number} */\nconst RtlScrollAxisType = {\n    /**\n     * scrollLeft is 0 when scrolled all the way left and (scrollWidth - clientWidth) when scrolled\n     * all the way right.\n     */\n    NORMAL: 0,\n    /**\n     * scrollLeft is -(scrollWidth - clientWidth) when scrolled all the way left and 0 when scrolled\n     * all the way right.\n     */\n    NEGATED: 1,\n    /**\n     * scrollLeft is (scrollWidth - clientWidth) when scrolled all the way left and 0 when scrolled\n     * all the way right.\n     */\n    INVERTED: 2,\n};\n/**\n * Cached result of the way the browser handles the horizontal scroll axis in RTL mode.\n * @type {?}\n */\nlet rtlScrollAxisType;\n/**\n * Check whether the browser supports scroll behaviors.\n * @return {?}\n */\nfunction supportsScrollBehavior() {\n    return !!(typeof document == 'object' && 'scrollBehavior' in (/** @type {?} */ (document.documentElement)).style);\n}\n/**\n * Checks the type of RTL scroll axis used by this browser. As of time of writing, Chrome is NORMAL,\n * Firefox & Safari are NEGATED, and IE & Edge are INVERTED.\n * @return {?}\n */\nfunction getRtlScrollAxisType() {\n    // We can't check unless we're on the browser. Just assume 'normal' if we're not.\n    if (typeof document !== 'object' || !document) {\n        return 0 /* NORMAL */;\n    }\n    if (rtlScrollAxisType == null) {\n        // Create a 1px wide scrolling container and a 2px wide content element.\n        /** @type {?} */\n        const scrollContainer = document.createElement('div');\n        /** @type {?} */\n        const containerStyle = scrollContainer.style;\n        scrollContainer.dir = 'rtl';\n        containerStyle.height = '1px';\n        containerStyle.width = '1px';\n        containerStyle.overflow = 'auto';\n        containerStyle.visibility = 'hidden';\n        containerStyle.pointerEvents = 'none';\n        containerStyle.position = 'absolute';\n        /** @type {?} */\n        const content = document.createElement('div');\n        /** @type {?} */\n        const contentStyle = content.style;\n        contentStyle.width = '2px';\n        contentStyle.height = '1px';\n        scrollContainer.appendChild(content);\n        document.body.appendChild(scrollContainer);\n        rtlScrollAxisType = 0 /* NORMAL */;\n        // The viewport starts scrolled all the way to the right in RTL mode. If we are in a NORMAL\n        // browser this would mean that the scrollLeft should be 1. If it's zero instead we know we're\n        // dealing with one of the other two types of browsers.\n        if (scrollContainer.scrollLeft === 0) {\n            // In a NEGATED browser the scrollLeft is always somewhere in [-maxScrollAmount, 0]. For an\n            // INVERTED browser it is always somewhere in [0, maxScrollAmount]. We can determine which by\n            // setting to the scrollLeft to 1. This is past the max for a NEGATED browser, so it will\n            // return 0 when we read it again.\n            scrollContainer.scrollLeft = 1;\n            rtlScrollAxisType =\n                scrollContainer.scrollLeft === 0 ? 1 /* NEGATED */ : 2 /* INVERTED */;\n        }\n        (/** @type {?} */ (scrollContainer.parentNode)).removeChild(scrollContainer);\n    }\n    return rtlScrollAxisType;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/platform/features/shadow-dom.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/** @type {?} */\nlet shadowDomIsSupported;\n/**\n * Checks whether the user's browser support Shadow DOM.\n * @return {?}\n */\nfunction _supportsShadowDom() {\n    if (shadowDomIsSupported == null) {\n        /** @type {?} */\n        const head = typeof document !== 'undefined' ? document.head : null;\n        shadowDomIsSupported = !!(head && (((/** @type {?} */ (head))).createShadowRoot || head.attachShadow));\n    }\n    return shadowDomIsSupported;\n}\n/**\n * Gets the shadow root of an element, if supported and the element is inside the Shadow DOM.\n * @param {?} element\n * @return {?}\n */\nfunction _getShadowRoot(element) {\n    if (_supportsShadowDom()) {\n        /** @type {?} */\n        const rootNode = element.getRootNode ? element.getRootNode() : null;\n        // Note that this should be caught by `_supportsShadowDom`, but some\n        // teams have been able to hit this code path on unsupported browsers.\n        if (typeof ShadowRoot !== 'undefined' && ShadowRoot && rootNode instanceof ShadowRoot) {\n            return rootNode;\n        }\n    }\n    return null;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/platform/public-api.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 { Platform, PlatformModule, _getShadowRoot, _supportsShadowDom, getRtlScrollAxisType, getSupportedInputTypes, normalizePassiveListenerOptions, supportsPassiveEventListeners, supportsScrollBehavior };\n\n//# sourceMappingURL=platform.js.map","import { Component, OnInit, Input, TemplateRef, ChangeDetectionStrategy } from '@angular/core';\r\n\r\nimport { HComponent } from '../h/h.shared.component';\r\n\r\n@Component({\r\n    selector: 'shared-header',\r\n    templateUrl: './header.shared.component.html',\r\n    styleUrls: ['./header.shared.component.scss'],\r\n    changeDetection: ChangeDetectionStrategy.OnPush\r\n})\r\nexport class HeaderComponent extends HComponent {\r\n    @Input() public left: TemplateRef<any>;\r\n    @Input() public right: TemplateRef<any>;\r\n}\r\n","<ng-template #content>\r\n    <ng-content></ng-content>\r\n</ng-template>\r\n\r\n<header\r\n    class=\"header{{marginTop ? ' -margin-top-'+marginTop : ''}}{{marginBottom ? ' -margin-bottom-'+marginBottom : ''}}{{paddingTop ? ' -padding-top-'+paddingTop : ''}}{{paddingBottom ? ' -padding-bottom-'+paddingBottom : ''}}\"\r\n    [ngClass]=\"{'has-right-col': right, '-inverted': inverted, '-center': center}\">\r\n    <div class=\"header__inner\">\r\n        <div class=\"header__col -left\" *ngIf=\"left\">\r\n            <ng-container *ngTemplateOutlet=\"left || null\"></ng-container>\r\n        </div>\r\n\r\n        <div class=\"header__col -main\" [ngClass]=\"{'-width-full': !right}\">\r\n            <ng-container *ngIf=\"type\">\r\n                <shared-h [center]=\"center\" [ellipsis]=\"ellipsis\" [loading]=\"loading\" [counter]=\"counter\"\r\n                    [postContent]=\"postContent\" [preContent]=\"preContent\" [type]=\"type\" [inverted]=\"inverted\"\r\n                    [paddingTop]=\"'none'\" [marginTop]=\"'none'\" [marginBottom]=\"'none'\" [brandAccent]=\"brandAccent\">\r\n                    <ng-container *ngTemplateOutlet=\"content\"></ng-container>\r\n                </shared-h>\r\n            </ng-container>\r\n\r\n            <ng-container *ngIf=\"!type\">\r\n                <ng-container *ngTemplateOutlet=\"content\"></ng-container>\r\n            </ng-container>\r\n        </div>\r\n\r\n        <div class=\"header__col -right\" *ngIf=\"right\">\r\n            <ng-container *ngTemplateOutlet=\"right || null\"></ng-container>\r\n        </div>\r\n\r\n    </div>\r\n</header>\r\n","/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/keycodes/keycodes.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/** @type {?} */\nconst MAC_ENTER = 3;\n/** @type {?} */\nconst BACKSPACE = 8;\n/** @type {?} */\nconst TAB = 9;\n/** @type {?} */\nconst NUM_CENTER = 12;\n/** @type {?} */\nconst ENTER = 13;\n/** @type {?} */\nconst SHIFT = 16;\n/** @type {?} */\nconst CONTROL = 17;\n/** @type {?} */\nconst ALT = 18;\n/** @type {?} */\nconst PAUSE = 19;\n/** @type {?} */\nconst CAPS_LOCK = 20;\n/** @type {?} */\nconst ESCAPE = 27;\n/** @type {?} */\nconst SPACE = 32;\n/** @type {?} */\nconst PAGE_UP = 33;\n/** @type {?} */\nconst PAGE_DOWN = 34;\n/** @type {?} */\nconst END = 35;\n/** @type {?} */\nconst HOME = 36;\n/** @type {?} */\nconst LEFT_ARROW = 37;\n/** @type {?} */\nconst UP_ARROW = 38;\n/** @type {?} */\nconst RIGHT_ARROW = 39;\n/** @type {?} */\nconst DOWN_ARROW = 40;\n/** @type {?} */\nconst PLUS_SIGN = 43;\n/** @type {?} */\nconst PRINT_SCREEN = 44;\n/** @type {?} */\nconst INSERT = 45;\n/** @type {?} */\nconst DELETE = 46;\n/** @type {?} */\nconst ZERO = 48;\n/** @type {?} */\nconst ONE = 49;\n/** @type {?} */\nconst TWO = 50;\n/** @type {?} */\nconst THREE = 51;\n/** @type {?} */\nconst FOUR = 52;\n/** @type {?} */\nconst FIVE = 53;\n/** @type {?} */\nconst SIX = 54;\n/** @type {?} */\nconst SEVEN = 55;\n/** @type {?} */\nconst EIGHT = 56;\n/** @type {?} */\nconst NINE = 57;\n/** @type {?} */\nconst FF_SEMICOLON = 59;\n// Firefox (Gecko) fires this for semicolon instead of 186\n/** @type {?} */\nconst FF_EQUALS = 61;\n// Firefox (Gecko) fires this for equals instead of 187\n/** @type {?} */\nconst QUESTION_MARK = 63;\n/** @type {?} */\nconst AT_SIGN = 64;\n/** @type {?} */\nconst A = 65;\n/** @type {?} */\nconst B = 66;\n/** @type {?} */\nconst C = 67;\n/** @type {?} */\nconst D = 68;\n/** @type {?} */\nconst E = 69;\n/** @type {?} */\nconst F = 70;\n/** @type {?} */\nconst G = 71;\n/** @type {?} */\nconst H = 72;\n/** @type {?} */\nconst I = 73;\n/** @type {?} */\nconst J = 74;\n/** @type {?} */\nconst K = 75;\n/** @type {?} */\nconst L = 76;\n/** @type {?} */\nconst M = 77;\n/** @type {?} */\nconst N = 78;\n/** @type {?} */\nconst O = 79;\n/** @type {?} */\nconst P = 80;\n/** @type {?} */\nconst Q = 81;\n/** @type {?} */\nconst R = 82;\n/** @type {?} */\nconst S = 83;\n/** @type {?} */\nconst T = 84;\n/** @type {?} */\nconst U = 85;\n/** @type {?} */\nconst V = 86;\n/** @type {?} */\nconst W = 87;\n/** @type {?} */\nconst X = 88;\n/** @type {?} */\nconst Y = 89;\n/** @type {?} */\nconst Z = 90;\n/** @type {?} */\nconst META = 91;\n// WIN_KEY_LEFT\n/** @type {?} */\nconst MAC_WK_CMD_LEFT = 91;\n/** @type {?} */\nconst MAC_WK_CMD_RIGHT = 93;\n/** @type {?} */\nconst CONTEXT_MENU = 93;\n/** @type {?} */\nconst NUMPAD_ZERO = 96;\n/** @type {?} */\nconst NUMPAD_ONE = 97;\n/** @type {?} */\nconst NUMPAD_TWO = 98;\n/** @type {?} */\nconst NUMPAD_THREE = 99;\n/** @type {?} */\nconst NUMPAD_FOUR = 100;\n/** @type {?} */\nconst NUMPAD_FIVE = 101;\n/** @type {?} */\nconst NUMPAD_SIX = 102;\n/** @type {?} */\nconst NUMPAD_SEVEN = 103;\n/** @type {?} */\nconst NUMPAD_EIGHT = 104;\n/** @type {?} */\nconst NUMPAD_NINE = 105;\n/** @type {?} */\nconst NUMPAD_MULTIPLY = 106;\n/** @type {?} */\nconst NUMPAD_PLUS = 107;\n/** @type {?} */\nconst NUMPAD_MINUS = 109;\n/** @type {?} */\nconst NUMPAD_PERIOD = 110;\n/** @type {?} */\nconst NUMPAD_DIVIDE = 111;\n/** @type {?} */\nconst F1 = 112;\n/** @type {?} */\nconst F2 = 113;\n/** @type {?} */\nconst F3 = 114;\n/** @type {?} */\nconst F4 = 115;\n/** @type {?} */\nconst F5 = 116;\n/** @type {?} */\nconst F6 = 117;\n/** @type {?} */\nconst F7 = 118;\n/** @type {?} */\nconst F8 = 119;\n/** @type {?} */\nconst F9 = 120;\n/** @type {?} */\nconst F10 = 121;\n/** @type {?} */\nconst F11 = 122;\n/** @type {?} */\nconst F12 = 123;\n/** @type {?} */\nconst NUM_LOCK = 144;\n/** @type {?} */\nconst SCROLL_LOCK = 145;\n/** @type {?} */\nconst FIRST_MEDIA = 166;\n/** @type {?} */\nconst FF_MINUS = 173;\n/** @type {?} */\nconst MUTE = 173;\n// Firefox (Gecko) fires 181 for MUTE\n/** @type {?} */\nconst VOLUME_DOWN = 174;\n// Firefox (Gecko) fires 182 for VOLUME_DOWN\n/** @type {?} */\nconst VOLUME_UP = 175;\n// Firefox (Gecko) fires 183 for VOLUME_UP\n/** @type {?} */\nconst FF_MUTE = 181;\n/** @type {?} */\nconst FF_VOLUME_DOWN = 182;\n/** @type {?} */\nconst LAST_MEDIA = 183;\n/** @type {?} */\nconst FF_VOLUME_UP = 183;\n/** @type {?} */\nconst SEMICOLON = 186;\n// Firefox (Gecko) fires 59 for SEMICOLON\n/** @type {?} */\nconst EQUALS = 187;\n// Firefox (Gecko) fires 61 for EQUALS\n/** @type {?} */\nconst COMMA = 188;\n/** @type {?} */\nconst DASH = 189;\n// Firefox (Gecko) fires 173 for DASH/MINUS\n/** @type {?} */\nconst SLASH = 191;\n/** @type {?} */\nconst APOSTROPHE = 192;\n/** @type {?} */\nconst TILDE = 192;\n/** @type {?} */\nconst OPEN_SQUARE_BRACKET = 219;\n/** @type {?} */\nconst BACKSLASH = 220;\n/** @type {?} */\nconst CLOSE_SQUARE_BRACKET = 221;\n/** @type {?} */\nconst SINGLE_QUOTE = 222;\n/** @type {?} */\nconst MAC_META = 224;\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/keycodes/modifiers.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 * Checks whether a modifier key is pressed.\n * @param {?} event Event to be checked.\n * @param {...?} modifiers\n * @return {?}\n */\nfunction hasModifierKey(event, ...modifiers) {\n    if (modifiers.length) {\n        return modifiers.some((/**\n         * @param {?} modifier\n         * @return {?}\n         */\n        modifier => event[modifier]));\n    }\n    return event.altKey || event.shiftKey || event.ctrlKey || event.metaKey;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/keycodes/public-api.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 { A, ALT, APOSTROPHE, AT_SIGN, B, BACKSLASH, BACKSPACE, C, CAPS_LOCK, CLOSE_SQUARE_BRACKET, COMMA, CONTEXT_MENU, CONTROL, D, DASH, DELETE, DOWN_ARROW, E, EIGHT, END, ENTER, EQUALS, ESCAPE, F, F1, F10, F11, F12, F2, F3, F4, F5, F6, F7, F8, F9, FF_EQUALS, FF_MINUS, FF_MUTE, FF_SEMICOLON, FF_VOLUME_DOWN, FF_VOLUME_UP, FIRST_MEDIA, FIVE, FOUR, G, H, HOME, I, INSERT, J, K, L, LAST_MEDIA, LEFT_ARROW, M, MAC_ENTER, MAC_META, MAC_WK_CMD_LEFT, MAC_WK_CMD_RIGHT, META, MUTE, N, NINE, NUMPAD_DIVIDE, NUMPAD_EIGHT, NUMPAD_FIVE, NUMPAD_FOUR, NUMPAD_MINUS, NUMPAD_MULTIPLY, NUMPAD_NINE, NUMPAD_ONE, NUMPAD_PERIOD, NUMPAD_PLUS, NUMPAD_SEVEN, NUMPAD_SIX, NUMPAD_THREE, NUMPAD_TWO, NUMPAD_ZERO, NUM_CENTER, NUM_LOCK, O, ONE, OPEN_SQUARE_BRACKET, P, PAGE_DOWN, PAGE_UP, PAUSE, PLUS_SIGN, PRINT_SCREEN, Q, QUESTION_MARK, R, RIGHT_ARROW, S, SCROLL_LOCK, SEMICOLON, SEVEN, SHIFT, SINGLE_QUOTE, SIX, SLASH, SPACE, T, TAB, THREE, TILDE, TWO, U, UP_ARROW, V, VOLUME_DOWN, VOLUME_UP, W, X, Y, Z, ZERO, hasModifierKey };\n\n//# sourceMappingURL=keycodes.js.map","import { OuterSubscriber } from '../OuterSubscriber';\nimport { subscribeToResult } from '../util/subscribeToResult';\nexport function takeUntil(notifier) {\n    return (source) => source.lift(new TakeUntilOperator(notifier));\n}\nclass TakeUntilOperator {\n    constructor(notifier) {\n        this.notifier = notifier;\n    }\n    call(subscriber, source) {\n        const takeUntilSubscriber = new TakeUntilSubscriber(subscriber);\n        const notifierSubscription = subscribeToResult(takeUntilSubscriber, this.notifier);\n        if (notifierSubscription && !takeUntilSubscriber.seenValue) {\n            takeUntilSubscriber.add(notifierSubscription);\n            return source.subscribe(takeUntilSubscriber);\n        }\n        return takeUntilSubscriber;\n    }\n}\nclass TakeUntilSubscriber extends OuterSubscriber {\n    constructor(destination) {\n        super(destination);\n        this.seenValue = false;\n    }\n    notifyNext(outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        this.seenValue = true;\n        this.complete();\n    }\n    notifyComplete() {\n    }\n}\n//# sourceMappingURL=takeUntil.js.map","import { coerceNumberProperty } from '@angular/cdk/coercion';\nimport { InjectionToken, Directive, forwardRef, Input, Injectable, NgZone, Optional, Inject, ɵɵdefineInjectable, ɵɵinject, ElementRef, Component, ViewEncapsulation, ChangeDetectionStrategy, ChangeDetectorRef, Output, ViewChild, ViewContainerRef, TemplateRef, IterableDiffers, SkipSelf, NgModule } from '@angular/core';\nimport { Subject, of, Observable, fromEvent, merge, animationFrameScheduler, asapScheduler, Subscription, isObservable } from 'rxjs';\nimport { distinctUntilChanged, auditTime, filter, takeUntil, startWith, pairwise, switchMap, shareReplay } from 'rxjs/operators';\nimport { Platform, getRtlScrollAxisType, supportsScrollBehavior, PlatformModule } from '@angular/cdk/platform';\nimport { DOCUMENT } from '@angular/common';\nimport { Directionality, BidiModule } from '@angular/cdk/bidi';\nimport { isDataSource, ArrayDataSource } from '@angular/cdk/collections';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/scrolling/virtual-scroll-strategy.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * The injection token used to specify the virtual scrolling strategy.\n * @type {?}\n */\nimport * as ɵngcc0 from '@angular/core';\nimport * as ɵngcc1 from '@angular/cdk/platform';\nimport * as ɵngcc2 from '@angular/cdk/bidi';\n\nconst _c0 = [\"contentWrapper\"];\nconst _c1 = [\"*\"];\nconst VIRTUAL_SCROLL_STRATEGY = new InjectionToken('VIRTUAL_SCROLL_STRATEGY');\n/**\n * A strategy that dictates which items should be rendered in the viewport.\n * @record\n */\nfunction VirtualScrollStrategy() { }\nif (false) {\n    /**\n     * Emits when the index of the first element visible in the viewport changes.\n     * @type {?}\n     */\n    VirtualScrollStrategy.prototype.scrolledIndexChange;\n    /**\n     * Attaches this scroll strategy to a viewport.\n     * @param {?} viewport The viewport to attach this strategy to.\n     * @return {?}\n     */\n    VirtualScrollStrategy.prototype.attach = function (viewport) { };\n    /**\n     * Detaches this scroll strategy from the currently attached viewport.\n     * @return {?}\n     */\n    VirtualScrollStrategy.prototype.detach = function () { };\n    /**\n     * Called when the viewport is scrolled (debounced using requestAnimationFrame).\n     * @return {?}\n     */\n    VirtualScrollStrategy.prototype.onContentScrolled = function () { };\n    /**\n     * Called when the length of the data changes.\n     * @return {?}\n     */\n    VirtualScrollStrategy.prototype.onDataLengthChanged = function () { };\n    /**\n     * Called when the range of items rendered in the DOM has changed.\n     * @return {?}\n     */\n    VirtualScrollStrategy.prototype.onContentRendered = function () { };\n    /**\n     * Called when the offset of the rendered items changed.\n     * @return {?}\n     */\n    VirtualScrollStrategy.prototype.onRenderedOffsetChanged = function () { };\n    /**\n     * Scroll to the offset for the given index.\n     * @param {?} index The index of the element to scroll to.\n     * @param {?} behavior The ScrollBehavior to use when scrolling.\n     * @return {?}\n     */\n    VirtualScrollStrategy.prototype.scrollToIndex = function (index, behavior) { };\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/scrolling/fixed-size-virtual-scroll.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Virtual scrolling strategy for lists with items of known fixed size.\n */\nclass FixedSizeVirtualScrollStrategy {\n    /**\n     * @param {?} itemSize The size of the items in the virtually scrolling list.\n     * @param {?} minBufferPx The minimum amount of buffer (in pixels) before needing to render more\n     * @param {?} maxBufferPx The amount of buffer (in pixels) to render when rendering more.\n     */\n    constructor(itemSize, minBufferPx, maxBufferPx) {\n        this._scrolledIndexChange = new Subject();\n        /**\n         * \\@docs-private Implemented as part of VirtualScrollStrategy.\n         */\n        this.scrolledIndexChange = this._scrolledIndexChange.pipe(distinctUntilChanged());\n        /**\n         * The attached viewport.\n         */\n        this._viewport = null;\n        this._itemSize = itemSize;\n        this._minBufferPx = minBufferPx;\n        this._maxBufferPx = maxBufferPx;\n    }\n    /**\n     * Attaches this scroll strategy to a viewport.\n     * @param {?} viewport The viewport to attach this strategy to.\n     * @return {?}\n     */\n    attach(viewport) {\n        this._viewport = viewport;\n        this._updateTotalContentSize();\n        this._updateRenderedRange();\n    }\n    /**\n     * Detaches this scroll strategy from the currently attached viewport.\n     * @return {?}\n     */\n    detach() {\n        this._scrolledIndexChange.complete();\n        this._viewport = null;\n    }\n    /**\n     * Update the item size and buffer size.\n     * @param {?} itemSize The size of the items in the virtually scrolling list.\n     * @param {?} minBufferPx The minimum amount of buffer (in pixels) before needing to render more\n     * @param {?} maxBufferPx The amount of buffer (in pixels) to render when rendering more.\n     * @return {?}\n     */\n    updateItemAndBufferSize(itemSize, minBufferPx, maxBufferPx) {\n        if (maxBufferPx < minBufferPx) {\n            throw Error('CDK virtual scroll: maxBufferPx must be greater than or equal to minBufferPx');\n        }\n        this._itemSize = itemSize;\n        this._minBufferPx = minBufferPx;\n        this._maxBufferPx = maxBufferPx;\n        this._updateTotalContentSize();\n        this._updateRenderedRange();\n    }\n    /**\n     * \\@docs-private Implemented as part of VirtualScrollStrategy.\n     * @return {?}\n     */\n    onContentScrolled() {\n        this._updateRenderedRange();\n    }\n    /**\n     * \\@docs-private Implemented as part of VirtualScrollStrategy.\n     * @return {?}\n     */\n    onDataLengthChanged() {\n        this._updateTotalContentSize();\n        this._updateRenderedRange();\n    }\n    /**\n     * \\@docs-private Implemented as part of VirtualScrollStrategy.\n     * @return {?}\n     */\n    onContentRendered() { }\n    /**\n     * \\@docs-private Implemented as part of VirtualScrollStrategy.\n     * @return {?}\n     */\n    onRenderedOffsetChanged() { }\n    /**\n     * Scroll to the offset for the given index.\n     * @param {?} index The index of the element to scroll to.\n     * @param {?} behavior The ScrollBehavior to use when scrolling.\n     * @return {?}\n     */\n    scrollToIndex(index, behavior) {\n        if (this._viewport) {\n            this._viewport.scrollToOffset(index * this._itemSize, behavior);\n        }\n    }\n    /**\n     * Update the viewport's total content size.\n     * @private\n     * @return {?}\n     */\n    _updateTotalContentSize() {\n        if (!this._viewport) {\n            return;\n        }\n        this._viewport.setTotalContentSize(this._viewport.getDataLength() * this._itemSize);\n    }\n    /**\n     * Update the viewport's rendered range.\n     * @private\n     * @return {?}\n     */\n    _updateRenderedRange() {\n        if (!this._viewport) {\n            return;\n        }\n        /** @type {?} */\n        const scrollOffset = this._viewport.measureScrollOffset();\n        /** @type {?} */\n        const firstVisibleIndex = scrollOffset / this._itemSize;\n        /** @type {?} */\n        const renderedRange = this._viewport.getRenderedRange();\n        /** @type {?} */\n        const newRange = { start: renderedRange.start, end: renderedRange.end };\n        /** @type {?} */\n        const viewportSize = this._viewport.getViewportSize();\n        /** @type {?} */\n        const dataLength = this._viewport.getDataLength();\n        /** @type {?} */\n        const startBuffer = scrollOffset - newRange.start * this._itemSize;\n        if (startBuffer < this._minBufferPx && newRange.start != 0) {\n            /** @type {?} */\n            const expandStart = Math.ceil((this._maxBufferPx - startBuffer) / this._itemSize);\n            newRange.start = Math.max(0, newRange.start - expandStart);\n            newRange.end = Math.min(dataLength, Math.ceil(firstVisibleIndex + (viewportSize + this._minBufferPx) / this._itemSize));\n        }\n        else {\n            /** @type {?} */\n            const endBuffer = newRange.end * this._itemSize - (scrollOffset + viewportSize);\n            if (endBuffer < this._minBufferPx && newRange.end != dataLength) {\n                /** @type {?} */\n                const expandEnd = Math.ceil((this._maxBufferPx - endBuffer) / this._itemSize);\n                if (expandEnd > 0) {\n                    newRange.end = Math.min(dataLength, newRange.end + expandEnd);\n                    newRange.start = Math.max(0, Math.floor(firstVisibleIndex - this._minBufferPx / this._itemSize));\n                }\n            }\n        }\n        this._viewport.setRenderedRange(newRange);\n        this._viewport.setRenderedContentOffset(this._itemSize * newRange.start);\n        this._scrolledIndexChange.next(Math.floor(firstVisibleIndex));\n    }\n}\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    FixedSizeVirtualScrollStrategy.prototype._scrolledIndexChange;\n    /**\n     * \\@docs-private Implemented as part of VirtualScrollStrategy.\n     * @type {?}\n     */\n    FixedSizeVirtualScrollStrategy.prototype.scrolledIndexChange;\n    /**\n     * The attached viewport.\n     * @type {?}\n     * @private\n     */\n    FixedSizeVirtualScrollStrategy.prototype._viewport;\n    /**\n     * The size of the items in the virtually scrolling list.\n     * @type {?}\n     * @private\n     */\n    FixedSizeVirtualScrollStrategy.prototype._itemSize;\n    /**\n     * The minimum amount of buffer rendered beyond the viewport (in pixels).\n     * @type {?}\n     * @private\n     */\n    FixedSizeVirtualScrollStrategy.prototype._minBufferPx;\n    /**\n     * The number of buffer items to render beyond the edge of the viewport (in pixels).\n     * @type {?}\n     * @private\n     */\n    FixedSizeVirtualScrollStrategy.prototype._maxBufferPx;\n}\n/**\n * Provider factory for `FixedSizeVirtualScrollStrategy` that simply extracts the already created\n * `FixedSizeVirtualScrollStrategy` from the given directive.\n * @param {?} fixedSizeDir The instance of `CdkFixedSizeVirtualScroll` to extract the\n *     `FixedSizeVirtualScrollStrategy` from.\n * @return {?}\n */\nfunction _fixedSizeVirtualScrollStrategyFactory(fixedSizeDir) {\n    return fixedSizeDir._scrollStrategy;\n}\n/**\n * A virtual scroll strategy that supports fixed-size items.\n */\nclass CdkFixedSizeVirtualScroll {\n    constructor() {\n        this._itemSize = 20;\n        this._minBufferPx = 100;\n        this._maxBufferPx = 200;\n        /**\n         * The scroll strategy used by this directive.\n         */\n        this._scrollStrategy = new FixedSizeVirtualScrollStrategy(this.itemSize, this.minBufferPx, this.maxBufferPx);\n    }\n    /**\n     * The size of the items in the list (in pixels).\n     * @return {?}\n     */\n    get itemSize() { return this._itemSize; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set itemSize(value) { this._itemSize = coerceNumberProperty(value); }\n    /**\n     * The minimum amount of buffer rendered beyond the viewport (in pixels).\n     * If the amount of buffer dips below this number, more items will be rendered. Defaults to 100px.\n     * @return {?}\n     */\n    get minBufferPx() { return this._minBufferPx; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set minBufferPx(value) { this._minBufferPx = coerceNumberProperty(value); }\n    /**\n     * The number of pixels worth of buffer to render for when rendering new items. Defaults to 200px.\n     * @return {?}\n     */\n    get maxBufferPx() { return this._maxBufferPx; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set maxBufferPx(value) { this._maxBufferPx = coerceNumberProperty(value); }\n    /**\n     * @return {?}\n     */\n    ngOnChanges() {\n        this._scrollStrategy.updateItemAndBufferSize(this.itemSize, this.minBufferPx, this.maxBufferPx);\n    }\n}\nCdkFixedSizeVirtualScroll.ɵfac = function CdkFixedSizeVirtualScroll_Factory(t) { return new (t || CdkFixedSizeVirtualScroll)(); };\nCdkFixedSizeVirtualScroll.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: CdkFixedSizeVirtualScroll, selectors: [[\"cdk-virtual-scroll-viewport\", \"itemSize\", \"\"]], inputs: { itemSize: \"itemSize\", minBufferPx: \"minBufferPx\", maxBufferPx: \"maxBufferPx\" }, features: [ɵngcc0.ɵɵProvidersFeature([{\n                provide: VIRTUAL_SCROLL_STRATEGY,\n                useFactory: _fixedSizeVirtualScrollStrategyFactory,\n                deps: [forwardRef(( /**\n                         * @return {?}\n                         */() => CdkFixedSizeVirtualScroll))]\n            }]), ɵngcc0.ɵɵNgOnChangesFeature] });\nCdkFixedSizeVirtualScroll.propDecorators = {\n    itemSize: [{ type: Input }],\n    minBufferPx: [{ type: Input }],\n    maxBufferPx: [{ type: Input }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(CdkFixedSizeVirtualScroll, [{\n        type: Directive,\n        args: [{\n                selector: 'cdk-virtual-scroll-viewport[itemSize]',\n                providers: [{\n                        provide: VIRTUAL_SCROLL_STRATEGY,\n                        useFactory: _fixedSizeVirtualScrollStrategyFactory,\n                        deps: [forwardRef(( /**\n                                 * @return {?}\n                                 */() => CdkFixedSizeVirtualScroll))]\n                    }]\n            }]\n    }], function () { return []; }, { itemSize: [{\n            type: Input\n        }], minBufferPx: [{\n            type: Input\n        }], maxBufferPx: [{\n            type: Input\n        }] }); })();\nif (false) {\n    /** @type {?} */\n    CdkFixedSizeVirtualScroll.ngAcceptInputType_itemSize;\n    /** @type {?} */\n    CdkFixedSizeVirtualScroll.ngAcceptInputType_minBufferPx;\n    /** @type {?} */\n    CdkFixedSizeVirtualScroll.ngAcceptInputType_maxBufferPx;\n    /** @type {?} */\n    CdkFixedSizeVirtualScroll.prototype._itemSize;\n    /** @type {?} */\n    CdkFixedSizeVirtualScroll.prototype._minBufferPx;\n    /** @type {?} */\n    CdkFixedSizeVirtualScroll.prototype._maxBufferPx;\n    /**\n     * The scroll strategy used by this directive.\n     * @type {?}\n     */\n    CdkFixedSizeVirtualScroll.prototype._scrollStrategy;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/scrolling/scroll-dispatcher.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Time in ms to throttle the scrolling events by default.\n * @type {?}\n */\nconst DEFAULT_SCROLL_TIME = 20;\n/**\n * Service contained all registered Scrollable references and emits an event when any one of the\n * Scrollable references emit a scrolled event.\n */\nclass ScrollDispatcher {\n    /**\n     * @param {?} _ngZone\n     * @param {?} _platform\n     * @param {?=} document\n     */\n    constructor(_ngZone, _platform, \n    /** @breaking-change 11.0.0 make document required */\n    document) {\n        this._ngZone = _ngZone;\n        this._platform = _platform;\n        /**\n         * Subject for notifying that a registered scrollable reference element has been scrolled.\n         */\n        this._scrolled = new Subject();\n        /**\n         * Keeps track of the global `scroll` and `resize` subscriptions.\n         */\n        this._globalSubscription = null;\n        /**\n         * Keeps track of the amount of subscriptions to `scrolled`. Used for cleaning up afterwards.\n         */\n        this._scrolledCount = 0;\n        /**\n         * Map of all the scrollable references that are registered with the service and their\n         * scroll event subscriptions.\n         */\n        this.scrollContainers = new Map();\n        this._document = document;\n    }\n    /**\n     * Registers a scrollable instance with the service and listens for its scrolled events. When the\n     * scrollable is scrolled, the service emits the event to its scrolled observable.\n     * @param {?} scrollable Scrollable instance to be registered.\n     * @return {?}\n     */\n    register(scrollable) {\n        if (!this.scrollContainers.has(scrollable)) {\n            this.scrollContainers.set(scrollable, scrollable.elementScrolled()\n                .subscribe((/**\n             * @return {?}\n             */\n            () => this._scrolled.next(scrollable))));\n        }\n    }\n    /**\n     * Deregisters a Scrollable reference and unsubscribes from its scroll event observable.\n     * @param {?} scrollable Scrollable instance to be deregistered.\n     * @return {?}\n     */\n    deregister(scrollable) {\n        /** @type {?} */\n        const scrollableReference = this.scrollContainers.get(scrollable);\n        if (scrollableReference) {\n            scrollableReference.unsubscribe();\n            this.scrollContainers.delete(scrollable);\n        }\n    }\n    /**\n     * Returns an observable that emits an event whenever any of the registered Scrollable\n     * references (or window, document, or body) fire a scrolled event. Can provide a time in ms\n     * to override the default \"throttle\" time.\n     *\n     * **Note:** in order to avoid hitting change detection for every scroll event,\n     * all of the events emitted from this stream will be run outside the Angular zone.\n     * If you need to update any data bindings as a result of a scroll event, you have\n     * to run the callback using `NgZone.run`.\n     * @param {?=} auditTimeInMs\n     * @return {?}\n     */\n    scrolled(auditTimeInMs = DEFAULT_SCROLL_TIME) {\n        if (!this._platform.isBrowser) {\n            return of();\n        }\n        return new Observable((/**\n         * @param {?} observer\n         * @return {?}\n         */\n        (observer) => {\n            if (!this._globalSubscription) {\n                this._addGlobalListener();\n            }\n            // In the case of a 0ms delay, use an observable without auditTime\n            // since it does add a perceptible delay in processing overhead.\n            /** @type {?} */\n            const subscription = auditTimeInMs > 0 ?\n                this._scrolled.pipe(auditTime(auditTimeInMs)).subscribe(observer) :\n                this._scrolled.subscribe(observer);\n            this._scrolledCount++;\n            return (/**\n             * @return {?}\n             */\n            () => {\n                subscription.unsubscribe();\n                this._scrolledCount--;\n                if (!this._scrolledCount) {\n                    this._removeGlobalListener();\n                }\n            });\n        }));\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._removeGlobalListener();\n        this.scrollContainers.forEach((/**\n         * @param {?} _\n         * @param {?} container\n         * @return {?}\n         */\n        (_, container) => this.deregister(container)));\n        this._scrolled.complete();\n    }\n    /**\n     * Returns an observable that emits whenever any of the\n     * scrollable ancestors of an element are scrolled.\n     * @param {?} elementRef Element whose ancestors to listen for.\n     * @param {?=} auditTimeInMs Time to throttle the scroll events.\n     * @return {?}\n     */\n    ancestorScrolled(elementRef, auditTimeInMs) {\n        /** @type {?} */\n        const ancestors = this.getAncestorScrollContainers(elementRef);\n        return this.scrolled(auditTimeInMs).pipe(filter((/**\n         * @param {?} target\n         * @return {?}\n         */\n        target => {\n            return !target || ancestors.indexOf(target) > -1;\n        })));\n    }\n    /**\n     * Returns all registered Scrollables that contain the provided element.\n     * @param {?} elementRef\n     * @return {?}\n     */\n    getAncestorScrollContainers(elementRef) {\n        /** @type {?} */\n        const scrollingContainers = [];\n        this.scrollContainers.forEach((/**\n         * @param {?} _subscription\n         * @param {?} scrollable\n         * @return {?}\n         */\n        (_subscription, scrollable) => {\n            if (this._scrollableContainsElement(scrollable, elementRef)) {\n                scrollingContainers.push(scrollable);\n            }\n        }));\n        return scrollingContainers;\n    }\n    /**\n     * Access injected document if available or fallback to global document reference\n     * @private\n     * @return {?}\n     */\n    _getDocument() {\n        return this._document || document;\n    }\n    /**\n     * Use defaultView of injected document if available or fallback to global window reference\n     * @private\n     * @return {?}\n     */\n    _getWindow() {\n        /** @type {?} */\n        const doc = this._getDocument();\n        return doc.defaultView || window;\n    }\n    /**\n     * Returns true if the element is contained within the provided Scrollable.\n     * @private\n     * @param {?} scrollable\n     * @param {?} elementRef\n     * @return {?}\n     */\n    _scrollableContainsElement(scrollable, elementRef) {\n        /** @type {?} */\n        let element = elementRef.nativeElement;\n        /** @type {?} */\n        let scrollableElement = scrollable.getElementRef().nativeElement;\n        // Traverse through the element parents until we reach null, checking if any of the elements\n        // are the scrollable's element.\n        do {\n            if (element == scrollableElement) {\n                return true;\n            }\n        } while (element = (/** @type {?} */ (element)).parentElement);\n        return false;\n    }\n    /**\n     * Sets up the global scroll listeners.\n     * @private\n     * @return {?}\n     */\n    _addGlobalListener() {\n        this._globalSubscription = this._ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => {\n            /** @type {?} */\n            const window = this._getWindow();\n            return fromEvent(window.document, 'scroll').subscribe((/**\n             * @return {?}\n             */\n            () => this._scrolled.next()));\n        }));\n    }\n    /**\n     * Cleans up the global scroll listener.\n     * @private\n     * @return {?}\n     */\n    _removeGlobalListener() {\n        if (this._globalSubscription) {\n            this._globalSubscription.unsubscribe();\n            this._globalSubscription = null;\n        }\n    }\n}\nScrollDispatcher.ɵfac = function ScrollDispatcher_Factory(t) { return new (t || ScrollDispatcher)(ɵngcc0.ɵɵinject(ɵngcc0.NgZone), ɵngcc0.ɵɵinject(ɵngcc1.Platform), ɵngcc0.ɵɵinject(DOCUMENT, 8)); };\n/** @nocollapse */\nScrollDispatcher.ctorParameters = () => [\n    { type: NgZone },\n    { type: Platform },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] }\n];\n/** @nocollapse */ ScrollDispatcher.ɵprov = ɵɵdefineInjectable({ factory: function ScrollDispatcher_Factory() { return new ScrollDispatcher(ɵɵinject(NgZone), ɵɵinject(Platform), ɵɵinject(DOCUMENT, 8)); }, token: ScrollDispatcher, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(ScrollDispatcher, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: ɵngcc0.NgZone }, { type: ɵngcc1.Platform }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [DOCUMENT]\n            }] }]; }, null); })();\nif (false) {\n    /**\n     * Used to reference correct document/window\n     * @type {?}\n     * @protected\n     */\n    ScrollDispatcher.prototype._document;\n    /**\n     * Subject for notifying that a registered scrollable reference element has been scrolled.\n     * @type {?}\n     * @private\n     */\n    ScrollDispatcher.prototype._scrolled;\n    /**\n     * Keeps track of the global `scroll` and `resize` subscriptions.\n     * @type {?}\n     */\n    ScrollDispatcher.prototype._globalSubscription;\n    /**\n     * Keeps track of the amount of subscriptions to `scrolled`. Used for cleaning up afterwards.\n     * @type {?}\n     * @private\n     */\n    ScrollDispatcher.prototype._scrolledCount;\n    /**\n     * Map of all the scrollable references that are registered with the service and their\n     * scroll event subscriptions.\n     * @type {?}\n     */\n    ScrollDispatcher.prototype.scrollContainers;\n    /**\n     * @type {?}\n     * @private\n     */\n    ScrollDispatcher.prototype._ngZone;\n    /**\n     * @type {?}\n     * @private\n     */\n    ScrollDispatcher.prototype._platform;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/scrolling/scrollable.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Sends an event when the directive's element is scrolled. Registers itself with the\n * ScrollDispatcher service to include itself as part of its collection of scrolling events that it\n * can be listened to through the service.\n */\nclass CdkScrollable {\n    /**\n     * @param {?} elementRef\n     * @param {?} scrollDispatcher\n     * @param {?} ngZone\n     * @param {?=} dir\n     */\n    constructor(elementRef, scrollDispatcher, ngZone, dir) {\n        this.elementRef = elementRef;\n        this.scrollDispatcher = scrollDispatcher;\n        this.ngZone = ngZone;\n        this.dir = dir;\n        this._destroyed = new Subject();\n        this._elementScrolled = new Observable((/**\n         * @param {?} observer\n         * @return {?}\n         */\n        (observer) => this.ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => fromEvent(this.elementRef.nativeElement, 'scroll').pipe(takeUntil(this._destroyed))\n            .subscribe(observer)))));\n    }\n    /**\n     * @return {?}\n     */\n    ngOnInit() {\n        this.scrollDispatcher.register(this);\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this.scrollDispatcher.deregister(this);\n        this._destroyed.next();\n        this._destroyed.complete();\n    }\n    /**\n     * Returns observable that emits when a scroll event is fired on the host element.\n     * @return {?}\n     */\n    elementScrolled() {\n        return this._elementScrolled;\n    }\n    /**\n     * Gets the ElementRef for the viewport.\n     * @return {?}\n     */\n    getElementRef() {\n        return this.elementRef;\n    }\n    /**\n     * Scrolls to the specified offsets. This is a normalized version of the browser's native scrollTo\n     * method, since browsers are not consistent about what scrollLeft means in RTL. For this method\n     * left and right always refer to the left and right side of the scrolling container irrespective\n     * of the layout direction. start and end refer to left and right in an LTR context and vice-versa\n     * in an RTL context.\n     * @param {?} options specified the offsets to scroll to.\n     * @return {?}\n     */\n    scrollTo(options) {\n        /** @type {?} */\n        const el = this.elementRef.nativeElement;\n        /** @type {?} */\n        const isRtl = this.dir && this.dir.value == 'rtl';\n        // Rewrite start & end offsets as right or left offsets.\n        if (options.left == null) {\n            options.left = isRtl ? options.end : options.start;\n        }\n        if (options.right == null) {\n            options.right = isRtl ? options.start : options.end;\n        }\n        // Rewrite the bottom offset as a top offset.\n        if (options.bottom != null) {\n            ((/** @type {?} */ (options))).top =\n                el.scrollHeight - el.clientHeight - options.bottom;\n        }\n        // Rewrite the right offset as a left offset.\n        if (isRtl && getRtlScrollAxisType() != 0 /* NORMAL */) {\n            if (options.left != null) {\n                ((/** @type {?} */ (options))).right =\n                    el.scrollWidth - el.clientWidth - options.left;\n            }\n            if (getRtlScrollAxisType() == 2 /* INVERTED */) {\n                options.left = options.right;\n            }\n            else if (getRtlScrollAxisType() == 1 /* NEGATED */) {\n                options.left = options.right ? -options.right : options.right;\n            }\n        }\n        else {\n            if (options.right != null) {\n                ((/** @type {?} */ (options))).left =\n                    el.scrollWidth - el.clientWidth - options.right;\n            }\n        }\n        this._applyScrollToOptions(options);\n    }\n    /**\n     * @private\n     * @param {?} options\n     * @return {?}\n     */\n    _applyScrollToOptions(options) {\n        /** @type {?} */\n        const el = this.elementRef.nativeElement;\n        if (supportsScrollBehavior()) {\n            el.scrollTo(options);\n        }\n        else {\n            if (options.top != null) {\n                el.scrollTop = options.top;\n            }\n            if (options.left != null) {\n                el.scrollLeft = options.left;\n            }\n        }\n    }\n    /**\n     * Measures the scroll offset relative to the specified edge of the viewport. This method can be\n     * used instead of directly checking scrollLeft or scrollTop, since browsers are not consistent\n     * about what scrollLeft means in RTL. The values returned by this method are normalized such that\n     * left and right always refer to the left and right side of the scrolling container irrespective\n     * of the layout direction. start and end refer to left and right in an LTR context and vice-versa\n     * in an RTL context.\n     * @param {?} from The edge to measure from.\n     * @return {?}\n     */\n    measureScrollOffset(from) {\n        /** @type {?} */\n        const LEFT = 'left';\n        /** @type {?} */\n        const RIGHT = 'right';\n        /** @type {?} */\n        const el = this.elementRef.nativeElement;\n        if (from == 'top') {\n            return el.scrollTop;\n        }\n        if (from == 'bottom') {\n            return el.scrollHeight - el.clientHeight - el.scrollTop;\n        }\n        // Rewrite start & end as left or right offsets.\n        /** @type {?} */\n        const isRtl = this.dir && this.dir.value == 'rtl';\n        if (from == 'start') {\n            from = isRtl ? RIGHT : LEFT;\n        }\n        else if (from == 'end') {\n            from = isRtl ? LEFT : RIGHT;\n        }\n        if (isRtl && getRtlScrollAxisType() == 2 /* INVERTED */) {\n            // For INVERTED, scrollLeft is (scrollWidth - clientWidth) when scrolled all the way left and\n            // 0 when scrolled all the way right.\n            if (from == LEFT) {\n                return el.scrollWidth - el.clientWidth - el.scrollLeft;\n            }\n            else {\n                return el.scrollLeft;\n            }\n        }\n        else if (isRtl && getRtlScrollAxisType() == 1 /* NEGATED */) {\n            // For NEGATED, scrollLeft is -(scrollWidth - clientWidth) when scrolled all the way left and\n            // 0 when scrolled all the way right.\n            if (from == LEFT) {\n                return el.scrollLeft + el.scrollWidth - el.clientWidth;\n            }\n            else {\n                return -el.scrollLeft;\n            }\n        }\n        else {\n            // For NORMAL, as well as non-RTL contexts, scrollLeft is 0 when scrolled all the way left and\n            // (scrollWidth - clientWidth) when scrolled all the way right.\n            if (from == LEFT) {\n                return el.scrollLeft;\n            }\n            else {\n                return el.scrollWidth - el.clientWidth - el.scrollLeft;\n            }\n        }\n    }\n}\nCdkScrollable.ɵfac = function CdkScrollable_Factory(t) { return new (t || CdkScrollable)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ScrollDispatcher), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.Directionality, 8)); };\nCdkScrollable.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: CdkScrollable, selectors: [[\"\", \"cdk-scrollable\", \"\"], [\"\", \"cdkScrollable\", \"\"]] });\n/** @nocollapse */\nCdkScrollable.ctorParameters = () => [\n    { type: ElementRef },\n    { type: ScrollDispatcher },\n    { type: NgZone },\n    { type: Directionality, decorators: [{ type: Optional }] }\n];\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(CdkScrollable, [{\n        type: Directive,\n        args: [{\n                selector: '[cdk-scrollable], [cdkScrollable]'\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: ScrollDispatcher }, { type: ɵngcc0.NgZone }, { type: ɵngcc2.Directionality, decorators: [{\n                type: Optional\n            }] }]; }, null); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkScrollable.prototype._destroyed;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkScrollable.prototype._elementScrolled;\n    /**\n     * @type {?}\n     * @protected\n     */\n    CdkScrollable.prototype.elementRef;\n    /**\n     * @type {?}\n     * @protected\n     */\n    CdkScrollable.prototype.scrollDispatcher;\n    /**\n     * @type {?}\n     * @protected\n     */\n    CdkScrollable.prototype.ngZone;\n    /**\n     * @type {?}\n     * @protected\n     */\n    CdkScrollable.prototype.dir;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/scrolling/viewport-ruler.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Time in ms to throttle the resize events by default.\n * @type {?}\n */\nconst DEFAULT_RESIZE_TIME = 20;\n/**\n * Object that holds the scroll position of the viewport in each direction.\n * @record\n */\nfunction ViewportScrollPosition() { }\nif (false) {\n    /** @type {?} */\n    ViewportScrollPosition.prototype.top;\n    /** @type {?} */\n    ViewportScrollPosition.prototype.left;\n}\n/**\n * Simple utility for getting the bounds of the browser viewport.\n * \\@docs-private\n */\nclass ViewportRuler {\n    /**\n     * @param {?} _platform\n     * @param {?} ngZone\n     * @param {?=} document\n     */\n    constructor(_platform, ngZone, \n    /** @breaking-change 11.0.0 make document required */\n    document) {\n        this._platform = _platform;\n        this._document = document;\n        ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => {\n            /** @type {?} */\n            const window = this._getWindow();\n            this._change = _platform.isBrowser ?\n                merge(fromEvent(window, 'resize'), fromEvent(window, 'orientationchange')) :\n                of();\n            // Note that we need to do the subscription inside `runOutsideAngular`\n            // since subscribing is what causes the event listener to be added.\n            this._invalidateCache = this.change().subscribe((/**\n             * @return {?}\n             */\n            () => this._updateViewportSize()));\n        }));\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._invalidateCache.unsubscribe();\n    }\n    /**\n     * Returns the viewport's width and height.\n     * @return {?}\n     */\n    getViewportSize() {\n        if (!this._viewportSize) {\n            this._updateViewportSize();\n        }\n        /** @type {?} */\n        const output = { width: this._viewportSize.width, height: this._viewportSize.height };\n        // If we're not on a browser, don't cache the size since it'll be mocked out anyway.\n        if (!this._platform.isBrowser) {\n            this._viewportSize = (/** @type {?} */ (null));\n        }\n        return output;\n    }\n    /**\n     * Gets a ClientRect for the viewport's bounds.\n     * @return {?}\n     */\n    getViewportRect() {\n        // Use the document element's bounding rect rather than the window scroll properties\n        // (e.g. pageYOffset, scrollY) due to in issue in Chrome and IE where window scroll\n        // properties and client coordinates (boundingClientRect, clientX/Y, etc.) are in different\n        // conceptual viewports. Under most circumstances these viewports are equivalent, but they\n        // can disagree when the page is pinch-zoomed (on devices that support touch).\n        // See https://bugs.chromium.org/p/chromium/issues/detail?id=489206#c4\n        // We use the documentElement instead of the body because, by default (without a css reset)\n        // browsers typically give the document body an 8px margin, which is not included in\n        // getBoundingClientRect().\n        /** @type {?} */\n        const scrollPosition = this.getViewportScrollPosition();\n        const { width, height } = this.getViewportSize();\n        return {\n            top: scrollPosition.top,\n            left: scrollPosition.left,\n            bottom: scrollPosition.top + height,\n            right: scrollPosition.left + width,\n            height,\n            width,\n        };\n    }\n    /**\n     * Gets the (top, left) scroll position of the viewport.\n     * @return {?}\n     */\n    getViewportScrollPosition() {\n        // While we can get a reference to the fake document\n        // during SSR, it doesn't have getBoundingClientRect.\n        if (!this._platform.isBrowser) {\n            return { top: 0, left: 0 };\n        }\n        // The top-left-corner of the viewport is determined by the scroll position of the document\n        // body, normally just (scrollLeft, scrollTop). However, Chrome and Firefox disagree about\n        // whether `document.body` or `document.documentElement` is the scrolled element, so reading\n        // `scrollTop` and `scrollLeft` is inconsistent. However, using the bounding rect of\n        // `document.documentElement` works consistently, where the `top` and `left` values will\n        // equal negative the scroll position.\n        /** @type {?} */\n        const document = this._getDocument();\n        /** @type {?} */\n        const window = this._getWindow();\n        /** @type {?} */\n        const documentElement = (/** @type {?} */ (document.documentElement));\n        /** @type {?} */\n        const documentRect = documentElement.getBoundingClientRect();\n        /** @type {?} */\n        const top = -documentRect.top || document.body.scrollTop || window.scrollY ||\n            documentElement.scrollTop || 0;\n        /** @type {?} */\n        const left = -documentRect.left || document.body.scrollLeft || window.scrollX ||\n            documentElement.scrollLeft || 0;\n        return { top, left };\n    }\n    /**\n     * Returns a stream that emits whenever the size of the viewport changes.\n     * @param {?=} throttleTime Time in milliseconds to throttle the stream.\n     * @return {?}\n     */\n    change(throttleTime = DEFAULT_RESIZE_TIME) {\n        return throttleTime > 0 ? this._change.pipe(auditTime(throttleTime)) : this._change;\n    }\n    /**\n     * Access injected document if available or fallback to global document reference\n     * @private\n     * @return {?}\n     */\n    _getDocument() {\n        return this._document || document;\n    }\n    /**\n     * Use defaultView of injected document if available or fallback to global window reference\n     * @private\n     * @return {?}\n     */\n    _getWindow() {\n        /** @type {?} */\n        const doc = this._getDocument();\n        return doc.defaultView || window;\n    }\n    /**\n     * Updates the cached viewport size.\n     * @private\n     * @return {?}\n     */\n    _updateViewportSize() {\n        /** @type {?} */\n        const window = this._getWindow();\n        this._viewportSize = this._platform.isBrowser ?\n            { width: window.innerWidth, height: window.innerHeight } :\n            { width: 0, height: 0 };\n    }\n}\nViewportRuler.ɵfac = function ViewportRuler_Factory(t) { return new (t || ViewportRuler)(ɵngcc0.ɵɵinject(ɵngcc1.Platform), ɵngcc0.ɵɵinject(ɵngcc0.NgZone), ɵngcc0.ɵɵinject(DOCUMENT, 8)); };\n/** @nocollapse */\nViewportRuler.ctorParameters = () => [\n    { type: Platform },\n    { type: NgZone },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] }\n];\n/** @nocollapse */ ViewportRuler.ɵprov = ɵɵdefineInjectable({ factory: function ViewportRuler_Factory() { return new ViewportRuler(ɵɵinject(Platform), ɵɵinject(NgZone), ɵɵinject(DOCUMENT, 8)); }, token: ViewportRuler, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(ViewportRuler, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: ɵngcc1.Platform }, { type: ɵngcc0.NgZone }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [DOCUMENT]\n            }] }]; }, null); })();\nif (false) {\n    /**\n     * Cached viewport dimensions.\n     * @type {?}\n     * @private\n     */\n    ViewportRuler.prototype._viewportSize;\n    /**\n     * Stream of viewport change events.\n     * @type {?}\n     * @private\n     */\n    ViewportRuler.prototype._change;\n    /**\n     * Subscription to streams that invalidate the cached viewport dimensions.\n     * @type {?}\n     * @private\n     */\n    ViewportRuler.prototype._invalidateCache;\n    /**\n     * Used to reference correct document/window\n     * @type {?}\n     * @protected\n     */\n    ViewportRuler.prototype._document;\n    /**\n     * @type {?}\n     * @private\n     */\n    ViewportRuler.prototype._platform;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/scrolling/virtual-scroll-viewport.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Checks if the given ranges are equal.\n * @param {?} r1\n * @param {?} r2\n * @return {?}\n */\nfunction rangesEqual(r1, r2) {\n    return r1.start == r2.start && r1.end == r2.end;\n}\n/**\n * Scheduler to be used for scroll events. Needs to fall back to\n * something that doesn't rely on requestAnimationFrame on environments\n * that don't support it (e.g. server-side rendering).\n * @type {?}\n */\nconst SCROLL_SCHEDULER = typeof requestAnimationFrame !== 'undefined' ? animationFrameScheduler : asapScheduler;\n/**\n * A viewport that virtualizes its scrolling with the help of `CdkVirtualForOf`.\n */\nclass CdkVirtualScrollViewport extends CdkScrollable {\n    /**\n     * @param {?} elementRef\n     * @param {?} _changeDetectorRef\n     * @param {?} ngZone\n     * @param {?} _scrollStrategy\n     * @param {?} dir\n     * @param {?} scrollDispatcher\n     * @param {?=} viewportRuler\n     */\n    constructor(elementRef, _changeDetectorRef, ngZone, _scrollStrategy, dir, scrollDispatcher, \n    /**\n     * @deprecated `viewportRuler` parameter to become required.\n     * @breaking-change 11.0.0\n     */\n    viewportRuler) {\n        super(elementRef, scrollDispatcher, ngZone, dir);\n        this.elementRef = elementRef;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._scrollStrategy = _scrollStrategy;\n        /**\n         * Emits when the viewport is detached from a CdkVirtualForOf.\n         */\n        this._detachedSubject = new Subject();\n        /**\n         * Emits when the rendered range changes.\n         */\n        this._renderedRangeSubject = new Subject();\n        this._orientation = 'vertical';\n        // Note: we don't use the typical EventEmitter here because we need to subscribe to the scroll\n        // strategy lazily (i.e. only if the user is actually listening to the events). We do this because\n        // depending on how the strategy calculates the scrolled index, it may come at a cost to\n        // performance.\n        /**\n         * Emits when the index of the first element visible in the viewport changes.\n         */\n        this.scrolledIndexChange = new Observable((/**\n         * @param {?} observer\n         * @return {?}\n         */\n        (observer) => this._scrollStrategy.scrolledIndexChange.subscribe((/**\n         * @param {?} index\n         * @return {?}\n         */\n        index => Promise.resolve().then((/**\n         * @return {?}\n         */\n        () => this.ngZone.run((/**\n         * @return {?}\n         */\n        () => observer.next(index)))))))));\n        /**\n         * A stream that emits whenever the rendered range changes.\n         */\n        this.renderedRangeStream = this._renderedRangeSubject.asObservable();\n        /**\n         * The total size of all content (in pixels), including content that is not currently rendered.\n         */\n        this._totalContentSize = 0;\n        /**\n         * A string representing the `style.width` property value to be used for the spacer element.\n         */\n        this._totalContentWidth = '';\n        /**\n         * A string representing the `style.height` property value to be used for the spacer element.\n         */\n        this._totalContentHeight = '';\n        /**\n         * The currently rendered range of indices.\n         */\n        this._renderedRange = { start: 0, end: 0 };\n        /**\n         * The length of the data bound to this viewport (in number of items).\n         */\n        this._dataLength = 0;\n        /**\n         * The size of the viewport (in pixels).\n         */\n        this._viewportSize = 0;\n        /**\n         * The last rendered content offset that was set.\n         */\n        this._renderedContentOffset = 0;\n        /**\n         * Whether the last rendered content offset was to the end of the content (and therefore needs to\n         * be rewritten as an offset to the start of the content).\n         */\n        this._renderedContentOffsetNeedsRewrite = false;\n        /**\n         * Whether there is a pending change detection cycle.\n         */\n        this._isChangeDetectionPending = false;\n        /**\n         * A list of functions to run after the next change detection cycle.\n         */\n        this._runAfterChangeDetection = [];\n        /**\n         * Subscription to changes in the viewport size.\n         */\n        this._viewportChanges = Subscription.EMPTY;\n        if (!_scrollStrategy) {\n            throw Error('Error: cdk-virtual-scroll-viewport requires the \"itemSize\" property to be set.');\n        }\n        // @breaking-change 11.0.0 Remove null check for `viewportRuler`.\n        if (viewportRuler) {\n            this._viewportChanges = viewportRuler.change().subscribe((/**\n             * @return {?}\n             */\n            () => {\n                this.checkViewportSize();\n            }));\n        }\n    }\n    /**\n     * The direction the viewport scrolls.\n     * @return {?}\n     */\n    get orientation() {\n        return this._orientation;\n    }\n    /**\n     * @param {?} orientation\n     * @return {?}\n     */\n    set orientation(orientation) {\n        if (this._orientation !== orientation) {\n            this._orientation = orientation;\n            this._calculateSpacerSize();\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngOnInit() {\n        super.ngOnInit();\n        // It's still too early to measure the viewport at this point. Deferring with a promise allows\n        // the Viewport to be rendered with the correct size before we measure. We run this outside the\n        // zone to avoid causing more change detection cycles. We handle the change detection loop\n        // ourselves instead.\n        this.ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => Promise.resolve().then((/**\n         * @return {?}\n         */\n        () => {\n            this._measureViewportSize();\n            this._scrollStrategy.attach(this);\n            this.elementScrolled()\n                .pipe(\n            // Start off with a fake scroll event so we properly detect our initial position.\n            startWith((/** @type {?} */ (null))), \n            // Collect multiple events into one until the next animation frame. This way if\n            // there are multiple scroll events in the same frame we only need to recheck\n            // our layout once.\n            auditTime(0, SCROLL_SCHEDULER))\n                .subscribe((/**\n             * @return {?}\n             */\n            () => this._scrollStrategy.onContentScrolled()));\n            this._markChangeDetectionNeeded();\n        }))));\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this.detach();\n        this._scrollStrategy.detach();\n        // Complete all subjects\n        this._renderedRangeSubject.complete();\n        this._detachedSubject.complete();\n        this._viewportChanges.unsubscribe();\n        super.ngOnDestroy();\n    }\n    /**\n     * Attaches a `CdkVirtualForOf` to this viewport.\n     * @param {?} forOf\n     * @return {?}\n     */\n    attach(forOf) {\n        if (this._forOf) {\n            throw Error('CdkVirtualScrollViewport is already attached.');\n        }\n        // Subscribe to the data stream of the CdkVirtualForOf to keep track of when the data length\n        // changes. Run outside the zone to avoid triggering change detection, since we're managing the\n        // change detection loop ourselves.\n        this.ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => {\n            this._forOf = forOf;\n            this._forOf.dataStream.pipe(takeUntil(this._detachedSubject)).subscribe((/**\n             * @param {?} data\n             * @return {?}\n             */\n            data => {\n                /** @type {?} */\n                const newLength = data.length;\n                if (newLength !== this._dataLength) {\n                    this._dataLength = newLength;\n                    this._scrollStrategy.onDataLengthChanged();\n                }\n                this._doChangeDetection();\n            }));\n        }));\n    }\n    /**\n     * Detaches the current `CdkVirtualForOf`.\n     * @return {?}\n     */\n    detach() {\n        this._forOf = null;\n        this._detachedSubject.next();\n    }\n    /**\n     * Gets the length of the data bound to this viewport (in number of items).\n     * @return {?}\n     */\n    getDataLength() {\n        return this._dataLength;\n    }\n    /**\n     * Gets the size of the viewport (in pixels).\n     * @return {?}\n     */\n    getViewportSize() {\n        return this._viewportSize;\n    }\n    // TODO(mmalerba): This is technically out of sync with what's really rendered until a render\n    // cycle happens. I'm being careful to only call it after the render cycle is complete and before\n    // setting it to something else, but its error prone and should probably be split into\n    // `pendingRange` and `renderedRange`, the latter reflecting whats actually in the DOM.\n    /**\n     * Get the current rendered range of items.\n     * @return {?}\n     */\n    getRenderedRange() {\n        return this._renderedRange;\n    }\n    /**\n     * Sets the total size of all content (in pixels), including content that is not currently\n     * rendered.\n     * @param {?} size\n     * @return {?}\n     */\n    setTotalContentSize(size) {\n        if (this._totalContentSize !== size) {\n            this._totalContentSize = size;\n            this._calculateSpacerSize();\n            this._markChangeDetectionNeeded();\n        }\n    }\n    /**\n     * Sets the currently rendered range of indices.\n     * @param {?} range\n     * @return {?}\n     */\n    setRenderedRange(range) {\n        if (!rangesEqual(this._renderedRange, range)) {\n            this._renderedRangeSubject.next(this._renderedRange = range);\n            this._markChangeDetectionNeeded((/**\n             * @return {?}\n             */\n            () => this._scrollStrategy.onContentRendered()));\n        }\n    }\n    /**\n     * Gets the offset from the start of the viewport to the start of the rendered data (in pixels).\n     * @return {?}\n     */\n    getOffsetToRenderedContentStart() {\n        return this._renderedContentOffsetNeedsRewrite ? null : this._renderedContentOffset;\n    }\n    /**\n     * Sets the offset from the start of the viewport to either the start or end of the rendered data\n     * (in pixels).\n     * @param {?} offset\n     * @param {?=} to\n     * @return {?}\n     */\n    setRenderedContentOffset(offset, to = 'to-start') {\n        // For a horizontal viewport in a right-to-left language we need to translate along the x-axis\n        // in the negative direction.\n        /** @type {?} */\n        const isRtl = this.dir && this.dir.value == 'rtl';\n        /** @type {?} */\n        const isHorizontal = this.orientation == 'horizontal';\n        /** @type {?} */\n        const axis = isHorizontal ? 'X' : 'Y';\n        /** @type {?} */\n        const axisDirection = isHorizontal && isRtl ? -1 : 1;\n        /** @type {?} */\n        let transform = `translate${axis}(${Number(axisDirection * offset)}px)`;\n        this._renderedContentOffset = offset;\n        if (to === 'to-end') {\n            transform += ` translate${axis}(-100%)`;\n            // The viewport should rewrite this as a `to-start` offset on the next render cycle. Otherwise\n            // elements will appear to expand in the wrong direction (e.g. `mat-expansion-panel` would\n            // expand upward).\n            this._renderedContentOffsetNeedsRewrite = true;\n        }\n        if (this._renderedContentTransform != transform) {\n            // We know this value is safe because we parse `offset` with `Number()` before passing it\n            // into the string.\n            this._renderedContentTransform = transform;\n            this._markChangeDetectionNeeded((/**\n             * @return {?}\n             */\n            () => {\n                if (this._renderedContentOffsetNeedsRewrite) {\n                    this._renderedContentOffset -= this.measureRenderedContentSize();\n                    this._renderedContentOffsetNeedsRewrite = false;\n                    this.setRenderedContentOffset(this._renderedContentOffset);\n                }\n                else {\n                    this._scrollStrategy.onRenderedOffsetChanged();\n                }\n            }));\n        }\n    }\n    /**\n     * Scrolls to the given offset from the start of the viewport. Please note that this is not always\n     * the same as setting `scrollTop` or `scrollLeft`. In a horizontal viewport with right-to-left\n     * direction, this would be the equivalent of setting a fictional `scrollRight` property.\n     * @param {?} offset The offset to scroll to.\n     * @param {?=} behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.\n     * @return {?}\n     */\n    scrollToOffset(offset, behavior = 'auto') {\n        /** @type {?} */\n        const options = { behavior };\n        if (this.orientation === 'horizontal') {\n            options.start = offset;\n        }\n        else {\n            options.top = offset;\n        }\n        this.scrollTo(options);\n    }\n    /**\n     * Scrolls to the offset for the given index.\n     * @param {?} index The index of the element to scroll to.\n     * @param {?=} behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.\n     * @return {?}\n     */\n    scrollToIndex(index, behavior = 'auto') {\n        this._scrollStrategy.scrollToIndex(index, behavior);\n    }\n    /**\n     * Gets the current scroll offset from the start of the viewport (in pixels).\n     * @param {?=} from The edge to measure the offset from. Defaults to 'top' in vertical mode and 'start'\n     *     in horizontal mode.\n     * @return {?}\n     */\n    measureScrollOffset(from) {\n        return from ?\n            super.measureScrollOffset(from) :\n            super.measureScrollOffset(this.orientation === 'horizontal' ? 'start' : 'top');\n    }\n    /**\n     * Measure the combined size of all of the rendered items.\n     * @return {?}\n     */\n    measureRenderedContentSize() {\n        /** @type {?} */\n        const contentEl = this._contentWrapper.nativeElement;\n        return this.orientation === 'horizontal' ? contentEl.offsetWidth : contentEl.offsetHeight;\n    }\n    /**\n     * Measure the total combined size of the given range. Throws if the range includes items that are\n     * not rendered.\n     * @param {?} range\n     * @return {?}\n     */\n    measureRangeSize(range) {\n        if (!this._forOf) {\n            return 0;\n        }\n        return this._forOf.measureRangeSize(range, this.orientation);\n    }\n    /**\n     * Update the viewport dimensions and re-render.\n     * @return {?}\n     */\n    checkViewportSize() {\n        // TODO: Cleanup later when add logic for handling content resize\n        this._measureViewportSize();\n        this._scrollStrategy.onDataLengthChanged();\n    }\n    /**\n     * Measure the viewport size.\n     * @private\n     * @return {?}\n     */\n    _measureViewportSize() {\n        /** @type {?} */\n        const viewportEl = this.elementRef.nativeElement;\n        this._viewportSize = this.orientation === 'horizontal' ?\n            viewportEl.clientWidth : viewportEl.clientHeight;\n    }\n    /**\n     * Queue up change detection to run.\n     * @private\n     * @param {?=} runAfter\n     * @return {?}\n     */\n    _markChangeDetectionNeeded(runAfter) {\n        if (runAfter) {\n            this._runAfterChangeDetection.push(runAfter);\n        }\n        // Use a Promise to batch together calls to `_doChangeDetection`. This way if we set a bunch of\n        // properties sequentially we only have to run `_doChangeDetection` once at the end.\n        if (!this._isChangeDetectionPending) {\n            this._isChangeDetectionPending = true;\n            this.ngZone.runOutsideAngular((/**\n             * @return {?}\n             */\n            () => Promise.resolve().then((/**\n             * @return {?}\n             */\n            () => {\n                this._doChangeDetection();\n            }))));\n        }\n    }\n    /**\n     * Run change detection.\n     * @private\n     * @return {?}\n     */\n    _doChangeDetection() {\n        this._isChangeDetectionPending = false;\n        // Apply the content transform. The transform can't be set via an Angular binding because\n        // bypassSecurityTrustStyle is banned in Google. However the value is safe, it's composed of\n        // string literals, a variable that can only be 'X' or 'Y', and user input that is run through\n        // the `Number` function first to coerce it to a numeric value.\n        this._contentWrapper.nativeElement.style.transform = this._renderedContentTransform;\n        // Apply changes to Angular bindings. Note: We must call `markForCheck` to run change detection\n        // from the root, since the repeated items are content projected in. Calling `detectChanges`\n        // instead does not properly check the projected content.\n        this.ngZone.run((/**\n         * @return {?}\n         */\n        () => this._changeDetectorRef.markForCheck()));\n        /** @type {?} */\n        const runAfterChangeDetection = this._runAfterChangeDetection;\n        this._runAfterChangeDetection = [];\n        for (const fn of runAfterChangeDetection) {\n            fn();\n        }\n    }\n    /**\n     * Calculates the `style.width` and `style.height` for the spacer element.\n     * @private\n     * @return {?}\n     */\n    _calculateSpacerSize() {\n        this._totalContentHeight =\n            this.orientation === 'horizontal' ? '' : `${this._totalContentSize}px`;\n        this._totalContentWidth =\n            this.orientation === 'horizontal' ? `${this._totalContentSize}px` : '';\n    }\n}\nCdkVirtualScrollViewport.ɵfac = function CdkVirtualScrollViewport_Factory(t) { return new (t || CdkVirtualScrollViewport)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone), ɵngcc0.ɵɵdirectiveInject(VIRTUAL_SCROLL_STRATEGY, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.Directionality, 8), ɵngcc0.ɵɵdirectiveInject(ScrollDispatcher), ɵngcc0.ɵɵdirectiveInject(ViewportRuler, 8)); };\nCdkVirtualScrollViewport.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: CdkVirtualScrollViewport, selectors: [[\"cdk-virtual-scroll-viewport\"]], viewQuery: function CdkVirtualScrollViewport_Query(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵstaticViewQuery(_c0, true);\n    } if (rf & 2) {\n        var _t;\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._contentWrapper = _t.first);\n    } }, hostAttrs: [1, \"cdk-virtual-scroll-viewport\"], hostVars: 4, hostBindings: function CdkVirtualScrollViewport_HostBindings(rf, ctx) { if (rf & 2) {\n        ɵngcc0.ɵɵclassProp(\"cdk-virtual-scroll-orientation-horizontal\", ctx.orientation === \"horizontal\")(\"cdk-virtual-scroll-orientation-vertical\", ctx.orientation !== \"horizontal\");\n    } }, inputs: { orientation: \"orientation\" }, outputs: { scrolledIndexChange: \"scrolledIndexChange\" }, features: [ɵngcc0.ɵɵProvidersFeature([{\n                provide: CdkScrollable,\n                useExisting: CdkVirtualScrollViewport\n            }]), ɵngcc0.ɵɵInheritDefinitionFeature], ngContentSelectors: _c1, decls: 4, vars: 4, consts: [[1, \"cdk-virtual-scroll-content-wrapper\"], [\"contentWrapper\", \"\"], [1, \"cdk-virtual-scroll-spacer\"]], template: function CdkVirtualScrollViewport_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵprojectionDef();\n        ɵngcc0.ɵɵelementStart(0, \"div\", 0, 1);\n        ɵngcc0.ɵɵprojection(2);\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelement(3, \"div\", 2);\n    } if (rf & 2) {\n        ɵngcc0.ɵɵadvance(3);\n        ɵngcc0.ɵɵstyleProp(\"width\", ctx._totalContentWidth)(\"height\", ctx._totalContentHeight);\n    } }, styles: [\"cdk-virtual-scroll-viewport{display:block;position:relative;overflow:auto;contain:strict;transform:translateZ(0);will-change:scroll-position;-webkit-overflow-scrolling:touch}.cdk-virtual-scroll-content-wrapper{position:absolute;top:0;left:0;contain:content}[dir=rtl] .cdk-virtual-scroll-content-wrapper{right:0;left:auto}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper{min-height:100%}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-left:0;padding-right:0;margin-left:0;margin-right:0;border-left-width:0;border-right-width:0;outline:none}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper{min-width:100%}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-top:0;padding-bottom:0;margin-top:0;margin-bottom:0;border-top-width:0;border-bottom-width:0;outline:none}.cdk-virtual-scroll-spacer{position:absolute;top:0;left:0;height:1px;width:1px;transform-origin:0 0}[dir=rtl] .cdk-virtual-scroll-spacer{right:0;left:auto;transform-origin:100% 0}\\n\"], encapsulation: 2, changeDetection: 0 });\n/** @nocollapse */\nCdkVirtualScrollViewport.ctorParameters = () => [\n    { type: ElementRef },\n    { type: ChangeDetectorRef },\n    { type: NgZone },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [VIRTUAL_SCROLL_STRATEGY,] }] },\n    { type: Directionality, decorators: [{ type: Optional }] },\n    { type: ScrollDispatcher },\n    { type: ViewportRuler, decorators: [{ type: Optional }] }\n];\nCdkVirtualScrollViewport.propDecorators = {\n    orientation: [{ type: Input }],\n    scrolledIndexChange: [{ type: Output }],\n    _contentWrapper: [{ type: ViewChild, args: ['contentWrapper', { static: true },] }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(CdkVirtualScrollViewport, [{\n        type: Component,\n        args: [{\n                selector: 'cdk-virtual-scroll-viewport',\n                template: \"<!--\\n  Wrap the rendered content in an element that will be used to offset it based on the scroll\\n  position.\\n-->\\n<div #contentWrapper class=\\\"cdk-virtual-scroll-content-wrapper\\\">\\n  <ng-content></ng-content>\\n</div>\\n<!--\\n  Spacer used to force the scrolling container to the correct size for the *total* number of items\\n  so that the scrollbar captures the size of the entire data set.\\n-->\\n<div class=\\\"cdk-virtual-scroll-spacer\\\"\\n     [style.width]=\\\"_totalContentWidth\\\" [style.height]=\\\"_totalContentHeight\\\"></div>\\n\",\n                host: {\n                    'class': 'cdk-virtual-scroll-viewport',\n                    '[class.cdk-virtual-scroll-orientation-horizontal]': 'orientation === \"horizontal\"',\n                    '[class.cdk-virtual-scroll-orientation-vertical]': 'orientation !== \"horizontal\"'\n                },\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush,\n                providers: [{\n                        provide: CdkScrollable,\n                        useExisting: CdkVirtualScrollViewport\n                    }],\n                styles: [\"cdk-virtual-scroll-viewport{display:block;position:relative;overflow:auto;contain:strict;transform:translateZ(0);will-change:scroll-position;-webkit-overflow-scrolling:touch}.cdk-virtual-scroll-content-wrapper{position:absolute;top:0;left:0;contain:content}[dir=rtl] .cdk-virtual-scroll-content-wrapper{right:0;left:auto}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper{min-height:100%}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-left:0;padding-right:0;margin-left:0;margin-right:0;border-left-width:0;border-right-width:0;outline:none}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper{min-width:100%}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-top:0;padding-bottom:0;margin-top:0;margin-bottom:0;border-top-width:0;border-bottom-width:0;outline:none}.cdk-virtual-scroll-spacer{position:absolute;top:0;left:0;height:1px;width:1px;transform-origin:0 0}[dir=rtl] .cdk-virtual-scroll-spacer{right:0;left:auto;transform-origin:100% 0}\\n\"]\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: ɵngcc0.ChangeDetectorRef }, { type: ɵngcc0.NgZone }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [VIRTUAL_SCROLL_STRATEGY]\n            }] }, { type: ɵngcc2.Directionality, decorators: [{\n                type: Optional\n            }] }, { type: ScrollDispatcher }, { type: ViewportRuler, decorators: [{\n                type: Optional\n            }] }]; }, { scrolledIndexChange: [{\n            type: Output\n        }], orientation: [{\n            type: Input\n        }], _contentWrapper: [{\n            type: ViewChild,\n            args: ['contentWrapper', { static: true }]\n        }] }); })();\nif (false) {\n    /**\n     * Emits when the viewport is detached from a CdkVirtualForOf.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualScrollViewport.prototype._detachedSubject;\n    /**\n     * Emits when the rendered range changes.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualScrollViewport.prototype._renderedRangeSubject;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkVirtualScrollViewport.prototype._orientation;\n    /**\n     * Emits when the index of the first element visible in the viewport changes.\n     * @type {?}\n     */\n    CdkVirtualScrollViewport.prototype.scrolledIndexChange;\n    /**\n     * The element that wraps the rendered content.\n     * @type {?}\n     */\n    CdkVirtualScrollViewport.prototype._contentWrapper;\n    /**\n     * A stream that emits whenever the rendered range changes.\n     * @type {?}\n     */\n    CdkVirtualScrollViewport.prototype.renderedRangeStream;\n    /**\n     * The total size of all content (in pixels), including content that is not currently rendered.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualScrollViewport.prototype._totalContentSize;\n    /**\n     * A string representing the `style.width` property value to be used for the spacer element.\n     * @type {?}\n     */\n    CdkVirtualScrollViewport.prototype._totalContentWidth;\n    /**\n     * A string representing the `style.height` property value to be used for the spacer element.\n     * @type {?}\n     */\n    CdkVirtualScrollViewport.prototype._totalContentHeight;\n    /**\n     * The CSS transform applied to the rendered subset of items so that they appear within the bounds\n     * of the visible viewport.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualScrollViewport.prototype._renderedContentTransform;\n    /**\n     * The currently rendered range of indices.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualScrollViewport.prototype._renderedRange;\n    /**\n     * The length of the data bound to this viewport (in number of items).\n     * @type {?}\n     * @private\n     */\n    CdkVirtualScrollViewport.prototype._dataLength;\n    /**\n     * The size of the viewport (in pixels).\n     * @type {?}\n     * @private\n     */\n    CdkVirtualScrollViewport.prototype._viewportSize;\n    /**\n     * the currently attached CdkVirtualForOf.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualScrollViewport.prototype._forOf;\n    /**\n     * The last rendered content offset that was set.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualScrollViewport.prototype._renderedContentOffset;\n    /**\n     * Whether the last rendered content offset was to the end of the content (and therefore needs to\n     * be rewritten as an offset to the start of the content).\n     * @type {?}\n     * @private\n     */\n    CdkVirtualScrollViewport.prototype._renderedContentOffsetNeedsRewrite;\n    /**\n     * Whether there is a pending change detection cycle.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualScrollViewport.prototype._isChangeDetectionPending;\n    /**\n     * A list of functions to run after the next change detection cycle.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualScrollViewport.prototype._runAfterChangeDetection;\n    /**\n     * Subscription to changes in the viewport size.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualScrollViewport.prototype._viewportChanges;\n    /** @type {?} */\n    CdkVirtualScrollViewport.prototype.elementRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkVirtualScrollViewport.prototype._changeDetectorRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkVirtualScrollViewport.prototype._scrollStrategy;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/scrolling/virtual-for-of.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Helper to extract size from a DOM Node.\n * @param {?} orientation\n * @param {?} node\n * @return {?}\n */\nfunction getSize(orientation, node) {\n    /** @type {?} */\n    const el = (/** @type {?} */ (node));\n    if (!el.getBoundingClientRect) {\n        return 0;\n    }\n    /** @type {?} */\n    const rect = el.getBoundingClientRect();\n    return orientation == 'horizontal' ? rect.width : rect.height;\n}\n/**\n * A directive similar to `ngForOf` to be used for rendering data inside a virtual scrolling\n * container.\n * @template T\n */\nclass CdkVirtualForOf {\n    /**\n     * @param {?} _viewContainerRef\n     * @param {?} _template\n     * @param {?} _differs\n     * @param {?} _viewport\n     * @param {?} ngZone\n     */\n    constructor(_viewContainerRef, _template, _differs, _viewport, ngZone) {\n        this._viewContainerRef = _viewContainerRef;\n        this._template = _template;\n        this._differs = _differs;\n        this._viewport = _viewport;\n        /**\n         * Emits when the rendered view of the data changes.\n         */\n        this.viewChange = new Subject();\n        /**\n         * Subject that emits when a new DataSource instance is given.\n         */\n        this._dataSourceChanges = new Subject();\n        /**\n         * The size of the cache used to store templates that are not being used for re-use later.\n         * Setting the cache size to `0` will disable caching. Defaults to 20 templates.\n         */\n        this.cdkVirtualForTemplateCacheSize = 20;\n        /**\n         * Emits whenever the data in the current DataSource changes.\n         */\n        this.dataStream = this._dataSourceChanges\n            .pipe(\n        // Start off with null `DataSource`.\n        startWith((/** @type {?} */ (null))), \n        // Bundle up the previous and current data sources so we can work with both.\n        pairwise(), \n        // Use `_changeDataSource` to disconnect from the previous data source and connect to the\n        // new one, passing back a stream of data changes which we run through `switchMap` to give\n        // us a data stream that emits the latest data from whatever the current `DataSource` is.\n        switchMap((/**\n         * @param {?} __0\n         * @return {?}\n         */\n        ([prev, cur]) => this._changeDataSource(prev, cur))), \n        // Replay the last emitted data when someone subscribes.\n        shareReplay(1));\n        /**\n         * The differ used to calculate changes to the data.\n         */\n        this._differ = null;\n        /**\n         * The template cache used to hold on ot template instancess that have been stamped out, but don't\n         * currently need to be rendered. These instances will be reused in the future rather than\n         * stamping out brand new ones.\n         */\n        this._templateCache = [];\n        /**\n         * Whether the rendered data should be updated during the next ngDoCheck cycle.\n         */\n        this._needsUpdate = false;\n        this._destroyed = new Subject();\n        this.dataStream.subscribe((/**\n         * @param {?} data\n         * @return {?}\n         */\n        data => {\n            this._data = data;\n            this._onRenderedDataChange();\n        }));\n        this._viewport.renderedRangeStream.pipe(takeUntil(this._destroyed)).subscribe((/**\n         * @param {?} range\n         * @return {?}\n         */\n        range => {\n            this._renderedRange = range;\n            ngZone.run((/**\n             * @return {?}\n             */\n            () => this.viewChange.next(this._renderedRange)));\n            this._onRenderedDataChange();\n        }));\n        this._viewport.attach(this);\n    }\n    /**\n     * The DataSource to display.\n     * @return {?}\n     */\n    get cdkVirtualForOf() {\n        return this._cdkVirtualForOf;\n    }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set cdkVirtualForOf(value) {\n        this._cdkVirtualForOf = value;\n        if (isDataSource(value)) {\n            this._dataSourceChanges.next(value);\n        }\n        else {\n            // Slice the value if its an NgIterable to ensure we're working with an array.\n            this._dataSourceChanges.next(new ArrayDataSource(isObservable(value) ? value : Array.prototype.slice.call(value || [])));\n        }\n    }\n    /**\n     * The `TrackByFunction` to use for tracking changes. The `TrackByFunction` takes the index and\n     * the item and produces a value to be used as the item's identity when tracking changes.\n     * @return {?}\n     */\n    get cdkVirtualForTrackBy() {\n        return this._cdkVirtualForTrackBy;\n    }\n    /**\n     * @param {?} fn\n     * @return {?}\n     */\n    set cdkVirtualForTrackBy(fn) {\n        this._needsUpdate = true;\n        this._cdkVirtualForTrackBy = fn ?\n            (/**\n             * @param {?} index\n             * @param {?} item\n             * @return {?}\n             */\n            (index, item) => fn(index + (this._renderedRange ? this._renderedRange.start : 0), item)) :\n            undefined;\n    }\n    /**\n     * The template used to stamp out new elements.\n     * @param {?} value\n     * @return {?}\n     */\n    set cdkVirtualForTemplate(value) {\n        if (value) {\n            this._needsUpdate = true;\n            this._template = value;\n        }\n    }\n    /**\n     * Measures the combined size (width for horizontal orientation, height for vertical) of all items\n     * in the specified range. Throws an error if the range includes items that are not currently\n     * rendered.\n     * @param {?} range\n     * @param {?} orientation\n     * @return {?}\n     */\n    measureRangeSize(range, orientation) {\n        if (range.start >= range.end) {\n            return 0;\n        }\n        if (range.start < this._renderedRange.start || range.end > this._renderedRange.end) {\n            throw Error(`Error: attempted to measure an item that isn't rendered.`);\n        }\n        // The index into the list of rendered views for the first item in the range.\n        /** @type {?} */\n        const renderedStartIndex = range.start - this._renderedRange.start;\n        // The length of the range we're measuring.\n        /** @type {?} */\n        const rangeLen = range.end - range.start;\n        // Loop over all root nodes for all items in the range and sum up their size.\n        /** @type {?} */\n        let totalSize = 0;\n        /** @type {?} */\n        let i = rangeLen;\n        while (i--) {\n            /** @type {?} */\n            const view = (/** @type {?} */ (this._viewContainerRef.get(i + renderedStartIndex)));\n            /** @type {?} */\n            let j = view ? view.rootNodes.length : 0;\n            while (j--) {\n                totalSize += getSize(orientation, (/** @type {?} */ (view)).rootNodes[j]);\n            }\n        }\n        return totalSize;\n    }\n    /**\n     * @return {?}\n     */\n    ngDoCheck() {\n        if (this._differ && this._needsUpdate) {\n            // TODO(mmalerba): We should differentiate needs update due to scrolling and a new portion of\n            // this list being rendered (can use simpler algorithm) vs needs update due to data actually\n            // changing (need to do this diff).\n            /** @type {?} */\n            const changes = this._differ.diff(this._renderedItems);\n            if (!changes) {\n                this._updateContext();\n            }\n            else {\n                this._applyChanges(changes);\n            }\n            this._needsUpdate = false;\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._viewport.detach();\n        this._dataSourceChanges.next();\n        this._dataSourceChanges.complete();\n        this.viewChange.complete();\n        this._destroyed.next();\n        this._destroyed.complete();\n        for (let view of this._templateCache) {\n            view.destroy();\n        }\n    }\n    /**\n     * React to scroll state changes in the viewport.\n     * @private\n     * @return {?}\n     */\n    _onRenderedDataChange() {\n        if (!this._renderedRange) {\n            return;\n        }\n        this._renderedItems = this._data.slice(this._renderedRange.start, this._renderedRange.end);\n        if (!this._differ) {\n            this._differ = this._differs.find(this._renderedItems).create(this.cdkVirtualForTrackBy);\n        }\n        this._needsUpdate = true;\n    }\n    /**\n     * Swap out one `DataSource` for another.\n     * @private\n     * @param {?} oldDs\n     * @param {?} newDs\n     * @return {?}\n     */\n    _changeDataSource(oldDs, newDs) {\n        if (oldDs) {\n            oldDs.disconnect(this);\n        }\n        this._needsUpdate = true;\n        return newDs ? newDs.connect(this) : of();\n    }\n    /**\n     * Update the `CdkVirtualForOfContext` for all views.\n     * @private\n     * @return {?}\n     */\n    _updateContext() {\n        /** @type {?} */\n        const count = this._data.length;\n        /** @type {?} */\n        let i = this._viewContainerRef.length;\n        while (i--) {\n            /** @type {?} */\n            let view = (/** @type {?} */ (this._viewContainerRef.get(i)));\n            view.context.index = this._renderedRange.start + i;\n            view.context.count = count;\n            this._updateComputedContextProperties(view.context);\n            view.detectChanges();\n        }\n    }\n    /**\n     * Apply changes to the DOM.\n     * @private\n     * @param {?} changes\n     * @return {?}\n     */\n    _applyChanges(changes) {\n        // Rearrange the views to put them in the right location.\n        changes.forEachOperation((/**\n         * @param {?} record\n         * @param {?} adjustedPreviousIndex\n         * @param {?} currentIndex\n         * @return {?}\n         */\n        (record, adjustedPreviousIndex, currentIndex) => {\n            if (record.previousIndex == null) { // Item added.\n                // Item added.\n                /** @type {?} */\n                const view = this._insertViewForNewItem((/** @type {?} */ (currentIndex)));\n                view.context.$implicit = record.item;\n            }\n            else if (currentIndex == null) { // Item removed.\n                this._cacheView(this._detachView((/** @type {?} */ (adjustedPreviousIndex))));\n            }\n            else { // Item moved.\n                // Item moved.\n                /** @type {?} */\n                const view = (/** @type {?} */ (this._viewContainerRef.get((/** @type {?} */ (adjustedPreviousIndex)))));\n                this._viewContainerRef.move(view, currentIndex);\n                view.context.$implicit = record.item;\n            }\n        }));\n        // Update $implicit for any items that had an identity change.\n        changes.forEachIdentityChange((/**\n         * @param {?} record\n         * @return {?}\n         */\n        (record) => {\n            /** @type {?} */\n            const view = (/** @type {?} */ (this._viewContainerRef.get((/** @type {?} */ (record.currentIndex)))));\n            view.context.$implicit = record.item;\n        }));\n        // Update the context variables on all items.\n        /** @type {?} */\n        const count = this._data.length;\n        /** @type {?} */\n        let i = this._viewContainerRef.length;\n        while (i--) {\n            /** @type {?} */\n            const view = (/** @type {?} */ (this._viewContainerRef.get(i)));\n            view.context.index = this._renderedRange.start + i;\n            view.context.count = count;\n            this._updateComputedContextProperties(view.context);\n        }\n    }\n    /**\n     * Cache the given detached view.\n     * @private\n     * @param {?} view\n     * @return {?}\n     */\n    _cacheView(view) {\n        if (this._templateCache.length < this.cdkVirtualForTemplateCacheSize) {\n            this._templateCache.push(view);\n        }\n        else {\n            /** @type {?} */\n            const index = this._viewContainerRef.indexOf(view);\n            // It's very unlikely that the index will ever be -1, but just in case,\n            // destroy the view on its own, otherwise destroy it through the\n            // container to ensure that all the references are removed.\n            if (index === -1) {\n                view.destroy();\n            }\n            else {\n                this._viewContainerRef.remove(index);\n            }\n        }\n    }\n    /**\n     * Inserts a view for a new item, either from the cache or by creating a new one.\n     * @private\n     * @param {?} index\n     * @return {?}\n     */\n    _insertViewForNewItem(index) {\n        return this._insertViewFromCache(index) || this._createEmbeddedViewAt(index);\n    }\n    /**\n     * Update the computed properties on the `CdkVirtualForOfContext`.\n     * @private\n     * @param {?} context\n     * @return {?}\n     */\n    _updateComputedContextProperties(context) {\n        context.first = context.index === 0;\n        context.last = context.index === context.count - 1;\n        context.even = context.index % 2 === 0;\n        context.odd = !context.even;\n    }\n    /**\n     * Creates a new embedded view and moves it to the given index\n     * @private\n     * @param {?} index\n     * @return {?}\n     */\n    _createEmbeddedViewAt(index) {\n        // Note that it's important that we insert the item directly at the proper index,\n        // rather than inserting it and the moving it in place, because if there's a directive\n        // on the same node that injects the `ViewContainerRef`, Angular will insert another\n        // comment node which can throw off the move when it's being repeated for all items.\n        return this._viewContainerRef.createEmbeddedView(this._template, {\n            $implicit: (/** @type {?} */ (null)),\n            // It's guaranteed that the iterable is not \"undefined\" or \"null\" because we only\n            // generate views for elements if the \"cdkVirtualForOf\" iterable has elements.\n            cdkVirtualForOf: (/** @type {?} */ (this._cdkVirtualForOf)),\n            index: -1,\n            count: -1,\n            first: false,\n            last: false,\n            odd: false,\n            even: false\n        }, index);\n    }\n    /**\n     * Inserts a recycled view from the cache at the given index.\n     * @private\n     * @param {?} index\n     * @return {?}\n     */\n    _insertViewFromCache(index) {\n        /** @type {?} */\n        const cachedView = this._templateCache.pop();\n        if (cachedView) {\n            this._viewContainerRef.insert(cachedView, index);\n        }\n        return cachedView || null;\n    }\n    /**\n     * Detaches the embedded view at the given index.\n     * @private\n     * @param {?} index\n     * @return {?}\n     */\n    _detachView(index) {\n        return (/** @type {?} */ (this._viewContainerRef.detach(index)));\n    }\n}\nCdkVirtualForOf.ɵfac = function CdkVirtualForOf_Factory(t) { return new (t || CdkVirtualForOf)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.IterableDiffers), ɵngcc0.ɵɵdirectiveInject(CdkVirtualScrollViewport, 4), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone)); };\nCdkVirtualForOf.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: CdkVirtualForOf, selectors: [[\"\", \"cdkVirtualFor\", \"\", \"cdkVirtualForOf\", \"\"]], inputs: { cdkVirtualForTemplateCacheSize: \"cdkVirtualForTemplateCacheSize\", cdkVirtualForOf: \"cdkVirtualForOf\", cdkVirtualForTrackBy: \"cdkVirtualForTrackBy\", cdkVirtualForTemplate: \"cdkVirtualForTemplate\" } });\n/** @nocollapse */\nCdkVirtualForOf.ctorParameters = () => [\n    { type: ViewContainerRef },\n    { type: TemplateRef },\n    { type: IterableDiffers },\n    { type: CdkVirtualScrollViewport, decorators: [{ type: SkipSelf }] },\n    { type: NgZone }\n];\nCdkVirtualForOf.propDecorators = {\n    cdkVirtualForOf: [{ type: Input }],\n    cdkVirtualForTrackBy: [{ type: Input }],\n    cdkVirtualForTemplate: [{ type: Input }],\n    cdkVirtualForTemplateCacheSize: [{ type: Input }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(CdkVirtualForOf, [{\n        type: Directive,\n        args: [{\n                selector: '[cdkVirtualFor][cdkVirtualForOf]'\n            }]\n    }], function () { return [{ type: ɵngcc0.ViewContainerRef }, { type: ɵngcc0.TemplateRef }, { type: ɵngcc0.IterableDiffers }, { type: CdkVirtualScrollViewport, decorators: [{\n                type: SkipSelf\n            }] }, { type: ɵngcc0.NgZone }]; }, { cdkVirtualForTemplateCacheSize: [{\n            type: Input\n        }], cdkVirtualForOf: [{\n            type: Input\n        }], cdkVirtualForTrackBy: [{\n            type: Input\n        }], cdkVirtualForTemplate: [{\n            type: Input\n        }] }); })();\nif (false) {\n    /**\n     * Emits when the rendered view of the data changes.\n     * @type {?}\n     */\n    CdkVirtualForOf.prototype.viewChange;\n    /**\n     * Subject that emits when a new DataSource instance is given.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualForOf.prototype._dataSourceChanges;\n    /** @type {?} */\n    CdkVirtualForOf.prototype._cdkVirtualForOf;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkVirtualForOf.prototype._cdkVirtualForTrackBy;\n    /**\n     * The size of the cache used to store templates that are not being used for re-use later.\n     * Setting the cache size to `0` will disable caching. Defaults to 20 templates.\n     * @type {?}\n     */\n    CdkVirtualForOf.prototype.cdkVirtualForTemplateCacheSize;\n    /**\n     * Emits whenever the data in the current DataSource changes.\n     * @type {?}\n     */\n    CdkVirtualForOf.prototype.dataStream;\n    /**\n     * The differ used to calculate changes to the data.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualForOf.prototype._differ;\n    /**\n     * The most recent data emitted from the DataSource.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualForOf.prototype._data;\n    /**\n     * The currently rendered items.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualForOf.prototype._renderedItems;\n    /**\n     * The currently rendered range of indices.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualForOf.prototype._renderedRange;\n    /**\n     * The template cache used to hold on ot template instancess that have been stamped out, but don't\n     * currently need to be rendered. These instances will be reused in the future rather than\n     * stamping out brand new ones.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualForOf.prototype._templateCache;\n    /**\n     * Whether the rendered data should be updated during the next ngDoCheck cycle.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualForOf.prototype._needsUpdate;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkVirtualForOf.prototype._destroyed;\n    /**\n     * The view container to add items to.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualForOf.prototype._viewContainerRef;\n    /**\n     * The template to use when stamping out new items.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualForOf.prototype._template;\n    /**\n     * The set of available differs.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualForOf.prototype._differs;\n    /**\n     * The virtual scrolling viewport that these items are being rendered in.\n     * @type {?}\n     * @private\n     */\n    CdkVirtualForOf.prototype._viewport;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/scrolling/scrolling-module.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass CdkScrollableModule {\n}\nCdkScrollableModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: CdkScrollableModule });\nCdkScrollableModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function CdkScrollableModule_Factory(t) { return new (t || CdkScrollableModule)(); } });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(CdkScrollableModule, { declarations: [CdkScrollable], exports: [CdkScrollable] }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(CdkScrollableModule, [{\n        type: NgModule,\n        args: [{\n                exports: [CdkScrollable],\n                declarations: [CdkScrollable]\n            }]\n    }], null, null); })();\nclass ScrollingModule {\n}\nScrollingModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: ScrollingModule });\nScrollingModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function ScrollingModule_Factory(t) { return new (t || ScrollingModule)(); }, imports: [[\n            BidiModule,\n            PlatformModule,\n            CdkScrollableModule\n        ],\n        BidiModule,\n        CdkScrollableModule] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(ScrollingModule, { declarations: function () { return [CdkFixedSizeVirtualScroll,\n        CdkVirtualForOf,\n        CdkVirtualScrollViewport]; }, imports: function () { return [BidiModule,\n        PlatformModule,\n        CdkScrollableModule]; }, exports: function () { return [BidiModule,\n        CdkScrollableModule,\n        CdkFixedSizeVirtualScroll,\n        CdkVirtualForOf,\n        CdkVirtualScrollViewport]; } }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(ScrollingModule, [{\n        type: NgModule,\n        args: [{\n                imports: [\n                    BidiModule,\n                    PlatformModule,\n                    CdkScrollableModule\n                ],\n                exports: [\n                    BidiModule,\n                    CdkScrollableModule,\n                    CdkFixedSizeVirtualScroll,\n                    CdkVirtualForOf,\n                    CdkVirtualScrollViewport,\n                ],\n                declarations: [\n                    CdkFixedSizeVirtualScroll,\n                    CdkVirtualForOf,\n                    CdkVirtualScrollViewport,\n                ]\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/scrolling/public-api.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 { CdkFixedSizeVirtualScroll, CdkScrollable, CdkScrollableModule, CdkVirtualForOf, CdkVirtualScrollViewport, DEFAULT_RESIZE_TIME, DEFAULT_SCROLL_TIME, FixedSizeVirtualScrollStrategy, ScrollDispatcher, ScrollingModule, VIRTUAL_SCROLL_STRATEGY, ViewportRuler, _fixedSizeVirtualScrollStrategyFactory };\n\n//# sourceMappingURL=scrolling.js.map","import { ElementRef, Directive, TemplateRef, ViewContainerRef, EventEmitter, ComponentFactoryResolver, Inject, Output, NgModule } from '@angular/core';\nimport { DOCUMENT } from '@angular/common';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/portal/portal-errors.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 * Throws an exception when attempting to attach a null portal to a host.\n * \\@docs-private\n * @return {?}\n */\nimport * as ɵngcc0 from '@angular/core';\nfunction throwNullPortalError() {\n    throw Error('Must provide a portal to attach');\n}\n/**\n * Throws an exception when attempting to attach a portal to a host that is already attached.\n * \\@docs-private\n * @return {?}\n */\nfunction throwPortalAlreadyAttachedError() {\n    throw Error('Host already has a portal attached');\n}\n/**\n * Throws an exception when attempting to attach a portal to an already-disposed host.\n * \\@docs-private\n * @return {?}\n */\nfunction throwPortalOutletAlreadyDisposedError() {\n    throw Error('This PortalOutlet has already been disposed');\n}\n/**\n * Throws an exception when attempting to attach an unknown portal type.\n * \\@docs-private\n * @return {?}\n */\nfunction throwUnknownPortalTypeError() {\n    throw Error('Attempting to attach an unknown Portal type. BasePortalOutlet accepts either ' +\n        'a ComponentPortal or a TemplatePortal.');\n}\n/**\n * Throws an exception when attempting to attach a portal to a null host.\n * \\@docs-private\n * @return {?}\n */\nfunction throwNullPortalOutletError() {\n    throw Error('Attempting to attach a portal to a null PortalOutlet');\n}\n/**\n * Throws an exception when attempting to detach a portal that is not attached.\n * \\@docs-private\n * @return {?}\n */\nfunction throwNoPortalAttachedError() {\n    throw Error('Attempting to detach a portal that is not attached to a host');\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/portal/portal.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Interface that can be used to generically type a class.\n * @record\n * @template T\n */\nfunction ComponentType() { }\n/**\n * A `Portal` is something that you want to render somewhere else.\n * It can be attach to / detached from a `PortalOutlet`.\n * @abstract\n * @template T\n */\nclass Portal {\n    /**\n     * Attach this portal to a host.\n     * @param {?} host\n     * @return {?}\n     */\n    attach(host) {\n        if (host == null) {\n            throwNullPortalOutletError();\n        }\n        if (host.hasAttached()) {\n            throwPortalAlreadyAttachedError();\n        }\n        this._attachedHost = host;\n        return (/** @type {?} */ (host.attach(this)));\n    }\n    /**\n     * Detach this portal from its host\n     * @return {?}\n     */\n    detach() {\n        /** @type {?} */\n        let host = this._attachedHost;\n        if (host == null) {\n            throwNoPortalAttachedError();\n        }\n        else {\n            this._attachedHost = null;\n            host.detach();\n        }\n    }\n    /**\n     * Whether this portal is attached to a host.\n     * @return {?}\n     */\n    get isAttached() {\n        return this._attachedHost != null;\n    }\n    /**\n     * Sets the PortalOutlet reference without performing `attach()`. This is used directly by\n     * the PortalOutlet when it is performing an `attach()` or `detach()`.\n     * @param {?} host\n     * @return {?}\n     */\n    setAttachedHost(host) {\n        this._attachedHost = host;\n    }\n}\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    Portal.prototype._attachedHost;\n}\n/**\n * A `ComponentPortal` is a portal that instantiates some Component upon attachment.\n * @template T\n */\nclass ComponentPortal extends Portal {\n    /**\n     * @param {?} component\n     * @param {?=} viewContainerRef\n     * @param {?=} injector\n     * @param {?=} componentFactoryResolver\n     */\n    constructor(component, viewContainerRef, injector, componentFactoryResolver) {\n        super();\n        this.component = component;\n        this.viewContainerRef = viewContainerRef;\n        this.injector = injector;\n        this.componentFactoryResolver = componentFactoryResolver;\n    }\n}\nif (false) {\n    /**\n     * The type of the component that will be instantiated for attachment.\n     * @type {?}\n     */\n    ComponentPortal.prototype.component;\n    /**\n     * [Optional] Where the attached component should live in Angular's *logical* component tree.\n     * This is different from where the component *renders*, which is determined by the PortalOutlet.\n     * The origin is necessary when the host is outside of the Angular application context.\n     * @type {?}\n     */\n    ComponentPortal.prototype.viewContainerRef;\n    /**\n     * [Optional] Injector used for the instantiation of the component.\n     * @type {?}\n     */\n    ComponentPortal.prototype.injector;\n    /**\n     * Alternate `ComponentFactoryResolver` to use when resolving the associated component.\n     * Defaults to using the resolver from the outlet that the portal is attached to.\n     * @type {?}\n     */\n    ComponentPortal.prototype.componentFactoryResolver;\n}\n/**\n * A `TemplatePortal` is a portal that represents some embedded template (TemplateRef).\n * @template C\n */\nclass TemplatePortal extends Portal {\n    /**\n     * @param {?} template\n     * @param {?} viewContainerRef\n     * @param {?=} context\n     */\n    constructor(template, viewContainerRef, context) {\n        super();\n        this.templateRef = template;\n        this.viewContainerRef = viewContainerRef;\n        this.context = context;\n    }\n    /**\n     * @return {?}\n     */\n    get origin() {\n        return this.templateRef.elementRef;\n    }\n    /**\n     * Attach the portal to the provided `PortalOutlet`.\n     * When a context is provided it will override the `context` property of the `TemplatePortal`\n     * instance.\n     * @param {?} host\n     * @param {?=} context\n     * @return {?}\n     */\n    attach(host, context = this.context) {\n        this.context = context;\n        return super.attach(host);\n    }\n    /**\n     * @return {?}\n     */\n    detach() {\n        this.context = undefined;\n        return super.detach();\n    }\n}\nif (false) {\n    /**\n     * The embedded template that will be used to instantiate an embedded View in the host.\n     * @type {?}\n     */\n    TemplatePortal.prototype.templateRef;\n    /**\n     * Reference to the ViewContainer into which the template will be stamped out.\n     * @type {?}\n     */\n    TemplatePortal.prototype.viewContainerRef;\n    /**\n     * Contextual data to be passed in to the embedded view.\n     * @type {?}\n     */\n    TemplatePortal.prototype.context;\n}\n/**\n * A `DomPortal` is a portal whose DOM element will be taken from its current position\n * in the DOM and moved into a portal outlet, when it is attached. On detach, the content\n * will be restored to its original position.\n * @template T\n */\nclass DomPortal extends Portal {\n    /**\n     * @param {?} element\n     */\n    constructor(element) {\n        super();\n        this.element = element instanceof ElementRef ? element.nativeElement : element;\n    }\n}\nif (false) {\n    /**\n     * DOM node hosting the portal's content.\n     * @type {?}\n     */\n    DomPortal.prototype.element;\n}\n/**\n * A `PortalOutlet` is an space that can contain a single `Portal`.\n * @record\n */\nfunction PortalOutlet() { }\nif (false) {\n    /**\n     * Attaches a portal to this outlet.\n     * @param {?} portal\n     * @return {?}\n     */\n    PortalOutlet.prototype.attach = function (portal) { };\n    /**\n     * Detaches the currently attached portal from this outlet.\n     * @return {?}\n     */\n    PortalOutlet.prototype.detach = function () { };\n    /**\n     * Performs cleanup before the outlet is destroyed.\n     * @return {?}\n     */\n    PortalOutlet.prototype.dispose = function () { };\n    /**\n     * Whether there is currently a portal attached to this outlet.\n     * @return {?}\n     */\n    PortalOutlet.prototype.hasAttached = function () { };\n}\n/**\n * Partial implementation of PortalOutlet that handles attaching\n * ComponentPortal and TemplatePortal.\n * @abstract\n */\nclass BasePortalOutlet {\n    constructor() {\n        /**\n         * Whether this host has already been permanently disposed.\n         */\n        this._isDisposed = false;\n        // @breaking-change 10.0.0 `attachDomPortal` to become a required abstract method.\n        this.attachDomPortal = null;\n    }\n    /**\n     * Whether this host has an attached portal.\n     * @return {?}\n     */\n    hasAttached() {\n        return !!this._attachedPortal;\n    }\n    /**\n     * Attaches a portal.\n     * @param {?} portal\n     * @return {?}\n     */\n    attach(portal) {\n        if (!portal) {\n            throwNullPortalError();\n        }\n        if (this.hasAttached()) {\n            throwPortalAlreadyAttachedError();\n        }\n        if (this._isDisposed) {\n            throwPortalOutletAlreadyDisposedError();\n        }\n        if (portal instanceof ComponentPortal) {\n            this._attachedPortal = portal;\n            return this.attachComponentPortal(portal);\n        }\n        else if (portal instanceof TemplatePortal) {\n            this._attachedPortal = portal;\n            return this.attachTemplatePortal(portal);\n            // @breaking-change 10.0.0 remove null check for `this.attachDomPortal`.\n        }\n        else if (this.attachDomPortal && portal instanceof DomPortal) {\n            this._attachedPortal = portal;\n            return this.attachDomPortal(portal);\n        }\n        throwUnknownPortalTypeError();\n    }\n    /**\n     * Detaches a previously attached portal.\n     * @return {?}\n     */\n    detach() {\n        if (this._attachedPortal) {\n            this._attachedPortal.setAttachedHost(null);\n            this._attachedPortal = null;\n        }\n        this._invokeDisposeFn();\n    }\n    /**\n     * Permanently dispose of this portal host.\n     * @return {?}\n     */\n    dispose() {\n        if (this.hasAttached()) {\n            this.detach();\n        }\n        this._invokeDisposeFn();\n        this._isDisposed = true;\n    }\n    /**\n     * \\@docs-private\n     * @param {?} fn\n     * @return {?}\n     */\n    setDisposeFn(fn) {\n        this._disposeFn = fn;\n    }\n    /**\n     * @private\n     * @return {?}\n     */\n    _invokeDisposeFn() {\n        if (this._disposeFn) {\n            this._disposeFn();\n            this._disposeFn = null;\n        }\n    }\n}\nif (false) {\n    /**\n     * The portal currently attached to the host.\n     * @type {?}\n     * @protected\n     */\n    BasePortalOutlet.prototype._attachedPortal;\n    /**\n     * A function that will permanently dispose this host.\n     * @type {?}\n     * @private\n     */\n    BasePortalOutlet.prototype._disposeFn;\n    /**\n     * Whether this host has already been permanently disposed.\n     * @type {?}\n     * @private\n     */\n    BasePortalOutlet.prototype._isDisposed;\n    /** @type {?} */\n    BasePortalOutlet.prototype.attachDomPortal;\n    /**\n     * @abstract\n     * @template T\n     * @param {?} portal\n     * @return {?}\n     */\n    BasePortalOutlet.prototype.attachComponentPortal = function (portal) { };\n    /**\n     * @abstract\n     * @template C\n     * @param {?} portal\n     * @return {?}\n     */\n    BasePortalOutlet.prototype.attachTemplatePortal = function (portal) { };\n}\n/**\n * @deprecated Use `BasePortalOutlet` instead.\n * \\@breaking-change 9.0.0\n * @abstract\n */\nclass BasePortalHost extends BasePortalOutlet {\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/portal/dom-portal-outlet.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * A PortalOutlet for attaching portals to an arbitrary DOM element outside of the Angular\n * application context.\n */\nclass DomPortalOutlet extends BasePortalOutlet {\n    /**\n     * @param {?} outletElement\n     * @param {?} _componentFactoryResolver\n     * @param {?} _appRef\n     * @param {?} _defaultInjector\n     * @param {?=} _document\n     */\n    constructor(outletElement, _componentFactoryResolver, _appRef, _defaultInjector, \n    /**\n     * @deprecated `_document` Parameter to be made required.\n     * @breaking-change 10.0.0\n     */\n    _document) {\n        super();\n        this.outletElement = outletElement;\n        this._componentFactoryResolver = _componentFactoryResolver;\n        this._appRef = _appRef;\n        this._defaultInjector = _defaultInjector;\n        /**\n         * Attaches a DOM portal by transferring its content into the outlet.\n         * @param portal Portal to be attached.\n         * @deprecated To be turned into a method.\n         * \\@breaking-change 10.0.0\n         */\n        this.attachDomPortal = (/**\n         * @param {?} portal\n         * @return {?}\n         */\n        (portal) => {\n            // @breaking-change 10.0.0 Remove check and error once the\n            // `_document` constructor parameter is required.\n            if (!this._document) {\n                throw Error('Cannot attach DOM portal without _document constructor parameter');\n            }\n            /** @type {?} */\n            const element = portal.element;\n            if (!element.parentNode) {\n                throw Error('DOM portal content must be attached to a parent node.');\n            }\n            // Anchor used to save the element's previous position so\n            // that we can restore it when the portal is detached.\n            /** @type {?} */\n            const anchorNode = this._document.createComment('dom-portal');\n            element.parentNode.insertBefore(anchorNode, element);\n            this.outletElement.appendChild(element);\n            super.setDisposeFn((/**\n             * @return {?}\n             */\n            () => {\n                // We can't use `replaceWith` here because IE doesn't support it.\n                if (anchorNode.parentNode) {\n                    anchorNode.parentNode.replaceChild(element, anchorNode);\n                }\n            }));\n        });\n        this._document = _document;\n    }\n    /**\n     * Attach the given ComponentPortal to DOM element using the ComponentFactoryResolver.\n     * @template T\n     * @param {?} portal Portal to be attached\n     * @return {?} Reference to the created component.\n     */\n    attachComponentPortal(portal) {\n        /** @type {?} */\n        const resolver = portal.componentFactoryResolver || this._componentFactoryResolver;\n        /** @type {?} */\n        const componentFactory = resolver.resolveComponentFactory(portal.component);\n        /** @type {?} */\n        let componentRef;\n        // If the portal specifies a ViewContainerRef, we will use that as the attachment point\n        // for the component (in terms of Angular's component tree, not rendering).\n        // When the ViewContainerRef is missing, we use the factory to create the component directly\n        // and then manually attach the view to the application.\n        if (portal.viewContainerRef) {\n            componentRef = portal.viewContainerRef.createComponent(componentFactory, portal.viewContainerRef.length, portal.injector || portal.viewContainerRef.injector);\n            this.setDisposeFn((/**\n             * @return {?}\n             */\n            () => componentRef.destroy()));\n        }\n        else {\n            componentRef = componentFactory.create(portal.injector || this._defaultInjector);\n            this._appRef.attachView(componentRef.hostView);\n            this.setDisposeFn((/**\n             * @return {?}\n             */\n            () => {\n                this._appRef.detachView(componentRef.hostView);\n                componentRef.destroy();\n            }));\n        }\n        // At this point the component has been instantiated, so we move it to the location in the DOM\n        // where we want it to be rendered.\n        this.outletElement.appendChild(this._getComponentRootNode(componentRef));\n        return componentRef;\n    }\n    /**\n     * Attaches a template portal to the DOM as an embedded view.\n     * @template C\n     * @param {?} portal Portal to be attached.\n     * @return {?} Reference to the created embedded view.\n     */\n    attachTemplatePortal(portal) {\n        /** @type {?} */\n        let viewContainer = portal.viewContainerRef;\n        /** @type {?} */\n        let viewRef = viewContainer.createEmbeddedView(portal.templateRef, portal.context);\n        viewRef.detectChanges();\n        // The method `createEmbeddedView` will add the view as a child of the viewContainer.\n        // But for the DomPortalOutlet the view can be added everywhere in the DOM\n        // (e.g Overlay Container) To move the view to the specified host element. We just\n        // re-append the existing root nodes.\n        viewRef.rootNodes.forEach((/**\n         * @param {?} rootNode\n         * @return {?}\n         */\n        rootNode => this.outletElement.appendChild(rootNode)));\n        this.setDisposeFn(((/**\n         * @return {?}\n         */\n        () => {\n            /** @type {?} */\n            let index = viewContainer.indexOf(viewRef);\n            if (index !== -1) {\n                viewContainer.remove(index);\n            }\n        })));\n        // TODO(jelbourn): Return locals from view.\n        return viewRef;\n    }\n    /**\n     * Clears out a portal from the DOM.\n     * @return {?}\n     */\n    dispose() {\n        super.dispose();\n        if (this.outletElement.parentNode != null) {\n            this.outletElement.parentNode.removeChild(this.outletElement);\n        }\n    }\n    /**\n     * Gets the root HTMLElement for an instantiated component.\n     * @private\n     * @param {?} componentRef\n     * @return {?}\n     */\n    _getComponentRootNode(componentRef) {\n        return (/** @type {?} */ (((/** @type {?} */ (componentRef.hostView))).rootNodes[0]));\n    }\n}\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    DomPortalOutlet.prototype._document;\n    /**\n     * Attaches a DOM portal by transferring its content into the outlet.\n     * \\@param portal Portal to be attached.\n     * @deprecated To be turned into a method.\n     * \\@breaking-change 10.0.0\n     * @type {?}\n     */\n    DomPortalOutlet.prototype.attachDomPortal;\n    /**\n     * Element into which the content is projected.\n     * @type {?}\n     */\n    DomPortalOutlet.prototype.outletElement;\n    /**\n     * @type {?}\n     * @private\n     */\n    DomPortalOutlet.prototype._componentFactoryResolver;\n    /**\n     * @type {?}\n     * @private\n     */\n    DomPortalOutlet.prototype._appRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    DomPortalOutlet.prototype._defaultInjector;\n}\n/**\n * @deprecated Use `DomPortalOutlet` instead.\n * \\@breaking-change 9.0.0\n */\nclass DomPortalHost extends DomPortalOutlet {\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/portal/portal-directives.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Directive version of a `TemplatePortal`. Because the directive *is* a TemplatePortal,\n * the directive instance itself can be attached to a host, enabling declarative use of portals.\n */\nclass CdkPortal extends TemplatePortal {\n    /**\n     * @param {?} templateRef\n     * @param {?} viewContainerRef\n     */\n    constructor(templateRef, viewContainerRef) {\n        super(templateRef, viewContainerRef);\n    }\n}\nCdkPortal.ɵfac = function CdkPortal_Factory(t) { return new (t || CdkPortal)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef)); };\nCdkPortal.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: CdkPortal, selectors: [[\"\", \"cdkPortal\", \"\"]], exportAs: [\"cdkPortal\"], features: [ɵngcc0.ɵɵInheritDefinitionFeature] });\n/** @nocollapse */\nCdkPortal.ctorParameters = () => [\n    { type: TemplateRef },\n    { type: ViewContainerRef }\n];\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(CdkPortal, [{\n        type: Directive,\n        args: [{\n                selector: '[cdkPortal]',\n                exportAs: 'cdkPortal'\n            }]\n    }], function () { return [{ type: ɵngcc0.TemplateRef }, { type: ɵngcc0.ViewContainerRef }]; }, null); })();\n/**\n * @deprecated Use `CdkPortal` instead.\n * \\@breaking-change 9.0.0\n */\nclass TemplatePortalDirective extends CdkPortal {\n}\nTemplatePortalDirective.ɵfac = function TemplatePortalDirective_Factory(t) { return ɵTemplatePortalDirective_BaseFactory(t || TemplatePortalDirective); };\nTemplatePortalDirective.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: TemplatePortalDirective, selectors: [[\"\", \"cdk-portal\", \"\"], [\"\", \"portal\", \"\"]], exportAs: [\"cdkPortal\"], features: [ɵngcc0.ɵɵProvidersFeature([{\n                provide: CdkPortal,\n                useExisting: TemplatePortalDirective\n            }]), ɵngcc0.ɵɵInheritDefinitionFeature] });\nconst ɵTemplatePortalDirective_BaseFactory = ɵngcc0.ɵɵgetInheritedFactory(TemplatePortalDirective);\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(TemplatePortalDirective, [{\n        type: Directive,\n        args: [{\n                selector: '[cdk-portal], [portal]',\n                exportAs: 'cdkPortal',\n                providers: [{\n                        provide: CdkPortal,\n                        useExisting: TemplatePortalDirective\n                    }]\n            }]\n    }], null, null); })();\n/**\n * Directive version of a PortalOutlet. Because the directive *is* a PortalOutlet, portals can be\n * directly attached to it, enabling declarative use.\n *\n * Usage:\n * `<ng-template [cdkPortalOutlet]=\"greeting\"></ng-template>`\n */\nclass CdkPortalOutlet extends BasePortalOutlet {\n    /**\n     * @param {?} _componentFactoryResolver\n     * @param {?} _viewContainerRef\n     * @param {?=} _document\n     */\n    constructor(_componentFactoryResolver, _viewContainerRef, \n    /**\n     * @deprecated `_document` parameter to be made required.\n     * @breaking-change 9.0.0\n     */\n    _document) {\n        super();\n        this._componentFactoryResolver = _componentFactoryResolver;\n        this._viewContainerRef = _viewContainerRef;\n        /**\n         * Whether the portal component is initialized.\n         */\n        this._isInitialized = false;\n        /**\n         * Emits when a portal is attached to the outlet.\n         */\n        this.attached = new EventEmitter();\n        /**\n         * Attaches the given DomPortal to this PortalHost by moving all of the portal content into it.\n         * @param portal Portal to be attached.\n         * @deprecated To be turned into a method.\n         * \\@breaking-change 10.0.0\n         */\n        this.attachDomPortal = (/**\n         * @param {?} portal\n         * @return {?}\n         */\n        (portal) => {\n            // @breaking-change 9.0.0 Remove check and error once the\n            // `_document` constructor parameter is required.\n            if (!this._document) {\n                throw Error('Cannot attach DOM portal without _document constructor parameter');\n            }\n            /** @type {?} */\n            const element = portal.element;\n            if (!element.parentNode) {\n                throw Error('DOM portal content must be attached to a parent node.');\n            }\n            // Anchor used to save the element's previous position so\n            // that we can restore it when the portal is detached.\n            /** @type {?} */\n            const anchorNode = this._document.createComment('dom-portal');\n            portal.setAttachedHost(this);\n            element.parentNode.insertBefore(anchorNode, element);\n            this._getRootNode().appendChild(element);\n            super.setDisposeFn((/**\n             * @return {?}\n             */\n            () => {\n                if (anchorNode.parentNode) {\n                    (/** @type {?} */ (anchorNode.parentNode)).replaceChild(element, anchorNode);\n                }\n            }));\n        });\n        this._document = _document;\n    }\n    /**\n     * Portal associated with the Portal outlet.\n     * @return {?}\n     */\n    get portal() {\n        return this._attachedPortal;\n    }\n    /**\n     * @param {?} portal\n     * @return {?}\n     */\n    set portal(portal) {\n        // Ignore the cases where the `portal` is set to a falsy value before the lifecycle hooks have\n        // run. This handles the cases where the user might do something like `<div cdkPortalOutlet>`\n        // and attach a portal programmatically in the parent component. When Angular does the first CD\n        // round, it will fire the setter with empty string, causing the user's content to be cleared.\n        if (this.hasAttached() && !portal && !this._isInitialized) {\n            return;\n        }\n        if (this.hasAttached()) {\n            super.detach();\n        }\n        if (portal) {\n            super.attach(portal);\n        }\n        this._attachedPortal = portal;\n    }\n    /**\n     * Component or view reference that is attached to the portal.\n     * @return {?}\n     */\n    get attachedRef() {\n        return this._attachedRef;\n    }\n    /**\n     * @return {?}\n     */\n    ngOnInit() {\n        this._isInitialized = true;\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        super.dispose();\n        this._attachedPortal = null;\n        this._attachedRef = null;\n    }\n    /**\n     * Attach the given ComponentPortal to this PortalOutlet using the ComponentFactoryResolver.\n     *\n     * @template T\n     * @param {?} portal Portal to be attached to the portal outlet.\n     * @return {?} Reference to the created component.\n     */\n    attachComponentPortal(portal) {\n        portal.setAttachedHost(this);\n        // If the portal specifies an origin, use that as the logical location of the component\n        // in the application tree. Otherwise use the location of this PortalOutlet.\n        /** @type {?} */\n        const viewContainerRef = portal.viewContainerRef != null ?\n            portal.viewContainerRef :\n            this._viewContainerRef;\n        /** @type {?} */\n        const resolver = portal.componentFactoryResolver || this._componentFactoryResolver;\n        /** @type {?} */\n        const componentFactory = resolver.resolveComponentFactory(portal.component);\n        /** @type {?} */\n        const ref = viewContainerRef.createComponent(componentFactory, viewContainerRef.length, portal.injector || viewContainerRef.injector);\n        // If we're using a view container that's different from the injected one (e.g. when the portal\n        // specifies its own) we need to move the component into the outlet, otherwise it'll be rendered\n        // inside of the alternate view container.\n        if (viewContainerRef !== this._viewContainerRef) {\n            this._getRootNode().appendChild(((/** @type {?} */ (ref.hostView))).rootNodes[0]);\n        }\n        super.setDisposeFn((/**\n         * @return {?}\n         */\n        () => ref.destroy()));\n        this._attachedPortal = portal;\n        this._attachedRef = ref;\n        this.attached.emit(ref);\n        return ref;\n    }\n    /**\n     * Attach the given TemplatePortal to this PortalHost as an embedded View.\n     * @template C\n     * @param {?} portal Portal to be attached.\n     * @return {?} Reference to the created embedded view.\n     */\n    attachTemplatePortal(portal) {\n        portal.setAttachedHost(this);\n        /** @type {?} */\n        const viewRef = this._viewContainerRef.createEmbeddedView(portal.templateRef, portal.context);\n        super.setDisposeFn((/**\n         * @return {?}\n         */\n        () => this._viewContainerRef.clear()));\n        this._attachedPortal = portal;\n        this._attachedRef = viewRef;\n        this.attached.emit(viewRef);\n        return viewRef;\n    }\n    /**\n     * Gets the root node of the portal outlet.\n     * @private\n     * @return {?}\n     */\n    _getRootNode() {\n        /** @type {?} */\n        const nativeElement = this._viewContainerRef.element.nativeElement;\n        // The directive could be set on a template which will result in a comment\n        // node being the root. Use the comment's parent node if that is the case.\n        return (/** @type {?} */ ((nativeElement.nodeType === nativeElement.ELEMENT_NODE ?\n            nativeElement : (/** @type {?} */ (nativeElement.parentNode)))));\n    }\n}\nCdkPortalOutlet.ɵfac = function CdkPortalOutlet_Factory(t) { return new (t || CdkPortalOutlet)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ComponentFactoryResolver), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(DOCUMENT)); };\nCdkPortalOutlet.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: CdkPortalOutlet, selectors: [[\"\", \"cdkPortalOutlet\", \"\"]], inputs: { portal: [\"cdkPortalOutlet\", \"portal\"] }, outputs: { attached: \"attached\" }, exportAs: [\"cdkPortalOutlet\"], features: [ɵngcc0.ɵɵInheritDefinitionFeature] });\n/** @nocollapse */\nCdkPortalOutlet.ctorParameters = () => [\n    { type: ComponentFactoryResolver },\n    { type: ViewContainerRef },\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }\n];\nCdkPortalOutlet.propDecorators = {\n    attached: [{ type: Output }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(CdkPortalOutlet, [{\n        type: Directive,\n        args: [{\n                selector: '[cdkPortalOutlet]',\n                exportAs: 'cdkPortalOutlet',\n                inputs: ['portal: cdkPortalOutlet']\n            }]\n    }], function () { return [{ type: ɵngcc0.ComponentFactoryResolver }, { type: ɵngcc0.ViewContainerRef }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }]; }, { attached: [{\n            type: Output\n        }] }); })();\nif (false) {\n    /** @type {?} */\n    CdkPortalOutlet.ngAcceptInputType_portal;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkPortalOutlet.prototype._document;\n    /**\n     * Whether the portal component is initialized.\n     * @type {?}\n     * @private\n     */\n    CdkPortalOutlet.prototype._isInitialized;\n    /**\n     * Reference to the currently-attached component/view ref.\n     * @type {?}\n     * @private\n     */\n    CdkPortalOutlet.prototype._attachedRef;\n    /**\n     * Emits when a portal is attached to the outlet.\n     * @type {?}\n     */\n    CdkPortalOutlet.prototype.attached;\n    /**\n     * Attaches the given DomPortal to this PortalHost by moving all of the portal content into it.\n     * \\@param portal Portal to be attached.\n     * @deprecated To be turned into a method.\n     * \\@breaking-change 10.0.0\n     * @type {?}\n     */\n    CdkPortalOutlet.prototype.attachDomPortal;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkPortalOutlet.prototype._componentFactoryResolver;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkPortalOutlet.prototype._viewContainerRef;\n}\n/**\n * @deprecated Use `CdkPortalOutlet` instead.\n * \\@breaking-change 9.0.0\n */\nclass PortalHostDirective extends CdkPortalOutlet {\n}\nPortalHostDirective.ɵfac = function PortalHostDirective_Factory(t) { return ɵPortalHostDirective_BaseFactory(t || PortalHostDirective); };\nPortalHostDirective.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: PortalHostDirective, selectors: [[\"\", \"cdkPortalHost\", \"\"], [\"\", \"portalHost\", \"\"]], inputs: { portal: [\"cdkPortalHost\", \"portal\"] }, exportAs: [\"cdkPortalHost\"], features: [ɵngcc0.ɵɵProvidersFeature([{\n                provide: CdkPortalOutlet,\n                useExisting: PortalHostDirective\n            }]), ɵngcc0.ɵɵInheritDefinitionFeature] });\nconst ɵPortalHostDirective_BaseFactory = ɵngcc0.ɵɵgetInheritedFactory(PortalHostDirective);\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(PortalHostDirective, [{\n        type: Directive,\n        args: [{\n                selector: '[cdkPortalHost], [portalHost]',\n                exportAs: 'cdkPortalHost',\n                inputs: ['portal: cdkPortalHost'],\n                providers: [{\n                        provide: CdkPortalOutlet,\n                        useExisting: PortalHostDirective\n                    }]\n            }]\n    }], null, null); })();\nclass PortalModule {\n}\nPortalModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: PortalModule });\nPortalModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function PortalModule_Factory(t) { return new (t || PortalModule)(); } });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(PortalModule, { declarations: [CdkPortal,\n        CdkPortalOutlet,\n        TemplatePortalDirective,\n        PortalHostDirective], exports: [CdkPortal,\n        CdkPortalOutlet,\n        TemplatePortalDirective,\n        PortalHostDirective] }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(PortalModule, [{\n        type: NgModule,\n        args: [{\n                exports: [CdkPortal, CdkPortalOutlet, TemplatePortalDirective, PortalHostDirective],\n                declarations: [CdkPortal, CdkPortalOutlet, TemplatePortalDirective, PortalHostDirective]\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/portal/portal-injector.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 * Custom injector to be used when providing custom\n * injection tokens to components inside a portal.\n * \\@docs-private\n */\nclass PortalInjector {\n    /**\n     * @param {?} _parentInjector\n     * @param {?} _customTokens\n     */\n    constructor(_parentInjector, _customTokens) {\n        this._parentInjector = _parentInjector;\n        this._customTokens = _customTokens;\n    }\n    /**\n     * @param {?} token\n     * @param {?=} notFoundValue\n     * @return {?}\n     */\n    get(token, notFoundValue) {\n        /** @type {?} */\n        const value = this._customTokens.get(token);\n        if (typeof value !== 'undefined') {\n            return value;\n        }\n        return this._parentInjector.get(token, notFoundValue);\n    }\n}\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    PortalInjector.prototype._parentInjector;\n    /**\n     * @type {?}\n     * @private\n     */\n    PortalInjector.prototype._customTokens;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/portal/public-api.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 { BasePortalHost, BasePortalOutlet, CdkPortal, CdkPortalOutlet, ComponentPortal, DomPortal, DomPortalHost, DomPortalOutlet, Portal, PortalHostDirective, PortalInjector, PortalModule, TemplatePortal, TemplatePortalDirective };\n\n//# sourceMappingURL=portal.js.map","import { ScrollDispatcher, ViewportRuler, ScrollingModule } from '@angular/cdk/scrolling';\nimport * as ɵngcc0 from '@angular/core';\nimport * as ɵngcc1 from '@angular/cdk/scrolling';\nimport * as ɵngcc2 from '@angular/cdk/platform';\nimport * as ɵngcc3 from '@angular/cdk/bidi';\nimport * as ɵngcc4 from '@angular/common';\nexport { CdkScrollable, ScrollDispatcher, ViewportRuler } from '@angular/cdk/scrolling';\nimport { DOCUMENT, Location } from '@angular/common';\nimport { Injectable, NgZone, Inject, ɵɵdefineInjectable, ɵɵinject, Optional, SkipSelf, ElementRef, ApplicationRef, ComponentFactoryResolver, Injector, InjectionToken, Directive, EventEmitter, TemplateRef, ViewContainerRef, Input, Output, NgModule } from '@angular/core';\nimport { coerceCssPixelValue, coerceArray, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { Directionality, BidiModule } from '@angular/cdk/bidi';\nimport { DomPortalOutlet, TemplatePortal, PortalModule } from '@angular/cdk/portal';\nimport { Platform } from '@angular/cdk/platform';\nimport { Subject, Subscription, Observable, merge } from 'rxjs';\nimport { take, takeUntil } from 'rxjs/operators';\nimport { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/scroll/block-scroll-strategy.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Strategy that will prevent the user from scrolling while the overlay is visible.\n */\nclass BlockScrollStrategy {\n    /**\n     * @param {?} _viewportRuler\n     * @param {?} document\n     */\n    constructor(_viewportRuler, document) {\n        this._viewportRuler = _viewportRuler;\n        this._previousHTMLStyles = { top: '', left: '' };\n        this._isEnabled = false;\n        this._document = document;\n    }\n    /**\n     * Attaches this scroll strategy to an overlay.\n     * @return {?}\n     */\n    attach() { }\n    /**\n     * Blocks page-level scroll while the attached overlay is open.\n     * @return {?}\n     */\n    enable() {\n        if (this._canBeEnabled()) {\n            /** @type {?} */\n            const root = (/** @type {?} */ (this._document.documentElement));\n            this._previousScrollPosition = this._viewportRuler.getViewportScrollPosition();\n            // Cache the previous inline styles in case the user had set them.\n            this._previousHTMLStyles.left = root.style.left || '';\n            this._previousHTMLStyles.top = root.style.top || '';\n            // Note: we're using the `html` node, instead of the `body`, because the `body` may\n            // have the user agent margin, whereas the `html` is guaranteed not to have one.\n            root.style.left = coerceCssPixelValue(-this._previousScrollPosition.left);\n            root.style.top = coerceCssPixelValue(-this._previousScrollPosition.top);\n            root.classList.add('cdk-global-scrollblock');\n            this._isEnabled = true;\n        }\n    }\n    /**\n     * Unblocks page-level scroll while the attached overlay is open.\n     * @return {?}\n     */\n    disable() {\n        if (this._isEnabled) {\n            /** @type {?} */\n            const html = (/** @type {?} */ (this._document.documentElement));\n            /** @type {?} */\n            const body = (/** @type {?} */ (this._document.body));\n            /** @type {?} */\n            const htmlStyle = (/** @type {?} */ (html.style));\n            /** @type {?} */\n            const bodyStyle = (/** @type {?} */ (body.style));\n            /** @type {?} */\n            const previousHtmlScrollBehavior = htmlStyle.scrollBehavior || '';\n            /** @type {?} */\n            const previousBodyScrollBehavior = bodyStyle.scrollBehavior || '';\n            this._isEnabled = false;\n            htmlStyle.left = this._previousHTMLStyles.left;\n            htmlStyle.top = this._previousHTMLStyles.top;\n            html.classList.remove('cdk-global-scrollblock');\n            // Disable user-defined smooth scrolling temporarily while we restore the scroll position.\n            // See https://developer.mozilla.org/en-US/docs/Web/CSS/scroll-behavior\n            htmlStyle.scrollBehavior = bodyStyle.scrollBehavior = 'auto';\n            window.scroll(this._previousScrollPosition.left, this._previousScrollPosition.top);\n            htmlStyle.scrollBehavior = previousHtmlScrollBehavior;\n            bodyStyle.scrollBehavior = previousBodyScrollBehavior;\n        }\n    }\n    /**\n     * @private\n     * @return {?}\n     */\n    _canBeEnabled() {\n        // Since the scroll strategies can't be singletons, we have to use a global CSS class\n        // (`cdk-global-scrollblock`) to make sure that we don't try to disable global\n        // scrolling multiple times.\n        /** @type {?} */\n        const html = (/** @type {?} */ (this._document.documentElement));\n        if (html.classList.contains('cdk-global-scrollblock') || this._isEnabled) {\n            return false;\n        }\n        /** @type {?} */\n        const body = this._document.body;\n        /** @type {?} */\n        const viewport = this._viewportRuler.getViewportSize();\n        return body.scrollHeight > viewport.height || body.scrollWidth > viewport.width;\n    }\n}\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    BlockScrollStrategy.prototype._previousHTMLStyles;\n    /**\n     * @type {?}\n     * @private\n     */\n    BlockScrollStrategy.prototype._previousScrollPosition;\n    /**\n     * @type {?}\n     * @private\n     */\n    BlockScrollStrategy.prototype._isEnabled;\n    /**\n     * @type {?}\n     * @private\n     */\n    BlockScrollStrategy.prototype._document;\n    /**\n     * @type {?}\n     * @private\n     */\n    BlockScrollStrategy.prototype._viewportRuler;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/scroll/scroll-strategy.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 * Describes a strategy that will be used by an overlay to handle scroll events while it is open.\n * @record\n */\nfunction ScrollStrategy() { }\nif (false) {\n    /**\n     * Enable this scroll strategy (called when the attached overlay is attached to a portal).\n     * @type {?}\n     */\n    ScrollStrategy.prototype.enable;\n    /**\n     * Disable this scroll strategy (called when the attached overlay is detached from a portal).\n     * @type {?}\n     */\n    ScrollStrategy.prototype.disable;\n    /**\n     * Attaches this `ScrollStrategy` to an overlay.\n     * @type {?}\n     */\n    ScrollStrategy.prototype.attach;\n    /**\n     * Detaches the scroll strategy from the current overlay.\n     * @type {?|undefined}\n     */\n    ScrollStrategy.prototype.detach;\n}\n/**\n * Returns an error to be thrown when attempting to attach an already-attached scroll strategy.\n * @return {?}\n */\nfunction getMatScrollStrategyAlreadyAttachedError() {\n    return Error(`Scroll strategy has already been attached.`);\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/scroll/close-scroll-strategy.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Config options for the CloseScrollStrategy.\n * @record\n */\nfunction CloseScrollStrategyConfig() { }\nif (false) {\n    /**\n     * Amount of pixels the user has to scroll before the overlay is closed.\n     * @type {?|undefined}\n     */\n    CloseScrollStrategyConfig.prototype.threshold;\n}\n/**\n * Strategy that will close the overlay as soon as the user starts scrolling.\n */\nclass CloseScrollStrategy {\n    /**\n     * @param {?} _scrollDispatcher\n     * @param {?} _ngZone\n     * @param {?} _viewportRuler\n     * @param {?=} _config\n     */\n    constructor(_scrollDispatcher, _ngZone, _viewportRuler, _config) {\n        this._scrollDispatcher = _scrollDispatcher;\n        this._ngZone = _ngZone;\n        this._viewportRuler = _viewportRuler;\n        this._config = _config;\n        this._scrollSubscription = null;\n        /**\n         * Detaches the overlay ref and disables the scroll strategy.\n         */\n        this._detach = (/**\n         * @return {?}\n         */\n        () => {\n            this.disable();\n            if (this._overlayRef.hasAttached()) {\n                this._ngZone.run((/**\n                 * @return {?}\n                 */\n                () => this._overlayRef.detach()));\n            }\n        });\n    }\n    /**\n     * Attaches this scroll strategy to an overlay.\n     * @param {?} overlayRef\n     * @return {?}\n     */\n    attach(overlayRef) {\n        if (this._overlayRef) {\n            throw getMatScrollStrategyAlreadyAttachedError();\n        }\n        this._overlayRef = overlayRef;\n    }\n    /**\n     * Enables the closing of the attached overlay on scroll.\n     * @return {?}\n     */\n    enable() {\n        if (this._scrollSubscription) {\n            return;\n        }\n        /** @type {?} */\n        const stream = this._scrollDispatcher.scrolled(0);\n        if (this._config && this._config.threshold && this._config.threshold > 1) {\n            this._initialScrollPosition = this._viewportRuler.getViewportScrollPosition().top;\n            this._scrollSubscription = stream.subscribe((/**\n             * @return {?}\n             */\n            () => {\n                /** @type {?} */\n                const scrollPosition = this._viewportRuler.getViewportScrollPosition().top;\n                if (Math.abs(scrollPosition - this._initialScrollPosition) > (/** @type {?} */ ((/** @type {?} */ (this._config)).threshold))) {\n                    this._detach();\n                }\n                else {\n                    this._overlayRef.updatePosition();\n                }\n            }));\n        }\n        else {\n            this._scrollSubscription = stream.subscribe(this._detach);\n        }\n    }\n    /**\n     * Disables the closing the attached overlay on scroll.\n     * @return {?}\n     */\n    disable() {\n        if (this._scrollSubscription) {\n            this._scrollSubscription.unsubscribe();\n            this._scrollSubscription = null;\n        }\n    }\n    /**\n     * @return {?}\n     */\n    detach() {\n        this.disable();\n        this._overlayRef = (/** @type {?} */ (null));\n    }\n}\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    CloseScrollStrategy.prototype._scrollSubscription;\n    /**\n     * @type {?}\n     * @private\n     */\n    CloseScrollStrategy.prototype._overlayRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    CloseScrollStrategy.prototype._initialScrollPosition;\n    /**\n     * Detaches the overlay ref and disables the scroll strategy.\n     * @type {?}\n     * @private\n     */\n    CloseScrollStrategy.prototype._detach;\n    /**\n     * @type {?}\n     * @private\n     */\n    CloseScrollStrategy.prototype._scrollDispatcher;\n    /**\n     * @type {?}\n     * @private\n     */\n    CloseScrollStrategy.prototype._ngZone;\n    /**\n     * @type {?}\n     * @private\n     */\n    CloseScrollStrategy.prototype._viewportRuler;\n    /**\n     * @type {?}\n     * @private\n     */\n    CloseScrollStrategy.prototype._config;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/scroll/noop-scroll-strategy.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 * Scroll strategy that doesn't do anything.\n */\nclass NoopScrollStrategy {\n    /**\n     * Does nothing, as this scroll strategy is a no-op.\n     * @return {?}\n     */\n    enable() { }\n    /**\n     * Does nothing, as this scroll strategy is a no-op.\n     * @return {?}\n     */\n    disable() { }\n    /**\n     * Does nothing, as this scroll strategy is a no-op.\n     * @return {?}\n     */\n    attach() { }\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/position/scroll-clip.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// TODO(jelbourn): move this to live with the rest of the scrolling code\n// TODO(jelbourn): someday replace this with IntersectionObservers\n/**\n * Gets whether an element is scrolled outside of view by any of its parent scrolling containers.\n * \\@docs-private\n * @param {?} element Dimensions of the element (from getBoundingClientRect)\n * @param {?} scrollContainers Dimensions of element's scrolling containers (from getBoundingClientRect)\n * @return {?} Whether the element is scrolled out of view\n */\nfunction isElementScrolledOutsideView(element, scrollContainers) {\n    return scrollContainers.some((/**\n     * @param {?} containerBounds\n     * @return {?}\n     */\n    containerBounds => {\n        /** @type {?} */\n        const outsideAbove = element.bottom < containerBounds.top;\n        /** @type {?} */\n        const outsideBelow = element.top > containerBounds.bottom;\n        /** @type {?} */\n        const outsideLeft = element.right < containerBounds.left;\n        /** @type {?} */\n        const outsideRight = element.left > containerBounds.right;\n        return outsideAbove || outsideBelow || outsideLeft || outsideRight;\n    }));\n}\n/**\n * Gets whether an element is clipped by any of its scrolling containers.\n * \\@docs-private\n * @param {?} element Dimensions of the element (from getBoundingClientRect)\n * @param {?} scrollContainers Dimensions of element's scrolling containers (from getBoundingClientRect)\n * @return {?} Whether the element is clipped\n */\nfunction isElementClippedByScrolling(element, scrollContainers) {\n    return scrollContainers.some((/**\n     * @param {?} scrollContainerRect\n     * @return {?}\n     */\n    scrollContainerRect => {\n        /** @type {?} */\n        const clippedAbove = element.top < scrollContainerRect.top;\n        /** @type {?} */\n        const clippedBelow = element.bottom > scrollContainerRect.bottom;\n        /** @type {?} */\n        const clippedLeft = element.left < scrollContainerRect.left;\n        /** @type {?} */\n        const clippedRight = element.right > scrollContainerRect.right;\n        return clippedAbove || clippedBelow || clippedLeft || clippedRight;\n    }));\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/scroll/reposition-scroll-strategy.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Config options for the RepositionScrollStrategy.\n * @record\n */\nfunction RepositionScrollStrategyConfig() { }\nif (false) {\n    /**\n     * Time in milliseconds to throttle the scroll events.\n     * @type {?|undefined}\n     */\n    RepositionScrollStrategyConfig.prototype.scrollThrottle;\n    /**\n     * Whether to close the overlay once the user has scrolled away completely.\n     * @type {?|undefined}\n     */\n    RepositionScrollStrategyConfig.prototype.autoClose;\n}\n/**\n * Strategy that will update the element position as the user is scrolling.\n */\nclass RepositionScrollStrategy {\n    /**\n     * @param {?} _scrollDispatcher\n     * @param {?} _viewportRuler\n     * @param {?} _ngZone\n     * @param {?=} _config\n     */\n    constructor(_scrollDispatcher, _viewportRuler, _ngZone, _config) {\n        this._scrollDispatcher = _scrollDispatcher;\n        this._viewportRuler = _viewportRuler;\n        this._ngZone = _ngZone;\n        this._config = _config;\n        this._scrollSubscription = null;\n    }\n    /**\n     * Attaches this scroll strategy to an overlay.\n     * @param {?} overlayRef\n     * @return {?}\n     */\n    attach(overlayRef) {\n        if (this._overlayRef) {\n            throw getMatScrollStrategyAlreadyAttachedError();\n        }\n        this._overlayRef = overlayRef;\n    }\n    /**\n     * Enables repositioning of the attached overlay on scroll.\n     * @return {?}\n     */\n    enable() {\n        if (!this._scrollSubscription) {\n            /** @type {?} */\n            const throttle = this._config ? this._config.scrollThrottle : 0;\n            this._scrollSubscription = this._scrollDispatcher.scrolled(throttle).subscribe((/**\n             * @return {?}\n             */\n            () => {\n                this._overlayRef.updatePosition();\n                // TODO(crisbeto): make `close` on by default once all components can handle it.\n                if (this._config && this._config.autoClose) {\n                    /** @type {?} */\n                    const overlayRect = this._overlayRef.overlayElement.getBoundingClientRect();\n                    const { width, height } = this._viewportRuler.getViewportSize();\n                    // TODO(crisbeto): include all ancestor scroll containers here once\n                    // we have a way of exposing the trigger element to the scroll strategy.\n                    /** @type {?} */\n                    const parentRects = [{ width, height, bottom: height, right: width, top: 0, left: 0 }];\n                    if (isElementScrolledOutsideView(overlayRect, parentRects)) {\n                        this.disable();\n                        this._ngZone.run((/**\n                         * @return {?}\n                         */\n                        () => this._overlayRef.detach()));\n                    }\n                }\n            }));\n        }\n    }\n    /**\n     * Disables repositioning of the attached overlay on scroll.\n     * @return {?}\n     */\n    disable() {\n        if (this._scrollSubscription) {\n            this._scrollSubscription.unsubscribe();\n            this._scrollSubscription = null;\n        }\n    }\n    /**\n     * @return {?}\n     */\n    detach() {\n        this.disable();\n        this._overlayRef = (/** @type {?} */ (null));\n    }\n}\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    RepositionScrollStrategy.prototype._scrollSubscription;\n    /**\n     * @type {?}\n     * @private\n     */\n    RepositionScrollStrategy.prototype._overlayRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    RepositionScrollStrategy.prototype._scrollDispatcher;\n    /**\n     * @type {?}\n     * @private\n     */\n    RepositionScrollStrategy.prototype._viewportRuler;\n    /**\n     * @type {?}\n     * @private\n     */\n    RepositionScrollStrategy.prototype._ngZone;\n    /**\n     * @type {?}\n     * @private\n     */\n    RepositionScrollStrategy.prototype._config;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/scroll/scroll-strategy-options.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Options for how an overlay will handle scrolling.\n *\n * Users can provide a custom value for `ScrollStrategyOptions` to replace the default\n * behaviors. This class primarily acts as a factory for ScrollStrategy instances.\n */\nclass ScrollStrategyOptions {\n    /**\n     * @param {?} _scrollDispatcher\n     * @param {?} _viewportRuler\n     * @param {?} _ngZone\n     * @param {?} document\n     */\n    constructor(_scrollDispatcher, _viewportRuler, _ngZone, document) {\n        this._scrollDispatcher = _scrollDispatcher;\n        this._viewportRuler = _viewportRuler;\n        this._ngZone = _ngZone;\n        /**\n         * Do nothing on scroll.\n         */\n        this.noop = (/**\n         * @return {?}\n         */\n        () => new NoopScrollStrategy());\n        /**\n         * Close the overlay as soon as the user scrolls.\n         * @param config Configuration to be used inside the scroll strategy.\n         */\n        this.close = (/**\n         * @param {?=} config\n         * @return {?}\n         */\n        (config) => new CloseScrollStrategy(this._scrollDispatcher, this._ngZone, this._viewportRuler, config));\n        /**\n         * Block scrolling.\n         */\n        this.block = (/**\n         * @return {?}\n         */\n        () => new BlockScrollStrategy(this._viewportRuler, this._document));\n        /**\n         * Update the overlay's position on scroll.\n         * @param config Configuration to be used inside the scroll strategy.\n         * Allows debouncing the reposition calls.\n         */\n        this.reposition = (/**\n         * @param {?=} config\n         * @return {?}\n         */\n        (config) => new RepositionScrollStrategy(this._scrollDispatcher, this._viewportRuler, this._ngZone, config));\n        this._document = document;\n    }\n}\nScrollStrategyOptions.ɵfac = function ScrollStrategyOptions_Factory(t) { return new (t || ScrollStrategyOptions)(ɵngcc0.ɵɵinject(ɵngcc1.ScrollDispatcher), ɵngcc0.ɵɵinject(ɵngcc1.ViewportRuler), ɵngcc0.ɵɵinject(ɵngcc0.NgZone), ɵngcc0.ɵɵinject(DOCUMENT)); };\n/** @nocollapse */\nScrollStrategyOptions.ctorParameters = () => [\n    { type: ScrollDispatcher },\n    { type: ViewportRuler },\n    { type: NgZone },\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }\n];\n/** @nocollapse */ ScrollStrategyOptions.ɵprov = ɵɵdefineInjectable({ factory: function ScrollStrategyOptions_Factory() { return new ScrollStrategyOptions(ɵɵinject(ScrollDispatcher), ɵɵinject(ViewportRuler), ɵɵinject(NgZone), ɵɵinject(DOCUMENT)); }, token: ScrollStrategyOptions, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(ScrollStrategyOptions, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: ɵngcc1.ScrollDispatcher }, { type: ɵngcc1.ViewportRuler }, { type: ɵngcc0.NgZone }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }]; }, null); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    ScrollStrategyOptions.prototype._document;\n    /**\n     * Do nothing on scroll.\n     * @type {?}\n     */\n    ScrollStrategyOptions.prototype.noop;\n    /**\n     * Close the overlay as soon as the user scrolls.\n     * \\@param config Configuration to be used inside the scroll strategy.\n     * @type {?}\n     */\n    ScrollStrategyOptions.prototype.close;\n    /**\n     * Block scrolling.\n     * @type {?}\n     */\n    ScrollStrategyOptions.prototype.block;\n    /**\n     * Update the overlay's position on scroll.\n     * \\@param config Configuration to be used inside the scroll strategy.\n     * Allows debouncing the reposition calls.\n     * @type {?}\n     */\n    ScrollStrategyOptions.prototype.reposition;\n    /**\n     * @type {?}\n     * @private\n     */\n    ScrollStrategyOptions.prototype._scrollDispatcher;\n    /**\n     * @type {?}\n     * @private\n     */\n    ScrollStrategyOptions.prototype._viewportRuler;\n    /**\n     * @type {?}\n     * @private\n     */\n    ScrollStrategyOptions.prototype._ngZone;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/scroll/index.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/overlay-config.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Initial configuration used when creating an overlay.\n */\nclass OverlayConfig {\n    /**\n     * @param {?=} config\n     */\n    constructor(config) {\n        /**\n         * Strategy to be used when handling scroll events while the overlay is open.\n         */\n        this.scrollStrategy = new NoopScrollStrategy();\n        /**\n         * Custom class to add to the overlay pane.\n         */\n        this.panelClass = '';\n        /**\n         * Whether the overlay has a backdrop.\n         */\n        this.hasBackdrop = false;\n        /**\n         * Custom class to add to the backdrop\n         */\n        this.backdropClass = 'cdk-overlay-dark-backdrop';\n        /**\n         * Whether the overlay should be disposed of when the user goes backwards/forwards in history.\n         * Note that this usually doesn't include clicking on links (unless the user is using\n         * the `HashLocationStrategy`).\n         */\n        this.disposeOnNavigation = false;\n        if (config) {\n            // Use `Iterable` instead of `Array` because TypeScript, as of 3.6.3,\n            // loses the array generic type in the `for of`. But we *also* have to use `Array` because\n            // typescript won't iterate over an `Iterable` unless you compile with `--downlevelIteration`\n            /** @type {?} */\n            const configKeys = (/** @type {?} */ (Object.keys(config)));\n            for (const key of configKeys) {\n                if (config[key] !== undefined) {\n                    // TypeScript, as of version 3.5, sees the left-hand-side of this expression\n                    // as \"I don't know *which* key this is, so the only valid value is the intersection\n                    // of all the posible values.\" In this case, that happens to be `undefined`. TypeScript\n                    // is not smart enough to see that the right-hand-side is actually an access of the same\n                    // exact type with the same exact key, meaning that the value type must be identical.\n                    // So we use `any` to work around this.\n                    this[key] = (/** @type {?} */ (config[key]));\n                }\n            }\n        }\n    }\n}\nif (false) {\n    /**\n     * Strategy with which to position the overlay.\n     * @type {?}\n     */\n    OverlayConfig.prototype.positionStrategy;\n    /**\n     * Strategy to be used when handling scroll events while the overlay is open.\n     * @type {?}\n     */\n    OverlayConfig.prototype.scrollStrategy;\n    /**\n     * Custom class to add to the overlay pane.\n     * @type {?}\n     */\n    OverlayConfig.prototype.panelClass;\n    /**\n     * Whether the overlay has a backdrop.\n     * @type {?}\n     */\n    OverlayConfig.prototype.hasBackdrop;\n    /**\n     * Custom class to add to the backdrop\n     * @type {?}\n     */\n    OverlayConfig.prototype.backdropClass;\n    /**\n     * The width of the overlay panel. If a number is provided, pixel units are assumed.\n     * @type {?}\n     */\n    OverlayConfig.prototype.width;\n    /**\n     * The height of the overlay panel. If a number is provided, pixel units are assumed.\n     * @type {?}\n     */\n    OverlayConfig.prototype.height;\n    /**\n     * The min-width of the overlay panel. If a number is provided, pixel units are assumed.\n     * @type {?}\n     */\n    OverlayConfig.prototype.minWidth;\n    /**\n     * The min-height of the overlay panel. If a number is provided, pixel units are assumed.\n     * @type {?}\n     */\n    OverlayConfig.prototype.minHeight;\n    /**\n     * The max-width of the overlay panel. If a number is provided, pixel units are assumed.\n     * @type {?}\n     */\n    OverlayConfig.prototype.maxWidth;\n    /**\n     * The max-height of the overlay panel. If a number is provided, pixel units are assumed.\n     * @type {?}\n     */\n    OverlayConfig.prototype.maxHeight;\n    /**\n     * Direction of the text in the overlay panel. If a `Directionality` instance\n     * is passed in, the overlay will handle changes to its value automatically.\n     * @type {?}\n     */\n    OverlayConfig.prototype.direction;\n    /**\n     * Whether the overlay should be disposed of when the user goes backwards/forwards in history.\n     * Note that this usually doesn't include clicking on links (unless the user is using\n     * the `HashLocationStrategy`).\n     * @type {?}\n     */\n    OverlayConfig.prototype.disposeOnNavigation;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/position/connected-position.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * A connection point on the origin element.\n * @record\n */\nfunction OriginConnectionPosition() { }\nif (false) {\n    /** @type {?} */\n    OriginConnectionPosition.prototype.originX;\n    /** @type {?} */\n    OriginConnectionPosition.prototype.originY;\n}\n/**\n * A connection point on the overlay element.\n * @record\n */\nfunction OverlayConnectionPosition() { }\nif (false) {\n    /** @type {?} */\n    OverlayConnectionPosition.prototype.overlayX;\n    /** @type {?} */\n    OverlayConnectionPosition.prototype.overlayY;\n}\n/**\n * The points of the origin element and the overlay element to connect.\n */\nclass ConnectionPositionPair {\n    /**\n     * @param {?} origin\n     * @param {?} overlay\n     * @param {?=} offsetX\n     * @param {?=} offsetY\n     * @param {?=} panelClass\n     */\n    constructor(origin, overlay, offsetX, offsetY, panelClass) {\n        this.offsetX = offsetX;\n        this.offsetY = offsetY;\n        this.panelClass = panelClass;\n        this.originX = origin.originX;\n        this.originY = origin.originY;\n        this.overlayX = overlay.overlayX;\n        this.overlayY = overlay.overlayY;\n    }\n}\nif (false) {\n    /**\n     * X-axis attachment point for connected overlay origin. Can be 'start', 'end', or 'center'.\n     * @type {?}\n     */\n    ConnectionPositionPair.prototype.originX;\n    /**\n     * Y-axis attachment point for connected overlay origin. Can be 'top', 'bottom', or 'center'.\n     * @type {?}\n     */\n    ConnectionPositionPair.prototype.originY;\n    /**\n     * X-axis attachment point for connected overlay. Can be 'start', 'end', or 'center'.\n     * @type {?}\n     */\n    ConnectionPositionPair.prototype.overlayX;\n    /**\n     * Y-axis attachment point for connected overlay. Can be 'top', 'bottom', or 'center'.\n     * @type {?}\n     */\n    ConnectionPositionPair.prototype.overlayY;\n    /**\n     * Offset along the X axis.\n     * @type {?}\n     */\n    ConnectionPositionPair.prototype.offsetX;\n    /**\n     * Offset along the Y axis.\n     * @type {?}\n     */\n    ConnectionPositionPair.prototype.offsetY;\n    /**\n     * Class(es) to be applied to the panel while this position is active.\n     * @type {?}\n     */\n    ConnectionPositionPair.prototype.panelClass;\n}\n/**\n * Set of properties regarding the position of the origin and overlay relative to the viewport\n * with respect to the containing Scrollable elements.\n *\n * The overlay and origin are clipped if any part of their bounding client rectangle exceeds the\n * bounds of any one of the strategy's Scrollable's bounding client rectangle.\n *\n * The overlay and origin are outside view if there is no overlap between their bounding client\n * rectangle and any one of the strategy's Scrollable's bounding client rectangle.\n *\n *       -----------                    -----------\n *       | outside |                    | clipped |\n *       |  view   |              --------------------------\n *       |         |              |     |         |        |\n *       ----------               |     -----------        |\n *  --------------------------    |                        |\n *  |                        |    |      Scrollable        |\n *  |                        |    |                        |\n *  |                        |     --------------------------\n *  |      Scrollable        |\n *  |                        |\n *  --------------------------\n *\n * \\@docs-private\n */\nclass ScrollingVisibility {\n}\nif (false) {\n    /** @type {?} */\n    ScrollingVisibility.prototype.isOriginClipped;\n    /** @type {?} */\n    ScrollingVisibility.prototype.isOriginOutsideView;\n    /** @type {?} */\n    ScrollingVisibility.prototype.isOverlayClipped;\n    /** @type {?} */\n    ScrollingVisibility.prototype.isOverlayOutsideView;\n}\n/**\n * The change event emitted by the strategy when a fallback position is used.\n */\nclass ConnectedOverlayPositionChange {\n    /**\n     * @param {?} connectionPair\n     * @param {?} scrollableViewProperties\n     */\n    constructor(connectionPair, scrollableViewProperties) {\n        this.connectionPair = connectionPair;\n        this.scrollableViewProperties = scrollableViewProperties;\n    }\n}\n/** @nocollapse */\nConnectedOverlayPositionChange.ctorParameters = () => [\n    { type: ConnectionPositionPair },\n    { type: ScrollingVisibility, decorators: [{ type: Optional }] }\n];\nif (false) {\n    /**\n     * The position used as a result of this change.\n     * @type {?}\n     */\n    ConnectedOverlayPositionChange.prototype.connectionPair;\n    /**\n     * \\@docs-private\n     * @type {?}\n     */\n    ConnectedOverlayPositionChange.prototype.scrollableViewProperties;\n}\n/**\n * Validates whether a vertical position property matches the expected values.\n * \\@docs-private\n * @param {?} property Name of the property being validated.\n * @param {?} value Value of the property being validated.\n * @return {?}\n */\nfunction validateVerticalPosition(property, value) {\n    if (value !== 'top' && value !== 'bottom' && value !== 'center') {\n        throw Error(`ConnectedPosition: Invalid ${property} \"${value}\". ` +\n            `Expected \"top\", \"bottom\" or \"center\".`);\n    }\n}\n/**\n * Validates whether a horizontal position property matches the expected values.\n * \\@docs-private\n * @param {?} property Name of the property being validated.\n * @param {?} value Value of the property being validated.\n * @return {?}\n */\nfunction validateHorizontalPosition(property, value) {\n    if (value !== 'start' && value !== 'end' && value !== 'center') {\n        throw Error(`ConnectedPosition: Invalid ${property} \"${value}\". ` +\n            `Expected \"start\", \"end\" or \"center\".`);\n    }\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/keyboard/overlay-keyboard-dispatcher.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Service for dispatching keyboard events that land on the body to appropriate overlay ref,\n * if any. It maintains a list of attached overlays to determine best suited overlay based\n * on event target and order of overlay opens.\n */\nclass OverlayKeyboardDispatcher {\n    /**\n     * @param {?} document\n     */\n    constructor(document) {\n        /**\n         * Currently attached overlays in the order they were attached.\n         */\n        this._attachedOverlays = [];\n        /**\n         * Keyboard event listener that will be attached to the body.\n         */\n        this._keydownListener = (/**\n         * @param {?} event\n         * @return {?}\n         */\n        (event) => {\n            /** @type {?} */\n            const overlays = this._attachedOverlays;\n            for (let i = overlays.length - 1; i > -1; i--) {\n                // Dispatch the keydown event to the top overlay which has subscribers to its keydown events.\n                // We want to target the most recent overlay, rather than trying to match where the event came\n                // from, because some components might open an overlay, but keep focus on a trigger element\n                // (e.g. for select and autocomplete). We skip overlays without keydown event subscriptions,\n                // because we don't want overlays that don't handle keyboard events to block the ones below\n                // them that do.\n                if (overlays[i]._keydownEventSubscriptions > 0) {\n                    overlays[i]._keydownEvents.next(event);\n                    break;\n                }\n            }\n        });\n        this._document = document;\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._detach();\n    }\n    /**\n     * Add a new overlay to the list of attached overlay refs.\n     * @param {?} overlayRef\n     * @return {?}\n     */\n    add(overlayRef) {\n        // Ensure that we don't get the same overlay multiple times.\n        this.remove(overlayRef);\n        // Lazily start dispatcher once first overlay is added\n        if (!this._isAttached) {\n            this._document.body.addEventListener('keydown', this._keydownListener);\n            this._isAttached = true;\n        }\n        this._attachedOverlays.push(overlayRef);\n    }\n    /**\n     * Remove an overlay from the list of attached overlay refs.\n     * @param {?} overlayRef\n     * @return {?}\n     */\n    remove(overlayRef) {\n        /** @type {?} */\n        const index = this._attachedOverlays.indexOf(overlayRef);\n        if (index > -1) {\n            this._attachedOverlays.splice(index, 1);\n        }\n        // Remove the global listener once there are no more overlays.\n        if (this._attachedOverlays.length === 0) {\n            this._detach();\n        }\n    }\n    /**\n     * Detaches the global keyboard event listener.\n     * @private\n     * @return {?}\n     */\n    _detach() {\n        if (this._isAttached) {\n            this._document.body.removeEventListener('keydown', this._keydownListener);\n            this._isAttached = false;\n        }\n    }\n}\nOverlayKeyboardDispatcher.ɵfac = function OverlayKeyboardDispatcher_Factory(t) { return new (t || OverlayKeyboardDispatcher)(ɵngcc0.ɵɵinject(DOCUMENT)); };\n/** @nocollapse */\nOverlayKeyboardDispatcher.ctorParameters = () => [\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }\n];\n/** @nocollapse */ OverlayKeyboardDispatcher.ɵprov = ɵɵdefineInjectable({ factory: function OverlayKeyboardDispatcher_Factory() { return new OverlayKeyboardDispatcher(ɵɵinject(DOCUMENT)); }, token: OverlayKeyboardDispatcher, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(OverlayKeyboardDispatcher, [{\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     * Currently attached overlays in the order they were attached.\n     * @type {?}\n     */\n    OverlayKeyboardDispatcher.prototype._attachedOverlays;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayKeyboardDispatcher.prototype._document;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayKeyboardDispatcher.prototype._isAttached;\n    /**\n     * Keyboard event listener that will be attached to the body.\n     * @type {?}\n     * @private\n     */\n    OverlayKeyboardDispatcher.prototype._keydownListener;\n}\n/**\n * \\@docs-private \\@deprecated \\@breaking-change 8.0.0\n * @param {?} dispatcher\n * @param {?} _document\n * @return {?}\n */\nfunction OVERLAY_KEYBOARD_DISPATCHER_PROVIDER_FACTORY(dispatcher, _document) {\n    return dispatcher || new OverlayKeyboardDispatcher(_document);\n}\n/**\n * \\@docs-private \\@deprecated \\@breaking-change 8.0.0\n * @type {?}\n */\nconst OVERLAY_KEYBOARD_DISPATCHER_PROVIDER = {\n    // If there is already an OverlayKeyboardDispatcher available, use that.\n    // Otherwise, provide a new one.\n    provide: OverlayKeyboardDispatcher,\n    deps: [\n        [new Optional(), new SkipSelf(), OverlayKeyboardDispatcher],\n        (/** @type {?} */ (\n        // Coerce to `InjectionToken` so that the `deps` match the \"shape\"\n        // of the type expected by Angular\n        DOCUMENT))\n    ],\n    useFactory: OVERLAY_KEYBOARD_DISPATCHER_PROVIDER_FACTORY\n};\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/overlay-container.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Whether we're in a testing environment.\n * TODO(crisbeto): remove this once we have an overlay testing module.\n * @type {?}\n */\nconst isTestEnvironment = typeof window !== 'undefined' && !!window &&\n    !!(((/** @type {?} */ (window))).__karma__ || ((/** @type {?} */ (window))).jasmine);\n/**\n * Container inside which all overlays will render.\n */\nclass OverlayContainer {\n    /**\n     * @param {?} document\n     * @param {?=} _platform\n     */\n    constructor(document, _platform) {\n        this._platform = _platform;\n        this._document = document;\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        /** @type {?} */\n        const container = this._containerElement;\n        if (container && container.parentNode) {\n            container.parentNode.removeChild(container);\n        }\n    }\n    /**\n     * This method returns the overlay container element. It will lazily\n     * create the element the first time  it is called to facilitate using\n     * the container in non-browser environments.\n     * @return {?} the container element\n     */\n    getContainerElement() {\n        if (!this._containerElement) {\n            this._createContainer();\n        }\n        return this._containerElement;\n    }\n    /**\n     * Create the overlay container element, which is simply a div\n     * with the 'cdk-overlay-container' class on the document body.\n     * @protected\n     * @return {?}\n     */\n    _createContainer() {\n        // @breaking-change 10.0.0 Remove null check for `_platform`.\n        /** @type {?} */\n        const isBrowser = this._platform ? this._platform.isBrowser : typeof window !== 'undefined';\n        /** @type {?} */\n        const containerClass = 'cdk-overlay-container';\n        if (isBrowser || isTestEnvironment) {\n            /** @type {?} */\n            const oppositePlatformContainers = this._document.querySelectorAll(`.${containerClass}[platform=\"server\"], ` +\n                `.${containerClass}[platform=\"test\"]`);\n            // Remove any old containers from the opposite platform.\n            // This can happen when transitioning from the server to the client.\n            for (let i = 0; i < oppositePlatformContainers.length; i++) {\n                (/** @type {?} */ (oppositePlatformContainers[i].parentNode)).removeChild(oppositePlatformContainers[i]);\n            }\n        }\n        /** @type {?} */\n        const container = this._document.createElement('div');\n        container.classList.add(containerClass);\n        // A long time ago we kept adding new overlay containers whenever a new app was instantiated,\n        // but at some point we added logic which clears the duplicate ones in order to avoid leaks.\n        // The new logic was a little too aggressive since it was breaking some legitimate use cases.\n        // To mitigate the problem we made it so that only containers from a different platform are\n        // cleared, but the side-effect was that people started depending on the overly-aggressive\n        // logic to clean up their tests for them. Until we can introduce an overlay-specific testing\n        // module which does the cleanup, we try to detect that we're in a test environment and we\n        // always clear the container. See #17006.\n        // TODO(crisbeto): remove the test environment check once we have an overlay testing module.\n        if (isTestEnvironment) {\n            container.setAttribute('platform', 'test');\n        }\n        else if (!isBrowser) {\n            container.setAttribute('platform', 'server');\n        }\n        this._document.body.appendChild(container);\n        this._containerElement = container;\n    }\n}\nOverlayContainer.ɵfac = function OverlayContainer_Factory(t) { return new (t || OverlayContainer)(ɵngcc0.ɵɵinject(DOCUMENT), ɵngcc0.ɵɵinject(ɵngcc2.Platform)); };\n/** @nocollapse */\nOverlayContainer.ctorParameters = () => [\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },\n    { type: Platform }\n];\n/** @nocollapse */ OverlayContainer.ɵprov = ɵɵdefineInjectable({ factory: function OverlayContainer_Factory() { return new OverlayContainer(ɵɵinject(DOCUMENT), ɵɵinject(Platform)); }, token: OverlayContainer, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(OverlayContainer, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }, { type: ɵngcc2.Platform }]; }, null); })();\nif (false) {\n    /**\n     * @type {?}\n     * @protected\n     */\n    OverlayContainer.prototype._containerElement;\n    /**\n     * @type {?}\n     * @protected\n     */\n    OverlayContainer.prototype._document;\n    /**\n     * @deprecated `platform` parameter to become required.\n     * \\@breaking-change 10.0.0\n     * @type {?}\n     * @protected\n     */\n    OverlayContainer.prototype._platform;\n}\n/**\n * \\@docs-private \\@deprecated \\@breaking-change 8.0.0\n * @param {?} parentContainer\n * @param {?} _document\n * @return {?}\n */\nfunction OVERLAY_CONTAINER_PROVIDER_FACTORY(parentContainer, _document) {\n    return parentContainer || new OverlayContainer(_document);\n}\n/**\n * \\@docs-private \\@deprecated \\@breaking-change 8.0.0\n * @type {?}\n */\nconst OVERLAY_CONTAINER_PROVIDER = {\n    // If there is already an OverlayContainer available, use that. Otherwise, provide a new one.\n    provide: OverlayContainer,\n    deps: [\n        [new Optional(), new SkipSelf(), OverlayContainer],\n        (/** @type {?} */ (DOCUMENT))\n    ],\n    useFactory: OVERLAY_CONTAINER_PROVIDER_FACTORY\n};\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/overlay-ref.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Reference to an overlay that has been created with the Overlay service.\n * Used to manipulate or dispose of said overlay.\n */\nclass OverlayRef {\n    /**\n     * @param {?} _portalOutlet\n     * @param {?} _host\n     * @param {?} _pane\n     * @param {?} _config\n     * @param {?} _ngZone\n     * @param {?} _keyboardDispatcher\n     * @param {?} _document\n     * @param {?=} _location\n     */\n    constructor(_portalOutlet, _host, _pane, _config, _ngZone, _keyboardDispatcher, _document, _location) {\n        this._portalOutlet = _portalOutlet;\n        this._host = _host;\n        this._pane = _pane;\n        this._config = _config;\n        this._ngZone = _ngZone;\n        this._keyboardDispatcher = _keyboardDispatcher;\n        this._document = _document;\n        this._location = _location;\n        this._backdropElement = null;\n        this._backdropClick = new Subject();\n        this._attachments = new Subject();\n        this._detachments = new Subject();\n        this._locationChanges = Subscription.EMPTY;\n        this._backdropClickHandler = (/**\n         * @param {?} event\n         * @return {?}\n         */\n        (event) => this._backdropClick.next(event));\n        this._keydownEventsObservable = new Observable((/**\n         * @param {?} observer\n         * @return {?}\n         */\n        (observer) => {\n            /** @type {?} */\n            const subscription = this._keydownEvents.subscribe(observer);\n            this._keydownEventSubscriptions++;\n            return (/**\n             * @return {?}\n             */\n            () => {\n                subscription.unsubscribe();\n                this._keydownEventSubscriptions--;\n            });\n        }));\n        /**\n         * Stream of keydown events dispatched to this overlay.\n         */\n        this._keydownEvents = new Subject();\n        /**\n         * Amount of subscriptions to the keydown events.\n         */\n        this._keydownEventSubscriptions = 0;\n        if (_config.scrollStrategy) {\n            this._scrollStrategy = _config.scrollStrategy;\n            this._scrollStrategy.attach(this);\n        }\n        this._positionStrategy = _config.positionStrategy;\n    }\n    /**\n     * The overlay's HTML element\n     * @return {?}\n     */\n    get overlayElement() {\n        return this._pane;\n    }\n    /**\n     * The overlay's backdrop HTML element.\n     * @return {?}\n     */\n    get backdropElement() {\n        return this._backdropElement;\n    }\n    /**\n     * Wrapper around the panel element. Can be used for advanced\n     * positioning where a wrapper with specific styling is\n     * required around the overlay pane.\n     * @return {?}\n     */\n    get hostElement() {\n        return this._host;\n    }\n    /**\n     * Attaches content, given via a Portal, to the overlay.\n     * If the overlay is configured to have a backdrop, it will be created.\n     *\n     * @param {?} portal Portal instance to which to attach the overlay.\n     * @return {?} The portal attachment result.\n     */\n    attach(portal) {\n        /** @type {?} */\n        let attachResult = this._portalOutlet.attach(portal);\n        // Update the pane element with the given configuration.\n        if (!this._host.parentElement && this._previousHostParent) {\n            this._previousHostParent.appendChild(this._host);\n        }\n        if (this._positionStrategy) {\n            this._positionStrategy.attach(this);\n        }\n        this._updateStackingOrder();\n        this._updateElementSize();\n        this._updateElementDirection();\n        if (this._scrollStrategy) {\n            this._scrollStrategy.enable();\n        }\n        // Update the position once the zone is stable so that the overlay will be fully rendered\n        // before attempting to position it, as the position may depend on the size of the rendered\n        // content.\n        this._ngZone.onStable\n            .asObservable()\n            .pipe(take(1))\n            .subscribe((/**\n         * @return {?}\n         */\n        () => {\n            // The overlay could've been detached before the zone has stabilized.\n            if (this.hasAttached()) {\n                this.updatePosition();\n            }\n        }));\n        // Enable pointer events for the overlay pane element.\n        this._togglePointerEvents(true);\n        if (this._config.hasBackdrop) {\n            this._attachBackdrop();\n        }\n        if (this._config.panelClass) {\n            this._toggleClasses(this._pane, this._config.panelClass, true);\n        }\n        // Only emit the `attachments` event once all other setup is done.\n        this._attachments.next();\n        // Track this overlay by the keyboard dispatcher\n        this._keyboardDispatcher.add(this);\n        // @breaking-change 8.0.0 remove the null check for `_location`\n        // once the constructor parameter is made required.\n        if (this._config.disposeOnNavigation && this._location) {\n            this._locationChanges = this._location.subscribe((/**\n             * @return {?}\n             */\n            () => this.dispose()));\n        }\n        return attachResult;\n    }\n    /**\n     * Detaches an overlay from a portal.\n     * @return {?} The portal detachment result.\n     */\n    detach() {\n        if (!this.hasAttached()) {\n            return;\n        }\n        this.detachBackdrop();\n        // When the overlay is detached, the pane element should disable pointer events.\n        // This is necessary because otherwise the pane element will cover the page and disable\n        // pointer events therefore. Depends on the position strategy and the applied pane boundaries.\n        this._togglePointerEvents(false);\n        if (this._positionStrategy && this._positionStrategy.detach) {\n            this._positionStrategy.detach();\n        }\n        if (this._scrollStrategy) {\n            this._scrollStrategy.disable();\n        }\n        /** @type {?} */\n        const detachmentResult = this._portalOutlet.detach();\n        // Only emit after everything is detached.\n        this._detachments.next();\n        // Remove this overlay from keyboard dispatcher tracking.\n        this._keyboardDispatcher.remove(this);\n        // Keeping the host element in the DOM can cause scroll jank, because it still gets\n        // rendered, even though it's transparent and unclickable which is why we remove it.\n        this._detachContentWhenStable();\n        // Stop listening for location changes.\n        this._locationChanges.unsubscribe();\n        return detachmentResult;\n    }\n    /**\n     * Cleans up the overlay from the DOM.\n     * @return {?}\n     */\n    dispose() {\n        /** @type {?} */\n        const isAttached = this.hasAttached();\n        if (this._positionStrategy) {\n            this._positionStrategy.dispose();\n        }\n        this._disposeScrollStrategy();\n        this.detachBackdrop();\n        this._locationChanges.unsubscribe();\n        this._keyboardDispatcher.remove(this);\n        this._portalOutlet.dispose();\n        this._attachments.complete();\n        this._backdropClick.complete();\n        this._keydownEvents.complete();\n        if (this._host && this._host.parentNode) {\n            this._host.parentNode.removeChild(this._host);\n            this._host = (/** @type {?} */ (null));\n        }\n        this._previousHostParent = this._pane = (/** @type {?} */ (null));\n        if (isAttached) {\n            this._detachments.next();\n        }\n        this._detachments.complete();\n    }\n    /**\n     * Whether the overlay has attached content.\n     * @return {?}\n     */\n    hasAttached() {\n        return this._portalOutlet.hasAttached();\n    }\n    /**\n     * Gets an observable that emits when the backdrop has been clicked.\n     * @return {?}\n     */\n    backdropClick() {\n        return this._backdropClick.asObservable();\n    }\n    /**\n     * Gets an observable that emits when the overlay has been attached.\n     * @return {?}\n     */\n    attachments() {\n        return this._attachments.asObservable();\n    }\n    /**\n     * Gets an observable that emits when the overlay has been detached.\n     * @return {?}\n     */\n    detachments() {\n        return this._detachments.asObservable();\n    }\n    /**\n     * Gets an observable of keydown events targeted to this overlay.\n     * @return {?}\n     */\n    keydownEvents() {\n        return this._keydownEventsObservable;\n    }\n    /**\n     * Gets the current overlay configuration, which is immutable.\n     * @return {?}\n     */\n    getConfig() {\n        return this._config;\n    }\n    /**\n     * Updates the position of the overlay based on the position strategy.\n     * @return {?}\n     */\n    updatePosition() {\n        if (this._positionStrategy) {\n            this._positionStrategy.apply();\n        }\n    }\n    /**\n     * Switches to a new position strategy and updates the overlay position.\n     * @param {?} strategy\n     * @return {?}\n     */\n    updatePositionStrategy(strategy) {\n        if (strategy === this._positionStrategy) {\n            return;\n        }\n        if (this._positionStrategy) {\n            this._positionStrategy.dispose();\n        }\n        this._positionStrategy = strategy;\n        if (this.hasAttached()) {\n            strategy.attach(this);\n            this.updatePosition();\n        }\n    }\n    /**\n     * Update the size properties of the overlay.\n     * @param {?} sizeConfig\n     * @return {?}\n     */\n    updateSize(sizeConfig) {\n        this._config = Object.assign(Object.assign({}, this._config), sizeConfig);\n        this._updateElementSize();\n    }\n    /**\n     * Sets the LTR/RTL direction for the overlay.\n     * @param {?} dir\n     * @return {?}\n     */\n    setDirection(dir) {\n        this._config = Object.assign(Object.assign({}, this._config), { direction: dir });\n        this._updateElementDirection();\n    }\n    /**\n     * Add a CSS class or an array of classes to the overlay pane.\n     * @param {?} classes\n     * @return {?}\n     */\n    addPanelClass(classes) {\n        if (this._pane) {\n            this._toggleClasses(this._pane, classes, true);\n        }\n    }\n    /**\n     * Remove a CSS class or an array of classes from the overlay pane.\n     * @param {?} classes\n     * @return {?}\n     */\n    removePanelClass(classes) {\n        if (this._pane) {\n            this._toggleClasses(this._pane, classes, false);\n        }\n    }\n    /**\n     * Returns the layout direction of the overlay panel.\n     * @return {?}\n     */\n    getDirection() {\n        /** @type {?} */\n        const direction = this._config.direction;\n        if (!direction) {\n            return 'ltr';\n        }\n        return typeof direction === 'string' ? direction : direction.value;\n    }\n    /**\n     * Switches to a new scroll strategy.\n     * @param {?} strategy\n     * @return {?}\n     */\n    updateScrollStrategy(strategy) {\n        if (strategy === this._scrollStrategy) {\n            return;\n        }\n        this._disposeScrollStrategy();\n        this._scrollStrategy = strategy;\n        if (this.hasAttached()) {\n            strategy.attach(this);\n            strategy.enable();\n        }\n    }\n    /**\n     * Updates the text direction of the overlay panel.\n     * @private\n     * @return {?}\n     */\n    _updateElementDirection() {\n        this._host.setAttribute('dir', this.getDirection());\n    }\n    /**\n     * Updates the size of the overlay element based on the overlay config.\n     * @private\n     * @return {?}\n     */\n    _updateElementSize() {\n        if (!this._pane) {\n            return;\n        }\n        /** @type {?} */\n        const style = this._pane.style;\n        style.width = coerceCssPixelValue(this._config.width);\n        style.height = coerceCssPixelValue(this._config.height);\n        style.minWidth = coerceCssPixelValue(this._config.minWidth);\n        style.minHeight = coerceCssPixelValue(this._config.minHeight);\n        style.maxWidth = coerceCssPixelValue(this._config.maxWidth);\n        style.maxHeight = coerceCssPixelValue(this._config.maxHeight);\n    }\n    /**\n     * Toggles the pointer events for the overlay pane element.\n     * @private\n     * @param {?} enablePointer\n     * @return {?}\n     */\n    _togglePointerEvents(enablePointer) {\n        this._pane.style.pointerEvents = enablePointer ? 'auto' : 'none';\n    }\n    /**\n     * Attaches a backdrop for this overlay.\n     * @private\n     * @return {?}\n     */\n    _attachBackdrop() {\n        /** @type {?} */\n        const showingClass = 'cdk-overlay-backdrop-showing';\n        this._backdropElement = this._document.createElement('div');\n        this._backdropElement.classList.add('cdk-overlay-backdrop');\n        if (this._config.backdropClass) {\n            this._toggleClasses(this._backdropElement, this._config.backdropClass, true);\n        }\n        // Insert the backdrop before the pane in the DOM order,\n        // in order to handle stacked overlays properly.\n        (/** @type {?} */ (this._host.parentElement)).insertBefore(this._backdropElement, this._host);\n        // Forward backdrop clicks such that the consumer of the overlay can perform whatever\n        // action desired when such a click occurs (usually closing the overlay).\n        this._backdropElement.addEventListener('click', this._backdropClickHandler);\n        // Add class to fade-in the backdrop after one frame.\n        if (typeof requestAnimationFrame !== 'undefined') {\n            this._ngZone.runOutsideAngular((/**\n             * @return {?}\n             */\n            () => {\n                requestAnimationFrame((/**\n                 * @return {?}\n                 */\n                () => {\n                    if (this._backdropElement) {\n                        this._backdropElement.classList.add(showingClass);\n                    }\n                }));\n            }));\n        }\n        else {\n            this._backdropElement.classList.add(showingClass);\n        }\n    }\n    /**\n     * Updates the stacking order of the element, moving it to the top if necessary.\n     * This is required in cases where one overlay was detached, while another one,\n     * that should be behind it, was destroyed. The next time both of them are opened,\n     * the stacking will be wrong, because the detached element's pane will still be\n     * in its original DOM position.\n     * @private\n     * @return {?}\n     */\n    _updateStackingOrder() {\n        if (this._host.nextSibling) {\n            (/** @type {?} */ (this._host.parentNode)).appendChild(this._host);\n        }\n    }\n    /**\n     * Detaches the backdrop (if any) associated with the overlay.\n     * @return {?}\n     */\n    detachBackdrop() {\n        /** @type {?} */\n        let backdropToDetach = this._backdropElement;\n        if (!backdropToDetach) {\n            return;\n        }\n        /** @type {?} */\n        let timeoutId;\n        /** @type {?} */\n        let finishDetach = (/**\n         * @return {?}\n         */\n        () => {\n            // It may not be attached to anything in certain cases (e.g. unit tests).\n            if (backdropToDetach) {\n                backdropToDetach.removeEventListener('click', this._backdropClickHandler);\n                backdropToDetach.removeEventListener('transitionend', finishDetach);\n                if (backdropToDetach.parentNode) {\n                    backdropToDetach.parentNode.removeChild(backdropToDetach);\n                }\n            }\n            // It is possible that a new portal has been attached to this overlay since we started\n            // removing the backdrop. If that is the case, only clear the backdrop reference if it\n            // is still the same instance that we started to remove.\n            if (this._backdropElement == backdropToDetach) {\n                this._backdropElement = null;\n            }\n            if (this._config.backdropClass) {\n                this._toggleClasses((/** @type {?} */ (backdropToDetach)), this._config.backdropClass, false);\n            }\n            clearTimeout(timeoutId);\n        });\n        backdropToDetach.classList.remove('cdk-overlay-backdrop-showing');\n        this._ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => {\n            (/** @type {?} */ (backdropToDetach)).addEventListener('transitionend', finishDetach);\n        }));\n        // If the backdrop doesn't have a transition, the `transitionend` event won't fire.\n        // In this case we make it unclickable and we try to remove it after a delay.\n        backdropToDetach.style.pointerEvents = 'none';\n        // Run this outside the Angular zone because there's nothing that Angular cares about.\n        // If it were to run inside the Angular zone, every test that used Overlay would have to be\n        // either async or fakeAsync.\n        timeoutId = this._ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => setTimeout(finishDetach, 500)));\n    }\n    /**\n     * Toggles a single CSS class or an array of classes on an element.\n     * @private\n     * @param {?} element\n     * @param {?} cssClasses\n     * @param {?} isAdd\n     * @return {?}\n     */\n    _toggleClasses(element, cssClasses, isAdd) {\n        /** @type {?} */\n        const classList = element.classList;\n        coerceArray(cssClasses).forEach((/**\n         * @param {?} cssClass\n         * @return {?}\n         */\n        cssClass => {\n            // We can't do a spread here, because IE doesn't support setting multiple classes.\n            // Also trying to add an empty string to a DOMTokenList will throw.\n            if (cssClass) {\n                isAdd ? classList.add(cssClass) : classList.remove(cssClass);\n            }\n        }));\n    }\n    /**\n     * Detaches the overlay content next time the zone stabilizes.\n     * @private\n     * @return {?}\n     */\n    _detachContentWhenStable() {\n        // Normally we wouldn't have to explicitly run this outside the `NgZone`, however\n        // if the consumer is using `zone-patch-rxjs`, the `Subscription.unsubscribe` call will\n        // be patched to run inside the zone, which will throw us into an infinite loop.\n        this._ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => {\n            // We can't remove the host here immediately, because the overlay pane's content\n            // might still be animating. This stream helps us avoid interrupting the animation\n            // by waiting for the pane to become empty.\n            /** @type {?} */\n            const subscription = this._ngZone.onStable\n                .asObservable()\n                .pipe(takeUntil(merge(this._attachments, this._detachments)))\n                .subscribe((/**\n             * @return {?}\n             */\n            () => {\n                // Needs a couple of checks for the pane and host, because\n                // they may have been removed by the time the zone stabilizes.\n                if (!this._pane || !this._host || this._pane.children.length === 0) {\n                    if (this._pane && this._config.panelClass) {\n                        this._toggleClasses(this._pane, this._config.panelClass, false);\n                    }\n                    if (this._host && this._host.parentElement) {\n                        this._previousHostParent = this._host.parentElement;\n                        this._previousHostParent.removeChild(this._host);\n                    }\n                    subscription.unsubscribe();\n                }\n            }));\n        }));\n    }\n    /**\n     * Disposes of a scroll strategy.\n     * @private\n     * @return {?}\n     */\n    _disposeScrollStrategy() {\n        /** @type {?} */\n        const scrollStrategy = this._scrollStrategy;\n        if (scrollStrategy) {\n            scrollStrategy.disable();\n            if (scrollStrategy.detach) {\n                scrollStrategy.detach();\n            }\n        }\n    }\n}\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._backdropElement;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._backdropClick;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._attachments;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._detachments;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._positionStrategy;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._scrollStrategy;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._locationChanges;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._backdropClickHandler;\n    /**\n     * Reference to the parent of the `_host` at the time it was detached. Used to restore\n     * the `_host` to its original position in the DOM when it gets re-attached.\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._previousHostParent;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._keydownEventsObservable;\n    /**\n     * Stream of keydown events dispatched to this overlay.\n     * @type {?}\n     */\n    OverlayRef.prototype._keydownEvents;\n    /**\n     * Amount of subscriptions to the keydown events.\n     * @type {?}\n     */\n    OverlayRef.prototype._keydownEventSubscriptions;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._portalOutlet;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._host;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._pane;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._config;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._ngZone;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._keyboardDispatcher;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._document;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayRef.prototype._location;\n}\n/**\n * Size properties for an overlay.\n * @record\n */\nfunction OverlaySizeConfig() { }\nif (false) {\n    /** @type {?|undefined} */\n    OverlaySizeConfig.prototype.width;\n    /** @type {?|undefined} */\n    OverlaySizeConfig.prototype.height;\n    /** @type {?|undefined} */\n    OverlaySizeConfig.prototype.minWidth;\n    /** @type {?|undefined} */\n    OverlaySizeConfig.prototype.minHeight;\n    /** @type {?|undefined} */\n    OverlaySizeConfig.prototype.maxWidth;\n    /** @type {?|undefined} */\n    OverlaySizeConfig.prototype.maxHeight;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/position/flexible-connected-position-strategy.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n// TODO: refactor clipping detection into a separate thing (part of scrolling module)\n// TODO: doesn't handle both flexible width and height when it has to scroll along both axis.\n/**\n * Class to be added to the overlay bounding box.\n * @type {?}\n */\nconst boundingBoxClass = 'cdk-overlay-connected-position-bounding-box';\n/**\n * Regex used to split a string on its CSS units.\n * @type {?}\n */\nconst cssUnitPattern = /([A-Za-z%]+)$/;\n/**\n * A strategy for positioning overlays. Using this strategy, an overlay is given an\n * implicit position relative some origin element. The relative position is defined in terms of\n * a point on the origin element that is connected to a point on the overlay element. For example,\n * a basic dropdown is connecting the bottom-left corner of the origin to the top-left corner\n * of the overlay.\n */\nclass FlexibleConnectedPositionStrategy {\n    /**\n     * @param {?} connectedTo\n     * @param {?} _viewportRuler\n     * @param {?} _document\n     * @param {?} _platform\n     * @param {?} _overlayContainer\n     */\n    constructor(connectedTo, _viewportRuler, _document, _platform, _overlayContainer) {\n        this._viewportRuler = _viewportRuler;\n        this._document = _document;\n        this._platform = _platform;\n        this._overlayContainer = _overlayContainer;\n        /**\n         * Last size used for the bounding box. Used to avoid resizing the overlay after open.\n         */\n        this._lastBoundingBoxSize = { width: 0, height: 0 };\n        /**\n         * Whether the overlay was pushed in a previous positioning.\n         */\n        this._isPushed = false;\n        /**\n         * Whether the overlay can be pushed on-screen on the initial open.\n         */\n        this._canPush = true;\n        /**\n         * Whether the overlay can grow via flexible width/height after the initial open.\n         */\n        this._growAfterOpen = false;\n        /**\n         * Whether the overlay's width and height can be constrained to fit within the viewport.\n         */\n        this._hasFlexibleDimensions = true;\n        /**\n         * Whether the overlay position is locked.\n         */\n        this._positionLocked = false;\n        /**\n         * Amount of space that must be maintained between the overlay and the edge of the viewport.\n         */\n        this._viewportMargin = 0;\n        /**\n         * The Scrollable containers used to check scrollable view properties on position change.\n         */\n        this._scrollables = [];\n        /**\n         * Ordered list of preferred positions, from most to least desirable.\n         */\n        this._preferredPositions = [];\n        /**\n         * Subject that emits whenever the position changes.\n         */\n        this._positionChanges = new Subject();\n        /**\n         * Subscription to viewport size changes.\n         */\n        this._resizeSubscription = Subscription.EMPTY;\n        /**\n         * Default offset for the overlay along the x axis.\n         */\n        this._offsetX = 0;\n        /**\n         * Default offset for the overlay along the y axis.\n         */\n        this._offsetY = 0;\n        /**\n         * Keeps track of the CSS classes that the position strategy has applied on the overlay panel.\n         */\n        this._appliedPanelClasses = [];\n        /**\n         * Observable sequence of position changes.\n         */\n        this.positionChanges = this._positionChanges.asObservable();\n        this.setOrigin(connectedTo);\n    }\n    /**\n     * Ordered list of preferred positions, from most to least desirable.\n     * @return {?}\n     */\n    get positions() {\n        return this._preferredPositions;\n    }\n    /**\n     * Attaches this position strategy to an overlay.\n     * @param {?} overlayRef\n     * @return {?}\n     */\n    attach(overlayRef) {\n        if (this._overlayRef && overlayRef !== this._overlayRef) {\n            throw Error('This position strategy is already attached to an overlay');\n        }\n        this._validatePositions();\n        overlayRef.hostElement.classList.add(boundingBoxClass);\n        this._overlayRef = overlayRef;\n        this._boundingBox = overlayRef.hostElement;\n        this._pane = overlayRef.overlayElement;\n        this._isDisposed = false;\n        this._isInitialRender = true;\n        this._lastPosition = null;\n        this._resizeSubscription.unsubscribe();\n        this._resizeSubscription = this._viewportRuler.change().subscribe((/**\n         * @return {?}\n         */\n        () => {\n            // When the window is resized, we want to trigger the next reposition as if it\n            // was an initial render, in order for the strategy to pick a new optimal position,\n            // otherwise position locking will cause it to stay at the old one.\n            this._isInitialRender = true;\n            this.apply();\n        }));\n    }\n    /**\n     * Updates the position of the overlay element, using whichever preferred position relative\n     * to the origin best fits on-screen.\n     *\n     * The selection of a position goes as follows:\n     *  - If any positions fit completely within the viewport as-is,\n     *      choose the first position that does so.\n     *  - If flexible dimensions are enabled and at least one satifies the given minimum width/height,\n     *      choose the position with the greatest available size modified by the positions' weight.\n     *  - If pushing is enabled, take the position that went off-screen the least and push it\n     *      on-screen.\n     *  - If none of the previous criteria were met, use the position that goes off-screen the least.\n     * \\@docs-private\n     * @return {?}\n     */\n    apply() {\n        // We shouldn't do anything if the strategy was disposed or we're on the server.\n        if (this._isDisposed || !this._platform.isBrowser) {\n            return;\n        }\n        // If the position has been applied already (e.g. when the overlay was opened) and the\n        // consumer opted into locking in the position, re-use the old position, in order to\n        // prevent the overlay from jumping around.\n        if (!this._isInitialRender && this._positionLocked && this._lastPosition) {\n            this.reapplyLastPosition();\n            return;\n        }\n        this._clearPanelClasses();\n        this._resetOverlayElementStyles();\n        this._resetBoundingBoxStyles();\n        // We need the bounding rects for the origin and the overlay to determine how to position\n        // the overlay relative to the origin.\n        // We use the viewport rect to determine whether a position would go off-screen.\n        this._viewportRect = this._getNarrowedViewportRect();\n        this._originRect = this._getOriginRect();\n        this._overlayRect = this._pane.getBoundingClientRect();\n        /** @type {?} */\n        const originRect = this._originRect;\n        /** @type {?} */\n        const overlayRect = this._overlayRect;\n        /** @type {?} */\n        const viewportRect = this._viewportRect;\n        // Positions where the overlay will fit with flexible dimensions.\n        /** @type {?} */\n        const flexibleFits = [];\n        // Fallback if none of the preferred positions fit within the viewport.\n        /** @type {?} */\n        let fallback;\n        // Go through each of the preferred positions looking for a good fit.\n        // If a good fit is found, it will be applied immediately.\n        for (let pos of this._preferredPositions) {\n            // Get the exact (x, y) coordinate for the point-of-origin on the origin element.\n            /** @type {?} */\n            let originPoint = this._getOriginPoint(originRect, pos);\n            // From that point-of-origin, get the exact (x, y) coordinate for the top-left corner of the\n            // overlay in this position. We use the top-left corner for calculations and later translate\n            // this into an appropriate (top, left, bottom, right) style.\n            /** @type {?} */\n            let overlayPoint = this._getOverlayPoint(originPoint, overlayRect, pos);\n            // Calculate how well the overlay would fit into the viewport with this point.\n            /** @type {?} */\n            let overlayFit = this._getOverlayFit(overlayPoint, overlayRect, viewportRect, pos);\n            // If the overlay, without any further work, fits into the viewport, use this position.\n            if (overlayFit.isCompletelyWithinViewport) {\n                this._isPushed = false;\n                this._applyPosition(pos, originPoint);\n                return;\n            }\n            // If the overlay has flexible dimensions, we can use this position\n            // so long as there's enough space for the minimum dimensions.\n            if (this._canFitWithFlexibleDimensions(overlayFit, overlayPoint, viewportRect)) {\n                // Save positions where the overlay will fit with flexible dimensions. We will use these\n                // if none of the positions fit *without* flexible dimensions.\n                flexibleFits.push({\n                    position: pos,\n                    origin: originPoint,\n                    overlayRect,\n                    boundingBoxRect: this._calculateBoundingBoxRect(originPoint, pos)\n                });\n                continue;\n            }\n            // If the current preferred position does not fit on the screen, remember the position\n            // if it has more visible area on-screen than we've seen and move onto the next preferred\n            // position.\n            if (!fallback || fallback.overlayFit.visibleArea < overlayFit.visibleArea) {\n                fallback = { overlayFit, overlayPoint, originPoint, position: pos, overlayRect };\n            }\n        }\n        // If there are any positions where the overlay would fit with flexible dimensions, choose the\n        // one that has the greatest area available modified by the position's weight\n        if (flexibleFits.length) {\n            /** @type {?} */\n            let bestFit = null;\n            /** @type {?} */\n            let bestScore = -1;\n            for (const fit of flexibleFits) {\n                /** @type {?} */\n                const score = fit.boundingBoxRect.width * fit.boundingBoxRect.height * (fit.position.weight || 1);\n                if (score > bestScore) {\n                    bestScore = score;\n                    bestFit = fit;\n                }\n            }\n            this._isPushed = false;\n            this._applyPosition((/** @type {?} */ (bestFit)).position, (/** @type {?} */ (bestFit)).origin);\n            return;\n        }\n        // When none of the preferred positions fit within the viewport, take the position\n        // that went off-screen the least and attempt to push it on-screen.\n        if (this._canPush) {\n            // TODO(jelbourn): after pushing, the opening \"direction\" of the overlay might not make sense.\n            this._isPushed = true;\n            this._applyPosition((/** @type {?} */ (fallback)).position, (/** @type {?} */ (fallback)).originPoint);\n            return;\n        }\n        // All options for getting the overlay within the viewport have been exhausted, so go with the\n        // position that went off-screen the least.\n        this._applyPosition((/** @type {?} */ (fallback)).position, (/** @type {?} */ (fallback)).originPoint);\n    }\n    /**\n     * @return {?}\n     */\n    detach() {\n        this._clearPanelClasses();\n        this._lastPosition = null;\n        this._previousPushAmount = null;\n        this._resizeSubscription.unsubscribe();\n    }\n    /**\n     * Cleanup after the element gets destroyed.\n     * @return {?}\n     */\n    dispose() {\n        if (this._isDisposed) {\n            return;\n        }\n        // We can't use `_resetBoundingBoxStyles` here, because it resets\n        // some properties to zero, rather than removing them.\n        if (this._boundingBox) {\n            extendStyles(this._boundingBox.style, (/** @type {?} */ ({\n                top: '',\n                left: '',\n                right: '',\n                bottom: '',\n                height: '',\n                width: '',\n                alignItems: '',\n                justifyContent: '',\n            })));\n        }\n        if (this._pane) {\n            this._resetOverlayElementStyles();\n        }\n        if (this._overlayRef) {\n            this._overlayRef.hostElement.classList.remove(boundingBoxClass);\n        }\n        this.detach();\n        this._positionChanges.complete();\n        this._overlayRef = this._boundingBox = (/** @type {?} */ (null));\n        this._isDisposed = true;\n    }\n    /**\n     * This re-aligns the overlay element with the trigger in its last calculated position,\n     * even if a position higher in the \"preferred positions\" list would now fit. This\n     * allows one to re-align the panel without changing the orientation of the panel.\n     * @return {?}\n     */\n    reapplyLastPosition() {\n        if (!this._isDisposed && (!this._platform || this._platform.isBrowser)) {\n            this._originRect = this._getOriginRect();\n            this._overlayRect = this._pane.getBoundingClientRect();\n            this._viewportRect = this._getNarrowedViewportRect();\n            /** @type {?} */\n            const lastPosition = this._lastPosition || this._preferredPositions[0];\n            /** @type {?} */\n            const originPoint = this._getOriginPoint(this._originRect, lastPosition);\n            this._applyPosition(lastPosition, originPoint);\n        }\n    }\n    /**\n     * Sets the list of Scrollable containers that host the origin element so that\n     * on reposition we can evaluate if it or the overlay has been clipped or outside view. Every\n     * Scrollable must be an ancestor element of the strategy's origin element.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} scrollables\n     * @return {THIS}\n     */\n    withScrollableContainers(scrollables) {\n        (/** @type {?} */ (this))._scrollables = scrollables;\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Adds new preferred positions.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} positions List of positions options for this overlay.\n     * @return {THIS}\n     */\n    withPositions(positions) {\n        (/** @type {?} */ (this))._preferredPositions = positions;\n        // If the last calculated position object isn't part of the positions anymore, clear\n        // it in order to avoid it being picked up if the consumer tries to re-apply.\n        if (positions.indexOf((/** @type {?} */ ((/** @type {?} */ (this))._lastPosition))) === -1) {\n            (/** @type {?} */ (this))._lastPosition = null;\n        }\n        (/** @type {?} */ (this))._validatePositions();\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets a minimum distance the overlay may be positioned to the edge of the viewport.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} margin Required margin between the overlay and the viewport edge in pixels.\n     * @return {THIS}\n     */\n    withViewportMargin(margin) {\n        (/** @type {?} */ (this))._viewportMargin = margin;\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets whether the overlay's width and height can be constrained to fit within the viewport.\n     * @template THIS\n     * @this {THIS}\n     * @param {?=} flexibleDimensions\n     * @return {THIS}\n     */\n    withFlexibleDimensions(flexibleDimensions = true) {\n        (/** @type {?} */ (this))._hasFlexibleDimensions = flexibleDimensions;\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets whether the overlay can grow after the initial open via flexible width/height.\n     * @template THIS\n     * @this {THIS}\n     * @param {?=} growAfterOpen\n     * @return {THIS}\n     */\n    withGrowAfterOpen(growAfterOpen = true) {\n        (/** @type {?} */ (this))._growAfterOpen = growAfterOpen;\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets whether the overlay can be pushed on-screen if none of the provided positions fit.\n     * @template THIS\n     * @this {THIS}\n     * @param {?=} canPush\n     * @return {THIS}\n     */\n    withPush(canPush = true) {\n        (/** @type {?} */ (this))._canPush = canPush;\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets whether the overlay's position should be locked in after it is positioned\n     * initially. When an overlay is locked in, it won't attempt to reposition itself\n     * when the position is re-applied (e.g. when the user scrolls away).\n     * @template THIS\n     * @this {THIS}\n     * @param {?=} isLocked Whether the overlay should locked in.\n     * @return {THIS}\n     */\n    withLockedPosition(isLocked = true) {\n        (/** @type {?} */ (this))._positionLocked = isLocked;\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets the origin, relative to which to position the overlay.\n     * Using an element origin is useful for building components that need to be positioned\n     * relatively to a trigger (e.g. dropdown menus or tooltips), whereas using a point can be\n     * used for cases like contextual menus which open relative to the user's pointer.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} origin Reference to the new origin.\n     * @return {THIS}\n     */\n    setOrigin(origin) {\n        (/** @type {?} */ (this))._origin = origin;\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets the default offset for the overlay's connection point on the x-axis.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} offset New offset in the X axis.\n     * @return {THIS}\n     */\n    withDefaultOffsetX(offset) {\n        (/** @type {?} */ (this))._offsetX = offset;\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets the default offset for the overlay's connection point on the y-axis.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} offset New offset in the Y axis.\n     * @return {THIS}\n     */\n    withDefaultOffsetY(offset) {\n        (/** @type {?} */ (this))._offsetY = offset;\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Configures that the position strategy should set a `transform-origin` on some elements\n     * inside the overlay, depending on the current position that is being applied. This is\n     * useful for the cases where the origin of an animation can change depending on the\n     * alignment of the overlay.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} selector CSS selector that will be used to find the target\n     *    elements onto which to set the transform origin.\n     * @return {THIS}\n     */\n    withTransformOriginOn(selector) {\n        (/** @type {?} */ (this))._transformOriginSelector = selector;\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Gets the (x, y) coordinate of a connection point on the origin based on a relative position.\n     * @private\n     * @param {?} originRect\n     * @param {?} pos\n     * @return {?}\n     */\n    _getOriginPoint(originRect, pos) {\n        /** @type {?} */\n        let x;\n        if (pos.originX == 'center') {\n            // Note: when centering we should always use the `left`\n            // offset, otherwise the position will be wrong in RTL.\n            x = originRect.left + (originRect.width / 2);\n        }\n        else {\n            /** @type {?} */\n            const startX = this._isRtl() ? originRect.right : originRect.left;\n            /** @type {?} */\n            const endX = this._isRtl() ? originRect.left : originRect.right;\n            x = pos.originX == 'start' ? startX : endX;\n        }\n        /** @type {?} */\n        let y;\n        if (pos.originY == 'center') {\n            y = originRect.top + (originRect.height / 2);\n        }\n        else {\n            y = pos.originY == 'top' ? originRect.top : originRect.bottom;\n        }\n        return { x, y };\n    }\n    /**\n     * Gets the (x, y) coordinate of the top-left corner of the overlay given a given position and\n     * origin point to which the overlay should be connected.\n     * @private\n     * @param {?} originPoint\n     * @param {?} overlayRect\n     * @param {?} pos\n     * @return {?}\n     */\n    _getOverlayPoint(originPoint, overlayRect, pos) {\n        // Calculate the (overlayStartX, overlayStartY), the start of the\n        // potential overlay position relative to the origin point.\n        /** @type {?} */\n        let overlayStartX;\n        if (pos.overlayX == 'center') {\n            overlayStartX = -overlayRect.width / 2;\n        }\n        else if (pos.overlayX === 'start') {\n            overlayStartX = this._isRtl() ? -overlayRect.width : 0;\n        }\n        else {\n            overlayStartX = this._isRtl() ? 0 : -overlayRect.width;\n        }\n        /** @type {?} */\n        let overlayStartY;\n        if (pos.overlayY == 'center') {\n            overlayStartY = -overlayRect.height / 2;\n        }\n        else {\n            overlayStartY = pos.overlayY == 'top' ? 0 : -overlayRect.height;\n        }\n        // The (x, y) coordinates of the overlay.\n        return {\n            x: originPoint.x + overlayStartX,\n            y: originPoint.y + overlayStartY,\n        };\n    }\n    /**\n     * Gets how well an overlay at the given point will fit within the viewport.\n     * @private\n     * @param {?} point\n     * @param {?} overlay\n     * @param {?} viewport\n     * @param {?} position\n     * @return {?}\n     */\n    _getOverlayFit(point, overlay, viewport, position) {\n        let { x, y } = point;\n        /** @type {?} */\n        let offsetX = this._getOffset(position, 'x');\n        /** @type {?} */\n        let offsetY = this._getOffset(position, 'y');\n        // Account for the offsets since they could push the overlay out of the viewport.\n        if (offsetX) {\n            x += offsetX;\n        }\n        if (offsetY) {\n            y += offsetY;\n        }\n        // How much the overlay would overflow at this position, on each side.\n        /** @type {?} */\n        let leftOverflow = 0 - x;\n        /** @type {?} */\n        let rightOverflow = (x + overlay.width) - viewport.width;\n        /** @type {?} */\n        let topOverflow = 0 - y;\n        /** @type {?} */\n        let bottomOverflow = (y + overlay.height) - viewport.height;\n        // Visible parts of the element on each axis.\n        /** @type {?} */\n        let visibleWidth = this._subtractOverflows(overlay.width, leftOverflow, rightOverflow);\n        /** @type {?} */\n        let visibleHeight = this._subtractOverflows(overlay.height, topOverflow, bottomOverflow);\n        /** @type {?} */\n        let visibleArea = visibleWidth * visibleHeight;\n        return {\n            visibleArea,\n            isCompletelyWithinViewport: (overlay.width * overlay.height) === visibleArea,\n            fitsInViewportVertically: visibleHeight === overlay.height,\n            fitsInViewportHorizontally: visibleWidth == overlay.width,\n        };\n    }\n    /**\n     * Whether the overlay can fit within the viewport when it may resize either its width or height.\n     * @private\n     * @param {?} fit How well the overlay fits in the viewport at some position.\n     * @param {?} point The (x, y) coordinates of the overlat at some position.\n     * @param {?} viewport The geometry of the viewport.\n     * @return {?}\n     */\n    _canFitWithFlexibleDimensions(fit, point, viewport) {\n        if (this._hasFlexibleDimensions) {\n            /** @type {?} */\n            const availableHeight = viewport.bottom - point.y;\n            /** @type {?} */\n            const availableWidth = viewport.right - point.x;\n            /** @type {?} */\n            const minHeight = getPixelValue(this._overlayRef.getConfig().minHeight);\n            /** @type {?} */\n            const minWidth = getPixelValue(this._overlayRef.getConfig().minWidth);\n            /** @type {?} */\n            const verticalFit = fit.fitsInViewportVertically ||\n                (minHeight != null && minHeight <= availableHeight);\n            /** @type {?} */\n            const horizontalFit = fit.fitsInViewportHorizontally ||\n                (minWidth != null && minWidth <= availableWidth);\n            return verticalFit && horizontalFit;\n        }\n        return false;\n    }\n    /**\n     * Gets the point at which the overlay can be \"pushed\" on-screen. If the overlay is larger than\n     * the viewport, the top-left corner will be pushed on-screen (with overflow occuring on the\n     * right and bottom).\n     *\n     * @private\n     * @param {?} start Starting point from which the overlay is pushed.\n     * @param {?} overlay Dimensions of the overlay.\n     * @param {?} scrollPosition Current viewport scroll position.\n     * @return {?} The point at which to position the overlay after pushing. This is effectively a new\n     *     originPoint.\n     */\n    _pushOverlayOnScreen(start, overlay, scrollPosition) {\n        // If the position is locked and we've pushed the overlay already, reuse the previous push\n        // amount, rather than pushing it again. If we were to continue pushing, the element would\n        // remain in the viewport, which goes against the expectations when position locking is enabled.\n        if (this._previousPushAmount && this._positionLocked) {\n            return {\n                x: start.x + this._previousPushAmount.x,\n                y: start.y + this._previousPushAmount.y\n            };\n        }\n        /** @type {?} */\n        const viewport = this._viewportRect;\n        // Determine how much the overlay goes outside the viewport on each\n        // side, which we'll use to decide which direction to push it.\n        /** @type {?} */\n        const overflowRight = Math.max(start.x + overlay.width - viewport.right, 0);\n        /** @type {?} */\n        const overflowBottom = Math.max(start.y + overlay.height - viewport.bottom, 0);\n        /** @type {?} */\n        const overflowTop = Math.max(viewport.top - scrollPosition.top - start.y, 0);\n        /** @type {?} */\n        const overflowLeft = Math.max(viewport.left - scrollPosition.left - start.x, 0);\n        // Amount by which to push the overlay in each axis such that it remains on-screen.\n        /** @type {?} */\n        let pushX = 0;\n        /** @type {?} */\n        let pushY = 0;\n        // If the overlay fits completely within the bounds of the viewport, push it from whichever\n        // direction is goes off-screen. Otherwise, push the top-left corner such that its in the\n        // viewport and allow for the trailing end of the overlay to go out of bounds.\n        if (overlay.width <= viewport.width) {\n            pushX = overflowLeft || -overflowRight;\n        }\n        else {\n            pushX = start.x < this._viewportMargin ? (viewport.left - scrollPosition.left) - start.x : 0;\n        }\n        if (overlay.height <= viewport.height) {\n            pushY = overflowTop || -overflowBottom;\n        }\n        else {\n            pushY = start.y < this._viewportMargin ? (viewport.top - scrollPosition.top) - start.y : 0;\n        }\n        this._previousPushAmount = { x: pushX, y: pushY };\n        return {\n            x: start.x + pushX,\n            y: start.y + pushY,\n        };\n    }\n    /**\n     * Applies a computed position to the overlay and emits a position change.\n     * @private\n     * @param {?} position The position preference\n     * @param {?} originPoint The point on the origin element where the overlay is connected.\n     * @return {?}\n     */\n    _applyPosition(position, originPoint) {\n        this._setTransformOrigin(position);\n        this._setOverlayElementStyles(originPoint, position);\n        this._setBoundingBoxStyles(originPoint, position);\n        if (position.panelClass) {\n            this._addPanelClasses(position.panelClass);\n        }\n        // Save the last connected position in case the position needs to be re-calculated.\n        this._lastPosition = position;\n        // Notify that the position has been changed along with its change properties.\n        // We only emit if we've got any subscriptions, because the scroll visibility\n        // calculcations can be somewhat expensive.\n        if (this._positionChanges.observers.length) {\n            /** @type {?} */\n            const scrollableViewProperties = this._getScrollVisibility();\n            /** @type {?} */\n            const changeEvent = new ConnectedOverlayPositionChange(position, scrollableViewProperties);\n            this._positionChanges.next(changeEvent);\n        }\n        this._isInitialRender = false;\n    }\n    /**\n     * Sets the transform origin based on the configured selector and the passed-in position.\n     * @private\n     * @param {?} position\n     * @return {?}\n     */\n    _setTransformOrigin(position) {\n        if (!this._transformOriginSelector) {\n            return;\n        }\n        /** @type {?} */\n        const elements = (/** @type {?} */ (this._boundingBox)).querySelectorAll(this._transformOriginSelector);\n        /** @type {?} */\n        let xOrigin;\n        /** @type {?} */\n        let yOrigin = position.overlayY;\n        if (position.overlayX === 'center') {\n            xOrigin = 'center';\n        }\n        else if (this._isRtl()) {\n            xOrigin = position.overlayX === 'start' ? 'right' : 'left';\n        }\n        else {\n            xOrigin = position.overlayX === 'start' ? 'left' : 'right';\n        }\n        for (let i = 0; i < elements.length; i++) {\n            elements[i].style.transformOrigin = `${xOrigin} ${yOrigin}`;\n        }\n    }\n    /**\n     * Gets the position and size of the overlay's sizing container.\n     *\n     * This method does no measuring and applies no styles so that we can cheaply compute the\n     * bounds for all positions and choose the best fit based on these results.\n     * @private\n     * @param {?} origin\n     * @param {?} position\n     * @return {?}\n     */\n    _calculateBoundingBoxRect(origin, position) {\n        /** @type {?} */\n        const viewport = this._viewportRect;\n        /** @type {?} */\n        const isRtl = this._isRtl();\n        /** @type {?} */\n        let height;\n        /** @type {?} */\n        let top;\n        /** @type {?} */\n        let bottom;\n        if (position.overlayY === 'top') {\n            // Overlay is opening \"downward\" and thus is bound by the bottom viewport edge.\n            top = origin.y;\n            height = viewport.height - top + this._viewportMargin;\n        }\n        else if (position.overlayY === 'bottom') {\n            // Overlay is opening \"upward\" and thus is bound by the top viewport edge. We need to add\n            // the viewport margin back in, because the viewport rect is narrowed down to remove the\n            // margin, whereas the `origin` position is calculated based on its `ClientRect`.\n            bottom = viewport.height - origin.y + this._viewportMargin * 2;\n            height = viewport.height - bottom + this._viewportMargin;\n        }\n        else {\n            // If neither top nor bottom, it means that the overlay is vertically centered on the\n            // origin point. Note that we want the position relative to the viewport, rather than\n            // the page, which is why we don't use something like `viewport.bottom - origin.y` and\n            // `origin.y - viewport.top`.\n            /** @type {?} */\n            const smallestDistanceToViewportEdge = Math.min(viewport.bottom - origin.y + viewport.top, origin.y);\n            /** @type {?} */\n            const previousHeight = this._lastBoundingBoxSize.height;\n            height = smallestDistanceToViewportEdge * 2;\n            top = origin.y - smallestDistanceToViewportEdge;\n            if (height > previousHeight && !this._isInitialRender && !this._growAfterOpen) {\n                top = origin.y - (previousHeight / 2);\n            }\n        }\n        // The overlay is opening 'right-ward' (the content flows to the right).\n        /** @type {?} */\n        const isBoundedByRightViewportEdge = (position.overlayX === 'start' && !isRtl) ||\n            (position.overlayX === 'end' && isRtl);\n        // The overlay is opening 'left-ward' (the content flows to the left).\n        /** @type {?} */\n        const isBoundedByLeftViewportEdge = (position.overlayX === 'end' && !isRtl) ||\n            (position.overlayX === 'start' && isRtl);\n        /** @type {?} */\n        let width;\n        /** @type {?} */\n        let left;\n        /** @type {?} */\n        let right;\n        if (isBoundedByLeftViewportEdge) {\n            right = viewport.width - origin.x + this._viewportMargin;\n            width = origin.x - this._viewportMargin;\n        }\n        else if (isBoundedByRightViewportEdge) {\n            left = origin.x;\n            width = viewport.right - origin.x;\n        }\n        else {\n            // If neither start nor end, it means that the overlay is horizontally centered on the\n            // origin point. Note that we want the position relative to the viewport, rather than\n            // the page, which is why we don't use something like `viewport.right - origin.x` and\n            // `origin.x - viewport.left`.\n            /** @type {?} */\n            const smallestDistanceToViewportEdge = Math.min(viewport.right - origin.x + viewport.left, origin.x);\n            /** @type {?} */\n            const previousWidth = this._lastBoundingBoxSize.width;\n            width = smallestDistanceToViewportEdge * 2;\n            left = origin.x - smallestDistanceToViewportEdge;\n            if (width > previousWidth && !this._isInitialRender && !this._growAfterOpen) {\n                left = origin.x - (previousWidth / 2);\n            }\n        }\n        return { top: (/** @type {?} */ (top)), left: (/** @type {?} */ (left)), bottom: (/** @type {?} */ (bottom)), right: (/** @type {?} */ (right)), width, height };\n    }\n    /**\n     * Sets the position and size of the overlay's sizing wrapper. The wrapper is positioned on the\n     * origin's connection point and stetches to the bounds of the viewport.\n     *\n     * @private\n     * @param {?} origin The point on the origin element where the overlay is connected.\n     * @param {?} position The position preference\n     * @return {?}\n     */\n    _setBoundingBoxStyles(origin, position) {\n        /** @type {?} */\n        const boundingBoxRect = this._calculateBoundingBoxRect(origin, position);\n        // It's weird if the overlay *grows* while scrolling, so we take the last size into account\n        // when applying a new size.\n        if (!this._isInitialRender && !this._growAfterOpen) {\n            boundingBoxRect.height = Math.min(boundingBoxRect.height, this._lastBoundingBoxSize.height);\n            boundingBoxRect.width = Math.min(boundingBoxRect.width, this._lastBoundingBoxSize.width);\n        }\n        /** @type {?} */\n        const styles = (/** @type {?} */ ({}));\n        if (this._hasExactPosition()) {\n            styles.top = styles.left = '0';\n            styles.bottom = styles.right = styles.maxHeight = styles.maxWidth = '';\n            styles.width = styles.height = '100%';\n        }\n        else {\n            /** @type {?} */\n            const maxHeight = this._overlayRef.getConfig().maxHeight;\n            /** @type {?} */\n            const maxWidth = this._overlayRef.getConfig().maxWidth;\n            styles.height = coerceCssPixelValue(boundingBoxRect.height);\n            styles.top = coerceCssPixelValue(boundingBoxRect.top);\n            styles.bottom = coerceCssPixelValue(boundingBoxRect.bottom);\n            styles.width = coerceCssPixelValue(boundingBoxRect.width);\n            styles.left = coerceCssPixelValue(boundingBoxRect.left);\n            styles.right = coerceCssPixelValue(boundingBoxRect.right);\n            // Push the pane content towards the proper direction.\n            if (position.overlayX === 'center') {\n                styles.alignItems = 'center';\n            }\n            else {\n                styles.alignItems = position.overlayX === 'end' ? 'flex-end' : 'flex-start';\n            }\n            if (position.overlayY === 'center') {\n                styles.justifyContent = 'center';\n            }\n            else {\n                styles.justifyContent = position.overlayY === 'bottom' ? 'flex-end' : 'flex-start';\n            }\n            if (maxHeight) {\n                styles.maxHeight = coerceCssPixelValue(maxHeight);\n            }\n            if (maxWidth) {\n                styles.maxWidth = coerceCssPixelValue(maxWidth);\n            }\n        }\n        this._lastBoundingBoxSize = boundingBoxRect;\n        extendStyles((/** @type {?} */ (this._boundingBox)).style, styles);\n    }\n    /**\n     * Resets the styles for the bounding box so that a new positioning can be computed.\n     * @private\n     * @return {?}\n     */\n    _resetBoundingBoxStyles() {\n        extendStyles((/** @type {?} */ (this._boundingBox)).style, (/** @type {?} */ ({\n            top: '0',\n            left: '0',\n            right: '0',\n            bottom: '0',\n            height: '',\n            width: '',\n            alignItems: '',\n            justifyContent: '',\n        })));\n    }\n    /**\n     * Resets the styles for the overlay pane so that a new positioning can be computed.\n     * @private\n     * @return {?}\n     */\n    _resetOverlayElementStyles() {\n        extendStyles(this._pane.style, (/** @type {?} */ ({\n            top: '',\n            left: '',\n            bottom: '',\n            right: '',\n            position: '',\n            transform: '',\n        })));\n    }\n    /**\n     * Sets positioning styles to the overlay element.\n     * @private\n     * @param {?} originPoint\n     * @param {?} position\n     * @return {?}\n     */\n    _setOverlayElementStyles(originPoint, position) {\n        /** @type {?} */\n        const styles = (/** @type {?} */ ({}));\n        /** @type {?} */\n        const hasExactPosition = this._hasExactPosition();\n        /** @type {?} */\n        const hasFlexibleDimensions = this._hasFlexibleDimensions;\n        /** @type {?} */\n        const config = this._overlayRef.getConfig();\n        if (hasExactPosition) {\n            /** @type {?} */\n            const scrollPosition = this._viewportRuler.getViewportScrollPosition();\n            extendStyles(styles, this._getExactOverlayY(position, originPoint, scrollPosition));\n            extendStyles(styles, this._getExactOverlayX(position, originPoint, scrollPosition));\n        }\n        else {\n            styles.position = 'static';\n        }\n        // Use a transform to apply the offsets. We do this because the `center` positions rely on\n        // being in the normal flex flow and setting a `top` / `left` at all will completely throw\n        // off the position. We also can't use margins, because they won't have an effect in some\n        // cases where the element doesn't have anything to \"push off of\". Finally, this works\n        // better both with flexible and non-flexible positioning.\n        /** @type {?} */\n        let transformString = '';\n        /** @type {?} */\n        let offsetX = this._getOffset(position, 'x');\n        /** @type {?} */\n        let offsetY = this._getOffset(position, 'y');\n        if (offsetX) {\n            transformString += `translateX(${offsetX}px) `;\n        }\n        if (offsetY) {\n            transformString += `translateY(${offsetY}px)`;\n        }\n        styles.transform = transformString.trim();\n        // If a maxWidth or maxHeight is specified on the overlay, we remove them. We do this because\n        // we need these values to both be set to \"100%\" for the automatic flexible sizing to work.\n        // The maxHeight and maxWidth are set on the boundingBox in order to enforce the constraint.\n        // Note that this doesn't apply when we have an exact position, in which case we do want to\n        // apply them because they'll be cleared from the bounding box.\n        if (config.maxHeight) {\n            if (hasExactPosition) {\n                styles.maxHeight = coerceCssPixelValue(config.maxHeight);\n            }\n            else if (hasFlexibleDimensions) {\n                styles.maxHeight = '';\n            }\n        }\n        if (config.maxWidth) {\n            if (hasExactPosition) {\n                styles.maxWidth = coerceCssPixelValue(config.maxWidth);\n            }\n            else if (hasFlexibleDimensions) {\n                styles.maxWidth = '';\n            }\n        }\n        extendStyles(this._pane.style, styles);\n    }\n    /**\n     * Gets the exact top/bottom for the overlay when not using flexible sizing or when pushing.\n     * @private\n     * @param {?} position\n     * @param {?} originPoint\n     * @param {?} scrollPosition\n     * @return {?}\n     */\n    _getExactOverlayY(position, originPoint, scrollPosition) {\n        // Reset any existing styles. This is necessary in case the\n        // preferred position has changed since the last `apply`.\n        /** @type {?} */\n        let styles = (/** @type {?} */ ({ top: '', bottom: '' }));\n        /** @type {?} */\n        let overlayPoint = this._getOverlayPoint(originPoint, this._overlayRect, position);\n        if (this._isPushed) {\n            overlayPoint = this._pushOverlayOnScreen(overlayPoint, this._overlayRect, scrollPosition);\n        }\n        /** @type {?} */\n        let virtualKeyboardOffset = this._overlayContainer.getContainerElement().getBoundingClientRect().top;\n        // Normally this would be zero, however when the overlay is attached to an input (e.g. in an\n        // autocomplete), mobile browsers will shift everything in order to put the input in the middle\n        // of the screen and to make space for the virtual keyboard. We need to account for this offset,\n        // otherwise our positioning will be thrown off.\n        overlayPoint.y -= virtualKeyboardOffset;\n        // We want to set either `top` or `bottom` based on whether the overlay wants to appear\n        // above or below the origin and the direction in which the element will expand.\n        if (position.overlayY === 'bottom') {\n            // When using `bottom`, we adjust the y position such that it is the distance\n            // from the bottom of the viewport rather than the top.\n            /** @type {?} */\n            const documentHeight = (/** @type {?} */ (this._document.documentElement)).clientHeight;\n            styles.bottom = `${documentHeight - (overlayPoint.y + this._overlayRect.height)}px`;\n        }\n        else {\n            styles.top = coerceCssPixelValue(overlayPoint.y);\n        }\n        return styles;\n    }\n    /**\n     * Gets the exact left/right for the overlay when not using flexible sizing or when pushing.\n     * @private\n     * @param {?} position\n     * @param {?} originPoint\n     * @param {?} scrollPosition\n     * @return {?}\n     */\n    _getExactOverlayX(position, originPoint, scrollPosition) {\n        // Reset any existing styles. This is necessary in case the preferred position has\n        // changed since the last `apply`.\n        /** @type {?} */\n        let styles = (/** @type {?} */ ({ left: '', right: '' }));\n        /** @type {?} */\n        let overlayPoint = this._getOverlayPoint(originPoint, this._overlayRect, position);\n        if (this._isPushed) {\n            overlayPoint = this._pushOverlayOnScreen(overlayPoint, this._overlayRect, scrollPosition);\n        }\n        // We want to set either `left` or `right` based on whether the overlay wants to appear \"before\"\n        // or \"after\" the origin, which determines the direction in which the element will expand.\n        // For the horizontal axis, the meaning of \"before\" and \"after\" change based on whether the\n        // page is in RTL or LTR.\n        /** @type {?} */\n        let horizontalStyleProperty;\n        if (this._isRtl()) {\n            horizontalStyleProperty = position.overlayX === 'end' ? 'left' : 'right';\n        }\n        else {\n            horizontalStyleProperty = position.overlayX === 'end' ? 'right' : 'left';\n        }\n        // When we're setting `right`, we adjust the x position such that it is the distance\n        // from the right edge of the viewport rather than the left edge.\n        if (horizontalStyleProperty === 'right') {\n            /** @type {?} */\n            const documentWidth = (/** @type {?} */ (this._document.documentElement)).clientWidth;\n            styles.right = `${documentWidth - (overlayPoint.x + this._overlayRect.width)}px`;\n        }\n        else {\n            styles.left = coerceCssPixelValue(overlayPoint.x);\n        }\n        return styles;\n    }\n    /**\n     * Gets the view properties of the trigger and overlay, including whether they are clipped\n     * or completely outside the view of any of the strategy's scrollables.\n     * @private\n     * @return {?}\n     */\n    _getScrollVisibility() {\n        // Note: needs fresh rects since the position could've changed.\n        /** @type {?} */\n        const originBounds = this._getOriginRect();\n        /** @type {?} */\n        const overlayBounds = this._pane.getBoundingClientRect();\n        // TODO(jelbourn): instead of needing all of the client rects for these scrolling containers\n        // every time, we should be able to use the scrollTop of the containers if the size of those\n        // containers hasn't changed.\n        /** @type {?} */\n        const scrollContainerBounds = this._scrollables.map((/**\n         * @param {?} scrollable\n         * @return {?}\n         */\n        scrollable => {\n            return scrollable.getElementRef().nativeElement.getBoundingClientRect();\n        }));\n        return {\n            isOriginClipped: isElementClippedByScrolling(originBounds, scrollContainerBounds),\n            isOriginOutsideView: isElementScrolledOutsideView(originBounds, scrollContainerBounds),\n            isOverlayClipped: isElementClippedByScrolling(overlayBounds, scrollContainerBounds),\n            isOverlayOutsideView: isElementScrolledOutsideView(overlayBounds, scrollContainerBounds),\n        };\n    }\n    /**\n     * Subtracts the amount that an element is overflowing on an axis from its length.\n     * @private\n     * @param {?} length\n     * @param {...?} overflows\n     * @return {?}\n     */\n    _subtractOverflows(length, ...overflows) {\n        return overflows.reduce((/**\n         * @param {?} currentValue\n         * @param {?} currentOverflow\n         * @return {?}\n         */\n        (currentValue, currentOverflow) => {\n            return currentValue - Math.max(currentOverflow, 0);\n        }), length);\n    }\n    /**\n     * Narrows the given viewport rect by the current _viewportMargin.\n     * @private\n     * @return {?}\n     */\n    _getNarrowedViewportRect() {\n        // We recalculate the viewport rect here ourselves, rather than using the ViewportRuler,\n        // because we want to use the `clientWidth` and `clientHeight` as the base. The difference\n        // being that the client properties don't include the scrollbar, as opposed to `innerWidth`\n        // and `innerHeight` that do. This is necessary, because the overlay container uses\n        // 100% `width` and `height` which don't include the scrollbar either.\n        /** @type {?} */\n        const width = (/** @type {?} */ (this._document.documentElement)).clientWidth;\n        /** @type {?} */\n        const height = (/** @type {?} */ (this._document.documentElement)).clientHeight;\n        /** @type {?} */\n        const scrollPosition = this._viewportRuler.getViewportScrollPosition();\n        return {\n            top: scrollPosition.top + this._viewportMargin,\n            left: scrollPosition.left + this._viewportMargin,\n            right: scrollPosition.left + width - this._viewportMargin,\n            bottom: scrollPosition.top + height - this._viewportMargin,\n            width: width - (2 * this._viewportMargin),\n            height: height - (2 * this._viewportMargin),\n        };\n    }\n    /**\n     * Whether the we're dealing with an RTL context\n     * @private\n     * @return {?}\n     */\n    _isRtl() {\n        return this._overlayRef.getDirection() === 'rtl';\n    }\n    /**\n     * Determines whether the overlay uses exact or flexible positioning.\n     * @private\n     * @return {?}\n     */\n    _hasExactPosition() {\n        return !this._hasFlexibleDimensions || this._isPushed;\n    }\n    /**\n     * Retrieves the offset of a position along the x or y axis.\n     * @private\n     * @param {?} position\n     * @param {?} axis\n     * @return {?}\n     */\n    _getOffset(position, axis) {\n        if (axis === 'x') {\n            // We don't do something like `position['offset' + axis]` in\n            // order to avoid breking minifiers that rename properties.\n            return position.offsetX == null ? this._offsetX : position.offsetX;\n        }\n        return position.offsetY == null ? this._offsetY : position.offsetY;\n    }\n    /**\n     * Validates that the current position match the expected values.\n     * @private\n     * @return {?}\n     */\n    _validatePositions() {\n        if (!this._preferredPositions.length) {\n            throw Error('FlexibleConnectedPositionStrategy: At least one position is required.');\n        }\n        // TODO(crisbeto): remove these once Angular's template type\n        // checking is advanced enough to catch these cases.\n        this._preferredPositions.forEach((/**\n         * @param {?} pair\n         * @return {?}\n         */\n        pair => {\n            validateHorizontalPosition('originX', pair.originX);\n            validateVerticalPosition('originY', pair.originY);\n            validateHorizontalPosition('overlayX', pair.overlayX);\n            validateVerticalPosition('overlayY', pair.overlayY);\n        }));\n    }\n    /**\n     * Adds a single CSS class or an array of classes on the overlay panel.\n     * @private\n     * @param {?} cssClasses\n     * @return {?}\n     */\n    _addPanelClasses(cssClasses) {\n        if (this._pane) {\n            coerceArray(cssClasses).forEach((/**\n             * @param {?} cssClass\n             * @return {?}\n             */\n            cssClass => {\n                if (cssClass !== '' && this._appliedPanelClasses.indexOf(cssClass) === -1) {\n                    this._appliedPanelClasses.push(cssClass);\n                    this._pane.classList.add(cssClass);\n                }\n            }));\n        }\n    }\n    /**\n     * Clears the classes that the position strategy has applied from the overlay panel.\n     * @private\n     * @return {?}\n     */\n    _clearPanelClasses() {\n        if (this._pane) {\n            this._appliedPanelClasses.forEach((/**\n             * @param {?} cssClass\n             * @return {?}\n             */\n            cssClass => {\n                this._pane.classList.remove(cssClass);\n            }));\n            this._appliedPanelClasses = [];\n        }\n    }\n    /**\n     * Returns the ClientRect of the current origin.\n     * @private\n     * @return {?}\n     */\n    _getOriginRect() {\n        /** @type {?} */\n        const origin = this._origin;\n        if (origin instanceof ElementRef) {\n            return origin.nativeElement.getBoundingClientRect();\n        }\n        // Check for Element so SVG elements are also supported.\n        if (origin instanceof Element) {\n            return origin.getBoundingClientRect();\n        }\n        /** @type {?} */\n        const width = origin.width || 0;\n        /** @type {?} */\n        const height = origin.height || 0;\n        // If the origin is a point, return a client rect as if it was a 0x0 element at the point.\n        return {\n            top: origin.y,\n            bottom: origin.y + height,\n            left: origin.x,\n            right: origin.x + width,\n            height,\n            width\n        };\n    }\n}\nif (false) {\n    /**\n     * The overlay to which this strategy is attached.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._overlayRef;\n    /**\n     * Whether we're performing the very first positioning of the overlay.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._isInitialRender;\n    /**\n     * Last size used for the bounding box. Used to avoid resizing the overlay after open.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._lastBoundingBoxSize;\n    /**\n     * Whether the overlay was pushed in a previous positioning.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._isPushed;\n    /**\n     * Whether the overlay can be pushed on-screen on the initial open.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._canPush;\n    /**\n     * Whether the overlay can grow via flexible width/height after the initial open.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._growAfterOpen;\n    /**\n     * Whether the overlay's width and height can be constrained to fit within the viewport.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._hasFlexibleDimensions;\n    /**\n     * Whether the overlay position is locked.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._positionLocked;\n    /**\n     * Cached origin dimensions\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._originRect;\n    /**\n     * Cached overlay dimensions\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._overlayRect;\n    /**\n     * Cached viewport dimensions\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._viewportRect;\n    /**\n     * Amount of space that must be maintained between the overlay and the edge of the viewport.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._viewportMargin;\n    /**\n     * The Scrollable containers used to check scrollable view properties on position change.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._scrollables;\n    /**\n     * Ordered list of preferred positions, from most to least desirable.\n     * @type {?}\n     */\n    FlexibleConnectedPositionStrategy.prototype._preferredPositions;\n    /**\n     * The origin element against which the overlay will be positioned.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._origin;\n    /**\n     * The overlay pane element.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._pane;\n    /**\n     * Whether the strategy has been disposed of already.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._isDisposed;\n    /**\n     * Parent element for the overlay panel used to constrain the overlay panel's size to fit\n     * within the viewport.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._boundingBox;\n    /**\n     * The last position to have been calculated as the best fit position.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._lastPosition;\n    /**\n     * Subject that emits whenever the position changes.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._positionChanges;\n    /**\n     * Subscription to viewport size changes.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._resizeSubscription;\n    /**\n     * Default offset for the overlay along the x axis.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._offsetX;\n    /**\n     * Default offset for the overlay along the y axis.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._offsetY;\n    /**\n     * Selector to be used when finding the elements on which to set the transform origin.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._transformOriginSelector;\n    /**\n     * Keeps track of the CSS classes that the position strategy has applied on the overlay panel.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._appliedPanelClasses;\n    /**\n     * Amount by which the overlay was pushed in each axis during the last time it was positioned.\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._previousPushAmount;\n    /**\n     * Observable sequence of position changes.\n     * @type {?}\n     */\n    FlexibleConnectedPositionStrategy.prototype.positionChanges;\n    /**\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._viewportRuler;\n    /**\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._document;\n    /**\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._platform;\n    /**\n     * @type {?}\n     * @private\n     */\n    FlexibleConnectedPositionStrategy.prototype._overlayContainer;\n}\n/**\n * A simple (x, y) coordinate.\n * @record\n */\nfunction Point() { }\nif (false) {\n    /** @type {?} */\n    Point.prototype.x;\n    /** @type {?} */\n    Point.prototype.y;\n}\n/**\n * Record of measurements for how an overlay (at a given position) fits into the viewport.\n * @record\n */\nfunction OverlayFit() { }\nif (false) {\n    /**\n     * Whether the overlay fits completely in the viewport.\n     * @type {?}\n     */\n    OverlayFit.prototype.isCompletelyWithinViewport;\n    /**\n     * Whether the overlay fits in the viewport on the y-axis.\n     * @type {?}\n     */\n    OverlayFit.prototype.fitsInViewportVertically;\n    /**\n     * Whether the overlay fits in the viewport on the x-axis.\n     * @type {?}\n     */\n    OverlayFit.prototype.fitsInViewportHorizontally;\n    /**\n     * The total visible area (in px^2) of the overlay inside the viewport.\n     * @type {?}\n     */\n    OverlayFit.prototype.visibleArea;\n}\n/**\n * Record of the measurments determining whether an overlay will fit in a specific position.\n * @record\n */\nfunction FallbackPosition() { }\nif (false) {\n    /** @type {?} */\n    FallbackPosition.prototype.position;\n    /** @type {?} */\n    FallbackPosition.prototype.originPoint;\n    /** @type {?} */\n    FallbackPosition.prototype.overlayPoint;\n    /** @type {?} */\n    FallbackPosition.prototype.overlayFit;\n    /** @type {?} */\n    FallbackPosition.prototype.overlayRect;\n}\n/**\n * Position and size of the overlay sizing wrapper for a specific position.\n * @record\n */\nfunction BoundingBoxRect() { }\nif (false) {\n    /** @type {?} */\n    BoundingBoxRect.prototype.top;\n    /** @type {?} */\n    BoundingBoxRect.prototype.left;\n    /** @type {?} */\n    BoundingBoxRect.prototype.bottom;\n    /** @type {?} */\n    BoundingBoxRect.prototype.right;\n    /** @type {?} */\n    BoundingBoxRect.prototype.height;\n    /** @type {?} */\n    BoundingBoxRect.prototype.width;\n}\n/**\n * Record of measures determining how well a given position will fit with flexible dimensions.\n * @record\n */\nfunction FlexibleFit() { }\nif (false) {\n    /** @type {?} */\n    FlexibleFit.prototype.position;\n    /** @type {?} */\n    FlexibleFit.prototype.origin;\n    /** @type {?} */\n    FlexibleFit.prototype.overlayRect;\n    /** @type {?} */\n    FlexibleFit.prototype.boundingBoxRect;\n}\n/**\n * A connected position as specified by the user.\n * @record\n */\nfunction ConnectedPosition() { }\nif (false) {\n    /** @type {?} */\n    ConnectedPosition.prototype.originX;\n    /** @type {?} */\n    ConnectedPosition.prototype.originY;\n    /** @type {?} */\n    ConnectedPosition.prototype.overlayX;\n    /** @type {?} */\n    ConnectedPosition.prototype.overlayY;\n    /** @type {?|undefined} */\n    ConnectedPosition.prototype.weight;\n    /** @type {?|undefined} */\n    ConnectedPosition.prototype.offsetX;\n    /** @type {?|undefined} */\n    ConnectedPosition.prototype.offsetY;\n    /** @type {?|undefined} */\n    ConnectedPosition.prototype.panelClass;\n}\n/**\n * Shallow-extends a stylesheet object with another stylesheet object.\n * @param {?} destination\n * @param {?} source\n * @return {?}\n */\nfunction extendStyles(destination, source) {\n    for (let key in source) {\n        if (source.hasOwnProperty(key)) {\n            destination[key] = source[key];\n        }\n    }\n    return destination;\n}\n/**\n * Extracts the pixel value as a number from a value, if it's a number\n * or a CSS pixel string (e.g. `1337px`). Otherwise returns null.\n * @param {?} input\n * @return {?}\n */\nfunction getPixelValue(input) {\n    if (typeof input !== 'number' && input != null) {\n        const [value, units] = input.split(cssUnitPattern);\n        return (!units || units === 'px') ? parseFloat(value) : null;\n    }\n    return input || null;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/position/connected-position-strategy.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * A strategy for positioning overlays. Using this strategy, an overlay is given an\n * implicit position relative to some origin element. The relative position is defined in terms of\n * a point on the origin element that is connected to a point on the overlay element. For example,\n * a basic dropdown is connecting the bottom-left corner of the origin to the top-left corner\n * of the overlay.\n * @deprecated Use `FlexibleConnectedPositionStrategy` instead.\n * \\@breaking-change 8.0.0\n */\nclass ConnectedPositionStrategy {\n    /**\n     * @param {?} originPos\n     * @param {?} overlayPos\n     * @param {?} connectedTo\n     * @param {?} viewportRuler\n     * @param {?} document\n     * @param {?} platform\n     * @param {?} overlayContainer\n     */\n    constructor(originPos, overlayPos, connectedTo, viewportRuler, document, platform, overlayContainer) {\n        /**\n         * Ordered list of preferred positions, from most to least desirable.\n         */\n        this._preferredPositions = [];\n        // Since the `ConnectedPositionStrategy` is deprecated and we don't want to maintain\n        // the extra logic, we create an instance of the positioning strategy that has some\n        // defaults that make it behave as the old position strategy and to which we'll\n        // proxy all of the API calls.\n        this._positionStrategy = new FlexibleConnectedPositionStrategy(connectedTo, viewportRuler, document, platform, overlayContainer)\n            .withFlexibleDimensions(false)\n            .withPush(false)\n            .withViewportMargin(0);\n        this.withFallbackPosition(originPos, overlayPos);\n    }\n    /**\n     * Whether the we're dealing with an RTL context\n     * @return {?}\n     */\n    get _isRtl() {\n        return this._overlayRef.getDirection() === 'rtl';\n    }\n    /**\n     * Emits an event when the connection point changes.\n     * @return {?}\n     */\n    get onPositionChange() {\n        return this._positionStrategy.positionChanges;\n    }\n    /**\n     * Ordered list of preferred positions, from most to least desirable.\n     * @return {?}\n     */\n    get positions() {\n        return this._preferredPositions;\n    }\n    /**\n     * Attach this position strategy to an overlay.\n     * @param {?} overlayRef\n     * @return {?}\n     */\n    attach(overlayRef) {\n        this._overlayRef = overlayRef;\n        this._positionStrategy.attach(overlayRef);\n        if (this._direction) {\n            overlayRef.setDirection(this._direction);\n            this._direction = null;\n        }\n    }\n    /**\n     * Disposes all resources used by the position strategy.\n     * @return {?}\n     */\n    dispose() {\n        this._positionStrategy.dispose();\n    }\n    /**\n     * \\@docs-private\n     * @return {?}\n     */\n    detach() {\n        this._positionStrategy.detach();\n    }\n    /**\n     * Updates the position of the overlay element, using whichever preferred position relative\n     * to the origin fits on-screen.\n     * \\@docs-private\n     * @return {?}\n     */\n    apply() {\n        this._positionStrategy.apply();\n    }\n    /**\n     * Re-positions the overlay element with the trigger in its last calculated position,\n     * even if a position higher in the \"preferred positions\" list would now fit. This\n     * allows one to re-align the panel without changing the orientation of the panel.\n     * @return {?}\n     */\n    recalculateLastPosition() {\n        this._positionStrategy.reapplyLastPosition();\n    }\n    /**\n     * Sets the list of Scrollable containers that host the origin element so that\n     * on reposition we can evaluate if it or the overlay has been clipped or outside view. Every\n     * Scrollable must be an ancestor element of the strategy's origin element.\n     * @param {?} scrollables\n     * @return {?}\n     */\n    withScrollableContainers(scrollables) {\n        this._positionStrategy.withScrollableContainers(scrollables);\n    }\n    /**\n     * Adds a new preferred fallback position.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} originPos\n     * @param {?} overlayPos\n     * @param {?=} offsetX\n     * @param {?=} offsetY\n     * @return {THIS}\n     */\n    withFallbackPosition(originPos, overlayPos, offsetX, offsetY) {\n        /** @type {?} */\n        const position = new ConnectionPositionPair(originPos, overlayPos, offsetX, offsetY);\n        (/** @type {?} */ (this))._preferredPositions.push(position);\n        (/** @type {?} */ (this))._positionStrategy.withPositions((/** @type {?} */ (this))._preferredPositions);\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets the layout direction so the overlay's position can be adjusted to match.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} dir New layout direction.\n     * @return {THIS}\n     */\n    withDirection(dir) {\n        // Since the direction might be declared before the strategy is attached,\n        // we save the value in a temporary property and we'll transfer it to the\n        // overlay ref on attachment.\n        if ((/** @type {?} */ (this))._overlayRef) {\n            (/** @type {?} */ (this))._overlayRef.setDirection(dir);\n        }\n        else {\n            (/** @type {?} */ (this))._direction = dir;\n        }\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets an offset for the overlay's connection point on the x-axis\n     * @template THIS\n     * @this {THIS}\n     * @param {?} offset New offset in the X axis.\n     * @return {THIS}\n     */\n    withOffsetX(offset) {\n        (/** @type {?} */ (this))._positionStrategy.withDefaultOffsetX(offset);\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets an offset for the overlay's connection point on the y-axis\n     * @template THIS\n     * @this {THIS}\n     * @param {?} offset New offset in the Y axis.\n     * @return {THIS}\n     */\n    withOffsetY(offset) {\n        (/** @type {?} */ (this))._positionStrategy.withDefaultOffsetY(offset);\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets whether the overlay's position should be locked in after it is positioned\n     * initially. When an overlay is locked in, it won't attempt to reposition itself\n     * when the position is re-applied (e.g. when the user scrolls away).\n     * @template THIS\n     * @this {THIS}\n     * @param {?} isLocked Whether the overlay should locked in.\n     * @return {THIS}\n     */\n    withLockedPosition(isLocked) {\n        (/** @type {?} */ (this))._positionStrategy.withLockedPosition(isLocked);\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Overwrites the current set of positions with an array of new ones.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} positions Position pairs to be set on the strategy.\n     * @return {THIS}\n     */\n    withPositions(positions) {\n        (/** @type {?} */ (this))._preferredPositions = positions.slice();\n        (/** @type {?} */ (this))._positionStrategy.withPositions((/** @type {?} */ (this))._preferredPositions);\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets the origin element, relative to which to position the overlay.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} origin Reference to the new origin element.\n     * @return {THIS}\n     */\n    setOrigin(origin) {\n        (/** @type {?} */ (this))._positionStrategy.setOrigin(origin);\n        return (/** @type {?} */ (this));\n    }\n}\nif (false) {\n    /**\n     * Reference to the underlying position strategy to which all the API calls are proxied.\n     * \\@docs-private\n     * @type {?}\n     */\n    ConnectedPositionStrategy.prototype._positionStrategy;\n    /**\n     * The overlay to which this strategy is attached.\n     * @type {?}\n     * @private\n     */\n    ConnectedPositionStrategy.prototype._overlayRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    ConnectedPositionStrategy.prototype._direction;\n    /**\n     * Ordered list of preferred positions, from most to least desirable.\n     * @type {?}\n     */\n    ConnectedPositionStrategy.prototype._preferredPositions;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/position/global-position-strategy.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 * Class to be added to the overlay pane wrapper.\n * @type {?}\n */\nconst wrapperClass = 'cdk-global-overlay-wrapper';\n/**\n * A strategy for positioning overlays. Using this strategy, an overlay is given an\n * explicit position relative to the browser's viewport. We use flexbox, instead of\n * transforms, in order to avoid issues with subpixel rendering which can cause the\n * element to become blurry.\n */\nclass GlobalPositionStrategy {\n    constructor() {\n        this._cssPosition = 'static';\n        this._topOffset = '';\n        this._bottomOffset = '';\n        this._leftOffset = '';\n        this._rightOffset = '';\n        this._alignItems = '';\n        this._justifyContent = '';\n        this._width = '';\n        this._height = '';\n    }\n    /**\n     * @param {?} overlayRef\n     * @return {?}\n     */\n    attach(overlayRef) {\n        /** @type {?} */\n        const config = overlayRef.getConfig();\n        this._overlayRef = overlayRef;\n        if (this._width && !config.width) {\n            overlayRef.updateSize({ width: this._width });\n        }\n        if (this._height && !config.height) {\n            overlayRef.updateSize({ height: this._height });\n        }\n        overlayRef.hostElement.classList.add(wrapperClass);\n        this._isDisposed = false;\n    }\n    /**\n     * Sets the top position of the overlay. Clears any previously set vertical position.\n     * @template THIS\n     * @this {THIS}\n     * @param {?=} value New top offset.\n     * @return {THIS}\n     */\n    top(value = '') {\n        (/** @type {?} */ (this))._bottomOffset = '';\n        (/** @type {?} */ (this))._topOffset = value;\n        (/** @type {?} */ (this))._alignItems = 'flex-start';\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets the left position of the overlay. Clears any previously set horizontal position.\n     * @template THIS\n     * @this {THIS}\n     * @param {?=} value New left offset.\n     * @return {THIS}\n     */\n    left(value = '') {\n        (/** @type {?} */ (this))._rightOffset = '';\n        (/** @type {?} */ (this))._leftOffset = value;\n        (/** @type {?} */ (this))._justifyContent = 'flex-start';\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets the bottom position of the overlay. Clears any previously set vertical position.\n     * @template THIS\n     * @this {THIS}\n     * @param {?=} value New bottom offset.\n     * @return {THIS}\n     */\n    bottom(value = '') {\n        (/** @type {?} */ (this))._topOffset = '';\n        (/** @type {?} */ (this))._bottomOffset = value;\n        (/** @type {?} */ (this))._alignItems = 'flex-end';\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets the right position of the overlay. Clears any previously set horizontal position.\n     * @template THIS\n     * @this {THIS}\n     * @param {?=} value New right offset.\n     * @return {THIS}\n     */\n    right(value = '') {\n        (/** @type {?} */ (this))._leftOffset = '';\n        (/** @type {?} */ (this))._rightOffset = value;\n        (/** @type {?} */ (this))._justifyContent = 'flex-end';\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets the overlay width and clears any previously set width.\n     * @deprecated Pass the `width` through the `OverlayConfig`.\n     * \\@breaking-change 8.0.0\n     * @template THIS\n     * @this {THIS}\n     * @param {?=} value New width for the overlay\n     * @return {THIS}\n     */\n    width(value = '') {\n        if ((/** @type {?} */ (this))._overlayRef) {\n            (/** @type {?} */ (this))._overlayRef.updateSize({ width: value });\n        }\n        else {\n            (/** @type {?} */ (this))._width = value;\n        }\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Sets the overlay height and clears any previously set height.\n     * @deprecated Pass the `height` through the `OverlayConfig`.\n     * \\@breaking-change 8.0.0\n     * @template THIS\n     * @this {THIS}\n     * @param {?=} value New height for the overlay\n     * @return {THIS}\n     */\n    height(value = '') {\n        if ((/** @type {?} */ (this))._overlayRef) {\n            (/** @type {?} */ (this))._overlayRef.updateSize({ height: value });\n        }\n        else {\n            (/** @type {?} */ (this))._height = value;\n        }\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Centers the overlay horizontally with an optional offset.\n     * Clears any previously set horizontal position.\n     *\n     * @template THIS\n     * @this {THIS}\n     * @param {?=} offset Overlay offset from the horizontal center.\n     * @return {THIS}\n     */\n    centerHorizontally(offset = '') {\n        (/** @type {?} */ (this)).left(offset);\n        (/** @type {?} */ (this))._justifyContent = 'center';\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Centers the overlay vertically with an optional offset.\n     * Clears any previously set vertical position.\n     *\n     * @template THIS\n     * @this {THIS}\n     * @param {?=} offset Overlay offset from the vertical center.\n     * @return {THIS}\n     */\n    centerVertically(offset = '') {\n        (/** @type {?} */ (this)).top(offset);\n        (/** @type {?} */ (this))._alignItems = 'center';\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Apply the position to the element.\n     * \\@docs-private\n     * @return {?}\n     */\n    apply() {\n        // Since the overlay ref applies the strategy asynchronously, it could\n        // have been disposed before it ends up being applied. If that is the\n        // case, we shouldn't do anything.\n        if (!this._overlayRef || !this._overlayRef.hasAttached()) {\n            return;\n        }\n        /** @type {?} */\n        const styles = this._overlayRef.overlayElement.style;\n        /** @type {?} */\n        const parentStyles = this._overlayRef.hostElement.style;\n        /** @type {?} */\n        const config = this._overlayRef.getConfig();\n        const { width, height, maxWidth, maxHeight } = config;\n        /** @type {?} */\n        const shouldBeFlushHorizontally = (width === '100%' || width === '100vw') &&\n            (!maxWidth || maxWidth === '100%' || maxWidth === '100vw');\n        /** @type {?} */\n        const shouldBeFlushVertically = (height === '100%' || height === '100vh') &&\n            (!maxHeight || maxHeight === '100%' || maxHeight === '100vh');\n        styles.position = this._cssPosition;\n        styles.marginLeft = shouldBeFlushHorizontally ? '0' : this._leftOffset;\n        styles.marginTop = shouldBeFlushVertically ? '0' : this._topOffset;\n        styles.marginBottom = this._bottomOffset;\n        styles.marginRight = this._rightOffset;\n        if (shouldBeFlushHorizontally) {\n            parentStyles.justifyContent = 'flex-start';\n        }\n        else if (this._justifyContent === 'center') {\n            parentStyles.justifyContent = 'center';\n        }\n        else if (this._overlayRef.getConfig().direction === 'rtl') {\n            // In RTL the browser will invert `flex-start` and `flex-end` automatically, but we\n            // don't want that because our positioning is explicitly `left` and `right`, hence\n            // why we do another inversion to ensure that the overlay stays in the same position.\n            // TODO: reconsider this if we add `start` and `end` methods.\n            if (this._justifyContent === 'flex-start') {\n                parentStyles.justifyContent = 'flex-end';\n            }\n            else if (this._justifyContent === 'flex-end') {\n                parentStyles.justifyContent = 'flex-start';\n            }\n        }\n        else {\n            parentStyles.justifyContent = this._justifyContent;\n        }\n        parentStyles.alignItems = shouldBeFlushVertically ? 'flex-start' : this._alignItems;\n    }\n    /**\n     * Cleans up the DOM changes from the position strategy.\n     * \\@docs-private\n     * @return {?}\n     */\n    dispose() {\n        if (this._isDisposed || !this._overlayRef) {\n            return;\n        }\n        /** @type {?} */\n        const styles = this._overlayRef.overlayElement.style;\n        /** @type {?} */\n        const parent = this._overlayRef.hostElement;\n        /** @type {?} */\n        const parentStyles = parent.style;\n        parent.classList.remove(wrapperClass);\n        parentStyles.justifyContent = parentStyles.alignItems = styles.marginTop =\n            styles.marginBottom = styles.marginLeft = styles.marginRight = styles.position = '';\n        this._overlayRef = (/** @type {?} */ (null));\n        this._isDisposed = true;\n    }\n}\nif (false) {\n    /**\n     * The overlay to which this strategy is attached.\n     * @type {?}\n     * @private\n     */\n    GlobalPositionStrategy.prototype._overlayRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    GlobalPositionStrategy.prototype._cssPosition;\n    /**\n     * @type {?}\n     * @private\n     */\n    GlobalPositionStrategy.prototype._topOffset;\n    /**\n     * @type {?}\n     * @private\n     */\n    GlobalPositionStrategy.prototype._bottomOffset;\n    /**\n     * @type {?}\n     * @private\n     */\n    GlobalPositionStrategy.prototype._leftOffset;\n    /**\n     * @type {?}\n     * @private\n     */\n    GlobalPositionStrategy.prototype._rightOffset;\n    /**\n     * @type {?}\n     * @private\n     */\n    GlobalPositionStrategy.prototype._alignItems;\n    /**\n     * @type {?}\n     * @private\n     */\n    GlobalPositionStrategy.prototype._justifyContent;\n    /**\n     * @type {?}\n     * @private\n     */\n    GlobalPositionStrategy.prototype._width;\n    /**\n     * @type {?}\n     * @private\n     */\n    GlobalPositionStrategy.prototype._height;\n    /**\n     * @type {?}\n     * @private\n     */\n    GlobalPositionStrategy.prototype._isDisposed;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/position/overlay-position-builder.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Builder for overlay position strategy.\n */\nclass OverlayPositionBuilder {\n    /**\n     * @param {?} _viewportRuler\n     * @param {?} _document\n     * @param {?} _platform\n     * @param {?} _overlayContainer\n     */\n    constructor(_viewportRuler, _document, _platform, _overlayContainer) {\n        this._viewportRuler = _viewportRuler;\n        this._document = _document;\n        this._platform = _platform;\n        this._overlayContainer = _overlayContainer;\n    }\n    /**\n     * Creates a global position strategy.\n     * @return {?}\n     */\n    global() {\n        return new GlobalPositionStrategy();\n    }\n    /**\n     * Creates a relative position strategy.\n     * @deprecated Use `flexibleConnectedTo` instead.\n     * \\@breaking-change 8.0.0\n     * @param {?} elementRef\n     * @param {?} originPos\n     * @param {?} overlayPos\n     * @return {?}\n     */\n    connectedTo(elementRef, originPos, overlayPos) {\n        return new ConnectedPositionStrategy(originPos, overlayPos, elementRef, this._viewportRuler, this._document, this._platform, this._overlayContainer);\n    }\n    /**\n     * Creates a flexible position strategy.\n     * @param {?} origin Origin relative to which to position the overlay.\n     * @return {?}\n     */\n    flexibleConnectedTo(origin) {\n        return new FlexibleConnectedPositionStrategy(origin, this._viewportRuler, this._document, this._platform, this._overlayContainer);\n    }\n}\nOverlayPositionBuilder.ɵfac = function OverlayPositionBuilder_Factory(t) { return new (t || OverlayPositionBuilder)(ɵngcc0.ɵɵinject(ɵngcc1.ViewportRuler), ɵngcc0.ɵɵinject(DOCUMENT), ɵngcc0.ɵɵinject(ɵngcc2.Platform), ɵngcc0.ɵɵinject(OverlayContainer)); };\n/** @nocollapse */\nOverlayPositionBuilder.ctorParameters = () => [\n    { type: ViewportRuler },\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },\n    { type: Platform },\n    { type: OverlayContainer }\n];\n/** @nocollapse */ OverlayPositionBuilder.ɵprov = ɵɵdefineInjectable({ factory: function OverlayPositionBuilder_Factory() { return new OverlayPositionBuilder(ɵɵinject(ViewportRuler), ɵɵinject(DOCUMENT), ɵɵinject(Platform), ɵɵinject(OverlayContainer)); }, token: OverlayPositionBuilder, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(OverlayPositionBuilder, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: ɵngcc1.ViewportRuler }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }, { type: ɵngcc2.Platform }, { type: OverlayContainer }]; }, null); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayPositionBuilder.prototype._viewportRuler;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayPositionBuilder.prototype._document;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayPositionBuilder.prototype._platform;\n    /**\n     * @type {?}\n     * @private\n     */\n    OverlayPositionBuilder.prototype._overlayContainer;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/overlay.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Next overlay unique ID.\n * @type {?}\n */\nlet nextUniqueId = 0;\n// Note that Overlay is *not* scoped to the app root because of the ComponentFactoryResolver\n// which needs to be different depending on where OverlayModule is imported.\n/**\n * Service to create Overlays. Overlays are dynamically added pieces of floating UI, meant to be\n * used as a low-level building block for other components. Dialogs, tooltips, menus,\n * selects, etc. can all be built using overlays. The service should primarily be used by authors\n * of re-usable components rather than developers building end-user applications.\n *\n * An overlay *is* a PortalOutlet, so any kind of Portal can be loaded into one.\n */\nclass Overlay {\n    /**\n     * @param {?} scrollStrategies\n     * @param {?} _overlayContainer\n     * @param {?} _componentFactoryResolver\n     * @param {?} _positionBuilder\n     * @param {?} _keyboardDispatcher\n     * @param {?} _injector\n     * @param {?} _ngZone\n     * @param {?} _document\n     * @param {?} _directionality\n     * @param {?=} _location\n     */\n    constructor(scrollStrategies, _overlayContainer, _componentFactoryResolver, _positionBuilder, _keyboardDispatcher, _injector, _ngZone, _document, _directionality, _location) {\n        this.scrollStrategies = scrollStrategies;\n        this._overlayContainer = _overlayContainer;\n        this._componentFactoryResolver = _componentFactoryResolver;\n        this._positionBuilder = _positionBuilder;\n        this._keyboardDispatcher = _keyboardDispatcher;\n        this._injector = _injector;\n        this._ngZone = _ngZone;\n        this._document = _document;\n        this._directionality = _directionality;\n        this._location = _location;\n    }\n    /**\n     * Creates an overlay.\n     * @param {?=} config Configuration applied to the overlay.\n     * @return {?} Reference to the created overlay.\n     */\n    create(config) {\n        /** @type {?} */\n        const host = this._createHostElement();\n        /** @type {?} */\n        const pane = this._createPaneElement(host);\n        /** @type {?} */\n        const portalOutlet = this._createPortalOutlet(pane);\n        /** @type {?} */\n        const overlayConfig = new OverlayConfig(config);\n        overlayConfig.direction = overlayConfig.direction || this._directionality.value;\n        return new OverlayRef(portalOutlet, host, pane, overlayConfig, this._ngZone, this._keyboardDispatcher, this._document, this._location);\n    }\n    /**\n     * Gets a position builder that can be used, via fluent API,\n     * to construct and configure a position strategy.\n     * @return {?} An overlay position builder.\n     */\n    position() {\n        return this._positionBuilder;\n    }\n    /**\n     * Creates the DOM element for an overlay and appends it to the overlay container.\n     * @private\n     * @param {?} host\n     * @return {?} Newly-created pane element\n     */\n    _createPaneElement(host) {\n        /** @type {?} */\n        const pane = this._document.createElement('div');\n        pane.id = `cdk-overlay-${nextUniqueId++}`;\n        pane.classList.add('cdk-overlay-pane');\n        host.appendChild(pane);\n        return pane;\n    }\n    /**\n     * Creates the host element that wraps around an overlay\n     * and can be used for advanced positioning.\n     * @private\n     * @return {?} Newly-create host element.\n     */\n    _createHostElement() {\n        /** @type {?} */\n        const host = this._document.createElement('div');\n        this._overlayContainer.getContainerElement().appendChild(host);\n        return host;\n    }\n    /**\n     * Create a DomPortalOutlet into which the overlay content can be loaded.\n     * @private\n     * @param {?} pane The DOM element to turn into a portal outlet.\n     * @return {?} A portal outlet for the given DOM element.\n     */\n    _createPortalOutlet(pane) {\n        // We have to resolve the ApplicationRef later in order to allow people\n        // to use overlay-based providers during app initialization.\n        if (!this._appRef) {\n            this._appRef = this._injector.get(ApplicationRef);\n        }\n        return new DomPortalOutlet(pane, this._componentFactoryResolver, this._appRef, this._injector, this._document);\n    }\n}\nOverlay.ɵfac = function Overlay_Factory(t) { return new (t || Overlay)(ɵngcc0.ɵɵinject(ScrollStrategyOptions), ɵngcc0.ɵɵinject(OverlayContainer), ɵngcc0.ɵɵinject(ɵngcc0.ComponentFactoryResolver), ɵngcc0.ɵɵinject(OverlayPositionBuilder), ɵngcc0.ɵɵinject(OverlayKeyboardDispatcher), ɵngcc0.ɵɵinject(ɵngcc0.Injector), ɵngcc0.ɵɵinject(ɵngcc0.NgZone), ɵngcc0.ɵɵinject(DOCUMENT), ɵngcc0.ɵɵinject(ɵngcc3.Directionality), ɵngcc0.ɵɵinject(ɵngcc4.Location, 8)); };\nOverlay.ɵprov = ɵngcc0.ɵɵdefineInjectable({ token: Overlay, factory: Overlay.ɵfac });\n/** @nocollapse */\nOverlay.ctorParameters = () => [\n    { type: ScrollStrategyOptions },\n    { type: OverlayContainer },\n    { type: ComponentFactoryResolver },\n    { type: OverlayPositionBuilder },\n    { type: OverlayKeyboardDispatcher },\n    { type: Injector },\n    { type: NgZone },\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },\n    { type: Directionality },\n    { type: Location, decorators: [{ type: Optional }] }\n];\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(Overlay, [{\n        type: Injectable\n    }], function () { return [{ type: ScrollStrategyOptions }, { type: OverlayContainer }, { type: ɵngcc0.ComponentFactoryResolver }, { type: OverlayPositionBuilder }, { type: OverlayKeyboardDispatcher }, { type: ɵngcc0.Injector }, { type: ɵngcc0.NgZone }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }, { type: ɵngcc3.Directionality }, { type: ɵngcc4.Location, decorators: [{\n                type: Optional\n            }] }]; }, null); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    Overlay.prototype._appRef;\n    /**\n     * Scrolling strategies that can be used when creating an overlay.\n     * @type {?}\n     */\n    Overlay.prototype.scrollStrategies;\n    /**\n     * @type {?}\n     * @private\n     */\n    Overlay.prototype._overlayContainer;\n    /**\n     * @type {?}\n     * @private\n     */\n    Overlay.prototype._componentFactoryResolver;\n    /**\n     * @type {?}\n     * @private\n     */\n    Overlay.prototype._positionBuilder;\n    /**\n     * @type {?}\n     * @private\n     */\n    Overlay.prototype._keyboardDispatcher;\n    /**\n     * @type {?}\n     * @private\n     */\n    Overlay.prototype._injector;\n    /**\n     * @type {?}\n     * @private\n     */\n    Overlay.prototype._ngZone;\n    /**\n     * @type {?}\n     * @private\n     */\n    Overlay.prototype._document;\n    /**\n     * @type {?}\n     * @private\n     */\n    Overlay.prototype._directionality;\n    /**\n     * @type {?}\n     * @private\n     */\n    Overlay.prototype._location;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/overlay-directives.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Default set of positions for the overlay. Follows the behavior of a dropdown.\n * @type {?}\n */\nconst defaultPositionList = [\n    {\n        originX: 'start',\n        originY: 'bottom',\n        overlayX: 'start',\n        overlayY: 'top'\n    },\n    {\n        originX: 'start',\n        originY: 'top',\n        overlayX: 'start',\n        overlayY: 'bottom'\n    },\n    {\n        originX: 'end',\n        originY: 'top',\n        overlayX: 'end',\n        overlayY: 'bottom'\n    },\n    {\n        originX: 'end',\n        originY: 'bottom',\n        overlayX: 'end',\n        overlayY: 'top'\n    }\n];\n/**\n * Injection token that determines the scroll handling while the connected overlay is open.\n * @type {?}\n */\nconst CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY = new InjectionToken('cdk-connected-overlay-scroll-strategy');\n/**\n * \\@docs-private \\@deprecated \\@breaking-change 8.0.0\n * @param {?} overlay\n * @return {?}\n */\nfunction CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_FACTORY(overlay) {\n    return (/**\n     * @param {?=} config\n     * @return {?}\n     */\n    (config) => overlay.scrollStrategies.reposition(config));\n}\n/**\n * Directive applied to an element to make it usable as an origin for an Overlay using a\n * ConnectedPositionStrategy.\n */\nclass CdkOverlayOrigin {\n    /**\n     * @param {?} elementRef\n     */\n    constructor(elementRef) {\n        this.elementRef = elementRef;\n    }\n}\nCdkOverlayOrigin.ɵfac = function CdkOverlayOrigin_Factory(t) { return new (t || CdkOverlayOrigin)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef)); };\nCdkOverlayOrigin.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: CdkOverlayOrigin, selectors: [[\"\", \"cdk-overlay-origin\", \"\"], [\"\", \"overlay-origin\", \"\"], [\"\", \"cdkOverlayOrigin\", \"\"]], exportAs: [\"cdkOverlayOrigin\"] });\n/** @nocollapse */\nCdkOverlayOrigin.ctorParameters = () => [\n    { type: ElementRef }\n];\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(CdkOverlayOrigin, [{\n        type: Directive,\n        args: [{\n                selector: '[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]',\n                exportAs: 'cdkOverlayOrigin'\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }]; }, null); })();\nif (false) {\n    /**\n     * Reference to the element on which the directive is applied.\n     * @type {?}\n     */\n    CdkOverlayOrigin.prototype.elementRef;\n}\n/**\n * Directive to facilitate declarative creation of an\n * Overlay using a FlexibleConnectedPositionStrategy.\n */\nclass CdkConnectedOverlay {\n    // TODO(jelbourn): inputs for size, scroll behavior, animation, etc.\n    /**\n     * @param {?} _overlay\n     * @param {?} templateRef\n     * @param {?} viewContainerRef\n     * @param {?} scrollStrategyFactory\n     * @param {?} _dir\n     */\n    constructor(_overlay, templateRef, viewContainerRef, scrollStrategyFactory, _dir) {\n        this._overlay = _overlay;\n        this._dir = _dir;\n        this._hasBackdrop = false;\n        this._lockPosition = false;\n        this._growAfterOpen = false;\n        this._flexibleDimensions = false;\n        this._push = false;\n        this._backdropSubscription = Subscription.EMPTY;\n        /**\n         * Margin between the overlay and the viewport edges.\n         */\n        this.viewportMargin = 0;\n        /**\n         * Whether the overlay is open.\n         */\n        this.open = false;\n        /**\n         * Event emitted when the backdrop is clicked.\n         */\n        this.backdropClick = new EventEmitter();\n        /**\n         * Event emitted when the position has changed.\n         */\n        this.positionChange = new EventEmitter();\n        /**\n         * Event emitted when the overlay has been attached.\n         */\n        this.attach = new EventEmitter();\n        /**\n         * Event emitted when the overlay has been detached.\n         */\n        this.detach = new EventEmitter();\n        /**\n         * Emits when there are keyboard events that are targeted at the overlay.\n         */\n        this.overlayKeydown = new EventEmitter();\n        this._templatePortal = new TemplatePortal(templateRef, viewContainerRef);\n        this._scrollStrategyFactory = scrollStrategyFactory;\n        this.scrollStrategy = this._scrollStrategyFactory();\n    }\n    /**\n     * The offset in pixels for the overlay connection point on the x-axis\n     * @return {?}\n     */\n    get offsetX() { return this._offsetX; }\n    /**\n     * @param {?} offsetX\n     * @return {?}\n     */\n    set offsetX(offsetX) {\n        this._offsetX = offsetX;\n        if (this._position) {\n            this._updatePositionStrategy(this._position);\n        }\n    }\n    /**\n     * The offset in pixels for the overlay connection point on the y-axis\n     * @return {?}\n     */\n    get offsetY() { return this._offsetY; }\n    /**\n     * @param {?} offsetY\n     * @return {?}\n     */\n    set offsetY(offsetY) {\n        this._offsetY = offsetY;\n        if (this._position) {\n            this._updatePositionStrategy(this._position);\n        }\n    }\n    /**\n     * Whether or not the overlay should attach a backdrop.\n     * @return {?}\n     */\n    get hasBackdrop() { return this._hasBackdrop; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set hasBackdrop(value) { this._hasBackdrop = coerceBooleanProperty(value); }\n    /**\n     * Whether or not the overlay should be locked when scrolling.\n     * @return {?}\n     */\n    get lockPosition() { return this._lockPosition; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set lockPosition(value) { this._lockPosition = coerceBooleanProperty(value); }\n    /**\n     * Whether the overlay's width and height can be constrained to fit within the viewport.\n     * @return {?}\n     */\n    get flexibleDimensions() { return this._flexibleDimensions; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set flexibleDimensions(value) {\n        this._flexibleDimensions = coerceBooleanProperty(value);\n    }\n    /**\n     * Whether the overlay can grow after the initial open when flexible positioning is turned on.\n     * @return {?}\n     */\n    get growAfterOpen() { return this._growAfterOpen; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set growAfterOpen(value) { this._growAfterOpen = coerceBooleanProperty(value); }\n    /**\n     * Whether the overlay can be pushed on-screen if none of the provided positions fit.\n     * @return {?}\n     */\n    get push() { return this._push; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set push(value) { this._push = coerceBooleanProperty(value); }\n    /**\n     * The associated overlay reference.\n     * @return {?}\n     */\n    get overlayRef() {\n        return this._overlayRef;\n    }\n    /**\n     * The element's layout direction.\n     * @return {?}\n     */\n    get dir() {\n        return this._dir ? this._dir.value : 'ltr';\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        if (this._overlayRef) {\n            this._overlayRef.dispose();\n        }\n        this._backdropSubscription.unsubscribe();\n    }\n    /**\n     * @param {?} changes\n     * @return {?}\n     */\n    ngOnChanges(changes) {\n        if (this._position) {\n            this._updatePositionStrategy(this._position);\n            this._overlayRef.updateSize({\n                width: this.width,\n                minWidth: this.minWidth,\n                height: this.height,\n                minHeight: this.minHeight,\n            });\n            if (changes['origin'] && this.open) {\n                this._position.apply();\n            }\n        }\n        if (changes['open']) {\n            this.open ? this._attachOverlay() : this._detachOverlay();\n        }\n    }\n    /**\n     * Creates an overlay\n     * @private\n     * @return {?}\n     */\n    _createOverlay() {\n        if (!this.positions || !this.positions.length) {\n            this.positions = defaultPositionList;\n        }\n        this._overlayRef = this._overlay.create(this._buildConfig());\n        this._overlayRef.keydownEvents().subscribe((/**\n         * @param {?} event\n         * @return {?}\n         */\n        (event) => {\n            this.overlayKeydown.next(event);\n            if (event.keyCode === ESCAPE && !hasModifierKey(event)) {\n                event.preventDefault();\n                this._detachOverlay();\n            }\n        }));\n    }\n    /**\n     * Builds the overlay config based on the directive's inputs\n     * @private\n     * @return {?}\n     */\n    _buildConfig() {\n        /** @type {?} */\n        const positionStrategy = this._position =\n            this.positionStrategy || this._createPositionStrategy();\n        /** @type {?} */\n        const overlayConfig = new OverlayConfig({\n            direction: this._dir,\n            positionStrategy,\n            scrollStrategy: this.scrollStrategy,\n            hasBackdrop: this.hasBackdrop\n        });\n        if (this.width || this.width === 0) {\n            overlayConfig.width = this.width;\n        }\n        if (this.height || this.height === 0) {\n            overlayConfig.height = this.height;\n        }\n        if (this.minWidth || this.minWidth === 0) {\n            overlayConfig.minWidth = this.minWidth;\n        }\n        if (this.minHeight || this.minHeight === 0) {\n            overlayConfig.minHeight = this.minHeight;\n        }\n        if (this.backdropClass) {\n            overlayConfig.backdropClass = this.backdropClass;\n        }\n        if (this.panelClass) {\n            overlayConfig.panelClass = this.panelClass;\n        }\n        return overlayConfig;\n    }\n    /**\n     * Updates the state of a position strategy, based on the values of the directive inputs.\n     * @private\n     * @param {?} positionStrategy\n     * @return {?}\n     */\n    _updatePositionStrategy(positionStrategy) {\n        /** @type {?} */\n        const positions = this.positions.map((/**\n         * @param {?} currentPosition\n         * @return {?}\n         */\n        currentPosition => ({\n            originX: currentPosition.originX,\n            originY: currentPosition.originY,\n            overlayX: currentPosition.overlayX,\n            overlayY: currentPosition.overlayY,\n            offsetX: currentPosition.offsetX || this.offsetX,\n            offsetY: currentPosition.offsetY || this.offsetY,\n            panelClass: currentPosition.panelClass || undefined,\n        })));\n        return positionStrategy\n            .setOrigin(this.origin.elementRef)\n            .withPositions(positions)\n            .withFlexibleDimensions(this.flexibleDimensions)\n            .withPush(this.push)\n            .withGrowAfterOpen(this.growAfterOpen)\n            .withViewportMargin(this.viewportMargin)\n            .withLockedPosition(this.lockPosition)\n            .withTransformOriginOn(this.transformOriginSelector);\n    }\n    /**\n     * Returns the position strategy of the overlay to be set on the overlay config\n     * @private\n     * @return {?}\n     */\n    _createPositionStrategy() {\n        /** @type {?} */\n        const strategy = this._overlay.position().flexibleConnectedTo(this.origin.elementRef);\n        this._updatePositionStrategy(strategy);\n        strategy.positionChanges.subscribe((/**\n         * @param {?} p\n         * @return {?}\n         */\n        p => this.positionChange.emit(p)));\n        return strategy;\n    }\n    /**\n     * Attaches the overlay and subscribes to backdrop clicks if backdrop exists\n     * @private\n     * @return {?}\n     */\n    _attachOverlay() {\n        if (!this._overlayRef) {\n            this._createOverlay();\n        }\n        else {\n            // Update the overlay size, in case the directive's inputs have changed\n            this._overlayRef.getConfig().hasBackdrop = this.hasBackdrop;\n        }\n        if (!this._overlayRef.hasAttached()) {\n            this._overlayRef.attach(this._templatePortal);\n            this.attach.emit();\n        }\n        if (this.hasBackdrop) {\n            this._backdropSubscription = this._overlayRef.backdropClick().subscribe((/**\n             * @param {?} event\n             * @return {?}\n             */\n            event => {\n                this.backdropClick.emit(event);\n            }));\n        }\n        else {\n            this._backdropSubscription.unsubscribe();\n        }\n    }\n    /**\n     * Detaches the overlay and unsubscribes to backdrop clicks if backdrop exists\n     * @private\n     * @return {?}\n     */\n    _detachOverlay() {\n        if (this._overlayRef) {\n            this._overlayRef.detach();\n            this.detach.emit();\n        }\n        this._backdropSubscription.unsubscribe();\n    }\n}\nCdkConnectedOverlay.ɵfac = function CdkConnectedOverlay_Factory(t) { return new (t || CdkConnectedOverlay)(ɵngcc0.ɵɵdirectiveInject(Overlay), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY), ɵngcc0.ɵɵdirectiveInject(ɵngcc3.Directionality, 8)); };\nCdkConnectedOverlay.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: CdkConnectedOverlay, selectors: [[\"\", \"cdk-connected-overlay\", \"\"], [\"\", \"connected-overlay\", \"\"], [\"\", \"cdkConnectedOverlay\", \"\"]], inputs: { viewportMargin: [\"cdkConnectedOverlayViewportMargin\", \"viewportMargin\"], open: [\"cdkConnectedOverlayOpen\", \"open\"], scrollStrategy: [\"cdkConnectedOverlayScrollStrategy\", \"scrollStrategy\"], offsetX: [\"cdkConnectedOverlayOffsetX\", \"offsetX\"], offsetY: [\"cdkConnectedOverlayOffsetY\", \"offsetY\"], hasBackdrop: [\"cdkConnectedOverlayHasBackdrop\", \"hasBackdrop\"], lockPosition: [\"cdkConnectedOverlayLockPosition\", \"lockPosition\"], flexibleDimensions: [\"cdkConnectedOverlayFlexibleDimensions\", \"flexibleDimensions\"], growAfterOpen: [\"cdkConnectedOverlayGrowAfterOpen\", \"growAfterOpen\"], push: [\"cdkConnectedOverlayPush\", \"push\"], positions: [\"cdkConnectedOverlayPositions\", \"positions\"], origin: [\"cdkConnectedOverlayOrigin\", \"origin\"], positionStrategy: [\"cdkConnectedOverlayPositionStrategy\", \"positionStrategy\"], width: [\"cdkConnectedOverlayWidth\", \"width\"], height: [\"cdkConnectedOverlayHeight\", \"height\"], minWidth: [\"cdkConnectedOverlayMinWidth\", \"minWidth\"], minHeight: [\"cdkConnectedOverlayMinHeight\", \"minHeight\"], backdropClass: [\"cdkConnectedOverlayBackdropClass\", \"backdropClass\"], panelClass: [\"cdkConnectedOverlayPanelClass\", \"panelClass\"], transformOriginSelector: [\"cdkConnectedOverlayTransformOriginOn\", \"transformOriginSelector\"] }, outputs: { backdropClick: \"backdropClick\", positionChange: \"positionChange\", attach: \"attach\", detach: \"detach\", overlayKeydown: \"overlayKeydown\" }, exportAs: [\"cdkConnectedOverlay\"], features: [ɵngcc0.ɵɵNgOnChangesFeature] });\n/** @nocollapse */\nCdkConnectedOverlay.ctorParameters = () => [\n    { type: Overlay },\n    { type: TemplateRef },\n    { type: ViewContainerRef },\n    { type: undefined, decorators: [{ type: Inject, args: [CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY,] }] },\n    { type: Directionality, decorators: [{ type: Optional }] }\n];\nCdkConnectedOverlay.propDecorators = {\n    origin: [{ type: Input, args: ['cdkConnectedOverlayOrigin',] }],\n    positions: [{ type: Input, args: ['cdkConnectedOverlayPositions',] }],\n    positionStrategy: [{ type: Input, args: ['cdkConnectedOverlayPositionStrategy',] }],\n    offsetX: [{ type: Input, args: ['cdkConnectedOverlayOffsetX',] }],\n    offsetY: [{ type: Input, args: ['cdkConnectedOverlayOffsetY',] }],\n    width: [{ type: Input, args: ['cdkConnectedOverlayWidth',] }],\n    height: [{ type: Input, args: ['cdkConnectedOverlayHeight',] }],\n    minWidth: [{ type: Input, args: ['cdkConnectedOverlayMinWidth',] }],\n    minHeight: [{ type: Input, args: ['cdkConnectedOverlayMinHeight',] }],\n    backdropClass: [{ type: Input, args: ['cdkConnectedOverlayBackdropClass',] }],\n    panelClass: [{ type: Input, args: ['cdkConnectedOverlayPanelClass',] }],\n    viewportMargin: [{ type: Input, args: ['cdkConnectedOverlayViewportMargin',] }],\n    scrollStrategy: [{ type: Input, args: ['cdkConnectedOverlayScrollStrategy',] }],\n    open: [{ type: Input, args: ['cdkConnectedOverlayOpen',] }],\n    transformOriginSelector: [{ type: Input, args: ['cdkConnectedOverlayTransformOriginOn',] }],\n    hasBackdrop: [{ type: Input, args: ['cdkConnectedOverlayHasBackdrop',] }],\n    lockPosition: [{ type: Input, args: ['cdkConnectedOverlayLockPosition',] }],\n    flexibleDimensions: [{ type: Input, args: ['cdkConnectedOverlayFlexibleDimensions',] }],\n    growAfterOpen: [{ type: Input, args: ['cdkConnectedOverlayGrowAfterOpen',] }],\n    push: [{ type: Input, args: ['cdkConnectedOverlayPush',] }],\n    backdropClick: [{ type: Output }],\n    positionChange: [{ type: Output }],\n    attach: [{ type: Output }],\n    detach: [{ type: Output }],\n    overlayKeydown: [{ type: Output }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(CdkConnectedOverlay, [{\n        type: Directive,\n        args: [{\n                selector: '[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]',\n                exportAs: 'cdkConnectedOverlay'\n            }]\n    }], function () { return [{ type: Overlay }, { type: ɵngcc0.TemplateRef }, { type: ɵngcc0.ViewContainerRef }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY]\n            }] }, { type: ɵngcc3.Directionality, decorators: [{\n                type: Optional\n            }] }]; }, { viewportMargin: [{\n            type: Input,\n            args: ['cdkConnectedOverlayViewportMargin']\n        }], open: [{\n            type: Input,\n            args: ['cdkConnectedOverlayOpen']\n        }], backdropClick: [{\n            type: Output\n        }], positionChange: [{\n            type: Output\n        }], attach: [{\n            type: Output\n        }], detach: [{\n            type: Output\n        }], overlayKeydown: [{\n            type: Output\n        }], scrollStrategy: [{\n            type: Input,\n            args: ['cdkConnectedOverlayScrollStrategy']\n        }], offsetX: [{\n            type: Input,\n            args: ['cdkConnectedOverlayOffsetX']\n        }], offsetY: [{\n            type: Input,\n            args: ['cdkConnectedOverlayOffsetY']\n        }], hasBackdrop: [{\n            type: Input,\n            args: ['cdkConnectedOverlayHasBackdrop']\n        }], lockPosition: [{\n            type: Input,\n            args: ['cdkConnectedOverlayLockPosition']\n        }], flexibleDimensions: [{\n            type: Input,\n            args: ['cdkConnectedOverlayFlexibleDimensions']\n        }], growAfterOpen: [{\n            type: Input,\n            args: ['cdkConnectedOverlayGrowAfterOpen']\n        }], push: [{\n            type: Input,\n            args: ['cdkConnectedOverlayPush']\n        }], positions: [{\n            type: Input,\n            args: ['cdkConnectedOverlayPositions']\n        }], origin: [{\n            type: Input,\n            args: ['cdkConnectedOverlayOrigin']\n        }], positionStrategy: [{\n            type: Input,\n            args: ['cdkConnectedOverlayPositionStrategy']\n        }], width: [{\n            type: Input,\n            args: ['cdkConnectedOverlayWidth']\n        }], height: [{\n            type: Input,\n            args: ['cdkConnectedOverlayHeight']\n        }], minWidth: [{\n            type: Input,\n            args: ['cdkConnectedOverlayMinWidth']\n        }], minHeight: [{\n            type: Input,\n            args: ['cdkConnectedOverlayMinHeight']\n        }], backdropClass: [{\n            type: Input,\n            args: ['cdkConnectedOverlayBackdropClass']\n        }], panelClass: [{\n            type: Input,\n            args: ['cdkConnectedOverlayPanelClass']\n        }], transformOriginSelector: [{\n            type: Input,\n            args: ['cdkConnectedOverlayTransformOriginOn']\n        }] }); })();\nif (false) {\n    /** @type {?} */\n    CdkConnectedOverlay.ngAcceptInputType_hasBackdrop;\n    /** @type {?} */\n    CdkConnectedOverlay.ngAcceptInputType_lockPosition;\n    /** @type {?} */\n    CdkConnectedOverlay.ngAcceptInputType_flexibleDimensions;\n    /** @type {?} */\n    CdkConnectedOverlay.ngAcceptInputType_growAfterOpen;\n    /** @type {?} */\n    CdkConnectedOverlay.ngAcceptInputType_push;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkConnectedOverlay.prototype._overlayRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkConnectedOverlay.prototype._templatePortal;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkConnectedOverlay.prototype._hasBackdrop;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkConnectedOverlay.prototype._lockPosition;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkConnectedOverlay.prototype._growAfterOpen;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkConnectedOverlay.prototype._flexibleDimensions;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkConnectedOverlay.prototype._push;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkConnectedOverlay.prototype._backdropSubscription;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkConnectedOverlay.prototype._offsetX;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkConnectedOverlay.prototype._offsetY;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkConnectedOverlay.prototype._position;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkConnectedOverlay.prototype._scrollStrategyFactory;\n    /**\n     * Origin for the connected overlay.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.origin;\n    /**\n     * Registered connected position pairs.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.positions;\n    /**\n     * This input overrides the positions input if specified. It lets users pass\n     * in arbitrary positioning strategies.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.positionStrategy;\n    /**\n     * The width of the overlay panel.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.width;\n    /**\n     * The height of the overlay panel.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.height;\n    /**\n     * The min width of the overlay panel.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.minWidth;\n    /**\n     * The min height of the overlay panel.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.minHeight;\n    /**\n     * The custom class to be set on the backdrop element.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.backdropClass;\n    /**\n     * The custom class to add to the overlay pane element.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.panelClass;\n    /**\n     * Margin between the overlay and the viewport edges.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.viewportMargin;\n    /**\n     * Strategy to be used when handling scroll events while the overlay is open.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.scrollStrategy;\n    /**\n     * Whether the overlay is open.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.open;\n    /**\n     * CSS selector which to set the transform origin.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.transformOriginSelector;\n    /**\n     * Event emitted when the backdrop is clicked.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.backdropClick;\n    /**\n     * Event emitted when the position has changed.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.positionChange;\n    /**\n     * Event emitted when the overlay has been attached.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.attach;\n    /**\n     * Event emitted when the overlay has been detached.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.detach;\n    /**\n     * Emits when there are keyboard events that are targeted at the overlay.\n     * @type {?}\n     */\n    CdkConnectedOverlay.prototype.overlayKeydown;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkConnectedOverlay.prototype._overlay;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkConnectedOverlay.prototype._dir;\n}\n/**\n * \\@docs-private\n * @param {?} overlay\n * @return {?}\n */\nfunction CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {\n    return (/**\n     * @return {?}\n     */\n    () => overlay.scrollStrategies.reposition());\n}\n/**\n * \\@docs-private\n * @type {?}\n */\nconst CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER = {\n    provide: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY,\n};\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/overlay-module.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass OverlayModule {\n}\nOverlayModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: OverlayModule });\nOverlayModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function OverlayModule_Factory(t) { return new (t || OverlayModule)(); }, providers: [\n        Overlay,\n        CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER,\n    ], imports: [[BidiModule, PortalModule, ScrollingModule],\n        ScrollingModule] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(OverlayModule, { declarations: function () { return [CdkConnectedOverlay,\n        CdkOverlayOrigin]; }, imports: function () { return [BidiModule, PortalModule, ScrollingModule]; }, exports: function () { return [CdkConnectedOverlay,\n        CdkOverlayOrigin,\n        ScrollingModule]; } }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(OverlayModule, [{\n        type: NgModule,\n        args: [{\n                imports: [BidiModule, PortalModule, ScrollingModule],\n                exports: [CdkConnectedOverlay, CdkOverlayOrigin, ScrollingModule],\n                declarations: [CdkConnectedOverlay, CdkOverlayOrigin],\n                providers: [\n                    Overlay,\n                    CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER,\n                ]\n            }]\n    }], null, null); })();\n/**\n * @deprecated Use `OverlayModule` instead.\n * \\@breaking-change 8.0.0\n * \\@docs-private\n * @type {?}\n */\nconst OVERLAY_PROVIDERS = [\n    Overlay,\n    OverlayPositionBuilder,\n    OVERLAY_KEYBOARD_DISPATCHER_PROVIDER,\n    OVERLAY_CONTAINER_PROVIDER,\n    CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER,\n];\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/fullscreen-overlay-container.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Alternative to OverlayContainer that supports correct displaying of overlay elements in\n * Fullscreen mode\n * https://developer.mozilla.org/en-US/docs/Web/API/Element/requestFullScreen\n *\n * Should be provided in the root component.\n */\nclass FullscreenOverlayContainer extends OverlayContainer {\n    /**\n     * @param {?} _document\n     * @param {?=} platform\n     */\n    constructor(_document, \n    /**\n     * @deprecated `platform` parameter to become required.\n     * @breaking-change 10.0.0\n     */\n    platform) {\n        super(_document, platform);\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        super.ngOnDestroy();\n        if (this._fullScreenEventName && this._fullScreenListener) {\n            this._document.removeEventListener(this._fullScreenEventName, this._fullScreenListener);\n        }\n    }\n    /**\n     * @protected\n     * @return {?}\n     */\n    _createContainer() {\n        super._createContainer();\n        this._adjustParentForFullscreenChange();\n        this._addFullscreenChangeListener((/**\n         * @return {?}\n         */\n        () => this._adjustParentForFullscreenChange()));\n    }\n    /**\n     * @private\n     * @return {?}\n     */\n    _adjustParentForFullscreenChange() {\n        if (!this._containerElement) {\n            return;\n        }\n        /** @type {?} */\n        const fullscreenElement = this.getFullscreenElement();\n        /** @type {?} */\n        const parent = fullscreenElement || this._document.body;\n        parent.appendChild(this._containerElement);\n    }\n    /**\n     * @private\n     * @param {?} fn\n     * @return {?}\n     */\n    _addFullscreenChangeListener(fn) {\n        /** @type {?} */\n        const eventName = this._getEventName();\n        if (eventName) {\n            if (this._fullScreenListener) {\n                this._document.removeEventListener(eventName, this._fullScreenListener);\n            }\n            this._document.addEventListener(eventName, fn);\n            this._fullScreenListener = fn;\n        }\n    }\n    /**\n     * @private\n     * @return {?}\n     */\n    _getEventName() {\n        if (!this._fullScreenEventName) {\n            /** @type {?} */\n            const _document = (/** @type {?} */ (this._document));\n            if (_document.fullscreenEnabled) {\n                this._fullScreenEventName = 'fullscreenchange';\n            }\n            else if (_document.webkitFullscreenEnabled) {\n                this._fullScreenEventName = 'webkitfullscreenchange';\n            }\n            else if (_document.mozFullScreenEnabled) {\n                this._fullScreenEventName = 'mozfullscreenchange';\n            }\n            else if (_document.msFullscreenEnabled) {\n                this._fullScreenEventName = 'MSFullscreenChange';\n            }\n        }\n        return this._fullScreenEventName;\n    }\n    /**\n     * When the page is put into fullscreen mode, a specific element is specified.\n     * Only that element and its children are visible when in fullscreen mode.\n     * @return {?}\n     */\n    getFullscreenElement() {\n        /** @type {?} */\n        const _document = (/** @type {?} */ (this._document));\n        return _document.fullscreenElement ||\n            _document.webkitFullscreenElement ||\n            _document.mozFullScreenElement ||\n            _document.msFullscreenElement ||\n            null;\n    }\n}\nFullscreenOverlayContainer.ɵfac = function FullscreenOverlayContainer_Factory(t) { return new (t || FullscreenOverlayContainer)(ɵngcc0.ɵɵinject(DOCUMENT), ɵngcc0.ɵɵinject(ɵngcc2.Platform)); };\n/** @nocollapse */\nFullscreenOverlayContainer.ctorParameters = () => [\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },\n    { type: Platform }\n];\n/** @nocollapse */ FullscreenOverlayContainer.ɵprov = ɵɵdefineInjectable({ factory: function FullscreenOverlayContainer_Factory() { return new FullscreenOverlayContainer(ɵɵinject(DOCUMENT), ɵɵinject(Platform)); }, token: FullscreenOverlayContainer, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(FullscreenOverlayContainer, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }, { type: ɵngcc2.Platform }]; }, null); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    FullscreenOverlayContainer.prototype._fullScreenEventName;\n    /**\n     * @type {?}\n     * @private\n     */\n    FullscreenOverlayContainer.prototype._fullScreenListener;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/overlay/public-api.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 { BlockScrollStrategy, CdkConnectedOverlay, CdkOverlayOrigin, CloseScrollStrategy, ConnectedOverlayPositionChange, ConnectedPositionStrategy, ConnectionPositionPair, FlexibleConnectedPositionStrategy, FullscreenOverlayContainer, GlobalPositionStrategy, NoopScrollStrategy, OVERLAY_PROVIDERS, Overlay, OverlayConfig, OverlayContainer, OverlayKeyboardDispatcher, OverlayModule, OverlayPositionBuilder, OverlayRef, RepositionScrollStrategy, ScrollStrategyOptions, ScrollingVisibility, validateHorizontalPosition, validateVerticalPosition, OVERLAY_CONTAINER_PROVIDER_FACTORY as ɵangular_material_src_cdk_overlay_overlay_a, OVERLAY_CONTAINER_PROVIDER as ɵangular_material_src_cdk_overlay_overlay_b, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY as ɵangular_material_src_cdk_overlay_overlay_c, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY as ɵangular_material_src_cdk_overlay_overlay_d, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER as ɵangular_material_src_cdk_overlay_overlay_e, OVERLAY_KEYBOARD_DISPATCHER_PROVIDER_FACTORY as ɵangular_material_src_cdk_overlay_overlay_f, OVERLAY_KEYBOARD_DISPATCHER_PROVIDER as ɵangular_material_src_cdk_overlay_overlay_g };\n\n//# sourceMappingURL=overlay.js.map","import { Component, ViewEncapsulation, ChangeDetectionStrategy, ElementRef, Optional, Inject, ViewChild, Input, NgModule } from '@angular/core';\nimport { mixinColor, mixinDisabled, mixinDisableRipple, MatRipple, MatRippleModule, MatCommonModule } from '@angular/material/core';\nimport { FocusMonitor } from '@angular/cdk/a11y';\nimport { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/button/button.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Default color palette for round buttons (mat-fab and mat-mini-fab)\n * @type {?}\n */\nimport * as ɵngcc0 from '@angular/core';\nimport * as ɵngcc1 from '@angular/cdk/a11y';\nimport * as ɵngcc2 from '@angular/material/core';\n\nconst _c0 = [\"mat-button\", \"\"];\nconst _c1 = [\"*\"];\nconst DEFAULT_ROUND_BUTTON_COLOR = 'accent';\n/**\n * List of classes to add to MatButton instances based on host attributes to\n * style as different variants.\n * @type {?}\n */\nconst BUTTON_HOST_ATTRIBUTES = [\n    'mat-button',\n    'mat-flat-button',\n    'mat-icon-button',\n    'mat-raised-button',\n    'mat-stroked-button',\n    'mat-mini-fab',\n    'mat-fab',\n];\n// Boilerplate for applying mixins to MatButton.\n/**\n * \\@docs-private\n */\nclass MatButtonBase {\n    /**\n     * @param {?} _elementRef\n     */\n    constructor(_elementRef) {\n        this._elementRef = _elementRef;\n    }\n}\nif (false) {\n    /** @type {?} */\n    MatButtonBase.prototype._elementRef;\n}\n/** @type {?} */\nconst _MatButtonMixinBase = mixinColor(mixinDisabled(mixinDisableRipple(MatButtonBase)));\n/**\n * Material design button.\n */\nclass MatButton extends _MatButtonMixinBase {\n    /**\n     * @param {?} elementRef\n     * @param {?} _focusMonitor\n     * @param {?} _animationMode\n     */\n    constructor(elementRef, _focusMonitor, _animationMode) {\n        super(elementRef);\n        this._focusMonitor = _focusMonitor;\n        this._animationMode = _animationMode;\n        /**\n         * Whether the button is round.\n         */\n        this.isRoundButton = this._hasHostAttributes('mat-fab', 'mat-mini-fab');\n        /**\n         * Whether the button is icon button.\n         */\n        this.isIconButton = this._hasHostAttributes('mat-icon-button');\n        // For each of the variant selectors that is present in the button's host\n        // attributes, add the correct corresponding class.\n        for (const attr of BUTTON_HOST_ATTRIBUTES) {\n            if (this._hasHostAttributes(attr)) {\n                ((/** @type {?} */ (this._getHostElement()))).classList.add(attr);\n            }\n        }\n        // Add a class that applies to all buttons. This makes it easier to target if somebody\n        // wants to target all Material buttons. We do it here rather than `host` to ensure that\n        // the class is applied to derived classes.\n        elementRef.nativeElement.classList.add('mat-button-base');\n        this._focusMonitor.monitor(this._elementRef, true);\n        if (this.isRoundButton) {\n            this.color = DEFAULT_ROUND_BUTTON_COLOR;\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._focusMonitor.stopMonitoring(this._elementRef);\n    }\n    /**\n     * Focuses the button.\n     * @param {?=} origin\n     * @param {?=} options\n     * @return {?}\n     */\n    focus(origin = 'program', options) {\n        this._focusMonitor.focusVia(this._getHostElement(), origin, options);\n    }\n    /**\n     * @return {?}\n     */\n    _getHostElement() {\n        return this._elementRef.nativeElement;\n    }\n    /**\n     * @return {?}\n     */\n    _isRippleDisabled() {\n        return this.disableRipple || this.disabled;\n    }\n    /**\n     * Gets whether the button has one of the given attributes.\n     * @param {...?} attributes\n     * @return {?}\n     */\n    _hasHostAttributes(...attributes) {\n        return attributes.some((/**\n         * @param {?} attribute\n         * @return {?}\n         */\n        attribute => this._getHostElement().hasAttribute(attribute)));\n    }\n}\nMatButton.ɵfac = function MatButton_Factory(t) { return new (t || MatButton)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.FocusMonitor), ɵngcc0.ɵɵdirectiveInject(ANIMATION_MODULE_TYPE, 8)); };\nMatButton.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatButton, selectors: [[\"button\", \"mat-button\", \"\"], [\"button\", \"mat-raised-button\", \"\"], [\"button\", \"mat-icon-button\", \"\"], [\"button\", \"mat-fab\", \"\"], [\"button\", \"mat-mini-fab\", \"\"], [\"button\", \"mat-stroked-button\", \"\"], [\"button\", \"mat-flat-button\", \"\"]], viewQuery: function MatButton_Query(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵviewQuery(MatRipple, true);\n    } if (rf & 2) {\n        var _t;\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.ripple = _t.first);\n    } }, hostAttrs: [1, \"mat-focus-indicator\"], hostVars: 3, hostBindings: function MatButton_HostBindings(rf, ctx) { if (rf & 2) {\n        ɵngcc0.ɵɵattribute(\"disabled\", ctx.disabled || null);\n        ɵngcc0.ɵɵclassProp(\"_mat-animation-noopable\", ctx._animationMode === \"NoopAnimations\");\n    } }, inputs: { disabled: \"disabled\", disableRipple: \"disableRipple\", color: \"color\" }, exportAs: [\"matButton\"], features: [ɵngcc0.ɵɵInheritDefinitionFeature], attrs: _c0, ngContentSelectors: _c1, decls: 4, vars: 5, consts: [[1, \"mat-button-wrapper\"], [\"matRipple\", \"\", 1, \"mat-button-ripple\", 3, \"matRippleDisabled\", \"matRippleCentered\", \"matRippleTrigger\"], [1, \"mat-button-focus-overlay\"]], template: function MatButton_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵprojectionDef();\n        ɵngcc0.ɵɵelementStart(0, \"span\", 0);\n        ɵngcc0.ɵɵprojection(1);\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelement(2, \"div\", 1);\n        ɵngcc0.ɵɵelement(3, \"div\", 2);\n    } if (rf & 2) {\n        ɵngcc0.ɵɵadvance(2);\n        ɵngcc0.ɵɵclassProp(\"mat-button-ripple-round\", ctx.isRoundButton || ctx.isIconButton);\n        ɵngcc0.ɵɵproperty(\"matRippleDisabled\", ctx._isRippleDisabled())(\"matRippleCentered\", ctx.isIconButton)(\"matRippleTrigger\", ctx._getHostElement());\n    } }, directives: [ɵngcc2.MatRipple], styles: [\".mat-button .mat-button-focus-overlay,.mat-icon-button .mat-button-focus-overlay{opacity:0}.mat-button:hover .mat-button-focus-overlay,.mat-stroked-button:hover .mat-button-focus-overlay{opacity:.04}@media(hover: none){.mat-button:hover .mat-button-focus-overlay,.mat-stroked-button:hover .mat-button-focus-overlay{opacity:0}}.mat-button,.mat-icon-button,.mat-stroked-button,.mat-flat-button{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-button[disabled],.mat-icon-button[disabled],.mat-stroked-button[disabled],.mat-flat-button[disabled]{cursor:default}.mat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-button.cdk-program-focused .mat-button-focus-overlay,.mat-icon-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-icon-button.cdk-program-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-program-focused .mat-button-focus-overlay,.mat-flat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-flat-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-raised-button{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mat-raised-button::-moz-focus-inner{border:0}.mat-raised-button[disabled]{cursor:default}.mat-raised-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-raised-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-raised-button::-moz-focus-inner{border:0}._mat-animation-noopable.mat-raised-button{transition:none;animation:none}.mat-stroked-button{border:1px solid currentColor;padding:0 15px;line-height:34px}.mat-stroked-button .mat-button-ripple.mat-ripple,.mat-stroked-button .mat-button-focus-overlay{top:-1px;left:-1px;right:-1px;bottom:-1px}.mat-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:56px;height:56px;padding:0;flex-shrink:0}.mat-fab::-moz-focus-inner{border:0}.mat-fab[disabled]{cursor:default}.mat-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-fab::-moz-focus-inner{border:0}._mat-animation-noopable.mat-fab{transition:none;animation:none}.mat-fab .mat-button-wrapper{padding:16px 0;display:inline-block;line-height:24px}.mat-mini-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:40px;height:40px;padding:0;flex-shrink:0}.mat-mini-fab::-moz-focus-inner{border:0}.mat-mini-fab[disabled]{cursor:default}.mat-mini-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-mini-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-mini-fab::-moz-focus-inner{border:0}._mat-animation-noopable.mat-mini-fab{transition:none;animation:none}.mat-mini-fab .mat-button-wrapper{padding:8px 0;display:inline-block;line-height:24px}.mat-icon-button{padding:0;min-width:0;width:40px;height:40px;flex-shrink:0;line-height:40px;border-radius:50%}.mat-icon-button i,.mat-icon-button .mat-icon{line-height:24px}.mat-button-ripple.mat-ripple,.mat-button-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-button-ripple.mat-ripple:not(:empty){transform:translateZ(0)}.mat-button-focus-overlay{opacity:0;transition:opacity 200ms cubic-bezier(0.35, 0, 0.25, 1),background-color 200ms cubic-bezier(0.35, 0, 0.25, 1)}._mat-animation-noopable .mat-button-focus-overlay{transition:none}.cdk-high-contrast-active .mat-button-focus-overlay{background-color:#fff}.cdk-high-contrast-black-on-white .mat-button-focus-overlay{background-color:#000}.mat-button-ripple-round{border-radius:50%;z-index:1}.mat-button .mat-button-wrapper>*,.mat-flat-button .mat-button-wrapper>*,.mat-stroked-button .mat-button-wrapper>*,.mat-raised-button .mat-button-wrapper>*,.mat-icon-button .mat-button-wrapper>*,.mat-fab .mat-button-wrapper>*,.mat-mini-fab .mat-button-wrapper>*{vertical-align:middle}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button{display:block;font-size:inherit;width:2.5em;height:2.5em}.cdk-high-contrast-active .mat-button,.cdk-high-contrast-active .mat-flat-button,.cdk-high-contrast-active .mat-raised-button,.cdk-high-contrast-active .mat-icon-button,.cdk-high-contrast-active .mat-fab,.cdk-high-contrast-active .mat-mini-fab{outline:solid 1px}\\n\"], encapsulation: 2, changeDetection: 0 });\n/** @nocollapse */\nMatButton.ctorParameters = () => [\n    { type: ElementRef },\n    { type: FocusMonitor },\n    { type: String, decorators: [{ type: Optional }, { type: Inject, args: [ANIMATION_MODULE_TYPE,] }] }\n];\nMatButton.propDecorators = {\n    ripple: [{ type: ViewChild, args: [MatRipple,] }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatButton, [{\n        type: Component,\n        args: [{\n                selector: `button[mat-button], button[mat-raised-button], button[mat-icon-button],\n             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],\n             button[mat-flat-button]`,\n                exportAs: 'matButton',\n                host: {\n                    '[attr.disabled]': 'disabled || null',\n                    '[class._mat-animation-noopable]': '_animationMode === \"NoopAnimations\"',\n                    'class': 'mat-focus-indicator'\n                },\n                template: \"<span class=\\\"mat-button-wrapper\\\"><ng-content></ng-content></span>\\n<div matRipple class=\\\"mat-button-ripple\\\"\\n     [class.mat-button-ripple-round]=\\\"isRoundButton || isIconButton\\\"\\n     [matRippleDisabled]=\\\"_isRippleDisabled()\\\"\\n     [matRippleCentered]=\\\"isIconButton\\\"\\n     [matRippleTrigger]=\\\"_getHostElement()\\\"></div>\\n<div class=\\\"mat-button-focus-overlay\\\"></div>\\n\",\n                inputs: ['disabled', 'disableRipple', 'color'],\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush,\n                styles: [\".mat-button .mat-button-focus-overlay,.mat-icon-button .mat-button-focus-overlay{opacity:0}.mat-button:hover .mat-button-focus-overlay,.mat-stroked-button:hover .mat-button-focus-overlay{opacity:.04}@media(hover: none){.mat-button:hover .mat-button-focus-overlay,.mat-stroked-button:hover .mat-button-focus-overlay{opacity:0}}.mat-button,.mat-icon-button,.mat-stroked-button,.mat-flat-button{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-button[disabled],.mat-icon-button[disabled],.mat-stroked-button[disabled],.mat-flat-button[disabled]{cursor:default}.mat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-button.cdk-program-focused .mat-button-focus-overlay,.mat-icon-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-icon-button.cdk-program-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-program-focused .mat-button-focus-overlay,.mat-flat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-flat-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-raised-button{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mat-raised-button::-moz-focus-inner{border:0}.mat-raised-button[disabled]{cursor:default}.mat-raised-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-raised-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-raised-button::-moz-focus-inner{border:0}._mat-animation-noopable.mat-raised-button{transition:none;animation:none}.mat-stroked-button{border:1px solid currentColor;padding:0 15px;line-height:34px}.mat-stroked-button .mat-button-ripple.mat-ripple,.mat-stroked-button .mat-button-focus-overlay{top:-1px;left:-1px;right:-1px;bottom:-1px}.mat-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:56px;height:56px;padding:0;flex-shrink:0}.mat-fab::-moz-focus-inner{border:0}.mat-fab[disabled]{cursor:default}.mat-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-fab::-moz-focus-inner{border:0}._mat-animation-noopable.mat-fab{transition:none;animation:none}.mat-fab .mat-button-wrapper{padding:16px 0;display:inline-block;line-height:24px}.mat-mini-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:40px;height:40px;padding:0;flex-shrink:0}.mat-mini-fab::-moz-focus-inner{border:0}.mat-mini-fab[disabled]{cursor:default}.mat-mini-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-mini-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-mini-fab::-moz-focus-inner{border:0}._mat-animation-noopable.mat-mini-fab{transition:none;animation:none}.mat-mini-fab .mat-button-wrapper{padding:8px 0;display:inline-block;line-height:24px}.mat-icon-button{padding:0;min-width:0;width:40px;height:40px;flex-shrink:0;line-height:40px;border-radius:50%}.mat-icon-button i,.mat-icon-button .mat-icon{line-height:24px}.mat-button-ripple.mat-ripple,.mat-button-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-button-ripple.mat-ripple:not(:empty){transform:translateZ(0)}.mat-button-focus-overlay{opacity:0;transition:opacity 200ms cubic-bezier(0.35, 0, 0.25, 1),background-color 200ms cubic-bezier(0.35, 0, 0.25, 1)}._mat-animation-noopable .mat-button-focus-overlay{transition:none}.cdk-high-contrast-active .mat-button-focus-overlay{background-color:#fff}.cdk-high-contrast-black-on-white .mat-button-focus-overlay{background-color:#000}.mat-button-ripple-round{border-radius:50%;z-index:1}.mat-button .mat-button-wrapper>*,.mat-flat-button .mat-button-wrapper>*,.mat-stroked-button .mat-button-wrapper>*,.mat-raised-button .mat-button-wrapper>*,.mat-icon-button .mat-button-wrapper>*,.mat-fab .mat-button-wrapper>*,.mat-mini-fab .mat-button-wrapper>*{vertical-align:middle}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button{display:block;font-size:inherit;width:2.5em;height:2.5em}.cdk-high-contrast-active .mat-button,.cdk-high-contrast-active .mat-flat-button,.cdk-high-contrast-active .mat-raised-button,.cdk-high-contrast-active .mat-icon-button,.cdk-high-contrast-active .mat-fab,.cdk-high-contrast-active .mat-mini-fab{outline:solid 1px}\\n\"]\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: ɵngcc1.FocusMonitor }, { type: String, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [ANIMATION_MODULE_TYPE]\n            }] }]; }, { ripple: [{\n            type: ViewChild,\n            args: [MatRipple]\n        }] }); })();\nif (false) {\n    /** @type {?} */\n    MatButton.ngAcceptInputType_disabled;\n    /** @type {?} */\n    MatButton.ngAcceptInputType_disableRipple;\n    /**\n     * Whether the button is round.\n     * @type {?}\n     */\n    MatButton.prototype.isRoundButton;\n    /**\n     * Whether the button is icon button.\n     * @type {?}\n     */\n    MatButton.prototype.isIconButton;\n    /**\n     * Reference to the MatRipple instance of the button.\n     * @type {?}\n     */\n    MatButton.prototype.ripple;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatButton.prototype._focusMonitor;\n    /** @type {?} */\n    MatButton.prototype._animationMode;\n}\n/**\n * Material design anchor button.\n */\nclass MatAnchor extends MatButton {\n    /**\n     * @param {?} focusMonitor\n     * @param {?} elementRef\n     * @param {?} animationMode\n     */\n    constructor(focusMonitor, elementRef, animationMode) {\n        super(elementRef, focusMonitor, animationMode);\n    }\n    /**\n     * @param {?} event\n     * @return {?}\n     */\n    _haltDisabledEvents(event) {\n        // A disabled button shouldn't apply any actions\n        if (this.disabled) {\n            event.preventDefault();\n            event.stopImmediatePropagation();\n        }\n    }\n}\nMatAnchor.ɵfac = function MatAnchor_Factory(t) { return new (t || MatAnchor)(ɵngcc0.ɵɵdirectiveInject(ɵngcc1.FocusMonitor), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ANIMATION_MODULE_TYPE, 8)); };\nMatAnchor.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatAnchor, selectors: [[\"a\", \"mat-button\", \"\"], [\"a\", \"mat-raised-button\", \"\"], [\"a\", \"mat-icon-button\", \"\"], [\"a\", \"mat-fab\", \"\"], [\"a\", \"mat-mini-fab\", \"\"], [\"a\", \"mat-stroked-button\", \"\"], [\"a\", \"mat-flat-button\", \"\"]], hostAttrs: [1, \"mat-focus-indicator\"], hostVars: 5, hostBindings: function MatAnchor_HostBindings(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵlistener(\"click\", function MatAnchor_click_HostBindingHandler($event) { return ctx._haltDisabledEvents($event); });\n    } if (rf & 2) {\n        ɵngcc0.ɵɵattribute(\"tabindex\", ctx.disabled ? 0 - 1 : ctx.tabIndex || 0)(\"disabled\", ctx.disabled || null)(\"aria-disabled\", ctx.disabled.toString());\n        ɵngcc0.ɵɵclassProp(\"_mat-animation-noopable\", ctx._animationMode === \"NoopAnimations\");\n    } }, inputs: { disabled: \"disabled\", disableRipple: \"disableRipple\", color: \"color\", tabIndex: \"tabIndex\" }, exportAs: [\"matButton\", \"matAnchor\"], features: [ɵngcc0.ɵɵInheritDefinitionFeature], attrs: _c0, ngContentSelectors: _c1, decls: 4, vars: 5, consts: [[1, \"mat-button-wrapper\"], [\"matRipple\", \"\", 1, \"mat-button-ripple\", 3, \"matRippleDisabled\", \"matRippleCentered\", \"matRippleTrigger\"], [1, \"mat-button-focus-overlay\"]], template: function MatAnchor_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵprojectionDef();\n        ɵngcc0.ɵɵelementStart(0, \"span\", 0);\n        ɵngcc0.ɵɵprojection(1);\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelement(2, \"div\", 1);\n        ɵngcc0.ɵɵelement(3, \"div\", 2);\n    } if (rf & 2) {\n        ɵngcc0.ɵɵadvance(2);\n        ɵngcc0.ɵɵclassProp(\"mat-button-ripple-round\", ctx.isRoundButton || ctx.isIconButton);\n        ɵngcc0.ɵɵproperty(\"matRippleDisabled\", ctx._isRippleDisabled())(\"matRippleCentered\", ctx.isIconButton)(\"matRippleTrigger\", ctx._getHostElement());\n    } }, directives: [ɵngcc2.MatRipple], styles: [\".mat-button .mat-button-focus-overlay,.mat-icon-button .mat-button-focus-overlay{opacity:0}.mat-button:hover .mat-button-focus-overlay,.mat-stroked-button:hover .mat-button-focus-overlay{opacity:.04}@media(hover: none){.mat-button:hover .mat-button-focus-overlay,.mat-stroked-button:hover .mat-button-focus-overlay{opacity:0}}.mat-button,.mat-icon-button,.mat-stroked-button,.mat-flat-button{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-button[disabled],.mat-icon-button[disabled],.mat-stroked-button[disabled],.mat-flat-button[disabled]{cursor:default}.mat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-button.cdk-program-focused .mat-button-focus-overlay,.mat-icon-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-icon-button.cdk-program-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-program-focused .mat-button-focus-overlay,.mat-flat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-flat-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-raised-button{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mat-raised-button::-moz-focus-inner{border:0}.mat-raised-button[disabled]{cursor:default}.mat-raised-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-raised-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-raised-button::-moz-focus-inner{border:0}._mat-animation-noopable.mat-raised-button{transition:none;animation:none}.mat-stroked-button{border:1px solid currentColor;padding:0 15px;line-height:34px}.mat-stroked-button .mat-button-ripple.mat-ripple,.mat-stroked-button .mat-button-focus-overlay{top:-1px;left:-1px;right:-1px;bottom:-1px}.mat-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:56px;height:56px;padding:0;flex-shrink:0}.mat-fab::-moz-focus-inner{border:0}.mat-fab[disabled]{cursor:default}.mat-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-fab::-moz-focus-inner{border:0}._mat-animation-noopable.mat-fab{transition:none;animation:none}.mat-fab .mat-button-wrapper{padding:16px 0;display:inline-block;line-height:24px}.mat-mini-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:40px;height:40px;padding:0;flex-shrink:0}.mat-mini-fab::-moz-focus-inner{border:0}.mat-mini-fab[disabled]{cursor:default}.mat-mini-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-mini-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-mini-fab::-moz-focus-inner{border:0}._mat-animation-noopable.mat-mini-fab{transition:none;animation:none}.mat-mini-fab .mat-button-wrapper{padding:8px 0;display:inline-block;line-height:24px}.mat-icon-button{padding:0;min-width:0;width:40px;height:40px;flex-shrink:0;line-height:40px;border-radius:50%}.mat-icon-button i,.mat-icon-button .mat-icon{line-height:24px}.mat-button-ripple.mat-ripple,.mat-button-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-button-ripple.mat-ripple:not(:empty){transform:translateZ(0)}.mat-button-focus-overlay{opacity:0;transition:opacity 200ms cubic-bezier(0.35, 0, 0.25, 1),background-color 200ms cubic-bezier(0.35, 0, 0.25, 1)}._mat-animation-noopable .mat-button-focus-overlay{transition:none}.cdk-high-contrast-active .mat-button-focus-overlay{background-color:#fff}.cdk-high-contrast-black-on-white .mat-button-focus-overlay{background-color:#000}.mat-button-ripple-round{border-radius:50%;z-index:1}.mat-button .mat-button-wrapper>*,.mat-flat-button .mat-button-wrapper>*,.mat-stroked-button .mat-button-wrapper>*,.mat-raised-button .mat-button-wrapper>*,.mat-icon-button .mat-button-wrapper>*,.mat-fab .mat-button-wrapper>*,.mat-mini-fab .mat-button-wrapper>*{vertical-align:middle}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button{display:block;font-size:inherit;width:2.5em;height:2.5em}.cdk-high-contrast-active .mat-button,.cdk-high-contrast-active .mat-flat-button,.cdk-high-contrast-active .mat-raised-button,.cdk-high-contrast-active .mat-icon-button,.cdk-high-contrast-active .mat-fab,.cdk-high-contrast-active .mat-mini-fab{outline:solid 1px}\\n\"], encapsulation: 2, changeDetection: 0 });\n/** @nocollapse */\nMatAnchor.ctorParameters = () => [\n    { type: FocusMonitor },\n    { type: ElementRef },\n    { type: String, decorators: [{ type: Optional }, { type: Inject, args: [ANIMATION_MODULE_TYPE,] }] }\n];\nMatAnchor.propDecorators = {\n    tabIndex: [{ type: Input }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatAnchor, [{\n        type: Component,\n        args: [{\n                selector: `a[mat-button], a[mat-raised-button], a[mat-icon-button], a[mat-fab],\n             a[mat-mini-fab], a[mat-stroked-button], a[mat-flat-button]`,\n                exportAs: 'matButton, matAnchor',\n                host: {\n                    // Note that we ignore the user-specified tabindex when it's disabled for\n                    // consistency with the `mat-button` applied on native buttons where even\n                    // though they have an index, they're not tabbable.\n                    '[attr.tabindex]': 'disabled ? -1 : (tabIndex || 0)',\n                    '[attr.disabled]': 'disabled || null',\n                    '[attr.aria-disabled]': 'disabled.toString()',\n                    '(click)': '_haltDisabledEvents($event)',\n                    '[class._mat-animation-noopable]': '_animationMode === \"NoopAnimations\"',\n                    'class': 'mat-focus-indicator'\n                },\n                inputs: ['disabled', 'disableRipple', 'color'],\n                template: \"<span class=\\\"mat-button-wrapper\\\"><ng-content></ng-content></span>\\n<div matRipple class=\\\"mat-button-ripple\\\"\\n     [class.mat-button-ripple-round]=\\\"isRoundButton || isIconButton\\\"\\n     [matRippleDisabled]=\\\"_isRippleDisabled()\\\"\\n     [matRippleCentered]=\\\"isIconButton\\\"\\n     [matRippleTrigger]=\\\"_getHostElement()\\\"></div>\\n<div class=\\\"mat-button-focus-overlay\\\"></div>\\n\",\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush,\n                styles: [\".mat-button .mat-button-focus-overlay,.mat-icon-button .mat-button-focus-overlay{opacity:0}.mat-button:hover .mat-button-focus-overlay,.mat-stroked-button:hover .mat-button-focus-overlay{opacity:.04}@media(hover: none){.mat-button:hover .mat-button-focus-overlay,.mat-stroked-button:hover .mat-button-focus-overlay{opacity:0}}.mat-button,.mat-icon-button,.mat-stroked-button,.mat-flat-button{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-button[disabled],.mat-icon-button[disabled],.mat-stroked-button[disabled],.mat-flat-button[disabled]{cursor:default}.mat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-button.cdk-program-focused .mat-button-focus-overlay,.mat-icon-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-icon-button.cdk-program-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-program-focused .mat-button-focus-overlay,.mat-flat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-flat-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-raised-button{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mat-raised-button::-moz-focus-inner{border:0}.mat-raised-button[disabled]{cursor:default}.mat-raised-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-raised-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-raised-button::-moz-focus-inner{border:0}._mat-animation-noopable.mat-raised-button{transition:none;animation:none}.mat-stroked-button{border:1px solid currentColor;padding:0 15px;line-height:34px}.mat-stroked-button .mat-button-ripple.mat-ripple,.mat-stroked-button .mat-button-focus-overlay{top:-1px;left:-1px;right:-1px;bottom:-1px}.mat-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:56px;height:56px;padding:0;flex-shrink:0}.mat-fab::-moz-focus-inner{border:0}.mat-fab[disabled]{cursor:default}.mat-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-fab::-moz-focus-inner{border:0}._mat-animation-noopable.mat-fab{transition:none;animation:none}.mat-fab .mat-button-wrapper{padding:16px 0;display:inline-block;line-height:24px}.mat-mini-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:40px;height:40px;padding:0;flex-shrink:0}.mat-mini-fab::-moz-focus-inner{border:0}.mat-mini-fab[disabled]{cursor:default}.mat-mini-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-mini-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-mini-fab::-moz-focus-inner{border:0}._mat-animation-noopable.mat-mini-fab{transition:none;animation:none}.mat-mini-fab .mat-button-wrapper{padding:8px 0;display:inline-block;line-height:24px}.mat-icon-button{padding:0;min-width:0;width:40px;height:40px;flex-shrink:0;line-height:40px;border-radius:50%}.mat-icon-button i,.mat-icon-button .mat-icon{line-height:24px}.mat-button-ripple.mat-ripple,.mat-button-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-button-ripple.mat-ripple:not(:empty){transform:translateZ(0)}.mat-button-focus-overlay{opacity:0;transition:opacity 200ms cubic-bezier(0.35, 0, 0.25, 1),background-color 200ms cubic-bezier(0.35, 0, 0.25, 1)}._mat-animation-noopable .mat-button-focus-overlay{transition:none}.cdk-high-contrast-active .mat-button-focus-overlay{background-color:#fff}.cdk-high-contrast-black-on-white .mat-button-focus-overlay{background-color:#000}.mat-button-ripple-round{border-radius:50%;z-index:1}.mat-button .mat-button-wrapper>*,.mat-flat-button .mat-button-wrapper>*,.mat-stroked-button .mat-button-wrapper>*,.mat-raised-button .mat-button-wrapper>*,.mat-icon-button .mat-button-wrapper>*,.mat-fab .mat-button-wrapper>*,.mat-mini-fab .mat-button-wrapper>*{vertical-align:middle}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button{display:block;font-size:inherit;width:2.5em;height:2.5em}.cdk-high-contrast-active .mat-button,.cdk-high-contrast-active .mat-flat-button,.cdk-high-contrast-active .mat-raised-button,.cdk-high-contrast-active .mat-icon-button,.cdk-high-contrast-active .mat-fab,.cdk-high-contrast-active .mat-mini-fab{outline:solid 1px}\\n\"]\n            }]\n    }], function () { return [{ type: ɵngcc1.FocusMonitor }, { type: ɵngcc0.ElementRef }, { type: String, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [ANIMATION_MODULE_TYPE]\n            }] }]; }, { tabIndex: [{\n            type: Input\n        }] }); })();\nif (false) {\n    /**\n     * Tabindex of the button.\n     * @type {?}\n     */\n    MatAnchor.prototype.tabIndex;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/button/button-module.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass MatButtonModule {\n}\nMatButtonModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: MatButtonModule });\nMatButtonModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function MatButtonModule_Factory(t) { return new (t || MatButtonModule)(); }, imports: [[\n            MatRippleModule,\n            MatCommonModule,\n        ],\n        MatCommonModule] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(MatButtonModule, { declarations: function () { return [MatButton,\n        MatAnchor]; }, imports: function () { return [MatRippleModule,\n        MatCommonModule]; }, exports: function () { return [MatButton,\n        MatAnchor,\n        MatCommonModule]; } }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatButtonModule, [{\n        type: NgModule,\n        args: [{\n                imports: [\n                    MatRippleModule,\n                    MatCommonModule,\n                ],\n                exports: [\n                    MatButton,\n                    MatAnchor,\n                    MatCommonModule,\n                ],\n                declarations: [\n                    MatButton,\n                    MatAnchor,\n                ]\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/button/public-api.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 { MatAnchor, MatButton, MatButtonModule };\n\n//# sourceMappingURL=button.js.map","import { Overlay, OverlayConfig, OverlayContainer, OverlayModule } from '@angular/cdk/overlay';\nimport { BasePortalOutlet, CdkPortalOutlet, ComponentPortal, TemplatePortal, PortalModule } from '@angular/cdk/portal';\nimport { EventEmitter, Component, ViewEncapsulation, ChangeDetectionStrategy, ElementRef, ChangeDetectorRef, Optional, Inject, ViewChild, InjectionToken, Injector, TemplateRef, Injectable, SkipSelf, Directive, Input, NgModule } from '@angular/core';\nimport { MatCommonModule } from '@angular/material/core';\nimport { Directionality } from '@angular/cdk/bidi';\nimport { DOCUMENT, Location } from '@angular/common';\nimport { Subject, defer, of } from 'rxjs';\nimport { filter, take, startWith } from 'rxjs/operators';\nimport { trigger, state, style, transition, animate } from '@angular/animations';\nimport { FocusTrapFactory } from '@angular/cdk/a11y';\nimport { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/dialog/dialog-config.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 * Possible overrides for a dialog's position.\n * @record\n */\nimport * as ɵngcc0 from '@angular/core';\nimport * as ɵngcc1 from '@angular/cdk/a11y';\nimport * as ɵngcc2 from '@angular/cdk/portal';\nimport * as ɵngcc3 from '@angular/cdk/overlay';\nimport * as ɵngcc4 from '@angular/common';\n\nfunction MatDialogContainer_ng_template_0_Template(rf, ctx) { }\nfunction DialogPosition() { }\nif (false) {\n    /**\n     * Override for the dialog's top position.\n     * @type {?|undefined}\n     */\n    DialogPosition.prototype.top;\n    /**\n     * Override for the dialog's bottom position.\n     * @type {?|undefined}\n     */\n    DialogPosition.prototype.bottom;\n    /**\n     * Override for the dialog's left position.\n     * @type {?|undefined}\n     */\n    DialogPosition.prototype.left;\n    /**\n     * Override for the dialog's right position.\n     * @type {?|undefined}\n     */\n    DialogPosition.prototype.right;\n}\n/**\n * Configuration for opening a modal dialog with the MatDialog service.\n * @template D\n */\nclass MatDialogConfig {\n    constructor() {\n        /**\n         * The ARIA role of the dialog element.\n         */\n        this.role = 'dialog';\n        /**\n         * Custom class for the overlay pane.\n         */\n        this.panelClass = '';\n        /**\n         * Whether the dialog has a backdrop.\n         */\n        this.hasBackdrop = true;\n        /**\n         * Custom class for the backdrop.\n         */\n        this.backdropClass = '';\n        /**\n         * Whether the user can use escape or clicking on the backdrop to close the modal.\n         */\n        this.disableClose = false;\n        /**\n         * Width of the dialog.\n         */\n        this.width = '';\n        /**\n         * Height of the dialog.\n         */\n        this.height = '';\n        /**\n         * Max-width of the dialog. If a number is provided, assumes pixel units. Defaults to 80vw.\n         */\n        this.maxWidth = '80vw';\n        /**\n         * Data being injected into the child component.\n         */\n        this.data = null;\n        /**\n         * ID of the element that describes the dialog.\n         */\n        this.ariaDescribedBy = null;\n        /**\n         * ID of the element that labels the dialog.\n         */\n        this.ariaLabelledBy = null;\n        /**\n         * Aria label to assign to the dialog element.\n         */\n        this.ariaLabel = null;\n        /**\n         * Whether the dialog should focus the first focusable element on open.\n         */\n        this.autoFocus = true;\n        /**\n         * Whether the dialog should restore focus to the\n         * previously-focused element, after it's closed.\n         */\n        this.restoreFocus = true;\n        /**\n         * Whether the dialog should close when the user goes backwards/forwards in history.\n         * Note that this usually doesn't include clicking on links (unless the user is using\n         * the `HashLocationStrategy`).\n         */\n        this.closeOnNavigation = true;\n        // TODO(jelbourn): add configuration for lifecycle hooks, ARIA labelling.\n    }\n}\nif (false) {\n    /**\n     * Where the attached component should live in Angular's *logical* component tree.\n     * This affects what is available for injection and the change detection order for the\n     * component instantiated inside of the dialog. This does not affect where the dialog\n     * content will be rendered.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.viewContainerRef;\n    /**\n     * ID for the dialog. If omitted, a unique one will be generated.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.id;\n    /**\n     * The ARIA role of the dialog element.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.role;\n    /**\n     * Custom class for the overlay pane.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.panelClass;\n    /**\n     * Whether the dialog has a backdrop.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.hasBackdrop;\n    /**\n     * Custom class for the backdrop.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.backdropClass;\n    /**\n     * Whether the user can use escape or clicking on the backdrop to close the modal.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.disableClose;\n    /**\n     * Width of the dialog.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.width;\n    /**\n     * Height of the dialog.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.height;\n    /**\n     * Min-width of the dialog. If a number is provided, assumes pixel units.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.minWidth;\n    /**\n     * Min-height of the dialog. If a number is provided, assumes pixel units.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.minHeight;\n    /**\n     * Max-width of the dialog. If a number is provided, assumes pixel units. Defaults to 80vw.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.maxWidth;\n    /**\n     * Max-height of the dialog. If a number is provided, assumes pixel units.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.maxHeight;\n    /**\n     * Position overrides.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.position;\n    /**\n     * Data being injected into the child component.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.data;\n    /**\n     * Layout direction for the dialog's content.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.direction;\n    /**\n     * ID of the element that describes the dialog.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.ariaDescribedBy;\n    /**\n     * ID of the element that labels the dialog.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.ariaLabelledBy;\n    /**\n     * Aria label to assign to the dialog element.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.ariaLabel;\n    /**\n     * Whether the dialog should focus the first focusable element on open.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.autoFocus;\n    /**\n     * Whether the dialog should restore focus to the\n     * previously-focused element, after it's closed.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.restoreFocus;\n    /**\n     * Scroll strategy to be used for the dialog.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.scrollStrategy;\n    /**\n     * Whether the dialog should close when the user goes backwards/forwards in history.\n     * Note that this usually doesn't include clicking on links (unless the user is using\n     * the `HashLocationStrategy`).\n     * @type {?}\n     */\n    MatDialogConfig.prototype.closeOnNavigation;\n    /**\n     * Alternate `ComponentFactoryResolver` to use when resolving the associated component.\n     * @type {?}\n     */\n    MatDialogConfig.prototype.componentFactoryResolver;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/dialog/dialog-animations.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Animations used by MatDialog.\n * \\@docs-private\n * @type {?}\n */\nconst matDialogAnimations = {\n    /**\n     * Animation that is applied on the dialog container by defalt.\n     */\n    dialogContainer: trigger('dialogContainer', [\n        // Note: The `enter` animation transitions to `transform: none`, because for some reason\n        // specifying the transform explicitly, causes IE both to blur the dialog content and\n        // decimate the animation performance. Leaving it as `none` solves both issues.\n        state('void, exit', style({ opacity: 0, transform: 'scale(0.7)' })),\n        state('enter', style({ transform: 'none' })),\n        transition('* => enter', animate('150ms cubic-bezier(0, 0, 0.2, 1)', style({ transform: 'none', opacity: 1 }))),\n        transition('* => void, * => exit', animate('75ms cubic-bezier(0.4, 0.0, 0.2, 1)', style({ opacity: 0 }))),\n    ])\n};\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/dialog/dialog-container.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Throws an exception for the case when a ComponentPortal is\n * attached to a DomPortalOutlet without an origin.\n * \\@docs-private\n * @return {?}\n */\nfunction throwMatDialogContentAlreadyAttachedError() {\n    throw Error('Attempting to attach dialog content after content is already attached');\n}\n/**\n * Internal component that wraps user-provided dialog content.\n * Animation is based on https://material.io/guidelines/motion/choreography.html.\n * \\@docs-private\n */\nclass MatDialogContainer extends BasePortalOutlet {\n    /**\n     * @param {?} _elementRef\n     * @param {?} _focusTrapFactory\n     * @param {?} _changeDetectorRef\n     * @param {?} _document\n     * @param {?} _config\n     */\n    constructor(_elementRef, _focusTrapFactory, _changeDetectorRef, _document, _config) {\n        super();\n        this._elementRef = _elementRef;\n        this._focusTrapFactory = _focusTrapFactory;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._config = _config;\n        /**\n         * Element that was focused before the dialog was opened. Save this to restore upon close.\n         */\n        this._elementFocusedBeforeDialogWasOpened = null;\n        /**\n         * State of the dialog animation.\n         */\n        this._state = 'enter';\n        /**\n         * Emits when an animation state changes.\n         */\n        this._animationStateChanged = new EventEmitter();\n        /**\n         * Attaches a DOM portal to the dialog container.\n         * @param portal Portal to be attached.\n         * @deprecated To be turned into a method.\n         * \\@breaking-change 10.0.0\n         */\n        this.attachDomPortal = (/**\n         * @param {?} portal\n         * @return {?}\n         */\n        (portal) => {\n            if (this._portalOutlet.hasAttached()) {\n                throwMatDialogContentAlreadyAttachedError();\n            }\n            this._savePreviouslyFocusedElement();\n            return this._portalOutlet.attachDomPortal(portal);\n        });\n        this._ariaLabelledBy = _config.ariaLabelledBy || null;\n        this._document = _document;\n    }\n    /**\n     * Attach a ComponentPortal as content to this dialog container.\n     * @template T\n     * @param {?} portal Portal to be attached as the dialog content.\n     * @return {?}\n     */\n    attachComponentPortal(portal) {\n        if (this._portalOutlet.hasAttached()) {\n            throwMatDialogContentAlreadyAttachedError();\n        }\n        this._savePreviouslyFocusedElement();\n        return this._portalOutlet.attachComponentPortal(portal);\n    }\n    /**\n     * Attach a TemplatePortal as content to this dialog container.\n     * @template C\n     * @param {?} portal Portal to be attached as the dialog content.\n     * @return {?}\n     */\n    attachTemplatePortal(portal) {\n        if (this._portalOutlet.hasAttached()) {\n            throwMatDialogContentAlreadyAttachedError();\n        }\n        this._savePreviouslyFocusedElement();\n        return this._portalOutlet.attachTemplatePortal(portal);\n    }\n    /**\n     * Moves focus back into the dialog if it was moved out.\n     * @return {?}\n     */\n    _recaptureFocus() {\n        if (!this._containsFocus()) {\n            /** @type {?} */\n            const focusWasTrapped = this._getFocusTrap().focusInitialElement();\n            if (!focusWasTrapped) {\n                this._elementRef.nativeElement.focus();\n            }\n        }\n    }\n    /**\n     * Moves the focus inside the focus trap.\n     * @private\n     * @return {?}\n     */\n    _trapFocus() {\n        // If we were to attempt to focus immediately, then the content of the dialog would not yet be\n        // ready in instances where change detection has to run first. To deal with this, we simply\n        // wait for the microtask queue to be empty.\n        if (this._config.autoFocus) {\n            this._getFocusTrap().focusInitialElementWhenReady();\n        }\n        else if (!this._containsFocus()) {\n            // Otherwise ensure that focus is on the dialog container. It's possible that a different\n            // component tried to move focus while the open animation was running. See:\n            // https://github.com/angular/components/issues/16215. Note that we only want to do this\n            // if the focus isn't inside the dialog already, because it's possible that the consumer\n            // turned off `autoFocus` in order to move focus themselves.\n            this._elementRef.nativeElement.focus();\n        }\n    }\n    /**\n     * Restores focus to the element that was focused before the dialog opened.\n     * @private\n     * @return {?}\n     */\n    _restoreFocus() {\n        /** @type {?} */\n        const toFocus = this._elementFocusedBeforeDialogWasOpened;\n        // We need the extra check, because IE can set the `activeElement` to null in some cases.\n        if (this._config.restoreFocus && toFocus && typeof toFocus.focus === 'function') {\n            /** @type {?} */\n            const activeElement = this._document.activeElement;\n            /** @type {?} */\n            const element = this._elementRef.nativeElement;\n            // Make sure that focus is still inside the dialog or is on the body (usually because a\n            // non-focusable element like the backdrop was clicked) before moving it. It's possible that\n            // the consumer moved it themselves before the animation was done, in which case we shouldn't\n            // do anything.\n            if (!activeElement || activeElement === this._document.body || activeElement === element ||\n                element.contains(activeElement)) {\n                toFocus.focus();\n            }\n        }\n        if (this._focusTrap) {\n            this._focusTrap.destroy();\n        }\n    }\n    /**\n     * Saves a reference to the element that was focused before the dialog was opened.\n     * @private\n     * @return {?}\n     */\n    _savePreviouslyFocusedElement() {\n        if (this._document) {\n            this._elementFocusedBeforeDialogWasOpened = (/** @type {?} */ (this._document.activeElement));\n            // Note that there is no focus method when rendering on the server.\n            if (this._elementRef.nativeElement.focus) {\n                // Move focus onto the dialog immediately in order to prevent the user from accidentally\n                // opening multiple dialogs at the same time. Needs to be async, because the element\n                // may not be focusable immediately.\n                Promise.resolve().then((/**\n                 * @return {?}\n                 */\n                () => this._elementRef.nativeElement.focus()));\n            }\n        }\n    }\n    /**\n     * Returns whether focus is inside the dialog.\n     * @private\n     * @return {?}\n     */\n    _containsFocus() {\n        /** @type {?} */\n        const element = this._elementRef.nativeElement;\n        /** @type {?} */\n        const activeElement = this._document.activeElement;\n        return element === activeElement || element.contains(activeElement);\n    }\n    /**\n     * Gets the focus trap associated with the dialog.\n     * @private\n     * @return {?}\n     */\n    _getFocusTrap() {\n        if (!this._focusTrap) {\n            this._focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement);\n        }\n        return this._focusTrap;\n    }\n    /**\n     * Callback, invoked whenever an animation on the host completes.\n     * @param {?} event\n     * @return {?}\n     */\n    _onAnimationDone(event) {\n        if (event.toState === 'enter') {\n            this._trapFocus();\n        }\n        else if (event.toState === 'exit') {\n            this._restoreFocus();\n        }\n        this._animationStateChanged.emit(event);\n    }\n    /**\n     * Callback, invoked when an animation on the host starts.\n     * @param {?} event\n     * @return {?}\n     */\n    _onAnimationStart(event) {\n        this._animationStateChanged.emit(event);\n    }\n    /**\n     * Starts the dialog exit animation.\n     * @return {?}\n     */\n    _startExitAnimation() {\n        this._state = 'exit';\n        // Mark the container for check so it can react if the\n        // view container is using OnPush change detection.\n        this._changeDetectorRef.markForCheck();\n    }\n}\nMatDialogContainer.ɵfac = function MatDialogContainer_Factory(t) { return new (t || MatDialogContainer)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.FocusTrapFactory), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(DOCUMENT, 8), ɵngcc0.ɵɵdirectiveInject(MatDialogConfig)); };\nMatDialogContainer.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatDialogContainer, selectors: [[\"mat-dialog-container\"]], viewQuery: function MatDialogContainer_Query(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵstaticViewQuery(CdkPortalOutlet, true);\n    } if (rf & 2) {\n        var _t;\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._portalOutlet = _t.first);\n    } }, hostAttrs: [\"tabindex\", \"-1\", \"aria-modal\", \"true\", 1, \"mat-dialog-container\"], hostVars: 6, hostBindings: function MatDialogContainer_HostBindings(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵcomponentHostSyntheticListener(\"@dialogContainer.start\", function MatDialogContainer_animation_dialogContainer_start_HostBindingHandler($event) { return ctx._onAnimationStart($event); })(\"@dialogContainer.done\", function MatDialogContainer_animation_dialogContainer_done_HostBindingHandler($event) { return ctx._onAnimationDone($event); });\n    } if (rf & 2) {\n        ɵngcc0.ɵɵattribute(\"id\", ctx._id)(\"role\", ctx._config.role)(\"aria-labelledby\", ctx._config.ariaLabel ? null : ctx._ariaLabelledBy)(\"aria-label\", ctx._config.ariaLabel)(\"aria-describedby\", ctx._config.ariaDescribedBy || null);\n        ɵngcc0.ɵɵupdateSyntheticHostBinding(\"@dialogContainer\", ctx._state);\n    } }, features: [ɵngcc0.ɵɵInheritDefinitionFeature], decls: 1, vars: 0, consts: [[\"cdkPortalOutlet\", \"\"]], template: function MatDialogContainer_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵtemplate(0, MatDialogContainer_ng_template_0_Template, 0, 0, \"ng-template\", 0);\n    } }, directives: [ɵngcc2.CdkPortalOutlet], styles: [\".mat-dialog-container{display:block;padding:24px;border-radius:4px;box-sizing:border-box;overflow:auto;outline:0;width:100%;height:100%;min-height:inherit;max-height:inherit}.cdk-high-contrast-active .mat-dialog-container{outline:solid 1px}.mat-dialog-content{display:block;margin:0 -24px;padding:0 24px;max-height:65vh;overflow:auto;-webkit-overflow-scrolling:touch}.mat-dialog-title{margin:0 0 20px;display:block}.mat-dialog-actions{padding:8px 0;display:flex;flex-wrap:wrap;min-height:52px;align-items:center;margin-bottom:-24px}.mat-dialog-actions[align=end]{justify-content:flex-end}.mat-dialog-actions[align=center]{justify-content:center}.mat-dialog-actions .mat-button-base+.mat-button-base,.mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:8px}[dir=rtl] .mat-dialog-actions .mat-button-base+.mat-button-base,[dir=rtl] .mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:0;margin-right:8px}\\n\"], encapsulation: 2, data: { animation: [matDialogAnimations.dialogContainer] } });\n/** @nocollapse */\nMatDialogContainer.ctorParameters = () => [\n    { type: ElementRef },\n    { type: FocusTrapFactory },\n    { type: ChangeDetectorRef },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] },\n    { type: MatDialogConfig }\n];\nMatDialogContainer.propDecorators = {\n    _portalOutlet: [{ type: ViewChild, args: [CdkPortalOutlet, { static: true },] }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatDialogContainer, [{\n        type: Component,\n        args: [{\n                selector: 'mat-dialog-container',\n                template: \"<ng-template cdkPortalOutlet></ng-template>\\n\",\n                encapsulation: ViewEncapsulation.None,\n                // Using OnPush for dialogs caused some G3 sync issues. Disabled until we can track them down.\n                // tslint:disable-next-line:validate-decorators\n                changeDetection: ChangeDetectionStrategy.Default,\n                animations: [matDialogAnimations.dialogContainer],\n                host: {\n                    'class': 'mat-dialog-container',\n                    'tabindex': '-1',\n                    'aria-modal': 'true',\n                    '[attr.id]': '_id',\n                    '[attr.role]': '_config.role',\n                    '[attr.aria-labelledby]': '_config.ariaLabel ? null : _ariaLabelledBy',\n                    '[attr.aria-label]': '_config.ariaLabel',\n                    '[attr.aria-describedby]': '_config.ariaDescribedBy || null',\n                    '[@dialogContainer]': '_state',\n                    '(@dialogContainer.start)': '_onAnimationStart($event)',\n                    '(@dialogContainer.done)': '_onAnimationDone($event)'\n                },\n                styles: [\".mat-dialog-container{display:block;padding:24px;border-radius:4px;box-sizing:border-box;overflow:auto;outline:0;width:100%;height:100%;min-height:inherit;max-height:inherit}.cdk-high-contrast-active .mat-dialog-container{outline:solid 1px}.mat-dialog-content{display:block;margin:0 -24px;padding:0 24px;max-height:65vh;overflow:auto;-webkit-overflow-scrolling:touch}.mat-dialog-title{margin:0 0 20px;display:block}.mat-dialog-actions{padding:8px 0;display:flex;flex-wrap:wrap;min-height:52px;align-items:center;margin-bottom:-24px}.mat-dialog-actions[align=end]{justify-content:flex-end}.mat-dialog-actions[align=center]{justify-content:center}.mat-dialog-actions .mat-button-base+.mat-button-base,.mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:8px}[dir=rtl] .mat-dialog-actions .mat-button-base+.mat-button-base,[dir=rtl] .mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:0;margin-right:8px}\\n\"]\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: ɵngcc1.FocusTrapFactory }, { type: ɵngcc0.ChangeDetectorRef }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [DOCUMENT]\n            }] }, { type: MatDialogConfig }]; }, { _portalOutlet: [{\n            type: ViewChild,\n            args: [CdkPortalOutlet, { static: true }]\n        }] }); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialogContainer.prototype._document;\n    /**\n     * The portal outlet inside of this container into which the dialog content will be loaded.\n     * @type {?}\n     */\n    MatDialogContainer.prototype._portalOutlet;\n    /**\n     * The class that traps and manages focus within the dialog.\n     * @type {?}\n     * @private\n     */\n    MatDialogContainer.prototype._focusTrap;\n    /**\n     * Element that was focused before the dialog was opened. Save this to restore upon close.\n     * @type {?}\n     * @private\n     */\n    MatDialogContainer.prototype._elementFocusedBeforeDialogWasOpened;\n    /**\n     * State of the dialog animation.\n     * @type {?}\n     */\n    MatDialogContainer.prototype._state;\n    /**\n     * Emits when an animation state changes.\n     * @type {?}\n     */\n    MatDialogContainer.prototype._animationStateChanged;\n    /**\n     * ID of the element that should be considered as the dialog's label.\n     * @type {?}\n     */\n    MatDialogContainer.prototype._ariaLabelledBy;\n    /**\n     * ID for the container DOM element.\n     * @type {?}\n     */\n    MatDialogContainer.prototype._id;\n    /**\n     * Attaches a DOM portal to the dialog container.\n     * \\@param portal Portal to be attached.\n     * @deprecated To be turned into a method.\n     * \\@breaking-change 10.0.0\n     * @type {?}\n     */\n    MatDialogContainer.prototype.attachDomPortal;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialogContainer.prototype._elementRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialogContainer.prototype._focusTrapFactory;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialogContainer.prototype._changeDetectorRef;\n    /**\n     * The dialog configuration.\n     * @type {?}\n     */\n    MatDialogContainer.prototype._config;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/dialog/dialog-ref.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n// TODO(jelbourn): resizing\n// Counter for unique dialog ids.\n/** @type {?} */\nlet uniqueId = 0;\n/** @enum {number} */\nconst MatDialogState = {\n    OPEN: 0, CLOSING: 1, CLOSED: 2,\n};\n/**\n * Reference to a dialog opened via the MatDialog service.\n * @template T, R\n */\nclass MatDialogRef {\n    /**\n     * @param {?} _overlayRef\n     * @param {?} _containerInstance\n     * @param {?=} id\n     */\n    constructor(_overlayRef, _containerInstance, id = `mat-dialog-${uniqueId++}`) {\n        this._overlayRef = _overlayRef;\n        this._containerInstance = _containerInstance;\n        this.id = id;\n        /**\n         * Whether the user is allowed to close the dialog.\n         */\n        this.disableClose = this._containerInstance._config.disableClose;\n        /**\n         * Subject for notifying the user that the dialog has finished opening.\n         */\n        this._afterOpened = new Subject();\n        /**\n         * Subject for notifying the user that the dialog has finished closing.\n         */\n        this._afterClosed = new Subject();\n        /**\n         * Subject for notifying the user that the dialog has started closing.\n         */\n        this._beforeClosed = new Subject();\n        /**\n         * Current state of the dialog.\n         */\n        this._state = 0 /* OPEN */;\n        // Pass the id along to the container.\n        _containerInstance._id = id;\n        // Emit when opening animation completes\n        _containerInstance._animationStateChanged.pipe(filter((/**\n         * @param {?} event\n         * @return {?}\n         */\n        event => event.phaseName === 'done' && event.toState === 'enter')), take(1))\n            .subscribe((/**\n         * @return {?}\n         */\n        () => {\n            this._afterOpened.next();\n            this._afterOpened.complete();\n        }));\n        // Dispose overlay when closing animation is complete\n        _containerInstance._animationStateChanged.pipe(filter((/**\n         * @param {?} event\n         * @return {?}\n         */\n        event => event.phaseName === 'done' && event.toState === 'exit')), take(1)).subscribe((/**\n         * @return {?}\n         */\n        () => {\n            clearTimeout(this._closeFallbackTimeout);\n            this._finishDialogClose();\n        }));\n        _overlayRef.detachments().subscribe((/**\n         * @return {?}\n         */\n        () => {\n            this._beforeClosed.next(this._result);\n            this._beforeClosed.complete();\n            this._afterClosed.next(this._result);\n            this._afterClosed.complete();\n            this.componentInstance = (/** @type {?} */ (null));\n            this._overlayRef.dispose();\n        }));\n        _overlayRef.keydownEvents()\n            .pipe(filter((/**\n         * @param {?} event\n         * @return {?}\n         */\n        event => {\n            return event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event);\n        })))\n            .subscribe((/**\n         * @param {?} event\n         * @return {?}\n         */\n        event => {\n            event.preventDefault();\n            this.close();\n        }));\n        _overlayRef.backdropClick().subscribe((/**\n         * @return {?}\n         */\n        () => {\n            if (this.disableClose) {\n                this._containerInstance._recaptureFocus();\n            }\n            else {\n                this.close();\n            }\n        }));\n    }\n    /**\n     * Close the dialog.\n     * @param {?=} dialogResult Optional result to return to the dialog opener.\n     * @return {?}\n     */\n    close(dialogResult) {\n        this._result = dialogResult;\n        // Transition the backdrop in parallel to the dialog.\n        this._containerInstance._animationStateChanged.pipe(filter((/**\n         * @param {?} event\n         * @return {?}\n         */\n        event => event.phaseName === 'start')), take(1))\n            .subscribe((/**\n         * @param {?} event\n         * @return {?}\n         */\n        event => {\n            this._beforeClosed.next(dialogResult);\n            this._beforeClosed.complete();\n            this._overlayRef.detachBackdrop();\n            // The logic that disposes of the overlay depends on the exit animation completing, however\n            // it isn't guaranteed if the parent view is destroyed while it's running. Add a fallback\n            // timeout which will clean everything up if the animation hasn't fired within the specified\n            // amount of time plus 100ms. We don't need to run this outside the NgZone, because for the\n            // vast majority of cases the timeout will have been cleared before it has the chance to fire.\n            this._closeFallbackTimeout = setTimeout((/**\n             * @return {?}\n             */\n            () => this._finishDialogClose()), event.totalTime + 100);\n        }));\n        this._containerInstance._startExitAnimation();\n        this._state = 1 /* CLOSING */;\n    }\n    /**\n     * Gets an observable that is notified when the dialog is finished opening.\n     * @return {?}\n     */\n    afterOpened() {\n        return this._afterOpened.asObservable();\n    }\n    /**\n     * Gets an observable that is notified when the dialog is finished closing.\n     * @return {?}\n     */\n    afterClosed() {\n        return this._afterClosed.asObservable();\n    }\n    /**\n     * Gets an observable that is notified when the dialog has started closing.\n     * @return {?}\n     */\n    beforeClosed() {\n        return this._beforeClosed.asObservable();\n    }\n    /**\n     * Gets an observable that emits when the overlay's backdrop has been clicked.\n     * @return {?}\n     */\n    backdropClick() {\n        return this._overlayRef.backdropClick();\n    }\n    /**\n     * Gets an observable that emits when keydown events are targeted on the overlay.\n     * @return {?}\n     */\n    keydownEvents() {\n        return this._overlayRef.keydownEvents();\n    }\n    /**\n     * Updates the dialog's position.\n     * @template THIS\n     * @this {THIS}\n     * @param {?=} position New dialog position.\n     * @return {THIS}\n     */\n    updatePosition(position) {\n        /** @type {?} */\n        let strategy = (/** @type {?} */ (this))._getPositionStrategy();\n        if (position && (position.left || position.right)) {\n            position.left ? strategy.left(position.left) : strategy.right(position.right);\n        }\n        else {\n            strategy.centerHorizontally();\n        }\n        if (position && (position.top || position.bottom)) {\n            position.top ? strategy.top(position.top) : strategy.bottom(position.bottom);\n        }\n        else {\n            strategy.centerVertically();\n        }\n        (/** @type {?} */ (this))._overlayRef.updatePosition();\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Updates the dialog's width and height.\n     * @template THIS\n     * @this {THIS}\n     * @param {?=} width New width of the dialog.\n     * @param {?=} height New height of the dialog.\n     * @return {THIS}\n     */\n    updateSize(width = '', height = '') {\n        (/** @type {?} */ (this))._getPositionStrategy().width(width).height(height);\n        (/** @type {?} */ (this))._overlayRef.updatePosition();\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Add a CSS class or an array of classes to the overlay pane.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} classes\n     * @return {THIS}\n     */\n    addPanelClass(classes) {\n        (/** @type {?} */ (this))._overlayRef.addPanelClass(classes);\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Remove a CSS class or an array of classes from the overlay pane.\n     * @template THIS\n     * @this {THIS}\n     * @param {?} classes\n     * @return {THIS}\n     */\n    removePanelClass(classes) {\n        (/** @type {?} */ (this))._overlayRef.removePanelClass(classes);\n        return (/** @type {?} */ (this));\n    }\n    /**\n     * Gets the current state of the dialog's lifecycle.\n     * @return {?}\n     */\n    getState() {\n        return this._state;\n    }\n    /**\n     * Finishes the dialog close by updating the state of the dialog\n     * and disposing the overlay.\n     * @private\n     * @return {?}\n     */\n    _finishDialogClose() {\n        this._state = 2 /* CLOSED */;\n        this._overlayRef.dispose();\n    }\n    /**\n     * Fetches the position strategy object from the overlay ref.\n     * @private\n     * @return {?}\n     */\n    _getPositionStrategy() {\n        return (/** @type {?} */ (this._overlayRef.getConfig().positionStrategy));\n    }\n}\nif (false) {\n    /**\n     * The instance of component opened into the dialog.\n     * @type {?}\n     */\n    MatDialogRef.prototype.componentInstance;\n    /**\n     * Whether the user is allowed to close the dialog.\n     * @type {?}\n     */\n    MatDialogRef.prototype.disableClose;\n    /**\n     * Subject for notifying the user that the dialog has finished opening.\n     * @type {?}\n     * @private\n     */\n    MatDialogRef.prototype._afterOpened;\n    /**\n     * Subject for notifying the user that the dialog has finished closing.\n     * @type {?}\n     * @private\n     */\n    MatDialogRef.prototype._afterClosed;\n    /**\n     * Subject for notifying the user that the dialog has started closing.\n     * @type {?}\n     * @private\n     */\n    MatDialogRef.prototype._beforeClosed;\n    /**\n     * Result to be passed to afterClosed.\n     * @type {?}\n     * @private\n     */\n    MatDialogRef.prototype._result;\n    /**\n     * Handle to the timeout that's running as a fallback in case the exit animation doesn't fire.\n     * @type {?}\n     * @private\n     */\n    MatDialogRef.prototype._closeFallbackTimeout;\n    /**\n     * Current state of the dialog.\n     * @type {?}\n     * @private\n     */\n    MatDialogRef.prototype._state;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialogRef.prototype._overlayRef;\n    /** @type {?} */\n    MatDialogRef.prototype._containerInstance;\n    /** @type {?} */\n    MatDialogRef.prototype.id;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/dialog/dialog.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Injection token that can be used to access the data that was passed in to a dialog.\n * @type {?}\n */\nconst MAT_DIALOG_DATA = new InjectionToken('MatDialogData');\n/**\n * Injection token that can be used to specify default dialog options.\n * @type {?}\n */\nconst MAT_DIALOG_DEFAULT_OPTIONS = new InjectionToken('mat-dialog-default-options');\n/**\n * Injection token that determines the scroll handling while the dialog is open.\n * @type {?}\n */\nconst MAT_DIALOG_SCROLL_STRATEGY = new InjectionToken('mat-dialog-scroll-strategy');\n/**\n * \\@docs-private\n * @param {?} overlay\n * @return {?}\n */\nfunction MAT_DIALOG_SCROLL_STRATEGY_FACTORY(overlay) {\n    return (/**\n     * @return {?}\n     */\n    () => overlay.scrollStrategies.block());\n}\n/**\n * \\@docs-private\n * @param {?} overlay\n * @return {?}\n */\nfunction MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {\n    return (/**\n     * @return {?}\n     */\n    () => overlay.scrollStrategies.block());\n}\n/**\n * \\@docs-private\n * @type {?}\n */\nconst MAT_DIALOG_SCROLL_STRATEGY_PROVIDER = {\n    provide: MAT_DIALOG_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY,\n};\n/**\n * Service to open Material Design modal dialogs.\n */\nclass MatDialog {\n    /**\n     * @param {?} _overlay\n     * @param {?} _injector\n     * @param {?} _location\n     * @param {?} _defaultOptions\n     * @param {?} scrollStrategy\n     * @param {?} _parentDialog\n     * @param {?} _overlayContainer\n     */\n    constructor(_overlay, _injector, \n    /**\n     * @deprecated `_location` parameter to be removed.\n     * @breaking-change 10.0.0\n     */\n    _location, _defaultOptions, scrollStrategy, _parentDialog, _overlayContainer) {\n        this._overlay = _overlay;\n        this._injector = _injector;\n        this._defaultOptions = _defaultOptions;\n        this._parentDialog = _parentDialog;\n        this._overlayContainer = _overlayContainer;\n        this._openDialogsAtThisLevel = [];\n        this._afterAllClosedAtThisLevel = new Subject();\n        this._afterOpenedAtThisLevel = new Subject();\n        this._ariaHiddenElements = new Map();\n        // TODO (jelbourn): tighten the typing right-hand side of this expression.\n        /**\n         * Stream that emits when all open dialog have finished closing.\n         * Will emit on subscribe if there are no open dialogs to begin with.\n         */\n        this.afterAllClosed = (/** @type {?} */ (defer((/**\n         * @return {?}\n         */\n        () => this.openDialogs.length ?\n            this._afterAllClosed :\n            this._afterAllClosed.pipe(startWith(undefined))))));\n        this._scrollStrategy = scrollStrategy;\n    }\n    /**\n     * Keeps track of the currently-open dialogs.\n     * @return {?}\n     */\n    get openDialogs() {\n        return this._parentDialog ? this._parentDialog.openDialogs : this._openDialogsAtThisLevel;\n    }\n    /**\n     * Stream that emits when a dialog has been opened.\n     * @return {?}\n     */\n    get afterOpened() {\n        return this._parentDialog ? this._parentDialog.afterOpened : this._afterOpenedAtThisLevel;\n    }\n    /**\n     * @return {?}\n     */\n    get _afterAllClosed() {\n        /** @type {?} */\n        const parent = this._parentDialog;\n        return parent ? parent._afterAllClosed : this._afterAllClosedAtThisLevel;\n    }\n    /**\n     * Opens a modal dialog containing the given component.\n     * @template T, D, R\n     * @param {?} componentOrTemplateRef Type of the component to load into the dialog,\n     *     or a TemplateRef to instantiate as the dialog content.\n     * @param {?=} config Extra configuration options.\n     * @return {?} Reference to the newly-opened dialog.\n     */\n    open(componentOrTemplateRef, config) {\n        config = _applyConfigDefaults(config, this._defaultOptions || new MatDialogConfig());\n        if (config.id && this.getDialogById(config.id)) {\n            throw Error(`Dialog with id \"${config.id}\" exists already. The dialog id must be unique.`);\n        }\n        /** @type {?} */\n        const overlayRef = this._createOverlay(config);\n        /** @type {?} */\n        const dialogContainer = this._attachDialogContainer(overlayRef, config);\n        /** @type {?} */\n        const dialogRef = this._attachDialogContent(componentOrTemplateRef, dialogContainer, overlayRef, config);\n        // If this is the first dialog that we're opening, hide all the non-overlay content.\n        if (!this.openDialogs.length) {\n            this._hideNonDialogContentFromAssistiveTechnology();\n        }\n        this.openDialogs.push(dialogRef);\n        dialogRef.afterClosed().subscribe((/**\n         * @return {?}\n         */\n        () => this._removeOpenDialog(dialogRef)));\n        this.afterOpened.next(dialogRef);\n        return dialogRef;\n    }\n    /**\n     * Closes all of the currently-open dialogs.\n     * @return {?}\n     */\n    closeAll() {\n        this._closeDialogs(this.openDialogs);\n    }\n    /**\n     * Finds an open dialog by its id.\n     * @param {?} id ID to use when looking up the dialog.\n     * @return {?}\n     */\n    getDialogById(id) {\n        return this.openDialogs.find((/**\n         * @param {?} dialog\n         * @return {?}\n         */\n        dialog => dialog.id === id));\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        // Only close the dialogs at this level on destroy\n        // since the parent service may still be active.\n        this._closeDialogs(this._openDialogsAtThisLevel);\n        this._afterAllClosedAtThisLevel.complete();\n        this._afterOpenedAtThisLevel.complete();\n    }\n    /**\n     * Creates the overlay into which the dialog will be loaded.\n     * @private\n     * @param {?} config The dialog configuration.\n     * @return {?} A promise resolving to the OverlayRef for the created overlay.\n     */\n    _createOverlay(config) {\n        /** @type {?} */\n        const overlayConfig = this._getOverlayConfig(config);\n        return this._overlay.create(overlayConfig);\n    }\n    /**\n     * Creates an overlay config from a dialog config.\n     * @private\n     * @param {?} dialogConfig The dialog configuration.\n     * @return {?} The overlay configuration.\n     */\n    _getOverlayConfig(dialogConfig) {\n        /** @type {?} */\n        const state = new OverlayConfig({\n            positionStrategy: this._overlay.position().global(),\n            scrollStrategy: dialogConfig.scrollStrategy || this._scrollStrategy(),\n            panelClass: dialogConfig.panelClass,\n            hasBackdrop: dialogConfig.hasBackdrop,\n            direction: dialogConfig.direction,\n            minWidth: dialogConfig.minWidth,\n            minHeight: dialogConfig.minHeight,\n            maxWidth: dialogConfig.maxWidth,\n            maxHeight: dialogConfig.maxHeight,\n            disposeOnNavigation: dialogConfig.closeOnNavigation\n        });\n        if (dialogConfig.backdropClass) {\n            state.backdropClass = dialogConfig.backdropClass;\n        }\n        return state;\n    }\n    /**\n     * Attaches an MatDialogContainer to a dialog's already-created overlay.\n     * @private\n     * @param {?} overlay Reference to the dialog's underlying overlay.\n     * @param {?} config The dialog configuration.\n     * @return {?} A promise resolving to a ComponentRef for the attached container.\n     */\n    _attachDialogContainer(overlay, config) {\n        /** @type {?} */\n        const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;\n        /** @type {?} */\n        const injector = Injector.create({\n            parent: userInjector || this._injector,\n            providers: [{ provide: MatDialogConfig, useValue: config }]\n        });\n        /** @type {?} */\n        const containerPortal = new ComponentPortal(MatDialogContainer, config.viewContainerRef, injector, config.componentFactoryResolver);\n        /** @type {?} */\n        const containerRef = overlay.attach(containerPortal);\n        return containerRef.instance;\n    }\n    /**\n     * Attaches the user-provided component to the already-created MatDialogContainer.\n     * @private\n     * @template T, R\n     * @param {?} componentOrTemplateRef The type of component being loaded into the dialog,\n     *     or a TemplateRef to instantiate as the content.\n     * @param {?} dialogContainer Reference to the wrapping MatDialogContainer.\n     * @param {?} overlayRef Reference to the overlay in which the dialog resides.\n     * @param {?} config The dialog configuration.\n     * @return {?} A promise resolving to the MatDialogRef that should be returned to the user.\n     */\n    _attachDialogContent(componentOrTemplateRef, dialogContainer, overlayRef, config) {\n        // Create a reference to the dialog we're creating in order to give the user a handle\n        // to modify and close it.\n        /** @type {?} */\n        const dialogRef = new MatDialogRef(overlayRef, dialogContainer, config.id);\n        if (componentOrTemplateRef instanceof TemplateRef) {\n            dialogContainer.attachTemplatePortal(new TemplatePortal(componentOrTemplateRef, (/** @type {?} */ (null)), (/** @type {?} */ ({ $implicit: config.data, dialogRef }))));\n        }\n        else {\n            /** @type {?} */\n            const injector = this._createInjector(config, dialogRef, dialogContainer);\n            /** @type {?} */\n            const contentRef = dialogContainer.attachComponentPortal(new ComponentPortal(componentOrTemplateRef, config.viewContainerRef, injector));\n            dialogRef.componentInstance = contentRef.instance;\n        }\n        dialogRef\n            .updateSize(config.width, config.height)\n            .updatePosition(config.position);\n        return dialogRef;\n    }\n    /**\n     * Creates a custom injector to be used inside the dialog. This allows a component loaded inside\n     * of a dialog to close itself and, optionally, to return a value.\n     * @private\n     * @template T\n     * @param {?} config Config object that is used to construct the dialog.\n     * @param {?} dialogRef Reference to the dialog.\n     * @param {?} dialogContainer\n     * @return {?} The custom injector that can be used inside the dialog.\n     */\n    _createInjector(config, dialogRef, dialogContainer) {\n        /** @type {?} */\n        const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;\n        // The MatDialogContainer is injected in the portal as the MatDialogContainer and the dialog's\n        // content are created out of the same ViewContainerRef and as such, are siblings for injector\n        // purposes. To allow the hierarchy that is expected, the MatDialogContainer is explicitly\n        // added to the injection tokens.\n        /** @type {?} */\n        const providers = [\n            { provide: MatDialogContainer, useValue: dialogContainer },\n            { provide: MAT_DIALOG_DATA, useValue: config.data },\n            { provide: MatDialogRef, useValue: dialogRef }\n        ];\n        if (config.direction &&\n            (!userInjector || !userInjector.get(Directionality, null))) {\n            providers.push({\n                provide: Directionality,\n                useValue: { value: config.direction, change: of() }\n            });\n        }\n        return Injector.create({ parent: userInjector || this._injector, providers });\n    }\n    /**\n     * Removes a dialog from the array of open dialogs.\n     * @private\n     * @param {?} dialogRef Dialog to be removed.\n     * @return {?}\n     */\n    _removeOpenDialog(dialogRef) {\n        /** @type {?} */\n        const index = this.openDialogs.indexOf(dialogRef);\n        if (index > -1) {\n            this.openDialogs.splice(index, 1);\n            // If all the dialogs were closed, remove/restore the `aria-hidden`\n            // to a the siblings and emit to the `afterAllClosed` stream.\n            if (!this.openDialogs.length) {\n                this._ariaHiddenElements.forEach((/**\n                 * @param {?} previousValue\n                 * @param {?} element\n                 * @return {?}\n                 */\n                (previousValue, element) => {\n                    if (previousValue) {\n                        element.setAttribute('aria-hidden', previousValue);\n                    }\n                    else {\n                        element.removeAttribute('aria-hidden');\n                    }\n                }));\n                this._ariaHiddenElements.clear();\n                this._afterAllClosed.next();\n            }\n        }\n    }\n    /**\n     * Hides all of the content that isn't an overlay from assistive technology.\n     * @private\n     * @return {?}\n     */\n    _hideNonDialogContentFromAssistiveTechnology() {\n        /** @type {?} */\n        const overlayContainer = this._overlayContainer.getContainerElement();\n        // Ensure that the overlay container is attached to the DOM.\n        if (overlayContainer.parentElement) {\n            /** @type {?} */\n            const siblings = overlayContainer.parentElement.children;\n            for (let i = siblings.length - 1; i > -1; i--) {\n                /** @type {?} */\n                let sibling = siblings[i];\n                if (sibling !== overlayContainer &&\n                    sibling.nodeName !== 'SCRIPT' &&\n                    sibling.nodeName !== 'STYLE' &&\n                    !sibling.hasAttribute('aria-live')) {\n                    this._ariaHiddenElements.set(sibling, sibling.getAttribute('aria-hidden'));\n                    sibling.setAttribute('aria-hidden', 'true');\n                }\n            }\n        }\n    }\n    /**\n     * Closes all of the dialogs in an array.\n     * @private\n     * @param {?} dialogs\n     * @return {?}\n     */\n    _closeDialogs(dialogs) {\n        /** @type {?} */\n        let i = dialogs.length;\n        while (i--) {\n            // The `_openDialogs` property isn't updated after close until the rxjs subscription\n            // runs on the next microtask, in addition to modifying the array as we're going\n            // through it. We loop through all of them and call close without assuming that\n            // they'll be removed from the list instantaneously.\n            dialogs[i].close();\n        }\n    }\n}\nMatDialog.ɵfac = function MatDialog_Factory(t) { return new (t || MatDialog)(ɵngcc0.ɵɵinject(ɵngcc3.Overlay), ɵngcc0.ɵɵinject(ɵngcc0.Injector), ɵngcc0.ɵɵinject(ɵngcc4.Location, 8), ɵngcc0.ɵɵinject(MAT_DIALOG_DEFAULT_OPTIONS, 8), ɵngcc0.ɵɵinject(MAT_DIALOG_SCROLL_STRATEGY), ɵngcc0.ɵɵinject(MatDialog, 12), ɵngcc0.ɵɵinject(ɵngcc3.OverlayContainer)); };\nMatDialog.ɵprov = ɵngcc0.ɵɵdefineInjectable({ token: MatDialog, factory: MatDialog.ɵfac });\n/** @nocollapse */\nMatDialog.ctorParameters = () => [\n    { type: Overlay },\n    { type: Injector },\n    { type: Location, decorators: [{ type: Optional }] },\n    { type: MatDialogConfig, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DIALOG_DEFAULT_OPTIONS,] }] },\n    { type: undefined, decorators: [{ type: Inject, args: [MAT_DIALOG_SCROLL_STRATEGY,] }] },\n    { type: MatDialog, decorators: [{ type: Optional }, { type: SkipSelf }] },\n    { type: OverlayContainer }\n];\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatDialog, [{\n        type: Injectable\n    }], function () { return [{ type: ɵngcc3.Overlay }, { type: ɵngcc0.Injector }, { type: ɵngcc4.Location, decorators: [{\n                type: Optional\n            }] }, { type: MatDialogConfig, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MAT_DIALOG_DEFAULT_OPTIONS]\n            }] }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [MAT_DIALOG_SCROLL_STRATEGY]\n            }] }, { type: MatDialog, decorators: [{\n                type: Optional\n            }, {\n                type: SkipSelf\n            }] }, { type: ɵngcc3.OverlayContainer }]; }, null); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialog.prototype._openDialogsAtThisLevel;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialog.prototype._afterAllClosedAtThisLevel;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialog.prototype._afterOpenedAtThisLevel;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialog.prototype._ariaHiddenElements;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialog.prototype._scrollStrategy;\n    /**\n     * Stream that emits when all open dialog have finished closing.\n     * Will emit on subscribe if there are no open dialogs to begin with.\n     * @type {?}\n     */\n    MatDialog.prototype.afterAllClosed;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialog.prototype._overlay;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialog.prototype._injector;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialog.prototype._defaultOptions;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialog.prototype._parentDialog;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialog.prototype._overlayContainer;\n}\n/**\n * Applies default options to the dialog config.\n * @param {?=} config Config to be modified.\n * @param {?=} defaultOptions Default options provided.\n * @return {?} The new configuration object.\n */\nfunction _applyConfigDefaults(config, defaultOptions) {\n    return Object.assign(Object.assign({}, defaultOptions), config);\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/dialog/dialog-content-directives.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Counter used to generate unique IDs for dialog elements.\n * @type {?}\n */\nlet dialogElementUid = 0;\n/**\n * Button that will close the current dialog.\n */\nclass MatDialogClose {\n    /**\n     * @param {?} dialogRef\n     * @param {?} _elementRef\n     * @param {?} _dialog\n     */\n    constructor(dialogRef, _elementRef, _dialog) {\n        this.dialogRef = dialogRef;\n        this._elementRef = _elementRef;\n        this._dialog = _dialog;\n        /**\n         * Default to \"button\" to prevents accidental form submits.\n         */\n        this.type = 'button';\n    }\n    /**\n     * @return {?}\n     */\n    ngOnInit() {\n        if (!this.dialogRef) {\n            // When this directive is included in a dialog via TemplateRef (rather than being\n            // in a Component), the DialogRef isn't available via injection because embedded\n            // views cannot be given a custom injector. Instead, we look up the DialogRef by\n            // ID. This must occur in `onInit`, as the ID binding for the dialog container won't\n            // be resolved at constructor time.\n            this.dialogRef = (/** @type {?} */ (getClosestDialog(this._elementRef, this._dialog.openDialogs)));\n        }\n    }\n    /**\n     * @param {?} changes\n     * @return {?}\n     */\n    ngOnChanges(changes) {\n        /** @type {?} */\n        const proxiedChange = changes['_matDialogClose'] || changes['_matDialogCloseResult'];\n        if (proxiedChange) {\n            this.dialogResult = proxiedChange.currentValue;\n        }\n    }\n}\nMatDialogClose.ɵfac = function MatDialogClose_Factory(t) { return new (t || MatDialogClose)(ɵngcc0.ɵɵdirectiveInject(MatDialogRef, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(MatDialog)); };\nMatDialogClose.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatDialogClose, selectors: [[\"\", \"mat-dialog-close\", \"\"], [\"\", \"matDialogClose\", \"\"]], hostVars: 2, hostBindings: function MatDialogClose_HostBindings(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵlistener(\"click\", function MatDialogClose_click_HostBindingHandler() { return ctx.dialogRef.close(ctx.dialogResult); });\n    } if (rf & 2) {\n        ɵngcc0.ɵɵattribute(\"aria-label\", ctx.ariaLabel || null)(\"type\", ctx.type);\n    } }, inputs: { type: \"type\", dialogResult: [\"mat-dialog-close\", \"dialogResult\"], ariaLabel: [\"aria-label\", \"ariaLabel\"], _matDialogClose: [\"matDialogClose\", \"_matDialogClose\"] }, exportAs: [\"matDialogClose\"], features: [ɵngcc0.ɵɵNgOnChangesFeature] });\n/** @nocollapse */\nMatDialogClose.ctorParameters = () => [\n    { type: MatDialogRef, decorators: [{ type: Optional }] },\n    { type: ElementRef },\n    { type: MatDialog }\n];\nMatDialogClose.propDecorators = {\n    ariaLabel: [{ type: Input, args: ['aria-label',] }],\n    type: [{ type: Input }],\n    dialogResult: [{ type: Input, args: ['mat-dialog-close',] }],\n    _matDialogClose: [{ type: Input, args: ['matDialogClose',] }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatDialogClose, [{\n        type: Directive,\n        args: [{\n                selector: '[mat-dialog-close], [matDialogClose]',\n                exportAs: 'matDialogClose',\n                host: {\n                    '(click)': 'dialogRef.close(dialogResult)',\n                    '[attr.aria-label]': 'ariaLabel || null',\n                    '[attr.type]': 'type'\n                }\n            }]\n    }], function () { return [{ type: MatDialogRef, decorators: [{\n                type: Optional\n            }] }, { type: ɵngcc0.ElementRef }, { type: MatDialog }]; }, { type: [{\n            type: Input\n        }], dialogResult: [{\n            type: Input,\n            args: ['mat-dialog-close']\n        }], ariaLabel: [{\n            type: Input,\n            args: ['aria-label']\n        }], _matDialogClose: [{\n            type: Input,\n            args: ['matDialogClose']\n        }] }); })();\nif (false) {\n    /**\n     * Screenreader label for the button.\n     * @type {?}\n     */\n    MatDialogClose.prototype.ariaLabel;\n    /**\n     * Default to \"button\" to prevents accidental form submits.\n     * @type {?}\n     */\n    MatDialogClose.prototype.type;\n    /**\n     * Dialog close input.\n     * @type {?}\n     */\n    MatDialogClose.prototype.dialogResult;\n    /** @type {?} */\n    MatDialogClose.prototype._matDialogClose;\n    /** @type {?} */\n    MatDialogClose.prototype.dialogRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialogClose.prototype._elementRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialogClose.prototype._dialog;\n}\n/**\n * Title of a dialog element. Stays fixed to the top of the dialog when scrolling.\n */\nclass MatDialogTitle {\n    /**\n     * @param {?} _dialogRef\n     * @param {?} _elementRef\n     * @param {?} _dialog\n     */\n    constructor(_dialogRef, _elementRef, _dialog) {\n        this._dialogRef = _dialogRef;\n        this._elementRef = _elementRef;\n        this._dialog = _dialog;\n        this.id = `mat-dialog-title-${dialogElementUid++}`;\n    }\n    /**\n     * @return {?}\n     */\n    ngOnInit() {\n        if (!this._dialogRef) {\n            this._dialogRef = (/** @type {?} */ (getClosestDialog(this._elementRef, this._dialog.openDialogs)));\n        }\n        if (this._dialogRef) {\n            Promise.resolve().then((/**\n             * @return {?}\n             */\n            () => {\n                /** @type {?} */\n                const container = this._dialogRef._containerInstance;\n                if (container && !container._ariaLabelledBy) {\n                    container._ariaLabelledBy = this.id;\n                }\n            }));\n        }\n    }\n}\nMatDialogTitle.ɵfac = function MatDialogTitle_Factory(t) { return new (t || MatDialogTitle)(ɵngcc0.ɵɵdirectiveInject(MatDialogRef, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(MatDialog)); };\nMatDialogTitle.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatDialogTitle, selectors: [[\"\", \"mat-dialog-title\", \"\"], [\"\", \"matDialogTitle\", \"\"]], hostAttrs: [1, \"mat-dialog-title\"], hostVars: 1, hostBindings: function MatDialogTitle_HostBindings(rf, ctx) { if (rf & 2) {\n        ɵngcc0.ɵɵhostProperty(\"id\", ctx.id);\n    } }, inputs: { id: \"id\" }, exportAs: [\"matDialogTitle\"] });\n/** @nocollapse */\nMatDialogTitle.ctorParameters = () => [\n    { type: MatDialogRef, decorators: [{ type: Optional }] },\n    { type: ElementRef },\n    { type: MatDialog }\n];\nMatDialogTitle.propDecorators = {\n    id: [{ type: Input }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatDialogTitle, [{\n        type: Directive,\n        args: [{\n                selector: '[mat-dialog-title], [matDialogTitle]',\n                exportAs: 'matDialogTitle',\n                host: {\n                    'class': 'mat-dialog-title',\n                    '[id]': 'id'\n                }\n            }]\n    }], function () { return [{ type: MatDialogRef, decorators: [{\n                type: Optional\n            }] }, { type: ɵngcc0.ElementRef }, { type: MatDialog }]; }, { id: [{\n            type: Input\n        }] }); })();\nif (false) {\n    /** @type {?} */\n    MatDialogTitle.prototype.id;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialogTitle.prototype._dialogRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialogTitle.prototype._elementRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDialogTitle.prototype._dialog;\n}\n/**\n * Scrollable content container of a dialog.\n */\nclass MatDialogContent {\n}\nMatDialogContent.ɵfac = function MatDialogContent_Factory(t) { return new (t || MatDialogContent)(); };\nMatDialogContent.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatDialogContent, selectors: [[\"\", \"mat-dialog-content\", \"\"], [\"mat-dialog-content\"], [\"\", \"matDialogContent\", \"\"]], hostAttrs: [1, \"mat-dialog-content\"] });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatDialogContent, [{\n        type: Directive,\n        args: [{\n                selector: `[mat-dialog-content], mat-dialog-content, [matDialogContent]`,\n                host: { 'class': 'mat-dialog-content' }\n            }]\n    }], null, null); })();\n/**\n * Container for the bottom action buttons in a dialog.\n * Stays fixed to the bottom when scrolling.\n */\nclass MatDialogActions {\n}\nMatDialogActions.ɵfac = function MatDialogActions_Factory(t) { return new (t || MatDialogActions)(); };\nMatDialogActions.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatDialogActions, selectors: [[\"\", \"mat-dialog-actions\", \"\"], [\"mat-dialog-actions\"], [\"\", \"matDialogActions\", \"\"]], hostAttrs: [1, \"mat-dialog-actions\"] });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatDialogActions, [{\n        type: Directive,\n        args: [{\n                selector: `[mat-dialog-actions], mat-dialog-actions, [matDialogActions]`,\n                host: { 'class': 'mat-dialog-actions' }\n            }]\n    }], null, null); })();\n/**\n * Finds the closest MatDialogRef to an element by looking at the DOM.\n * @param {?} element Element relative to which to look for a dialog.\n * @param {?} openDialogs References to the currently-open dialogs.\n * @return {?}\n */\nfunction getClosestDialog(element, openDialogs) {\n    /** @type {?} */\n    let parent = element.nativeElement.parentElement;\n    while (parent && !parent.classList.contains('mat-dialog-container')) {\n        parent = parent.parentElement;\n    }\n    return parent ? openDialogs.find((/**\n     * @param {?} dialog\n     * @return {?}\n     */\n    dialog => dialog.id === (/** @type {?} */ (parent)).id)) : null;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/dialog/dialog-module.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass MatDialogModule {\n}\nMatDialogModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: MatDialogModule });\nMatDialogModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function MatDialogModule_Factory(t) { return new (t || MatDialogModule)(); }, providers: [\n        MatDialog,\n        MAT_DIALOG_SCROLL_STRATEGY_PROVIDER,\n    ], imports: [[\n            OverlayModule,\n            PortalModule,\n            MatCommonModule,\n        ],\n        MatCommonModule] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(MatDialogModule, { declarations: function () { return [MatDialogContainer,\n        MatDialogClose,\n        MatDialogTitle,\n        MatDialogActions,\n        MatDialogContent]; }, imports: function () { return [OverlayModule,\n        PortalModule,\n        MatCommonModule]; }, exports: function () { return [MatDialogContainer,\n        MatDialogClose,\n        MatDialogTitle,\n        MatDialogContent,\n        MatDialogActions,\n        MatCommonModule]; } }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatDialogModule, [{\n        type: NgModule,\n        args: [{\n                imports: [\n                    OverlayModule,\n                    PortalModule,\n                    MatCommonModule,\n                ],\n                exports: [\n                    MatDialogContainer,\n                    MatDialogClose,\n                    MatDialogTitle,\n                    MatDialogContent,\n                    MatDialogActions,\n                    MatCommonModule,\n                ],\n                declarations: [\n                    MatDialogContainer,\n                    MatDialogClose,\n                    MatDialogTitle,\n                    MatDialogActions,\n                    MatDialogContent,\n                ],\n                providers: [\n                    MatDialog,\n                    MAT_DIALOG_SCROLL_STRATEGY_PROVIDER,\n                ],\n                entryComponents: [MatDialogContainer]\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/dialog/public-api.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 { MAT_DIALOG_DATA, MAT_DIALOG_DEFAULT_OPTIONS, MAT_DIALOG_SCROLL_STRATEGY, MAT_DIALOG_SCROLL_STRATEGY_FACTORY, MAT_DIALOG_SCROLL_STRATEGY_PROVIDER, MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY, MatDialog, MatDialogActions, MatDialogClose, MatDialogConfig, MatDialogContainer, MatDialogContent, MatDialogModule, MatDialogRef, MatDialogTitle, matDialogAnimations, throwMatDialogContentAlreadyAttachedError };\n\n//# sourceMappingURL=dialog.js.map","import { CommonModule } from '@angular/common';\nimport { Directive, Input, InjectionToken, Component, ViewEncapsulation, ChangeDetectionStrategy, ElementRef, ChangeDetectorRef, Optional, Inject, NgZone, ViewChild, ContentChild, ContentChildren, NgModule } from '@angular/core';\nimport { ObserversModule } from '@angular/cdk/observers';\nimport { Directionality } from '@angular/cdk/bidi';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { mixinColor, MAT_LABEL_GLOBAL_OPTIONS } from '@angular/material/core';\nimport { Subject, merge, fromEvent } from 'rxjs';\nimport { startWith, takeUntil, take } from 'rxjs/operators';\nimport { trigger, state, style, transition, animate } from '@angular/animations';\nimport { Platform } from '@angular/cdk/platform';\nimport { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/form-field/error.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nimport * as ɵngcc0 from '@angular/core';\nimport * as ɵngcc1 from '@angular/cdk/bidi';\nimport * as ɵngcc2 from '@angular/cdk/platform';\nimport * as ɵngcc3 from '@angular/common';\nimport * as ɵngcc4 from '@angular/cdk/observers';\n\nconst _c0 = [\"underline\"];\nconst _c1 = [\"connectionContainer\"];\nconst _c2 = [\"inputContainer\"];\nconst _c3 = [\"label\"];\nfunction MatFormField_ng_container_3_Template(rf, ctx) { if (rf & 1) {\n    ɵngcc0.ɵɵelementContainerStart(0);\n    ɵngcc0.ɵɵelementStart(1, \"div\", 14);\n    ɵngcc0.ɵɵelement(2, \"div\", 15);\n    ɵngcc0.ɵɵelement(3, \"div\", 16);\n    ɵngcc0.ɵɵelement(4, \"div\", 17);\n    ɵngcc0.ɵɵelementEnd();\n    ɵngcc0.ɵɵelementStart(5, \"div\", 18);\n    ɵngcc0.ɵɵelement(6, \"div\", 15);\n    ɵngcc0.ɵɵelement(7, \"div\", 16);\n    ɵngcc0.ɵɵelement(8, \"div\", 17);\n    ɵngcc0.ɵɵelementEnd();\n    ɵngcc0.ɵɵelementContainerEnd();\n} }\nfunction MatFormField_div_4_Template(rf, ctx) { if (rf & 1) {\n    ɵngcc0.ɵɵelementStart(0, \"div\", 19);\n    ɵngcc0.ɵɵprojection(1, 1);\n    ɵngcc0.ɵɵelementEnd();\n} }\nfunction MatFormField_label_9_ng_container_2_Template(rf, ctx) { if (rf & 1) {\n    ɵngcc0.ɵɵelementContainerStart(0);\n    ɵngcc0.ɵɵprojection(1, 2);\n    ɵngcc0.ɵɵelementStart(2, \"span\");\n    ɵngcc0.ɵɵtext(3);\n    ɵngcc0.ɵɵelementEnd();\n    ɵngcc0.ɵɵelementContainerEnd();\n} if (rf & 2) {\n    const ctx_r10 = ɵngcc0.ɵɵnextContext(2);\n    ɵngcc0.ɵɵadvance(3);\n    ɵngcc0.ɵɵtextInterpolate(ctx_r10._control.placeholder);\n} }\nfunction MatFormField_label_9_3_Template(rf, ctx) { if (rf & 1) {\n    ɵngcc0.ɵɵprojection(0, 3, [\"*ngSwitchCase\", \"true\"]);\n} }\nfunction MatFormField_label_9_span_4_Template(rf, ctx) { if (rf & 1) {\n    ɵngcc0.ɵɵelementStart(0, \"span\", 23);\n    ɵngcc0.ɵɵtext(1, \" *\");\n    ɵngcc0.ɵɵelementEnd();\n} }\nfunction MatFormField_label_9_Template(rf, ctx) { if (rf & 1) {\n    const _r14 = ɵngcc0.ɵɵgetCurrentView();\n    ɵngcc0.ɵɵelementStart(0, \"label\", 20, 21);\n    ɵngcc0.ɵɵlistener(\"cdkObserveContent\", function MatFormField_label_9_Template_label_cdkObserveContent_0_listener() { ɵngcc0.ɵɵrestoreView(_r14); const ctx_r13 = ɵngcc0.ɵɵnextContext(); return ctx_r13.updateOutlineGap(); });\n    ɵngcc0.ɵɵtemplate(2, MatFormField_label_9_ng_container_2_Template, 4, 1, \"ng-container\", 12);\n    ɵngcc0.ɵɵtemplate(3, MatFormField_label_9_3_Template, 1, 0, undefined, 12);\n    ɵngcc0.ɵɵtemplate(4, MatFormField_label_9_span_4_Template, 2, 0, \"span\", 22);\n    ɵngcc0.ɵɵelementEnd();\n} if (rf & 2) {\n    const ctx_r4 = ɵngcc0.ɵɵnextContext();\n    ɵngcc0.ɵɵclassProp(\"mat-empty\", ctx_r4._control.empty && !ctx_r4._shouldAlwaysFloat)(\"mat-form-field-empty\", ctx_r4._control.empty && !ctx_r4._shouldAlwaysFloat)(\"mat-accent\", ctx_r4.color == \"accent\")(\"mat-warn\", ctx_r4.color == \"warn\");\n    ɵngcc0.ɵɵproperty(\"cdkObserveContentDisabled\", ctx_r4.appearance != \"outline\")(\"id\", ctx_r4._labelId)(\"ngSwitch\", ctx_r4._hasLabel());\n    ɵngcc0.ɵɵattribute(\"for\", ctx_r4._control.id)(\"aria-owns\", ctx_r4._control.id);\n    ɵngcc0.ɵɵadvance(2);\n    ɵngcc0.ɵɵproperty(\"ngSwitchCase\", false);\n    ɵngcc0.ɵɵadvance(1);\n    ɵngcc0.ɵɵproperty(\"ngSwitchCase\", true);\n    ɵngcc0.ɵɵadvance(1);\n    ɵngcc0.ɵɵproperty(\"ngIf\", !ctx_r4.hideRequiredMarker && ctx_r4._control.required && !ctx_r4._control.disabled);\n} }\nfunction MatFormField_div_10_Template(rf, ctx) { if (rf & 1) {\n    ɵngcc0.ɵɵelementStart(0, \"div\", 24);\n    ɵngcc0.ɵɵprojection(1, 4);\n    ɵngcc0.ɵɵelementEnd();\n} }\nfunction MatFormField_div_11_Template(rf, ctx) { if (rf & 1) {\n    ɵngcc0.ɵɵelementStart(0, \"div\", 25, 26);\n    ɵngcc0.ɵɵelement(2, \"span\", 27);\n    ɵngcc0.ɵɵelementEnd();\n} if (rf & 2) {\n    const ctx_r6 = ɵngcc0.ɵɵnextContext();\n    ɵngcc0.ɵɵadvance(2);\n    ɵngcc0.ɵɵclassProp(\"mat-accent\", ctx_r6.color == \"accent\")(\"mat-warn\", ctx_r6.color == \"warn\");\n} }\nfunction MatFormField_div_13_Template(rf, ctx) { if (rf & 1) {\n    ɵngcc0.ɵɵelementStart(0, \"div\");\n    ɵngcc0.ɵɵprojection(1, 5);\n    ɵngcc0.ɵɵelementEnd();\n} if (rf & 2) {\n    const ctx_r7 = ɵngcc0.ɵɵnextContext();\n    ɵngcc0.ɵɵproperty(\"@transitionMessages\", ctx_r7._subscriptAnimationState);\n} }\nfunction MatFormField_div_14_div_1_Template(rf, ctx) { if (rf & 1) {\n    ɵngcc0.ɵɵelementStart(0, \"div\", 31);\n    ɵngcc0.ɵɵtext(1);\n    ɵngcc0.ɵɵelementEnd();\n} if (rf & 2) {\n    const ctx_r16 = ɵngcc0.ɵɵnextContext(2);\n    ɵngcc0.ɵɵproperty(\"id\", ctx_r16._hintLabelId);\n    ɵngcc0.ɵɵadvance(1);\n    ɵngcc0.ɵɵtextInterpolate(ctx_r16.hintLabel);\n} }\nfunction MatFormField_div_14_Template(rf, ctx) { if (rf & 1) {\n    ɵngcc0.ɵɵelementStart(0, \"div\", 28);\n    ɵngcc0.ɵɵtemplate(1, MatFormField_div_14_div_1_Template, 2, 2, \"div\", 29);\n    ɵngcc0.ɵɵprojection(2, 6);\n    ɵngcc0.ɵɵelement(3, \"div\", 30);\n    ɵngcc0.ɵɵprojection(4, 7);\n    ɵngcc0.ɵɵelementEnd();\n} if (rf & 2) {\n    const ctx_r8 = ɵngcc0.ɵɵnextContext();\n    ɵngcc0.ɵɵproperty(\"@transitionMessages\", ctx_r8._subscriptAnimationState);\n    ɵngcc0.ɵɵadvance(1);\n    ɵngcc0.ɵɵproperty(\"ngIf\", ctx_r8.hintLabel);\n} }\nconst _c4 = [\"*\", [[\"\", \"matPrefix\", \"\"]], [[\"mat-placeholder\"]], [[\"mat-label\"]], [[\"\", \"matSuffix\", \"\"]], [[\"mat-error\"]], [[\"mat-hint\", 3, \"align\", \"end\"]], [[\"mat-hint\", \"align\", \"end\"]]];\nconst _c5 = [\"*\", \"[matPrefix]\", \"mat-placeholder\", \"mat-label\", \"[matSuffix]\", \"mat-error\", \"mat-hint:not([align='end'])\", \"mat-hint[align='end']\"];\nlet nextUniqueId = 0;\n/**\n * Single error message to be shown underneath the form field.\n */\nclass MatError {\n    constructor() {\n        this.id = `mat-error-${nextUniqueId++}`;\n    }\n}\nMatError.ɵfac = function MatError_Factory(t) { return new (t || MatError)(); };\nMatError.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatError, selectors: [[\"mat-error\"]], hostAttrs: [\"role\", \"alert\", 1, \"mat-error\"], hostVars: 1, hostBindings: function MatError_HostBindings(rf, ctx) { if (rf & 2) {\n        ɵngcc0.ɵɵattribute(\"id\", ctx.id);\n    } }, inputs: { id: \"id\" } });\nMatError.propDecorators = {\n    id: [{ type: Input }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatError, [{\n        type: Directive,\n        args: [{\n                selector: 'mat-error',\n                host: {\n                    'class': 'mat-error',\n                    'role': 'alert',\n                    '[attr.id]': 'id'\n                }\n            }]\n    }], function () { return []; }, { id: [{\n            type: Input\n        }] }); })();\nif (false) {\n    /** @type {?} */\n    MatError.prototype.id;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/form-field/form-field-animations.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Animations used by the MatFormField.\n * \\@docs-private\n * @type {?}\n */\nconst matFormFieldAnimations = {\n    /**\n     * Animation that transitions the form field's error and hint messages.\n     */\n    transitionMessages: trigger('transitionMessages', [\n        // TODO(mmalerba): Use angular animations for label animation as well.\n        state('enter', style({ opacity: 1, transform: 'translateY(0%)' })),\n        transition('void => enter', [\n            style({ opacity: 0, transform: 'translateY(-100%)' }),\n            animate('300ms cubic-bezier(0.55, 0, 0.55, 0.2)'),\n        ]),\n    ])\n};\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/form-field/form-field-control.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * An interface which allows a control to work inside of a `MatFormField`.\n * @abstract\n * @template T\n */\nclass MatFormFieldControl {\n}\nMatFormFieldControl.ɵfac = function MatFormFieldControl_Factory(t) { return new (t || MatFormFieldControl)(); };\nMatFormFieldControl.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatFormFieldControl });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatFormFieldControl, [{\n        type: Directive\n    }], null, null); })();\nif (false) {\n    /**\n     * The value of the control.\n     * @type {?}\n     */\n    MatFormFieldControl.prototype.value;\n    /**\n     * Stream that emits whenever the state of the control changes such that the parent `MatFormField`\n     * needs to run change detection.\n     * @type {?}\n     */\n    MatFormFieldControl.prototype.stateChanges;\n    /**\n     * The element ID for this control.\n     * @type {?}\n     */\n    MatFormFieldControl.prototype.id;\n    /**\n     * The placeholder for this control.\n     * @type {?}\n     */\n    MatFormFieldControl.prototype.placeholder;\n    /**\n     * Gets the NgControl for this control.\n     * @type {?}\n     */\n    MatFormFieldControl.prototype.ngControl;\n    /**\n     * Whether the control is focused.\n     * @type {?}\n     */\n    MatFormFieldControl.prototype.focused;\n    /**\n     * Whether the control is empty.\n     * @type {?}\n     */\n    MatFormFieldControl.prototype.empty;\n    /**\n     * Whether the `MatFormField` label should try to float.\n     * @type {?}\n     */\n    MatFormFieldControl.prototype.shouldLabelFloat;\n    /**\n     * Whether the control is required.\n     * @type {?}\n     */\n    MatFormFieldControl.prototype.required;\n    /**\n     * Whether the control is disabled.\n     * @type {?}\n     */\n    MatFormFieldControl.prototype.disabled;\n    /**\n     * Whether the control is in an error state.\n     * @type {?}\n     */\n    MatFormFieldControl.prototype.errorState;\n    /**\n     * An optional name for the control type that can be used to distinguish `mat-form-field` elements\n     * based on their control type. The form field will add a class,\n     * `mat-form-field-type-{{controlType}}` to its root element.\n     * @type {?}\n     */\n    MatFormFieldControl.prototype.controlType;\n    /**\n     * Whether the input is currently in an autofilled state. If property is not present on the\n     * control it is assumed to be false.\n     * @type {?}\n     */\n    MatFormFieldControl.prototype.autofilled;\n    /**\n     * Sets the list of element IDs that currently describe this control.\n     * @abstract\n     * @param {?} ids\n     * @return {?}\n     */\n    MatFormFieldControl.prototype.setDescribedByIds = function (ids) { };\n    /**\n     * Handles a click on the control's container.\n     * @abstract\n     * @param {?} event\n     * @return {?}\n     */\n    MatFormFieldControl.prototype.onContainerClick = function (event) { };\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/form-field/form-field-errors.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 * \\@docs-private\n * @return {?}\n */\nfunction getMatFormFieldPlaceholderConflictError() {\n    return Error('Placeholder attribute and child element were both specified.');\n}\n/**\n * \\@docs-private\n * @param {?} align\n * @return {?}\n */\nfunction getMatFormFieldDuplicatedHintError(align) {\n    return Error(`A hint was already declared for 'align=\"${align}\"'.`);\n}\n/**\n * \\@docs-private\n * @return {?}\n */\nfunction getMatFormFieldMissingControlError() {\n    return Error('mat-form-field must contain a MatFormFieldControl.');\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/form-field/hint.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nlet nextUniqueId$1 = 0;\n/**\n * Hint text to be shown underneath the form field control.\n */\nclass MatHint {\n    constructor() {\n        /**\n         * Whether to align the hint label at the start or end of the line.\n         */\n        this.align = 'start';\n        /**\n         * Unique ID for the hint. Used for the aria-describedby on the form field control.\n         */\n        this.id = `mat-hint-${nextUniqueId$1++}`;\n    }\n}\nMatHint.ɵfac = function MatHint_Factory(t) { return new (t || MatHint)(); };\nMatHint.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatHint, selectors: [[\"mat-hint\"]], hostAttrs: [1, \"mat-hint\"], hostVars: 4, hostBindings: function MatHint_HostBindings(rf, ctx) { if (rf & 2) {\n        ɵngcc0.ɵɵattribute(\"id\", ctx.id)(\"align\", null);\n        ɵngcc0.ɵɵclassProp(\"mat-right\", ctx.align == \"end\");\n    } }, inputs: { align: \"align\", id: \"id\" } });\nMatHint.propDecorators = {\n    align: [{ type: Input }],\n    id: [{ type: Input }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatHint, [{\n        type: Directive,\n        args: [{\n                selector: 'mat-hint',\n                host: {\n                    'class': 'mat-hint',\n                    '[class.mat-right]': 'align == \"end\"',\n                    '[attr.id]': 'id',\n                    // Remove align attribute to prevent it from interfering with layout.\n                    '[attr.align]': 'null'\n                }\n            }]\n    }], function () { return []; }, { align: [{\n            type: Input\n        }], id: [{\n            type: Input\n        }] }); })();\nif (false) {\n    /**\n     * Whether to align the hint label at the start or end of the line.\n     * @type {?}\n     */\n    MatHint.prototype.align;\n    /**\n     * Unique ID for the hint. Used for the aria-describedby on the form field control.\n     * @type {?}\n     */\n    MatHint.prototype.id;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/form-field/label.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * The floating label for a `mat-form-field`.\n */\nclass MatLabel {\n}\nMatLabel.ɵfac = function MatLabel_Factory(t) { return new (t || MatLabel)(); };\nMatLabel.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatLabel, selectors: [[\"mat-label\"]] });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatLabel, [{\n        type: Directive,\n        args: [{\n                selector: 'mat-label'\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/form-field/placeholder.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * The placeholder text for an `MatFormField`.\n * @deprecated Use `<mat-label>` to specify the label and the `placeholder` attribute to specify the\n *     placeholder.\n * \\@breaking-change 8.0.0\n */\nclass MatPlaceholder {\n}\nMatPlaceholder.ɵfac = function MatPlaceholder_Factory(t) { return new (t || MatPlaceholder)(); };\nMatPlaceholder.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatPlaceholder, selectors: [[\"mat-placeholder\"]] });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatPlaceholder, [{\n        type: Directive,\n        args: [{\n                selector: 'mat-placeholder'\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/form-field/prefix.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Prefix to be placed in front of the form field.\n */\nclass MatPrefix {\n}\nMatPrefix.ɵfac = function MatPrefix_Factory(t) { return new (t || MatPrefix)(); };\nMatPrefix.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatPrefix, selectors: [[\"\", \"matPrefix\", \"\"]] });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatPrefix, [{\n        type: Directive,\n        args: [{\n                selector: '[matPrefix]'\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/form-field/suffix.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Suffix to be placed at the end of the form field.\n */\nclass MatSuffix {\n}\nMatSuffix.ɵfac = function MatSuffix_Factory(t) { return new (t || MatSuffix)(); };\nMatSuffix.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatSuffix, selectors: [[\"\", \"matSuffix\", \"\"]] });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatSuffix, [{\n        type: Directive,\n        args: [{\n                selector: '[matSuffix]'\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/form-field/form-field.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nlet nextUniqueId$2 = 0;\n/** @type {?} */\nconst floatingLabelScale = 0.75;\n/** @type {?} */\nconst outlineGapPadding = 5;\n/**\n * Boilerplate for applying mixins to MatFormField.\n * \\@docs-private\n */\nclass MatFormFieldBase {\n    /**\n     * @param {?} _elementRef\n     */\n    constructor(_elementRef) {\n        this._elementRef = _elementRef;\n    }\n}\nif (false) {\n    /** @type {?} */\n    MatFormFieldBase.prototype._elementRef;\n}\n/**\n * Base class to which we're applying the form field mixins.\n * \\@docs-private\n * @type {?}\n */\nconst _MatFormFieldMixinBase = mixinColor(MatFormFieldBase, 'primary');\n/**\n * Represents the default options for the form field that can be configured\n * using the `MAT_FORM_FIELD_DEFAULT_OPTIONS` injection token.\n * @record\n */\nfunction MatFormFieldDefaultOptions() { }\nif (false) {\n    /** @type {?|undefined} */\n    MatFormFieldDefaultOptions.prototype.appearance;\n    /** @type {?|undefined} */\n    MatFormFieldDefaultOptions.prototype.hideRequiredMarker;\n    /**\n     * Whether the label for form-fields should by default float `always`,\n     * `never`, or `auto` (only when necessary).\n     * @type {?|undefined}\n     */\n    MatFormFieldDefaultOptions.prototype.floatLabel;\n}\n/**\n * Injection token that can be used to configure the\n * default options for all form field within an app.\n * @type {?}\n */\nconst MAT_FORM_FIELD_DEFAULT_OPTIONS = new InjectionToken('MAT_FORM_FIELD_DEFAULT_OPTIONS');\n/**\n * Injection token that can be used to inject an instances of `MatFormField`. It serves\n * as alternative token to the actual `MatFormField` class which would cause unnecessary\n * retention of the `MatFormField` class and its component metadata.\n * @type {?}\n */\nconst MAT_FORM_FIELD = new InjectionToken('MatFormField');\n/**\n * Container for form controls that applies Material Design styling and behavior.\n */\nclass MatFormField extends _MatFormFieldMixinBase {\n    /**\n     * @param {?} _elementRef\n     * @param {?} _changeDetectorRef\n     * @param {?} labelOptions\n     * @param {?} _dir\n     * @param {?} _defaults\n     * @param {?} _platform\n     * @param {?} _ngZone\n     * @param {?} _animationMode\n     */\n    constructor(_elementRef, _changeDetectorRef, labelOptions, _dir, _defaults, _platform, _ngZone, _animationMode) {\n        super(_elementRef);\n        this._elementRef = _elementRef;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._dir = _dir;\n        this._defaults = _defaults;\n        this._platform = _platform;\n        this._ngZone = _ngZone;\n        /**\n         * Whether the outline gap needs to be calculated\n         * immediately on the next change detection run.\n         */\n        this._outlineGapCalculationNeededImmediately = false;\n        /**\n         * Whether the outline gap needs to be calculated next time the zone has stabilized.\n         */\n        this._outlineGapCalculationNeededOnStable = false;\n        this._destroyed = new Subject();\n        /**\n         * Override for the logic that disables the label animation in certain cases.\n         */\n        this._showAlwaysAnimate = false;\n        /**\n         * State of the mat-hint and mat-error animations.\n         */\n        this._subscriptAnimationState = '';\n        this._hintLabel = '';\n        // Unique id for the hint label.\n        this._hintLabelId = `mat-hint-${nextUniqueId$2++}`;\n        // Unique id for the internal form field label.\n        this._labelId = `mat-form-field-label-${nextUniqueId$2++}`;\n        this._labelOptions = labelOptions ? labelOptions : {};\n        this.floatLabel = this._getDefaultFloatLabelState();\n        this._animationsEnabled = _animationMode !== 'NoopAnimations';\n        // Set the default through here so we invoke the setter on the first run.\n        this.appearance = (_defaults && _defaults.appearance) ? _defaults.appearance : 'legacy';\n        this._hideRequiredMarker = (_defaults && _defaults.hideRequiredMarker != null) ?\n            _defaults.hideRequiredMarker : false;\n    }\n    /**\n     * The form-field appearance style.\n     * @return {?}\n     */\n    get appearance() { return this._appearance; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set appearance(value) {\n        /** @type {?} */\n        const oldValue = this._appearance;\n        this._appearance = value || (this._defaults && this._defaults.appearance) || 'legacy';\n        if (this._appearance === 'outline' && oldValue !== value) {\n            this._outlineGapCalculationNeededOnStable = true;\n        }\n    }\n    /**\n     * Whether the required marker should be hidden.\n     * @return {?}\n     */\n    get hideRequiredMarker() { return this._hideRequiredMarker; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set hideRequiredMarker(value) {\n        this._hideRequiredMarker = coerceBooleanProperty(value);\n    }\n    /**\n     * Whether the floating label should always float or not.\n     * @return {?}\n     */\n    get _shouldAlwaysFloat() {\n        return this.floatLabel === 'always' && !this._showAlwaysAnimate;\n    }\n    /**\n     * Whether the label can float or not.\n     * @return {?}\n     */\n    get _canLabelFloat() { return this.floatLabel !== 'never'; }\n    /**\n     * Text for the form field hint.\n     * @return {?}\n     */\n    get hintLabel() { return this._hintLabel; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set hintLabel(value) {\n        this._hintLabel = value;\n        this._processHints();\n    }\n    /**\n     * Whether the label should always float, never float or float as the user types.\n     *\n     * Note: only the legacy appearance supports the `never` option. `never` was originally added as a\n     * way to make the floating label emulate the behavior of a standard input placeholder. However\n     * the form field now supports both floating labels and placeholders. Therefore in the non-legacy\n     * appearances the `never` option has been disabled in favor of just using the placeholder.\n     * @return {?}\n     */\n    get floatLabel() {\n        return this.appearance !== 'legacy' && this._floatLabel === 'never' ? 'auto' : this._floatLabel;\n    }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set floatLabel(value) {\n        if (value !== this._floatLabel) {\n            this._floatLabel = value || this._getDefaultFloatLabelState();\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n    /**\n     * @return {?}\n     */\n    get _control() {\n        // TODO(crisbeto): we need this workaround in order to support both Ivy and ViewEngine.\n        //  We should clean this up once Ivy is the default renderer.\n        return this._explicitFormFieldControl || this._controlNonStatic || this._controlStatic;\n    }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set _control(value) {\n        this._explicitFormFieldControl = value;\n    }\n    /**\n     * @return {?}\n     */\n    get _labelChild() {\n        return this._labelChildNonStatic || this._labelChildStatic;\n    }\n    /**\n     * Gets an ElementRef for the element that a overlay attached to the form-field should be\n     * positioned relative to.\n     * @return {?}\n     */\n    getConnectedOverlayOrigin() {\n        return this._connectionContainerRef || this._elementRef;\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterContentInit() {\n        this._validateControlChild();\n        /** @type {?} */\n        const control = this._control;\n        if (control.controlType) {\n            this._elementRef.nativeElement.classList.add(`mat-form-field-type-${control.controlType}`);\n        }\n        // Subscribe to changes in the child control state in order to update the form field UI.\n        control.stateChanges.pipe(startWith((/** @type {?} */ (null)))).subscribe((/**\n         * @return {?}\n         */\n        () => {\n            this._validatePlaceholders();\n            this._syncDescribedByIds();\n            this._changeDetectorRef.markForCheck();\n        }));\n        // Run change detection if the value changes.\n        if (control.ngControl && control.ngControl.valueChanges) {\n            control.ngControl.valueChanges\n                .pipe(takeUntil(this._destroyed))\n                .subscribe((/**\n             * @return {?}\n             */\n            () => this._changeDetectorRef.markForCheck()));\n        }\n        // Note that we have to run outside of the `NgZone` explicitly,\n        // in order to avoid throwing users into an infinite loop\n        // if `zone-patch-rxjs` is included.\n        this._ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => {\n            this._ngZone.onStable.asObservable().pipe(takeUntil(this._destroyed)).subscribe((/**\n             * @return {?}\n             */\n            () => {\n                if (this._outlineGapCalculationNeededOnStable) {\n                    this.updateOutlineGap();\n                }\n            }));\n        }));\n        // Run change detection and update the outline if the suffix or prefix changes.\n        merge(this._prefixChildren.changes, this._suffixChildren.changes).subscribe((/**\n         * @return {?}\n         */\n        () => {\n            this._outlineGapCalculationNeededOnStable = true;\n            this._changeDetectorRef.markForCheck();\n        }));\n        // Re-validate when the number of hints changes.\n        this._hintChildren.changes.pipe(startWith(null)).subscribe((/**\n         * @return {?}\n         */\n        () => {\n            this._processHints();\n            this._changeDetectorRef.markForCheck();\n        }));\n        // Update the aria-described by when the number of errors changes.\n        this._errorChildren.changes.pipe(startWith(null)).subscribe((/**\n         * @return {?}\n         */\n        () => {\n            this._syncDescribedByIds();\n            this._changeDetectorRef.markForCheck();\n        }));\n        if (this._dir) {\n            this._dir.change.pipe(takeUntil(this._destroyed)).subscribe((/**\n             * @return {?}\n             */\n            () => {\n                if (typeof requestAnimationFrame === 'function') {\n                    this._ngZone.runOutsideAngular((/**\n                     * @return {?}\n                     */\n                    () => {\n                        requestAnimationFrame((/**\n                         * @return {?}\n                         */\n                        () => this.updateOutlineGap()));\n                    }));\n                }\n                else {\n                    this.updateOutlineGap();\n                }\n            }));\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterContentChecked() {\n        this._validateControlChild();\n        if (this._outlineGapCalculationNeededImmediately) {\n            this.updateOutlineGap();\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterViewInit() {\n        // Avoid animations on load.\n        this._subscriptAnimationState = 'enter';\n        this._changeDetectorRef.detectChanges();\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._destroyed.next();\n        this._destroyed.complete();\n    }\n    /**\n     * Determines whether a class from the NgControl should be forwarded to the host element.\n     * @param {?} prop\n     * @return {?}\n     */\n    _shouldForward(prop) {\n        /** @type {?} */\n        const ngControl = this._control ? this._control.ngControl : null;\n        return ngControl && ngControl[prop];\n    }\n    /**\n     * @return {?}\n     */\n    _hasPlaceholder() {\n        return !!(this._control && this._control.placeholder || this._placeholderChild);\n    }\n    /**\n     * @return {?}\n     */\n    _hasLabel() {\n        return !!this._labelChild;\n    }\n    /**\n     * @return {?}\n     */\n    _shouldLabelFloat() {\n        return this._canLabelFloat && (this._control.shouldLabelFloat || this._shouldAlwaysFloat);\n    }\n    /**\n     * @return {?}\n     */\n    _hideControlPlaceholder() {\n        // In the legacy appearance the placeholder is promoted to a label if no label is given.\n        return this.appearance === 'legacy' && !this._hasLabel() ||\n            this._hasLabel() && !this._shouldLabelFloat();\n    }\n    /**\n     * @return {?}\n     */\n    _hasFloatingLabel() {\n        // In the legacy appearance the placeholder is promoted to a label if no label is given.\n        return this._hasLabel() || this.appearance === 'legacy' && this._hasPlaceholder();\n    }\n    /**\n     * Determines whether to display hints or errors.\n     * @return {?}\n     */\n    _getDisplayedMessages() {\n        return (this._errorChildren && this._errorChildren.length > 0 &&\n            this._control.errorState) ? 'error' : 'hint';\n    }\n    /**\n     * Animates the placeholder up and locks it in position.\n     * @return {?}\n     */\n    _animateAndLockLabel() {\n        if (this._hasFloatingLabel() && this._canLabelFloat) {\n            // If animations are disabled, we shouldn't go in here,\n            // because the `transitionend` will never fire.\n            if (this._animationsEnabled && this._label) {\n                this._showAlwaysAnimate = true;\n                fromEvent(this._label.nativeElement, 'transitionend').pipe(take(1)).subscribe((/**\n                 * @return {?}\n                 */\n                () => {\n                    this._showAlwaysAnimate = false;\n                }));\n            }\n            this.floatLabel = 'always';\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n    /**\n     * Ensure that there is only one placeholder (either `placeholder` attribute on the child control\n     * or child element with the `mat-placeholder` directive).\n     * @private\n     * @return {?}\n     */\n    _validatePlaceholders() {\n        if (this._control.placeholder && this._placeholderChild) {\n            throw getMatFormFieldPlaceholderConflictError();\n        }\n    }\n    /**\n     * Does any extra processing that is required when handling the hints.\n     * @private\n     * @return {?}\n     */\n    _processHints() {\n        this._validateHints();\n        this._syncDescribedByIds();\n    }\n    /**\n     * Ensure that there is a maximum of one of each `<mat-hint>` alignment specified, with the\n     * attribute being considered as `align=\"start\"`.\n     * @private\n     * @return {?}\n     */\n    _validateHints() {\n        if (this._hintChildren) {\n            /** @type {?} */\n            let startHint;\n            /** @type {?} */\n            let endHint;\n            this._hintChildren.forEach((/**\n             * @param {?} hint\n             * @return {?}\n             */\n            (hint) => {\n                if (hint.align === 'start') {\n                    if (startHint || this.hintLabel) {\n                        throw getMatFormFieldDuplicatedHintError('start');\n                    }\n                    startHint = hint;\n                }\n                else if (hint.align === 'end') {\n                    if (endHint) {\n                        throw getMatFormFieldDuplicatedHintError('end');\n                    }\n                    endHint = hint;\n                }\n            }));\n        }\n    }\n    /**\n     * Gets the default float label state.\n     * @private\n     * @return {?}\n     */\n    _getDefaultFloatLabelState() {\n        return (this._defaults && this._defaults.floatLabel) || this._labelOptions.float || 'auto';\n    }\n    /**\n     * Sets the list of element IDs that describe the child control. This allows the control to update\n     * its `aria-describedby` attribute accordingly.\n     * @private\n     * @return {?}\n     */\n    _syncDescribedByIds() {\n        if (this._control) {\n            /** @type {?} */\n            let ids = [];\n            if (this._getDisplayedMessages() === 'hint') {\n                /** @type {?} */\n                const startHint = this._hintChildren ?\n                    this._hintChildren.find((/**\n                     * @param {?} hint\n                     * @return {?}\n                     */\n                    hint => hint.align === 'start')) : null;\n                /** @type {?} */\n                const endHint = this._hintChildren ?\n                    this._hintChildren.find((/**\n                     * @param {?} hint\n                     * @return {?}\n                     */\n                    hint => hint.align === 'end')) : null;\n                if (startHint) {\n                    ids.push(startHint.id);\n                }\n                else if (this._hintLabel) {\n                    ids.push(this._hintLabelId);\n                }\n                if (endHint) {\n                    ids.push(endHint.id);\n                }\n            }\n            else if (this._errorChildren) {\n                ids = this._errorChildren.map((/**\n                 * @param {?} error\n                 * @return {?}\n                 */\n                error => error.id));\n            }\n            this._control.setDescribedByIds(ids);\n        }\n    }\n    /**\n     * Throws an error if the form field's control is missing.\n     * @protected\n     * @return {?}\n     */\n    _validateControlChild() {\n        if (!this._control) {\n            throw getMatFormFieldMissingControlError();\n        }\n    }\n    /**\n     * Updates the width and position of the gap in the outline. Only relevant for the outline\n     * appearance.\n     * @return {?}\n     */\n    updateOutlineGap() {\n        /** @type {?} */\n        const labelEl = this._label ? this._label.nativeElement : null;\n        if (this.appearance !== 'outline' || !labelEl || !labelEl.children.length ||\n            !labelEl.textContent.trim()) {\n            return;\n        }\n        if (!this._platform.isBrowser) {\n            // getBoundingClientRect isn't available on the server.\n            return;\n        }\n        // If the element is not present in the DOM, the outline gap will need to be calculated\n        // the next time it is checked and in the DOM.\n        if (!this._isAttachedToDOM()) {\n            this._outlineGapCalculationNeededImmediately = true;\n            return;\n        }\n        /** @type {?} */\n        let startWidth = 0;\n        /** @type {?} */\n        let gapWidth = 0;\n        /** @type {?} */\n        const container = this._connectionContainerRef.nativeElement;\n        /** @type {?} */\n        const startEls = container.querySelectorAll('.mat-form-field-outline-start');\n        /** @type {?} */\n        const gapEls = container.querySelectorAll('.mat-form-field-outline-gap');\n        if (this._label && this._label.nativeElement.children.length) {\n            /** @type {?} */\n            const containerRect = container.getBoundingClientRect();\n            // If the container's width and height are zero, it means that the element is\n            // invisible and we can't calculate the outline gap. Mark the element as needing\n            // to be checked the next time the zone stabilizes. We can't do this immediately\n            // on the next change detection, because even if the element becomes visible,\n            // the `ClientRect` won't be reclaculated immediately. We reset the\n            // `_outlineGapCalculationNeededImmediately` flag some we don't run the checks twice.\n            if (containerRect.width === 0 && containerRect.height === 0) {\n                this._outlineGapCalculationNeededOnStable = true;\n                this._outlineGapCalculationNeededImmediately = false;\n                return;\n            }\n            /** @type {?} */\n            const containerStart = this._getStartEnd(containerRect);\n            /** @type {?} */\n            const labelStart = this._getStartEnd(labelEl.children[0].getBoundingClientRect());\n            /** @type {?} */\n            let labelWidth = 0;\n            for (const child of labelEl.children) {\n                labelWidth += child.offsetWidth;\n            }\n            startWidth = Math.abs(labelStart - containerStart) - outlineGapPadding;\n            gapWidth = labelWidth > 0 ? labelWidth * floatingLabelScale + outlineGapPadding * 2 : 0;\n        }\n        for (let i = 0; i < startEls.length; i++) {\n            startEls[i].style.width = `${startWidth}px`;\n        }\n        for (let i = 0; i < gapEls.length; i++) {\n            gapEls[i].style.width = `${gapWidth}px`;\n        }\n        this._outlineGapCalculationNeededOnStable =\n            this._outlineGapCalculationNeededImmediately = false;\n    }\n    /**\n     * Gets the start end of the rect considering the current directionality.\n     * @private\n     * @param {?} rect\n     * @return {?}\n     */\n    _getStartEnd(rect) {\n        return (this._dir && this._dir.value === 'rtl') ? rect.right : rect.left;\n    }\n    /**\n     * Checks whether the form field is attached to the DOM.\n     * @private\n     * @return {?}\n     */\n    _isAttachedToDOM() {\n        /** @type {?} */\n        const element = this._elementRef.nativeElement;\n        if (element.getRootNode) {\n            /** @type {?} */\n            const rootNode = element.getRootNode();\n            // If the element is inside the DOM the root node will be either the document\n            // or the closest shadow root, otherwise it'll be the element itself.\n            return rootNode && rootNode !== element;\n        }\n        // Otherwise fall back to checking if it's in the document. This doesn't account for\n        // shadow DOM, however browser that support shadow DOM should support `getRootNode` as well.\n        return (/** @type {?} */ (document.documentElement)).contains(element);\n    }\n}\nMatFormField.ɵfac = function MatFormField_Factory(t) { return new (t || MatFormField)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(MAT_LABEL_GLOBAL_OPTIONS, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.Directionality, 8), ɵngcc0.ɵɵdirectiveInject(MAT_FORM_FIELD_DEFAULT_OPTIONS, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.Platform), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone), ɵngcc0.ɵɵdirectiveInject(ANIMATION_MODULE_TYPE, 8)); };\nMatFormField.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatFormField, selectors: [[\"mat-form-field\"]], contentQueries: function MatFormField_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {\n        ɵngcc0.ɵɵcontentQuery(dirIndex, MatFormFieldControl, true);\n        ɵngcc0.ɵɵstaticContentQuery(dirIndex, MatFormFieldControl, true);\n        ɵngcc0.ɵɵcontentQuery(dirIndex, MatLabel, true);\n        ɵngcc0.ɵɵstaticContentQuery(dirIndex, MatLabel, true);\n        ɵngcc0.ɵɵcontentQuery(dirIndex, MatPlaceholder, true);\n        ɵngcc0.ɵɵcontentQuery(dirIndex, MatError, true);\n        ɵngcc0.ɵɵcontentQuery(dirIndex, MatHint, true);\n        ɵngcc0.ɵɵcontentQuery(dirIndex, MatPrefix, true);\n        ɵngcc0.ɵɵcontentQuery(dirIndex, MatSuffix, true);\n    } if (rf & 2) {\n        var _t;\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._controlNonStatic = _t.first);\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._controlStatic = _t.first);\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._labelChildNonStatic = _t.first);\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._labelChildStatic = _t.first);\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._placeholderChild = _t.first);\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._errorChildren = _t);\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._hintChildren = _t);\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._prefixChildren = _t);\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._suffixChildren = _t);\n    } }, viewQuery: function MatFormField_Query(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵviewQuery(_c0, true);\n        ɵngcc0.ɵɵstaticViewQuery(_c1, true);\n        ɵngcc0.ɵɵviewQuery(_c2, true);\n        ɵngcc0.ɵɵviewQuery(_c3, true);\n    } if (rf & 2) {\n        var _t;\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.underlineRef = _t.first);\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._connectionContainerRef = _t.first);\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._inputContainerRef = _t.first);\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._label = _t.first);\n    } }, hostAttrs: [1, \"mat-form-field\"], hostVars: 44, hostBindings: function MatFormField_HostBindings(rf, ctx) { if (rf & 2) {\n        ɵngcc0.ɵɵclassProp(\"mat-form-field-appearance-standard\", ctx.appearance == \"standard\")(\"mat-form-field-appearance-fill\", ctx.appearance == \"fill\")(\"mat-form-field-appearance-outline\", ctx.appearance == \"outline\")(\"mat-form-field-appearance-legacy\", ctx.appearance == \"legacy\")(\"mat-form-field-invalid\", ctx._control.errorState)(\"mat-form-field-can-float\", ctx._canLabelFloat)(\"mat-form-field-should-float\", ctx._shouldLabelFloat())(\"mat-form-field-has-label\", ctx._hasFloatingLabel())(\"mat-form-field-hide-placeholder\", ctx._hideControlPlaceholder())(\"mat-form-field-disabled\", ctx._control.disabled)(\"mat-form-field-autofilled\", ctx._control.autofilled)(\"mat-focused\", ctx._control.focused)(\"mat-accent\", ctx.color == \"accent\")(\"mat-warn\", ctx.color == \"warn\")(\"ng-untouched\", ctx._shouldForward(\"untouched\"))(\"ng-touched\", ctx._shouldForward(\"touched\"))(\"ng-pristine\", ctx._shouldForward(\"pristine\"))(\"ng-dirty\", ctx._shouldForward(\"dirty\"))(\"ng-valid\", ctx._shouldForward(\"valid\"))(\"ng-invalid\", ctx._shouldForward(\"invalid\"))(\"ng-pending\", ctx._shouldForward(\"pending\"))(\"_mat-animation-noopable\", !ctx._animationsEnabled);\n    } }, inputs: { color: \"color\", floatLabel: \"floatLabel\", appearance: \"appearance\", hideRequiredMarker: \"hideRequiredMarker\", hintLabel: \"hintLabel\" }, exportAs: [\"matFormField\"], features: [ɵngcc0.ɵɵProvidersFeature([\n            { provide: MAT_FORM_FIELD, useExisting: MatFormField },\n        ]), ɵngcc0.ɵɵInheritDefinitionFeature], ngContentSelectors: _c5, decls: 15, vars: 8, consts: [[1, \"mat-form-field-wrapper\"], [1, \"mat-form-field-flex\", 3, \"click\"], [\"connectionContainer\", \"\"], [4, \"ngIf\"], [\"class\", \"mat-form-field-prefix\", 4, \"ngIf\"], [1, \"mat-form-field-infix\"], [\"inputContainer\", \"\"], [1, \"mat-form-field-label-wrapper\"], [\"class\", \"mat-form-field-label\", 3, \"cdkObserveContentDisabled\", \"id\", \"mat-empty\", \"mat-form-field-empty\", \"mat-accent\", \"mat-warn\", \"ngSwitch\", \"cdkObserveContent\", 4, \"ngIf\"], [\"class\", \"mat-form-field-suffix\", 4, \"ngIf\"], [\"class\", \"mat-form-field-underline\", 4, \"ngIf\"], [1, \"mat-form-field-subscript-wrapper\", 3, \"ngSwitch\"], [4, \"ngSwitchCase\"], [\"class\", \"mat-form-field-hint-wrapper\", 4, \"ngSwitchCase\"], [1, \"mat-form-field-outline\"], [1, \"mat-form-field-outline-start\"], [1, \"mat-form-field-outline-gap\"], [1, \"mat-form-field-outline-end\"], [1, \"mat-form-field-outline\", \"mat-form-field-outline-thick\"], [1, \"mat-form-field-prefix\"], [1, \"mat-form-field-label\", 3, \"cdkObserveContentDisabled\", \"id\", \"ngSwitch\", \"cdkObserveContent\"], [\"label\", \"\"], [\"class\", \"mat-placeholder-required mat-form-field-required-marker\", \"aria-hidden\", \"true\", 4, \"ngIf\"], [\"aria-hidden\", \"true\", 1, \"mat-placeholder-required\", \"mat-form-field-required-marker\"], [1, \"mat-form-field-suffix\"], [1, \"mat-form-field-underline\"], [\"underline\", \"\"], [1, \"mat-form-field-ripple\"], [1, \"mat-form-field-hint-wrapper\"], [\"class\", \"mat-hint\", 3, \"id\", 4, \"ngIf\"], [1, \"mat-form-field-hint-spacer\"], [1, \"mat-hint\", 3, \"id\"]], template: function MatFormField_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵprojectionDef(_c4);\n        ɵngcc0.ɵɵelementStart(0, \"div\", 0);\n        ɵngcc0.ɵɵelementStart(1, \"div\", 1, 2);\n        ɵngcc0.ɵɵlistener(\"click\", function MatFormField_Template_div_click_1_listener($event) { return ctx._control.onContainerClick && ctx._control.onContainerClick($event); });\n        ɵngcc0.ɵɵtemplate(3, MatFormField_ng_container_3_Template, 9, 0, \"ng-container\", 3);\n        ɵngcc0.ɵɵtemplate(4, MatFormField_div_4_Template, 2, 0, \"div\", 4);\n        ɵngcc0.ɵɵelementStart(5, \"div\", 5, 6);\n        ɵngcc0.ɵɵprojection(7);\n        ɵngcc0.ɵɵelementStart(8, \"span\", 7);\n        ɵngcc0.ɵɵtemplate(9, MatFormField_label_9_Template, 5, 16, \"label\", 8);\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵtemplate(10, MatFormField_div_10_Template, 2, 0, \"div\", 9);\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵtemplate(11, MatFormField_div_11_Template, 3, 4, \"div\", 10);\n        ɵngcc0.ɵɵelementStart(12, \"div\", 11);\n        ɵngcc0.ɵɵtemplate(13, MatFormField_div_13_Template, 2, 1, \"div\", 12);\n        ɵngcc0.ɵɵtemplate(14, MatFormField_div_14_Template, 5, 2, \"div\", 13);\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelementEnd();\n    } if (rf & 2) {\n        ɵngcc0.ɵɵadvance(3);\n        ɵngcc0.ɵɵproperty(\"ngIf\", ctx.appearance == \"outline\");\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵproperty(\"ngIf\", ctx._prefixChildren.length);\n        ɵngcc0.ɵɵadvance(5);\n        ɵngcc0.ɵɵproperty(\"ngIf\", ctx._hasFloatingLabel());\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵproperty(\"ngIf\", ctx._suffixChildren.length);\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵproperty(\"ngIf\", ctx.appearance != \"outline\");\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵproperty(\"ngSwitch\", ctx._getDisplayedMessages());\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵproperty(\"ngSwitchCase\", \"error\");\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵproperty(\"ngSwitchCase\", \"hint\");\n    } }, directives: [ɵngcc3.NgIf, ɵngcc3.NgSwitch, ɵngcc3.NgSwitchCase, ɵngcc4.CdkObserveContent], styles: [\".mat-form-field{display:inline-block;position:relative;text-align:left}[dir=rtl] .mat-form-field{text-align:right}.mat-form-field-wrapper{position:relative}.mat-form-field-flex{display:inline-flex;align-items:baseline;box-sizing:border-box;width:100%}.mat-form-field-prefix,.mat-form-field-suffix{white-space:nowrap;flex:none;position:relative}.mat-form-field-infix{display:block;position:relative;flex:auto;min-width:0;width:180px}.cdk-high-contrast-active .mat-form-field-infix{border-image:linear-gradient(transparent, transparent)}.mat-form-field-label-wrapper{position:absolute;left:0;box-sizing:content-box;width:100%;height:100%;overflow:hidden;pointer-events:none}[dir=rtl] .mat-form-field-label-wrapper{left:auto;right:0}.mat-form-field-label{position:absolute;left:0;font:inherit;pointer-events:none;width:100%;white-space:nowrap;text-overflow:ellipsis;overflow:hidden;transform-origin:0 0;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),color 400ms cubic-bezier(0.25, 0.8, 0.25, 1),width 400ms cubic-bezier(0.25, 0.8, 0.25, 1);display:none}[dir=rtl] .mat-form-field-label{transform-origin:100% 0;left:auto;right:0}.mat-form-field-empty.mat-form-field-label,.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label{display:block}.mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{display:none}.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{display:block;transition:none}.mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label,.mat-input-server[placeholder]:not(:placeholder-shown)+.mat-form-field-label-wrapper .mat-form-field-label{display:none}.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label,.mat-form-field-can-float .mat-input-server[placeholder]:not(:placeholder-shown)+.mat-form-field-label-wrapper .mat-form-field-label{display:block}.mat-form-field-label:not(.mat-form-field-empty){transition:none}.mat-form-field-underline{position:absolute;width:100%;pointer-events:none;transform:scale3d(1, 1.0001, 1)}.mat-form-field-ripple{position:absolute;left:0;width:100%;transform-origin:50%;transform:scaleX(0.5);opacity:0;transition:background-color 300ms cubic-bezier(0.55, 0, 0.55, 0.2)}.mat-form-field.mat-focused .mat-form-field-ripple,.mat-form-field.mat-form-field-invalid .mat-form-field-ripple{opacity:1;transform:scaleX(1);transition:transform 300ms cubic-bezier(0.25, 0.8, 0.25, 1),opacity 100ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 300ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-subscript-wrapper{position:absolute;box-sizing:border-box;width:100%;overflow:hidden}.mat-form-field-subscript-wrapper .mat-icon,.mat-form-field-label-wrapper .mat-icon{width:1em;height:1em;font-size:inherit;vertical-align:baseline}.mat-form-field-hint-wrapper{display:flex}.mat-form-field-hint-spacer{flex:1 0 1em}.mat-error{display:block}.mat-form-field-control-wrapper{position:relative}.mat-form-field._mat-animation-noopable .mat-form-field-label,.mat-form-field._mat-animation-noopable .mat-form-field-ripple{transition:none}\\n\", \".mat-form-field-appearance-fill .mat-form-field-flex{border-radius:4px 4px 0 0;padding:.75em .75em 0 .75em}.cdk-high-contrast-active .mat-form-field-appearance-fill .mat-form-field-flex{outline:solid 1px}.mat-form-field-appearance-fill .mat-form-field-underline::before{content:\\\"\\\";display:block;position:absolute;bottom:0;height:1px;width:100%}.mat-form-field-appearance-fill .mat-form-field-ripple{bottom:0;height:2px}.cdk-high-contrast-active .mat-form-field-appearance-fill .mat-form-field-ripple{height:0;border-top:solid 2px}.mat-form-field-appearance-fill:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{opacity:1;transform:none;transition:opacity 600ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-fill._mat-animation-noopable:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{transition:none}.mat-form-field-appearance-fill .mat-form-field-subscript-wrapper{padding:0 1em}\\n\", \".mat-input-element{font:inherit;background:transparent;color:currentColor;border:none;outline:none;padding:0;margin:0;width:100%;max-width:100%;vertical-align:bottom;text-align:inherit}.mat-input-element:-moz-ui-invalid{box-shadow:none}.mat-input-element::-ms-clear,.mat-input-element::-ms-reveal{display:none}.mat-input-element,.mat-input-element::-webkit-search-cancel-button,.mat-input-element::-webkit-search-decoration,.mat-input-element::-webkit-search-results-button,.mat-input-element::-webkit-search-results-decoration{-webkit-appearance:none}.mat-input-element::-webkit-contacts-auto-fill-button,.mat-input-element::-webkit-caps-lock-indicator,.mat-input-element::-webkit-credentials-auto-fill-button{visibility:hidden}.mat-input-element[type=date],.mat-input-element[type=datetime],.mat-input-element[type=datetime-local],.mat-input-element[type=month],.mat-input-element[type=week],.mat-input-element[type=time]{line-height:1}.mat-input-element[type=date]::after,.mat-input-element[type=datetime]::after,.mat-input-element[type=datetime-local]::after,.mat-input-element[type=month]::after,.mat-input-element[type=week]::after,.mat-input-element[type=time]::after{content:\\\" \\\";white-space:pre;width:1px}.mat-input-element::-webkit-inner-spin-button,.mat-input-element::-webkit-calendar-picker-indicator,.mat-input-element::-webkit-clear-button{font-size:.75em}.mat-input-element::placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element::placeholder:-ms-input-placeholder{-ms-user-select:text}.mat-input-element::-moz-placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element::-moz-placeholder:-ms-input-placeholder{-ms-user-select:text}.mat-input-element::-webkit-input-placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element::-webkit-input-placeholder:-ms-input-placeholder{-ms-user-select:text}.mat-input-element:-ms-input-placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element:-ms-input-placeholder:-ms-input-placeholder{-ms-user-select:text}.mat-form-field-hide-placeholder .mat-input-element::placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.mat-form-field-hide-placeholder .mat-input-element::-moz-placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.mat-form-field-hide-placeholder .mat-input-element::-webkit-input-placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.mat-form-field-hide-placeholder .mat-input-element:-ms-input-placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}textarea.mat-input-element{resize:vertical;overflow:auto}textarea.mat-input-element.cdk-textarea-autosize{resize:none}textarea.mat-input-element{padding:2px 0;margin:-2px 0}select.mat-input-element{-moz-appearance:none;-webkit-appearance:none;position:relative;background-color:transparent;display:inline-flex;box-sizing:border-box;padding-top:1em;top:-1em;margin-bottom:-1em}select.mat-input-element::-ms-expand{display:none}select.mat-input-element::-moz-focus-inner{border:0}select.mat-input-element:not(:disabled){cursor:pointer}select.mat-input-element::-ms-value{color:inherit;background:none}.mat-focused .cdk-high-contrast-active select.mat-input-element::-ms-value{color:inherit}.mat-form-field-type-mat-native-select .mat-form-field-infix::after{content:\\\"\\\";width:0;height:0;border-left:5px solid transparent;border-right:5px solid transparent;border-top:5px solid;position:absolute;top:50%;right:0;margin-top:-2.5px;pointer-events:none}[dir=rtl] .mat-form-field-type-mat-native-select .mat-form-field-infix::after{right:auto;left:0}.mat-form-field-type-mat-native-select .mat-input-element{padding-right:15px}[dir=rtl] .mat-form-field-type-mat-native-select .mat-input-element{padding-right:0;padding-left:15px}.mat-form-field-type-mat-native-select .mat-form-field-label-wrapper{max-width:calc(100% - 10px)}.mat-form-field-type-mat-native-select.mat-form-field-appearance-outline .mat-form-field-infix::after{margin-top:-5px}.mat-form-field-type-mat-native-select.mat-form-field-appearance-fill .mat-form-field-infix::after{margin-top:-10px}\\n\", \".mat-form-field-appearance-legacy .mat-form-field-label{transform:perspective(100px);-ms-transform:none}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-icon,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-icon{width:1em}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-icon-button,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-icon-button{font:inherit;vertical-align:baseline}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-icon-button .mat-icon{font-size:inherit}.mat-form-field-appearance-legacy .mat-form-field-underline{height:1px}.cdk-high-contrast-active .mat-form-field-appearance-legacy .mat-form-field-underline{height:0;border-top:solid 1px}.mat-form-field-appearance-legacy .mat-form-field-ripple{top:0;height:2px;overflow:hidden}.cdk-high-contrast-active .mat-form-field-appearance-legacy .mat-form-field-ripple{height:0;border-top:solid 2px}.mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{background-position:0;background-color:transparent}.cdk-high-contrast-active .mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{border-top-style:dotted;border-top-width:2px}.mat-form-field-appearance-legacy.mat-form-field-invalid:not(.mat-focused) .mat-form-field-ripple{height:1px}\\n\", \".mat-form-field-appearance-outline .mat-form-field-wrapper{margin:.25em 0}.mat-form-field-appearance-outline .mat-form-field-flex{padding:0 .75em 0 .75em;margin-top:-0.25em;position:relative}.mat-form-field-appearance-outline .mat-form-field-prefix,.mat-form-field-appearance-outline .mat-form-field-suffix{top:.25em}.mat-form-field-appearance-outline .mat-form-field-outline{display:flex;position:absolute;top:.25em;left:0;right:0;bottom:0;pointer-events:none}.mat-form-field-appearance-outline .mat-form-field-outline-start,.mat-form-field-appearance-outline .mat-form-field-outline-end{border:1px solid currentColor;min-width:5px}.mat-form-field-appearance-outline .mat-form-field-outline-start{border-radius:5px 0 0 5px;border-right-style:none}[dir=rtl] .mat-form-field-appearance-outline .mat-form-field-outline-start{border-right-style:solid;border-left-style:none;border-radius:0 5px 5px 0}.mat-form-field-appearance-outline .mat-form-field-outline-end{border-radius:0 5px 5px 0;border-left-style:none;flex-grow:1}[dir=rtl] .mat-form-field-appearance-outline .mat-form-field-outline-end{border-left-style:solid;border-right-style:none;border-radius:5px 0 0 5px}.mat-form-field-appearance-outline .mat-form-field-outline-gap{border-radius:.000001px;border:1px solid currentColor;border-left-style:none;border-right-style:none}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-outline-gap{border-top-color:transparent}.mat-form-field-appearance-outline .mat-form-field-outline-thick{opacity:0}.mat-form-field-appearance-outline .mat-form-field-outline-thick .mat-form-field-outline-start,.mat-form-field-appearance-outline .mat-form-field-outline-thick .mat-form-field-outline-end,.mat-form-field-appearance-outline .mat-form-field-outline-thick .mat-form-field-outline-gap{border-width:2px}.mat-form-field-appearance-outline.mat-focused .mat-form-field-outline,.mat-form-field-appearance-outline.mat-form-field-invalid .mat-form-field-outline{opacity:0;transition:opacity 100ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick,.mat-form-field-appearance-outline.mat-form-field-invalid .mat-form-field-outline-thick{opacity:1}.mat-form-field-appearance-outline:not(.mat-form-field-disabled) .mat-form-field-flex:hover .mat-form-field-outline{opacity:0;transition:opacity 600ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-outline:not(.mat-form-field-disabled) .mat-form-field-flex:hover .mat-form-field-outline-thick{opacity:1}.mat-form-field-appearance-outline .mat-form-field-subscript-wrapper{padding:0 1em}.mat-form-field-appearance-outline._mat-animation-noopable:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-outline,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline-start,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline-end,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline-gap{transition:none}\\n\", \".mat-form-field-appearance-standard .mat-form-field-flex{padding-top:.75em}.mat-form-field-appearance-standard .mat-form-field-underline{height:1px}.cdk-high-contrast-active .mat-form-field-appearance-standard .mat-form-field-underline{height:0;border-top:solid 1px}.mat-form-field-appearance-standard .mat-form-field-ripple{bottom:0;height:2px}.cdk-high-contrast-active .mat-form-field-appearance-standard .mat-form-field-ripple{height:0;border-top:2px}.mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{background-position:0;background-color:transparent}.cdk-high-contrast-active .mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{border-top-style:dotted;border-top-width:2px}.mat-form-field-appearance-standard:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{opacity:1;transform:none;transition:opacity 600ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-standard._mat-animation-noopable:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{transition:none}\\n\"], encapsulation: 2, data: { animation: [matFormFieldAnimations.transitionMessages] }, changeDetection: 0 });\n/** @nocollapse */\nMatFormField.ctorParameters = () => [\n    { type: ElementRef },\n    { type: ChangeDetectorRef },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_LABEL_GLOBAL_OPTIONS,] }] },\n    { type: Directionality, decorators: [{ type: Optional }] },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_FORM_FIELD_DEFAULT_OPTIONS,] }] },\n    { type: Platform },\n    { type: NgZone },\n    { type: String, decorators: [{ type: Optional }, { type: Inject, args: [ANIMATION_MODULE_TYPE,] }] }\n];\nMatFormField.propDecorators = {\n    appearance: [{ type: Input }],\n    hideRequiredMarker: [{ type: Input }],\n    hintLabel: [{ type: Input }],\n    floatLabel: [{ type: Input }],\n    underlineRef: [{ type: ViewChild, args: ['underline',] }],\n    _connectionContainerRef: [{ type: ViewChild, args: ['connectionContainer', { static: true },] }],\n    _inputContainerRef: [{ type: ViewChild, args: ['inputContainer',] }],\n    _label: [{ type: ViewChild, args: ['label',] }],\n    _controlNonStatic: [{ type: ContentChild, args: [MatFormFieldControl,] }],\n    _controlStatic: [{ type: ContentChild, args: [MatFormFieldControl, { static: true },] }],\n    _labelChildNonStatic: [{ type: ContentChild, args: [MatLabel,] }],\n    _labelChildStatic: [{ type: ContentChild, args: [MatLabel, { static: true },] }],\n    _placeholderChild: [{ type: ContentChild, args: [MatPlaceholder,] }],\n    _errorChildren: [{ type: ContentChildren, args: [MatError, { descendants: true },] }],\n    _hintChildren: [{ type: ContentChildren, args: [MatHint, { descendants: true },] }],\n    _prefixChildren: [{ type: ContentChildren, args: [MatPrefix, { descendants: true },] }],\n    _suffixChildren: [{ type: ContentChildren, args: [MatSuffix, { descendants: true },] }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatFormField, [{\n        type: Component,\n        args: [{\n                selector: 'mat-form-field',\n                exportAs: 'matFormField',\n                template: \"<div class=\\\"mat-form-field-wrapper\\\">\\n  <div class=\\\"mat-form-field-flex\\\" #connectionContainer\\n       (click)=\\\"_control.onContainerClick && _control.onContainerClick($event)\\\">\\n\\n    <!-- Outline used for outline appearance. -->\\n    <ng-container *ngIf=\\\"appearance == 'outline'\\\">\\n      <div class=\\\"mat-form-field-outline\\\">\\n        <div class=\\\"mat-form-field-outline-start\\\"></div>\\n        <div class=\\\"mat-form-field-outline-gap\\\"></div>\\n        <div class=\\\"mat-form-field-outline-end\\\"></div>\\n      </div>\\n      <div class=\\\"mat-form-field-outline mat-form-field-outline-thick\\\">\\n        <div class=\\\"mat-form-field-outline-start\\\"></div>\\n        <div class=\\\"mat-form-field-outline-gap\\\"></div>\\n        <div class=\\\"mat-form-field-outline-end\\\"></div>\\n      </div>\\n    </ng-container>\\n\\n    <div class=\\\"mat-form-field-prefix\\\" *ngIf=\\\"_prefixChildren.length\\\">\\n      <ng-content select=\\\"[matPrefix]\\\"></ng-content>\\n    </div>\\n\\n    <div class=\\\"mat-form-field-infix\\\" #inputContainer>\\n      <ng-content></ng-content>\\n\\n      <span class=\\\"mat-form-field-label-wrapper\\\">\\n        <!-- We add aria-owns as a workaround for an issue in JAWS & NVDA where the label isn't\\n             read if it comes before the control in the DOM. -->\\n        <label class=\\\"mat-form-field-label\\\"\\n               (cdkObserveContent)=\\\"updateOutlineGap()\\\"\\n               [cdkObserveContentDisabled]=\\\"appearance != 'outline'\\\"\\n               [id]=\\\"_labelId\\\"\\n               [attr.for]=\\\"_control.id\\\"\\n               [attr.aria-owns]=\\\"_control.id\\\"\\n               [class.mat-empty]=\\\"_control.empty && !_shouldAlwaysFloat\\\"\\n               [class.mat-form-field-empty]=\\\"_control.empty && !_shouldAlwaysFloat\\\"\\n               [class.mat-accent]=\\\"color == 'accent'\\\"\\n               [class.mat-warn]=\\\"color == 'warn'\\\"\\n               #label\\n               *ngIf=\\\"_hasFloatingLabel()\\\"\\n               [ngSwitch]=\\\"_hasLabel()\\\">\\n\\n          <!-- @breaking-change 8.0.0 remove in favor of mat-label element an placeholder attr. -->\\n          <ng-container *ngSwitchCase=\\\"false\\\">\\n            <ng-content select=\\\"mat-placeholder\\\"></ng-content>\\n            <span>{{_control.placeholder}}</span>\\n          </ng-container>\\n\\n          <ng-content select=\\\"mat-label\\\" *ngSwitchCase=\\\"true\\\"></ng-content>\\n\\n          <!-- @breaking-change 8.0.0 remove `mat-placeholder-required` class -->\\n          <span\\n            class=\\\"mat-placeholder-required mat-form-field-required-marker\\\"\\n            aria-hidden=\\\"true\\\"\\n            *ngIf=\\\"!hideRequiredMarker && _control.required && !_control.disabled\\\">&#32;*</span>\\n        </label>\\n      </span>\\n    </div>\\n\\n    <div class=\\\"mat-form-field-suffix\\\" *ngIf=\\\"_suffixChildren.length\\\">\\n      <ng-content select=\\\"[matSuffix]\\\"></ng-content>\\n    </div>\\n  </div>\\n\\n  <!-- Underline used for legacy, standard, and box appearances. -->\\n  <div class=\\\"mat-form-field-underline\\\" #underline\\n       *ngIf=\\\"appearance != 'outline'\\\">\\n    <span class=\\\"mat-form-field-ripple\\\"\\n          [class.mat-accent]=\\\"color == 'accent'\\\"\\n          [class.mat-warn]=\\\"color == 'warn'\\\"></span>\\n  </div>\\n\\n  <div class=\\\"mat-form-field-subscript-wrapper\\\"\\n       [ngSwitch]=\\\"_getDisplayedMessages()\\\">\\n    <div *ngSwitchCase=\\\"'error'\\\" [@transitionMessages]=\\\"_subscriptAnimationState\\\">\\n      <ng-content select=\\\"mat-error\\\"></ng-content>\\n    </div>\\n\\n    <div class=\\\"mat-form-field-hint-wrapper\\\" *ngSwitchCase=\\\"'hint'\\\"\\n      [@transitionMessages]=\\\"_subscriptAnimationState\\\">\\n      <!-- TODO(mmalerba): use an actual <mat-hint> once all selectors are switched to mat-* -->\\n      <div *ngIf=\\\"hintLabel\\\" [id]=\\\"_hintLabelId\\\" class=\\\"mat-hint\\\">{{hintLabel}}</div>\\n      <ng-content select=\\\"mat-hint:not([align='end'])\\\"></ng-content>\\n      <div class=\\\"mat-form-field-hint-spacer\\\"></div>\\n      <ng-content select=\\\"mat-hint[align='end']\\\"></ng-content>\\n    </div>\\n  </div>\\n</div>\\n\",\n                animations: [matFormFieldAnimations.transitionMessages],\n                host: {\n                    'class': 'mat-form-field',\n                    '[class.mat-form-field-appearance-standard]': 'appearance == \"standard\"',\n                    '[class.mat-form-field-appearance-fill]': 'appearance == \"fill\"',\n                    '[class.mat-form-field-appearance-outline]': 'appearance == \"outline\"',\n                    '[class.mat-form-field-appearance-legacy]': 'appearance == \"legacy\"',\n                    '[class.mat-form-field-invalid]': '_control.errorState',\n                    '[class.mat-form-field-can-float]': '_canLabelFloat',\n                    '[class.mat-form-field-should-float]': '_shouldLabelFloat()',\n                    '[class.mat-form-field-has-label]': '_hasFloatingLabel()',\n                    '[class.mat-form-field-hide-placeholder]': '_hideControlPlaceholder()',\n                    '[class.mat-form-field-disabled]': '_control.disabled',\n                    '[class.mat-form-field-autofilled]': '_control.autofilled',\n                    '[class.mat-focused]': '_control.focused',\n                    '[class.mat-accent]': 'color == \"accent\"',\n                    '[class.mat-warn]': 'color == \"warn\"',\n                    '[class.ng-untouched]': '_shouldForward(\"untouched\")',\n                    '[class.ng-touched]': '_shouldForward(\"touched\")',\n                    '[class.ng-pristine]': '_shouldForward(\"pristine\")',\n                    '[class.ng-dirty]': '_shouldForward(\"dirty\")',\n                    '[class.ng-valid]': '_shouldForward(\"valid\")',\n                    '[class.ng-invalid]': '_shouldForward(\"invalid\")',\n                    '[class.ng-pending]': '_shouldForward(\"pending\")',\n                    '[class._mat-animation-noopable]': '!_animationsEnabled'\n                },\n                inputs: ['color'],\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush,\n                providers: [\n                    { provide: MAT_FORM_FIELD, useExisting: MatFormField },\n                ],\n                styles: [\".mat-form-field{display:inline-block;position:relative;text-align:left}[dir=rtl] .mat-form-field{text-align:right}.mat-form-field-wrapper{position:relative}.mat-form-field-flex{display:inline-flex;align-items:baseline;box-sizing:border-box;width:100%}.mat-form-field-prefix,.mat-form-field-suffix{white-space:nowrap;flex:none;position:relative}.mat-form-field-infix{display:block;position:relative;flex:auto;min-width:0;width:180px}.cdk-high-contrast-active .mat-form-field-infix{border-image:linear-gradient(transparent, transparent)}.mat-form-field-label-wrapper{position:absolute;left:0;box-sizing:content-box;width:100%;height:100%;overflow:hidden;pointer-events:none}[dir=rtl] .mat-form-field-label-wrapper{left:auto;right:0}.mat-form-field-label{position:absolute;left:0;font:inherit;pointer-events:none;width:100%;white-space:nowrap;text-overflow:ellipsis;overflow:hidden;transform-origin:0 0;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),color 400ms cubic-bezier(0.25, 0.8, 0.25, 1),width 400ms cubic-bezier(0.25, 0.8, 0.25, 1);display:none}[dir=rtl] .mat-form-field-label{transform-origin:100% 0;left:auto;right:0}.mat-form-field-empty.mat-form-field-label,.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label{display:block}.mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{display:none}.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{display:block;transition:none}.mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label,.mat-input-server[placeholder]:not(:placeholder-shown)+.mat-form-field-label-wrapper .mat-form-field-label{display:none}.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label,.mat-form-field-can-float .mat-input-server[placeholder]:not(:placeholder-shown)+.mat-form-field-label-wrapper .mat-form-field-label{display:block}.mat-form-field-label:not(.mat-form-field-empty){transition:none}.mat-form-field-underline{position:absolute;width:100%;pointer-events:none;transform:scale3d(1, 1.0001, 1)}.mat-form-field-ripple{position:absolute;left:0;width:100%;transform-origin:50%;transform:scaleX(0.5);opacity:0;transition:background-color 300ms cubic-bezier(0.55, 0, 0.55, 0.2)}.mat-form-field.mat-focused .mat-form-field-ripple,.mat-form-field.mat-form-field-invalid .mat-form-field-ripple{opacity:1;transform:scaleX(1);transition:transform 300ms cubic-bezier(0.25, 0.8, 0.25, 1),opacity 100ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 300ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-subscript-wrapper{position:absolute;box-sizing:border-box;width:100%;overflow:hidden}.mat-form-field-subscript-wrapper .mat-icon,.mat-form-field-label-wrapper .mat-icon{width:1em;height:1em;font-size:inherit;vertical-align:baseline}.mat-form-field-hint-wrapper{display:flex}.mat-form-field-hint-spacer{flex:1 0 1em}.mat-error{display:block}.mat-form-field-control-wrapper{position:relative}.mat-form-field._mat-animation-noopable .mat-form-field-label,.mat-form-field._mat-animation-noopable .mat-form-field-ripple{transition:none}\\n\", \".mat-form-field-appearance-fill .mat-form-field-flex{border-radius:4px 4px 0 0;padding:.75em .75em 0 .75em}.cdk-high-contrast-active .mat-form-field-appearance-fill .mat-form-field-flex{outline:solid 1px}.mat-form-field-appearance-fill .mat-form-field-underline::before{content:\\\"\\\";display:block;position:absolute;bottom:0;height:1px;width:100%}.mat-form-field-appearance-fill .mat-form-field-ripple{bottom:0;height:2px}.cdk-high-contrast-active .mat-form-field-appearance-fill .mat-form-field-ripple{height:0;border-top:solid 2px}.mat-form-field-appearance-fill:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{opacity:1;transform:none;transition:opacity 600ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-fill._mat-animation-noopable:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{transition:none}.mat-form-field-appearance-fill .mat-form-field-subscript-wrapper{padding:0 1em}\\n\", \".mat-input-element{font:inherit;background:transparent;color:currentColor;border:none;outline:none;padding:0;margin:0;width:100%;max-width:100%;vertical-align:bottom;text-align:inherit}.mat-input-element:-moz-ui-invalid{box-shadow:none}.mat-input-element::-ms-clear,.mat-input-element::-ms-reveal{display:none}.mat-input-element,.mat-input-element::-webkit-search-cancel-button,.mat-input-element::-webkit-search-decoration,.mat-input-element::-webkit-search-results-button,.mat-input-element::-webkit-search-results-decoration{-webkit-appearance:none}.mat-input-element::-webkit-contacts-auto-fill-button,.mat-input-element::-webkit-caps-lock-indicator,.mat-input-element::-webkit-credentials-auto-fill-button{visibility:hidden}.mat-input-element[type=date],.mat-input-element[type=datetime],.mat-input-element[type=datetime-local],.mat-input-element[type=month],.mat-input-element[type=week],.mat-input-element[type=time]{line-height:1}.mat-input-element[type=date]::after,.mat-input-element[type=datetime]::after,.mat-input-element[type=datetime-local]::after,.mat-input-element[type=month]::after,.mat-input-element[type=week]::after,.mat-input-element[type=time]::after{content:\\\" \\\";white-space:pre;width:1px}.mat-input-element::-webkit-inner-spin-button,.mat-input-element::-webkit-calendar-picker-indicator,.mat-input-element::-webkit-clear-button{font-size:.75em}.mat-input-element::placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element::placeholder:-ms-input-placeholder{-ms-user-select:text}.mat-input-element::-moz-placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element::-moz-placeholder:-ms-input-placeholder{-ms-user-select:text}.mat-input-element::-webkit-input-placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element::-webkit-input-placeholder:-ms-input-placeholder{-ms-user-select:text}.mat-input-element:-ms-input-placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element:-ms-input-placeholder:-ms-input-placeholder{-ms-user-select:text}.mat-form-field-hide-placeholder .mat-input-element::placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.mat-form-field-hide-placeholder .mat-input-element::-moz-placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.mat-form-field-hide-placeholder .mat-input-element::-webkit-input-placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.mat-form-field-hide-placeholder .mat-input-element:-ms-input-placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}textarea.mat-input-element{resize:vertical;overflow:auto}textarea.mat-input-element.cdk-textarea-autosize{resize:none}textarea.mat-input-element{padding:2px 0;margin:-2px 0}select.mat-input-element{-moz-appearance:none;-webkit-appearance:none;position:relative;background-color:transparent;display:inline-flex;box-sizing:border-box;padding-top:1em;top:-1em;margin-bottom:-1em}select.mat-input-element::-ms-expand{display:none}select.mat-input-element::-moz-focus-inner{border:0}select.mat-input-element:not(:disabled){cursor:pointer}select.mat-input-element::-ms-value{color:inherit;background:none}.mat-focused .cdk-high-contrast-active select.mat-input-element::-ms-value{color:inherit}.mat-form-field-type-mat-native-select .mat-form-field-infix::after{content:\\\"\\\";width:0;height:0;border-left:5px solid transparent;border-right:5px solid transparent;border-top:5px solid;position:absolute;top:50%;right:0;margin-top:-2.5px;pointer-events:none}[dir=rtl] .mat-form-field-type-mat-native-select .mat-form-field-infix::after{right:auto;left:0}.mat-form-field-type-mat-native-select .mat-input-element{padding-right:15px}[dir=rtl] .mat-form-field-type-mat-native-select .mat-input-element{padding-right:0;padding-left:15px}.mat-form-field-type-mat-native-select .mat-form-field-label-wrapper{max-width:calc(100% - 10px)}.mat-form-field-type-mat-native-select.mat-form-field-appearance-outline .mat-form-field-infix::after{margin-top:-5px}.mat-form-field-type-mat-native-select.mat-form-field-appearance-fill .mat-form-field-infix::after{margin-top:-10px}\\n\", \".mat-form-field-appearance-legacy .mat-form-field-label{transform:perspective(100px);-ms-transform:none}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-icon,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-icon{width:1em}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-icon-button,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-icon-button{font:inherit;vertical-align:baseline}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-icon-button .mat-icon{font-size:inherit}.mat-form-field-appearance-legacy .mat-form-field-underline{height:1px}.cdk-high-contrast-active .mat-form-field-appearance-legacy .mat-form-field-underline{height:0;border-top:solid 1px}.mat-form-field-appearance-legacy .mat-form-field-ripple{top:0;height:2px;overflow:hidden}.cdk-high-contrast-active .mat-form-field-appearance-legacy .mat-form-field-ripple{height:0;border-top:solid 2px}.mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{background-position:0;background-color:transparent}.cdk-high-contrast-active .mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{border-top-style:dotted;border-top-width:2px}.mat-form-field-appearance-legacy.mat-form-field-invalid:not(.mat-focused) .mat-form-field-ripple{height:1px}\\n\", \".mat-form-field-appearance-outline .mat-form-field-wrapper{margin:.25em 0}.mat-form-field-appearance-outline .mat-form-field-flex{padding:0 .75em 0 .75em;margin-top:-0.25em;position:relative}.mat-form-field-appearance-outline .mat-form-field-prefix,.mat-form-field-appearance-outline .mat-form-field-suffix{top:.25em}.mat-form-field-appearance-outline .mat-form-field-outline{display:flex;position:absolute;top:.25em;left:0;right:0;bottom:0;pointer-events:none}.mat-form-field-appearance-outline .mat-form-field-outline-start,.mat-form-field-appearance-outline .mat-form-field-outline-end{border:1px solid currentColor;min-width:5px}.mat-form-field-appearance-outline .mat-form-field-outline-start{border-radius:5px 0 0 5px;border-right-style:none}[dir=rtl] .mat-form-field-appearance-outline .mat-form-field-outline-start{border-right-style:solid;border-left-style:none;border-radius:0 5px 5px 0}.mat-form-field-appearance-outline .mat-form-field-outline-end{border-radius:0 5px 5px 0;border-left-style:none;flex-grow:1}[dir=rtl] .mat-form-field-appearance-outline .mat-form-field-outline-end{border-left-style:solid;border-right-style:none;border-radius:5px 0 0 5px}.mat-form-field-appearance-outline .mat-form-field-outline-gap{border-radius:.000001px;border:1px solid currentColor;border-left-style:none;border-right-style:none}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-outline-gap{border-top-color:transparent}.mat-form-field-appearance-outline .mat-form-field-outline-thick{opacity:0}.mat-form-field-appearance-outline .mat-form-field-outline-thick .mat-form-field-outline-start,.mat-form-field-appearance-outline .mat-form-field-outline-thick .mat-form-field-outline-end,.mat-form-field-appearance-outline .mat-form-field-outline-thick .mat-form-field-outline-gap{border-width:2px}.mat-form-field-appearance-outline.mat-focused .mat-form-field-outline,.mat-form-field-appearance-outline.mat-form-field-invalid .mat-form-field-outline{opacity:0;transition:opacity 100ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick,.mat-form-field-appearance-outline.mat-form-field-invalid .mat-form-field-outline-thick{opacity:1}.mat-form-field-appearance-outline:not(.mat-form-field-disabled) .mat-form-field-flex:hover .mat-form-field-outline{opacity:0;transition:opacity 600ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-outline:not(.mat-form-field-disabled) .mat-form-field-flex:hover .mat-form-field-outline-thick{opacity:1}.mat-form-field-appearance-outline .mat-form-field-subscript-wrapper{padding:0 1em}.mat-form-field-appearance-outline._mat-animation-noopable:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-outline,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline-start,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline-end,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline-gap{transition:none}\\n\", \".mat-form-field-appearance-standard .mat-form-field-flex{padding-top:.75em}.mat-form-field-appearance-standard .mat-form-field-underline{height:1px}.cdk-high-contrast-active .mat-form-field-appearance-standard .mat-form-field-underline{height:0;border-top:solid 1px}.mat-form-field-appearance-standard .mat-form-field-ripple{bottom:0;height:2px}.cdk-high-contrast-active .mat-form-field-appearance-standard .mat-form-field-ripple{height:0;border-top:2px}.mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{background-position:0;background-color:transparent}.cdk-high-contrast-active .mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{border-top-style:dotted;border-top-width:2px}.mat-form-field-appearance-standard:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{opacity:1;transform:none;transition:opacity 600ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-standard._mat-animation-noopable:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{transition:none}\\n\"]\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: ɵngcc0.ChangeDetectorRef }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MAT_LABEL_GLOBAL_OPTIONS]\n            }] }, { type: ɵngcc1.Directionality, decorators: [{\n                type: Optional\n            }] }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MAT_FORM_FIELD_DEFAULT_OPTIONS]\n            }] }, { type: ɵngcc2.Platform }, { type: ɵngcc0.NgZone }, { type: String, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [ANIMATION_MODULE_TYPE]\n            }] }]; }, { floatLabel: [{\n            type: Input\n        }], appearance: [{\n            type: Input\n        }], hideRequiredMarker: [{\n            type: Input\n        }], hintLabel: [{\n            type: Input\n        }], underlineRef: [{\n            type: ViewChild,\n            args: ['underline']\n        }], _connectionContainerRef: [{\n            type: ViewChild,\n            args: ['connectionContainer', { static: true }]\n        }], _inputContainerRef: [{\n            type: ViewChild,\n            args: ['inputContainer']\n        }], _label: [{\n            type: ViewChild,\n            args: ['label']\n        }], _controlNonStatic: [{\n            type: ContentChild,\n            args: [MatFormFieldControl]\n        }], _controlStatic: [{\n            type: ContentChild,\n            args: [MatFormFieldControl, { static: true }]\n        }], _labelChildNonStatic: [{\n            type: ContentChild,\n            args: [MatLabel]\n        }], _labelChildStatic: [{\n            type: ContentChild,\n            args: [MatLabel, { static: true }]\n        }], _placeholderChild: [{\n            type: ContentChild,\n            args: [MatPlaceholder]\n        }], _errorChildren: [{\n            type: ContentChildren,\n            args: [MatError, { descendants: true }]\n        }], _hintChildren: [{\n            type: ContentChildren,\n            args: [MatHint, { descendants: true }]\n        }], _prefixChildren: [{\n            type: ContentChildren,\n            args: [MatPrefix, { descendants: true }]\n        }], _suffixChildren: [{\n            type: ContentChildren,\n            args: [MatSuffix, { descendants: true }]\n        }] }); })();\nif (false) {\n    /** @type {?} */\n    MatFormField.ngAcceptInputType_hideRequiredMarker;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatFormField.prototype._labelOptions;\n    /**\n     * Whether the outline gap needs to be calculated\n     * immediately on the next change detection run.\n     * @type {?}\n     * @private\n     */\n    MatFormField.prototype._outlineGapCalculationNeededImmediately;\n    /**\n     * Whether the outline gap needs to be calculated next time the zone has stabilized.\n     * @type {?}\n     * @private\n     */\n    MatFormField.prototype._outlineGapCalculationNeededOnStable;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatFormField.prototype._destroyed;\n    /** @type {?} */\n    MatFormField.prototype._appearance;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatFormField.prototype._hideRequiredMarker;\n    /**\n     * Override for the logic that disables the label animation in certain cases.\n     * @type {?}\n     * @private\n     */\n    MatFormField.prototype._showAlwaysAnimate;\n    /**\n     * State of the mat-hint and mat-error animations.\n     * @type {?}\n     */\n    MatFormField.prototype._subscriptAnimationState;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatFormField.prototype._hintLabel;\n    /** @type {?} */\n    MatFormField.prototype._hintLabelId;\n    /** @type {?} */\n    MatFormField.prototype._labelId;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatFormField.prototype._floatLabel;\n    /**\n     * Whether the Angular animations are enabled.\n     * @type {?}\n     */\n    MatFormField.prototype._animationsEnabled;\n    /**\n     * @deprecated\n     * \\@breaking-change 8.0.0\n     * @type {?}\n     */\n    MatFormField.prototype.underlineRef;\n    /** @type {?} */\n    MatFormField.prototype._connectionContainerRef;\n    /** @type {?} */\n    MatFormField.prototype._inputContainerRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatFormField.prototype._label;\n    /** @type {?} */\n    MatFormField.prototype._controlNonStatic;\n    /** @type {?} */\n    MatFormField.prototype._controlStatic;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatFormField.prototype._explicitFormFieldControl;\n    /** @type {?} */\n    MatFormField.prototype._labelChildNonStatic;\n    /** @type {?} */\n    MatFormField.prototype._labelChildStatic;\n    /** @type {?} */\n    MatFormField.prototype._placeholderChild;\n    /** @type {?} */\n    MatFormField.prototype._errorChildren;\n    /** @type {?} */\n    MatFormField.prototype._hintChildren;\n    /** @type {?} */\n    MatFormField.prototype._prefixChildren;\n    /** @type {?} */\n    MatFormField.prototype._suffixChildren;\n    /** @type {?} */\n    MatFormField.prototype._elementRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatFormField.prototype._changeDetectorRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatFormField.prototype._dir;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatFormField.prototype._defaults;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatFormField.prototype._platform;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatFormField.prototype._ngZone;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/form-field/form-field-module.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass MatFormFieldModule {\n}\nMatFormFieldModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: MatFormFieldModule });\nMatFormFieldModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function MatFormFieldModule_Factory(t) { return new (t || MatFormFieldModule)(); }, imports: [[\n            CommonModule,\n            ObserversModule,\n        ]] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(MatFormFieldModule, { declarations: function () { return [MatError,\n        MatFormField,\n        MatHint,\n        MatLabel,\n        MatPlaceholder,\n        MatPrefix,\n        MatSuffix]; }, imports: function () { return [CommonModule,\n        ObserversModule]; }, exports: function () { return [MatError,\n        MatFormField,\n        MatHint,\n        MatLabel,\n        MatPlaceholder,\n        MatPrefix,\n        MatSuffix]; } }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatFormFieldModule, [{\n        type: NgModule,\n        args: [{\n                declarations: [\n                    MatError,\n                    MatFormField,\n                    MatHint,\n                    MatLabel,\n                    MatPlaceholder,\n                    MatPrefix,\n                    MatSuffix,\n                ],\n                imports: [\n                    CommonModule,\n                    ObserversModule,\n                ],\n                exports: [\n                    MatError,\n                    MatFormField,\n                    MatHint,\n                    MatLabel,\n                    MatPlaceholder,\n                    MatPrefix,\n                    MatSuffix,\n                ]\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/form-field/public-api.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 { MAT_FORM_FIELD, MAT_FORM_FIELD_DEFAULT_OPTIONS, MatError, MatFormField, MatFormFieldControl, MatFormFieldModule, MatHint, MatLabel, MatPlaceholder, MatPrefix, MatSuffix, getMatFormFieldDuplicatedHintError, getMatFormFieldMissingControlError, getMatFormFieldPlaceholderConflictError, matFormFieldAnimations };\n\n//# sourceMappingURL=form-field.js.map","import { CdkTextareaAutosize, AutofillMonitor, TextFieldModule } from '@angular/cdk/text-field';\nimport { Directive, Input, InjectionToken, ElementRef, Optional, Self, Inject, NgZone, HostListener, NgModule } from '@angular/core';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { getSupportedInputTypes, Platform } from '@angular/cdk/platform';\nimport { NgControl, NgForm, FormGroupDirective } from '@angular/forms';\nimport { mixinErrorState, ErrorStateMatcher } from '@angular/material/core';\nimport { MatFormFieldControl, MatFormFieldModule } from '@angular/material/form-field';\nimport { Subject } from 'rxjs';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/input/autosize.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Directive to automatically resize a textarea to fit its content.\n * @deprecated Use `cdkTextareaAutosize` from `\\@angular/cdk/text-field` instead.\n * \\@breaking-change 8.0.0\n */\nimport * as ɵngcc0 from '@angular/core';\nimport * as ɵngcc1 from '@angular/cdk/platform';\nimport * as ɵngcc2 from '@angular/forms';\nimport * as ɵngcc3 from '@angular/material/core';\nimport * as ɵngcc4 from '@angular/cdk/text-field';\nclass MatTextareaAutosize extends CdkTextareaAutosize {\n    /**\n     * @return {?}\n     */\n    get matAutosizeMinRows() { return this.minRows; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set matAutosizeMinRows(value) { this.minRows = value; }\n    /**\n     * @return {?}\n     */\n    get matAutosizeMaxRows() { return this.maxRows; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set matAutosizeMaxRows(value) { this.maxRows = value; }\n    /**\n     * @return {?}\n     */\n    get matAutosize() { return this.enabled; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set matAutosize(value) { this.enabled = value; }\n    /**\n     * @return {?}\n     */\n    get matTextareaAutosize() { return this.enabled; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set matTextareaAutosize(value) { this.enabled = value; }\n}\nMatTextareaAutosize.ɵfac = function MatTextareaAutosize_Factory(t) { return ɵMatTextareaAutosize_BaseFactory(t || MatTextareaAutosize); };\nMatTextareaAutosize.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatTextareaAutosize, selectors: [[\"textarea\", \"mat-autosize\", \"\"], [\"textarea\", \"matTextareaAutosize\", \"\"]], hostAttrs: [\"rows\", \"1\", 1, \"cdk-textarea-autosize\", \"mat-autosize\"], inputs: { cdkAutosizeMinRows: \"cdkAutosizeMinRows\", cdkAutosizeMaxRows: \"cdkAutosizeMaxRows\", matAutosizeMinRows: \"matAutosizeMinRows\", matAutosizeMaxRows: \"matAutosizeMaxRows\", matAutosize: [\"mat-autosize\", \"matAutosize\"], matTextareaAutosize: \"matTextareaAutosize\" }, exportAs: [\"matTextareaAutosize\"], features: [ɵngcc0.ɵɵInheritDefinitionFeature] });\nMatTextareaAutosize.propDecorators = {\n    matAutosizeMinRows: [{ type: Input }],\n    matAutosizeMaxRows: [{ type: Input }],\n    matAutosize: [{ type: Input, args: ['mat-autosize',] }],\n    matTextareaAutosize: [{ type: Input }]\n};\nconst ɵMatTextareaAutosize_BaseFactory = ɵngcc0.ɵɵgetInheritedFactory(MatTextareaAutosize);\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatTextareaAutosize, [{\n        type: Directive,\n        args: [{\n                selector: 'textarea[mat-autosize], textarea[matTextareaAutosize]',\n                exportAs: 'matTextareaAutosize',\n                inputs: ['cdkAutosizeMinRows', 'cdkAutosizeMaxRows'],\n                host: {\n                    'class': 'cdk-textarea-autosize mat-autosize',\n                    // Textarea elements that have the directive applied should have a single row by default.\n                    // Browsers normally show two rows by default and therefore this limits the minRows binding.\n                    'rows': '1'\n                }\n            }]\n    }], null, { matAutosizeMinRows: [{\n            type: Input\n        }], matAutosizeMaxRows: [{\n            type: Input\n        }], matAutosize: [{\n            type: Input,\n            args: ['mat-autosize']\n        }], matTextareaAutosize: [{\n            type: Input\n        }] }); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/input/input-errors.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 * \\@docs-private\n * @param {?} type\n * @return {?}\n */\nfunction getMatInputUnsupportedTypeError(type) {\n    return Error(`Input type \"${type}\" isn't supported by matInput.`);\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/input/input-value-accessor.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * This token is used to inject the object whose value should be set into `MatInput`. If none is\n * provided, the native `HTMLInputElement` is used. Directives like `MatDatepickerInput` can provide\n * themselves for this token, in order to make `MatInput` delegate the getting and setting of the\n * value to them.\n * @type {?}\n */\nconst MAT_INPUT_VALUE_ACCESSOR = new InjectionToken('MAT_INPUT_VALUE_ACCESSOR');\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/input/input.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n// Invalid input type. Using one of these will throw an MatInputUnsupportedTypeError.\n/** @type {?} */\nconst MAT_INPUT_INVALID_TYPES = [\n    'button',\n    'checkbox',\n    'file',\n    'hidden',\n    'image',\n    'radio',\n    'range',\n    'reset',\n    'submit'\n];\n/** @type {?} */\nlet nextUniqueId = 0;\n// Boilerplate for applying mixins to MatInput.\n/**\n * \\@docs-private\n */\nclass MatInputBase {\n    /**\n     * @param {?} _defaultErrorStateMatcher\n     * @param {?} _parentForm\n     * @param {?} _parentFormGroup\n     * @param {?} ngControl\n     */\n    constructor(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl) {\n        this._defaultErrorStateMatcher = _defaultErrorStateMatcher;\n        this._parentForm = _parentForm;\n        this._parentFormGroup = _parentFormGroup;\n        this.ngControl = ngControl;\n    }\n}\nif (false) {\n    /** @type {?} */\n    MatInputBase.prototype._defaultErrorStateMatcher;\n    /** @type {?} */\n    MatInputBase.prototype._parentForm;\n    /** @type {?} */\n    MatInputBase.prototype._parentFormGroup;\n    /**\n     * \\@docs-private\n     * @type {?}\n     */\n    MatInputBase.prototype.ngControl;\n}\n/** @type {?} */\nconst _MatInputMixinBase = mixinErrorState(MatInputBase);\n/**\n * Directive that allows a native input to work inside a `MatFormField`.\n */\nclass MatInput extends _MatInputMixinBase {\n    /**\n     * @param {?} _elementRef\n     * @param {?} _platform\n     * @param {?} ngControl\n     * @param {?} _parentForm\n     * @param {?} _parentFormGroup\n     * @param {?} _defaultErrorStateMatcher\n     * @param {?} inputValueAccessor\n     * @param {?} _autofillMonitor\n     * @param {?} ngZone\n     */\n    constructor(_elementRef, _platform, ngControl, _parentForm, _parentFormGroup, _defaultErrorStateMatcher, inputValueAccessor, _autofillMonitor, ngZone) {\n        super(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl);\n        this._elementRef = _elementRef;\n        this._platform = _platform;\n        this.ngControl = ngControl;\n        this._autofillMonitor = _autofillMonitor;\n        this._uid = `mat-input-${nextUniqueId++}`;\n        /**\n         * Whether the component is being rendered on the server.\n         */\n        this._isServer = false;\n        /**\n         * Whether the component is a native html select.\n         */\n        this._isNativeSelect = false;\n        /**\n         * Implemented as part of MatFormFieldControl.\n         * \\@docs-private\n         */\n        this.focused = false;\n        /**\n         * Implemented as part of MatFormFieldControl.\n         * \\@docs-private\n         */\n        this.stateChanges = new Subject();\n        /**\n         * Implemented as part of MatFormFieldControl.\n         * \\@docs-private\n         */\n        this.controlType = 'mat-input';\n        /**\n         * Implemented as part of MatFormFieldControl.\n         * \\@docs-private\n         */\n        this.autofilled = false;\n        this._disabled = false;\n        this._required = false;\n        this._type = 'text';\n        this._readonly = false;\n        this._neverEmptyInputTypes = [\n            'date',\n            'datetime',\n            'datetime-local',\n            'month',\n            'time',\n            'week'\n        ].filter((/**\n         * @param {?} t\n         * @return {?}\n         */\n        t => getSupportedInputTypes().has(t)));\n        /** @type {?} */\n        const element = this._elementRef.nativeElement;\n        // If no input value accessor was explicitly specified, use the element as the input value\n        // accessor.\n        this._inputValueAccessor = inputValueAccessor || element;\n        this._previousNativeValue = this.value;\n        // Force setter to be called in case id was not specified.\n        this.id = this.id;\n        // On some versions of iOS the caret gets stuck in the wrong place when holding down the delete\n        // key. In order to get around this we need to \"jiggle\" the caret loose. Since this bug only\n        // exists on iOS, we only bother to install the listener on iOS.\n        if (_platform.IOS) {\n            ngZone.runOutsideAngular((/**\n             * @return {?}\n             */\n            () => {\n                _elementRef.nativeElement.addEventListener('keyup', (/**\n                 * @param {?} event\n                 * @return {?}\n                 */\n                (event) => {\n                    /** @type {?} */\n                    let el = (/** @type {?} */ (event.target));\n                    if (!el.value && !el.selectionStart && !el.selectionEnd) {\n                        // Note: Just setting `0, 0` doesn't fix the issue. Setting\n                        // `1, 1` fixes it for the first time that you type text and\n                        // then hold delete. Toggling to `1, 1` and then back to\n                        // `0, 0` seems to completely fix it.\n                        el.setSelectionRange(1, 1);\n                        el.setSelectionRange(0, 0);\n                    }\n                }));\n            }));\n        }\n        this._isServer = !this._platform.isBrowser;\n        this._isNativeSelect = element.nodeName.toLowerCase() === 'select';\n        if (this._isNativeSelect) {\n            this.controlType = ((/** @type {?} */ (element))).multiple ? 'mat-native-select-multiple' :\n                'mat-native-select';\n        }\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * \\@docs-private\n     * @return {?}\n     */\n    get disabled() {\n        if (this.ngControl && this.ngControl.disabled !== null) {\n            return this.ngControl.disabled;\n        }\n        return this._disabled;\n    }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set disabled(value) {\n        this._disabled = coerceBooleanProperty(value);\n        // Browsers may not fire the blur event if the input is disabled too quickly.\n        // Reset from here to ensure that the element doesn't become stuck.\n        if (this.focused) {\n            this.focused = false;\n            this.stateChanges.next();\n        }\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * \\@docs-private\n     * @return {?}\n     */\n    get id() { return this._id; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set id(value) { this._id = value || this._uid; }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * \\@docs-private\n     * @return {?}\n     */\n    get required() { return this._required; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set required(value) { this._required = coerceBooleanProperty(value); }\n    /**\n     * Input type of the element.\n     * @return {?}\n     */\n    get type() { return this._type; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set type(value) {\n        this._type = value || 'text';\n        this._validateType();\n        // When using Angular inputs, developers are no longer able to set the properties on the native\n        // input element. To ensure that bindings for `type` work, we need to sync the setter\n        // with the native property. Textarea elements don't support the type property or attribute.\n        if (!this._isTextarea() && getSupportedInputTypes().has(this._type)) {\n            ((/** @type {?} */ (this._elementRef.nativeElement))).type = this._type;\n        }\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * \\@docs-private\n     * @return {?}\n     */\n    get value() { return this._inputValueAccessor.value; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set value(value) {\n        if (value !== this.value) {\n            this._inputValueAccessor.value = value;\n            this.stateChanges.next();\n        }\n    }\n    /**\n     * Whether the element is readonly.\n     * @return {?}\n     */\n    get readonly() { return this._readonly; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set readonly(value) { this._readonly = coerceBooleanProperty(value); }\n    /**\n     * @return {?}\n     */\n    ngOnInit() {\n        if (this._platform.isBrowser) {\n            this._autofillMonitor.monitor(this._elementRef.nativeElement).subscribe((/**\n             * @param {?} event\n             * @return {?}\n             */\n            event => {\n                this.autofilled = event.isAutofilled;\n                this.stateChanges.next();\n            }));\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngOnChanges() {\n        this.stateChanges.next();\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this.stateChanges.complete();\n        if (this._platform.isBrowser) {\n            this._autofillMonitor.stopMonitoring(this._elementRef.nativeElement);\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngDoCheck() {\n        if (this.ngControl) {\n            // We need to re-evaluate this on every change detection cycle, because there are some\n            // error triggers that we can't subscribe to (e.g. parent form submissions). This means\n            // that whatever logic is in here has to be super lean or we risk destroying the performance.\n            this.updateErrorState();\n        }\n        // We need to dirty-check the native element's value, because there are some cases where\n        // we won't be notified when it changes (e.g. the consumer isn't using forms or they're\n        // updating the value using `emitEvent: false`).\n        this._dirtyCheckNativeValue();\n    }\n    /**\n     * Focuses the input.\n     * @param {?=} options\n     * @return {?}\n     */\n    focus(options) {\n        this._elementRef.nativeElement.focus(options);\n    }\n    // We have to use a `HostListener` here in order to support both Ivy and ViewEngine.\n    // In Ivy the `host` bindings will be merged when this class is extended, whereas in\n    // ViewEngine they're overwritten.\n    // TODO(crisbeto): we move this back into `host` once Ivy is turned on by default.\n    /**\n     * Callback for the cases where the focused state of the input changes.\n     * @param {?} isFocused\n     * @return {?}\n     */\n    // tslint:disable:no-host-decorator-in-concrete\n    // tslint:enable:no-host-decorator-in-concrete\n    _focusChanged(isFocused) {\n        if (isFocused !== this.focused && (!this.readonly || !isFocused)) {\n            this.focused = isFocused;\n            this.stateChanges.next();\n        }\n    }\n    // We have to use a `HostListener` here in order to support both Ivy and ViewEngine.\n    // In Ivy the `host` bindings will be merged when this class is extended, whereas in\n    // ViewEngine they're overwritten.\n    // TODO(crisbeto): we move this back into `host` once Ivy is turned on by default.\n    // tslint:disable-next-line:no-host-decorator-in-concrete\n    /**\n     * @return {?}\n     */\n    _onInput() {\n        // This is a noop function and is used to let Angular know whenever the value changes.\n        // Angular will run a new change detection each time the `input` event has been dispatched.\n        // It's necessary that Angular recognizes the value change, because when floatingLabel\n        // is set to false and Angular forms aren't used, the placeholder won't recognize the\n        // value changes and will not disappear.\n        // Listening to the input event wouldn't be necessary when the input is using the\n        // FormsModule or ReactiveFormsModule, because Angular forms also listens to input events.\n    }\n    /**\n     * Determines if the component host is a textarea.\n     * @return {?}\n     */\n    _isTextarea() {\n        return this._elementRef.nativeElement.nodeName.toLowerCase() === 'textarea';\n    }\n    /**\n     * Does some manual dirty checking on the native input `value` property.\n     * @protected\n     * @return {?}\n     */\n    _dirtyCheckNativeValue() {\n        /** @type {?} */\n        const newValue = this._elementRef.nativeElement.value;\n        if (this._previousNativeValue !== newValue) {\n            this._previousNativeValue = newValue;\n            this.stateChanges.next();\n        }\n    }\n    /**\n     * Make sure the input is a supported type.\n     * @protected\n     * @return {?}\n     */\n    _validateType() {\n        if (MAT_INPUT_INVALID_TYPES.indexOf(this._type) > -1) {\n            throw getMatInputUnsupportedTypeError(this._type);\n        }\n    }\n    /**\n     * Checks whether the input type is one of the types that are never empty.\n     * @protected\n     * @return {?}\n     */\n    _isNeverEmpty() {\n        return this._neverEmptyInputTypes.indexOf(this._type) > -1;\n    }\n    /**\n     * Checks whether the input is invalid based on the native validation.\n     * @protected\n     * @return {?}\n     */\n    _isBadInput() {\n        // The `validity` property won't be present on platform-server.\n        /** @type {?} */\n        let validity = ((/** @type {?} */ (this._elementRef.nativeElement))).validity;\n        return validity && validity.badInput;\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * \\@docs-private\n     * @return {?}\n     */\n    get empty() {\n        return !this._isNeverEmpty() && !this._elementRef.nativeElement.value && !this._isBadInput() &&\n            !this.autofilled;\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * \\@docs-private\n     * @return {?}\n     */\n    get shouldLabelFloat() {\n        if (this._isNativeSelect) {\n            // For a single-selection `<select>`, the label should float when the selected option has\n            // a non-empty display value. For a `<select multiple>`, the label *always* floats to avoid\n            // overlapping the label with the options.\n            /** @type {?} */\n            const selectElement = (/** @type {?} */ (this._elementRef.nativeElement));\n            /** @type {?} */\n            const firstOption = selectElement.options[0];\n            // On most browsers the `selectedIndex` will always be 0, however on IE and Edge it'll be\n            // -1 if the `value` is set to something, that isn't in the list of options, at a later point.\n            return this.focused || selectElement.multiple || !this.empty ||\n                !!(selectElement.selectedIndex > -1 && firstOption && firstOption.label);\n        }\n        else {\n            return this.focused || !this.empty;\n        }\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * \\@docs-private\n     * @param {?} ids\n     * @return {?}\n     */\n    setDescribedByIds(ids) {\n        this._ariaDescribedby = ids.join(' ');\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * \\@docs-private\n     * @return {?}\n     */\n    onContainerClick() {\n        // Do not re-focus the input element if the element is already focused. Otherwise it can happen\n        // that someone clicks on a time input and the cursor resets to the \"hours\" field while the\n        // \"minutes\" field was actually clicked. See: https://github.com/angular/components/issues/12849\n        if (!this.focused) {\n            this.focus();\n        }\n    }\n}\nMatInput.ɵfac = function MatInput_Factory(t) { return new (t || MatInput)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.Platform), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.NgControl, 10), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.NgForm, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.FormGroupDirective, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc3.ErrorStateMatcher), ɵngcc0.ɵɵdirectiveInject(MAT_INPUT_VALUE_ACCESSOR, 10), ɵngcc0.ɵɵdirectiveInject(ɵngcc4.AutofillMonitor), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone)); };\nMatInput.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatInput, selectors: [[\"input\", \"matInput\", \"\"], [\"textarea\", \"matInput\", \"\"], [\"select\", \"matNativeControl\", \"\"], [\"input\", \"matNativeControl\", \"\"], [\"textarea\", \"matNativeControl\", \"\"]], hostAttrs: [1, \"mat-input-element\", \"mat-form-field-autofill-control\"], hostVars: 10, hostBindings: function MatInput_HostBindings(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵlistener(\"focus\", function MatInput_focus_HostBindingHandler() { return ctx._focusChanged(true); })(\"blur\", function MatInput_blur_HostBindingHandler() { return ctx._focusChanged(false); })(\"input\", function MatInput_input_HostBindingHandler() { return ctx._onInput(); });\n    } if (rf & 2) {\n        ɵngcc0.ɵɵhostProperty(\"disabled\", ctx.disabled)(\"required\", ctx.required);\n        ɵngcc0.ɵɵattribute(\"id\", ctx.id)(\"placeholder\", ctx.placeholder)(\"readonly\", ctx.readonly && !ctx._isNativeSelect || null)(\"aria-describedby\", ctx._ariaDescribedby || null)(\"aria-invalid\", ctx.errorState)(\"aria-required\", ctx.required.toString());\n        ɵngcc0.ɵɵclassProp(\"mat-input-server\", ctx._isServer);\n    } }, inputs: { id: \"id\", disabled: \"disabled\", required: \"required\", type: \"type\", value: \"value\", readonly: \"readonly\", placeholder: \"placeholder\", errorStateMatcher: \"errorStateMatcher\" }, exportAs: [\"matInput\"], features: [ɵngcc0.ɵɵProvidersFeature([{ provide: MatFormFieldControl, useExisting: MatInput }]), ɵngcc0.ɵɵInheritDefinitionFeature, ɵngcc0.ɵɵNgOnChangesFeature] });\n/** @nocollapse */\nMatInput.ctorParameters = () => [\n    { type: ElementRef },\n    { type: Platform },\n    { type: NgControl, decorators: [{ type: Optional }, { type: Self }] },\n    { type: NgForm, decorators: [{ type: Optional }] },\n    { type: FormGroupDirective, decorators: [{ type: Optional }] },\n    { type: ErrorStateMatcher },\n    { type: undefined, decorators: [{ type: Optional }, { type: Self }, { type: Inject, args: [MAT_INPUT_VALUE_ACCESSOR,] }] },\n    { type: AutofillMonitor },\n    { type: NgZone }\n];\nMatInput.propDecorators = {\n    disabled: [{ type: Input }],\n    id: [{ type: Input }],\n    placeholder: [{ type: Input }],\n    required: [{ type: Input }],\n    type: [{ type: Input }],\n    errorStateMatcher: [{ type: Input }],\n    value: [{ type: Input }],\n    readonly: [{ type: Input }],\n    _focusChanged: [{ type: HostListener, args: ['focus', ['true'],] }, { type: HostListener, args: ['blur', ['false'],] }],\n    _onInput: [{ type: HostListener, args: ['input',] }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatInput, [{\n        type: Directive,\n        args: [{\n                selector: `input[matInput], textarea[matInput], select[matNativeControl],\n      input[matNativeControl], textarea[matNativeControl]`,\n                exportAs: 'matInput',\n                host: {\n                    /**\n                     * \\@breaking-change 8.0.0 remove .mat-form-field-autofill-control in favor of AutofillMonitor.\n                     */\n                    'class': 'mat-input-element mat-form-field-autofill-control',\n                    '[class.mat-input-server]': '_isServer',\n                    // Native input properties that are overwritten by Angular inputs need to be synced with\n                    // the native input element. Otherwise property bindings for those don't work.\n                    '[attr.id]': 'id',\n                    '[attr.placeholder]': 'placeholder',\n                    '[disabled]': 'disabled',\n                    '[required]': 'required',\n                    '[attr.readonly]': 'readonly && !_isNativeSelect || null',\n                    '[attr.aria-describedby]': '_ariaDescribedby || null',\n                    '[attr.aria-invalid]': 'errorState',\n                    '[attr.aria-required]': 'required.toString()'\n                },\n                providers: [{ provide: MatFormFieldControl, useExisting: MatInput }]\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: ɵngcc1.Platform }, { type: ɵngcc2.NgControl, decorators: [{\n                type: Optional\n            }, {\n                type: Self\n            }] }, { type: ɵngcc2.NgForm, decorators: [{\n                type: Optional\n            }] }, { type: ɵngcc2.FormGroupDirective, decorators: [{\n                type: Optional\n            }] }, { type: ɵngcc3.ErrorStateMatcher }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Self\n            }, {\n                type: Inject,\n                args: [MAT_INPUT_VALUE_ACCESSOR]\n            }] }, { type: ɵngcc4.AutofillMonitor }, { type: ɵngcc0.NgZone }]; }, { id: [{\n            type: Input\n        }], disabled: [{\n            type: Input\n        }], required: [{\n            type: Input\n        }], type: [{\n            type: Input\n        }], value: [{\n            type: Input\n        }], readonly: [{\n            type: Input\n        }], _focusChanged: [{\n            type: HostListener,\n            args: ['focus', ['true']]\n        }, {\n            type: HostListener,\n            args: ['blur', ['false']]\n        }], _onInput: [{\n            type: HostListener,\n            args: ['input']\n        }], placeholder: [{\n            type: Input\n        }], errorStateMatcher: [{\n            type: Input\n        }] }); })();\nif (false) {\n    /** @type {?} */\n    MatInput.ngAcceptInputType_disabled;\n    /** @type {?} */\n    MatInput.ngAcceptInputType_readonly;\n    /** @type {?} */\n    MatInput.ngAcceptInputType_required;\n    /** @type {?} */\n    MatInput.ngAcceptInputType_value;\n    /**\n     * @type {?}\n     * @protected\n     */\n    MatInput.prototype._uid;\n    /**\n     * @type {?}\n     * @protected\n     */\n    MatInput.prototype._previousNativeValue;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatInput.prototype._inputValueAccessor;\n    /**\n     * The aria-describedby attribute on the input for improved a11y.\n     * @type {?}\n     */\n    MatInput.prototype._ariaDescribedby;\n    /**\n     * Whether the component is being rendered on the server.\n     * @type {?}\n     */\n    MatInput.prototype._isServer;\n    /**\n     * Whether the component is a native html select.\n     * @type {?}\n     */\n    MatInput.prototype._isNativeSelect;\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * \\@docs-private\n     * @type {?}\n     */\n    MatInput.prototype.focused;\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * \\@docs-private\n     * @type {?}\n     */\n    MatInput.prototype.stateChanges;\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * \\@docs-private\n     * @type {?}\n     */\n    MatInput.prototype.controlType;\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * \\@docs-private\n     * @type {?}\n     */\n    MatInput.prototype.autofilled;\n    /**\n     * @type {?}\n     * @protected\n     */\n    MatInput.prototype._disabled;\n    /**\n     * @type {?}\n     * @protected\n     */\n    MatInput.prototype._id;\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * \\@docs-private\n     * @type {?}\n     */\n    MatInput.prototype.placeholder;\n    /**\n     * @type {?}\n     * @protected\n     */\n    MatInput.prototype._required;\n    /**\n     * @type {?}\n     * @protected\n     */\n    MatInput.prototype._type;\n    /**\n     * An object used to control when error messages are shown.\n     * @type {?}\n     */\n    MatInput.prototype.errorStateMatcher;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatInput.prototype._readonly;\n    /**\n     * @type {?}\n     * @protected\n     */\n    MatInput.prototype._neverEmptyInputTypes;\n    /**\n     * @type {?}\n     * @protected\n     */\n    MatInput.prototype._elementRef;\n    /**\n     * @type {?}\n     * @protected\n     */\n    MatInput.prototype._platform;\n    /**\n     * \\@docs-private\n     * @type {?}\n     */\n    MatInput.prototype.ngControl;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatInput.prototype._autofillMonitor;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/input/input-module.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass MatInputModule {\n}\nMatInputModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: MatInputModule });\nMatInputModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function MatInputModule_Factory(t) { return new (t || MatInputModule)(); }, providers: [ErrorStateMatcher], imports: [[\n            TextFieldModule,\n            MatFormFieldModule,\n        ],\n        TextFieldModule,\n        // We re-export the `MatFormFieldModule` since `MatInput` will almost always\n        // be used together with `MatFormField`.\n        MatFormFieldModule] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(MatInputModule, { declarations: function () { return [MatInput,\n        MatTextareaAutosize]; }, imports: function () { return [TextFieldModule,\n        MatFormFieldModule]; }, exports: function () { return [TextFieldModule,\n        // We re-export the `MatFormFieldModule` since `MatInput` will almost always\n        // be used together with `MatFormField`.\n        MatFormFieldModule,\n        MatInput,\n        MatTextareaAutosize]; } }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatInputModule, [{\n        type: NgModule,\n        args: [{\n                declarations: [MatInput, MatTextareaAutosize],\n                imports: [\n                    TextFieldModule,\n                    MatFormFieldModule,\n                ],\n                exports: [\n                    TextFieldModule,\n                    // We re-export the `MatFormFieldModule` since `MatInput` will almost always\n                    // be used together with `MatFormField`.\n                    MatFormFieldModule,\n                    MatInput,\n                    MatTextareaAutosize,\n                ],\n                providers: [ErrorStateMatcher]\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/input/public-api.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 { MAT_INPUT_VALUE_ACCESSOR, MatInput, MatInputModule, MatTextareaAutosize, getMatInputUnsupportedTypeError };\n\n//# sourceMappingURL=input.js.map","import { A11yModule } from '@angular/cdk/a11y';\nimport { Overlay, OverlayConfig, OverlayModule } from '@angular/cdk/overlay';\nimport { ComponentPortal, PortalModule } from '@angular/cdk/portal';\nimport { DOCUMENT, CommonModule } from '@angular/common';\nimport { Injectable, ɵɵdefineInjectable, EventEmitter, Component, ViewEncapsulation, ChangeDetectionStrategy, ElementRef, NgZone, Input, Output, ChangeDetectorRef, Optional, Inject, ViewChild, forwardRef, InjectionToken, ViewContainerRef, Directive, Attribute, ContentChild, NgModule } from '@angular/core';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatDialog, MatDialogModule } from '@angular/material/dialog';\nimport { CdkScrollableModule } from '@angular/cdk/scrolling';\nimport { MAT_DATE_FORMATS, DateAdapter, mixinColor } from '@angular/material/core';\nimport { Subject, Subscription, merge, of } from 'rxjs';\nimport { SPACE, ENTER, PAGE_DOWN, PAGE_UP, END, HOME, DOWN_ARROW, UP_ARROW, RIGHT_ARROW, LEFT_ARROW, ESCAPE } from '@angular/cdk/keycodes';\nimport { Directionality } from '@angular/cdk/bidi';\nimport { take, startWith, filter } from 'rxjs/operators';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { trigger, state, style, transition, animate } from '@angular/animations';\nimport { NG_VALUE_ACCESSOR, NG_VALIDATORS, Validators } from '@angular/forms';\nimport { MatFormField, MAT_FORM_FIELD } from '@angular/material/form-field';\nimport { MAT_INPUT_VALUE_ACCESSOR } from '@angular/material/input';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/datepicker/datepicker-errors.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 * \\@docs-private\n * @param {?} provider\n * @return {?}\n */\nimport * as ɵngcc0 from '@angular/core';\nimport * as ɵngcc1 from '@angular/common';\nimport * as ɵngcc2 from '@angular/material/core';\nimport * as ɵngcc3 from '@angular/cdk/bidi';\nimport * as ɵngcc4 from '@angular/material/button';\nimport * as ɵngcc5 from '@angular/cdk/a11y';\nimport * as ɵngcc6 from '@angular/cdk/portal';\nimport * as ɵngcc7 from '@angular/material/dialog';\nimport * as ɵngcc8 from '@angular/cdk/overlay';\nimport * as ɵngcc9 from '@angular/material/form-field';\n\nconst _c0 = [\"mat-calendar-body\", \"\"];\nfunction MatCalendarBody_tr_0_Template(rf, ctx) { if (rf & 1) {\n    ɵngcc0.ɵɵelementStart(0, \"tr\", 2);\n    ɵngcc0.ɵɵelementStart(1, \"td\", 3);\n    ɵngcc0.ɵɵtext(2);\n    ɵngcc0.ɵɵelementEnd();\n    ɵngcc0.ɵɵelementEnd();\n} if (rf & 2) {\n    const ctx_r0 = ɵngcc0.ɵɵnextContext();\n    ɵngcc0.ɵɵadvance(1);\n    ɵngcc0.ɵɵstyleProp(\"padding-top\", ctx_r0._cellPadding)(\"padding-bottom\", ctx_r0._cellPadding);\n    ɵngcc0.ɵɵattribute(\"colspan\", ctx_r0.numCols);\n    ɵngcc0.ɵɵadvance(1);\n    ɵngcc0.ɵɵtextInterpolate1(\" \", ctx_r0.label, \" \");\n} }\nfunction MatCalendarBody_tr_1_td_1_Template(rf, ctx) { if (rf & 1) {\n    ɵngcc0.ɵɵelementStart(0, \"td\", 7);\n    ɵngcc0.ɵɵtext(1);\n    ɵngcc0.ɵɵelementEnd();\n} if (rf & 2) {\n    const ctx_r4 = ɵngcc0.ɵɵnextContext(2);\n    ɵngcc0.ɵɵstyleProp(\"padding-top\", ctx_r4._cellPadding)(\"padding-bottom\", ctx_r4._cellPadding);\n    ɵngcc0.ɵɵattribute(\"colspan\", ctx_r4._firstRowOffset);\n    ɵngcc0.ɵɵadvance(1);\n    ɵngcc0.ɵɵtextInterpolate1(\" \", ctx_r4._firstRowOffset >= ctx_r4.labelMinRequiredCells ? ctx_r4.label : \"\", \" \");\n} }\nfunction MatCalendarBody_tr_1_td_2_Template(rf, ctx) { if (rf & 1) {\n    const _r9 = ɵngcc0.ɵɵgetCurrentView();\n    ɵngcc0.ɵɵelementStart(0, \"td\", 8);\n    ɵngcc0.ɵɵlistener(\"click\", function MatCalendarBody_tr_1_td_2_Template_td_click_0_listener() { ɵngcc0.ɵɵrestoreView(_r9); const item_r6 = ctx.$implicit; const ctx_r8 = ɵngcc0.ɵɵnextContext(2); return ctx_r8._cellClicked(item_r6); });\n    ɵngcc0.ɵɵelementStart(1, \"div\", 9);\n    ɵngcc0.ɵɵtext(2);\n    ɵngcc0.ɵɵelementEnd();\n    ɵngcc0.ɵɵelementEnd();\n} if (rf & 2) {\n    const item_r6 = ctx.$implicit;\n    const colIndex_r7 = ctx.index;\n    const rowIndex_r3 = ɵngcc0.ɵɵnextContext().index;\n    const ctx_r5 = ɵngcc0.ɵɵnextContext();\n    ɵngcc0.ɵɵstyleProp(\"width\", ctx_r5._cellWidth)(\"padding-top\", ctx_r5._cellPadding)(\"padding-bottom\", ctx_r5._cellPadding);\n    ɵngcc0.ɵɵclassProp(\"mat-calendar-body-disabled\", !item_r6.enabled)(\"mat-calendar-body-active\", ctx_r5._isActiveCell(rowIndex_r3, colIndex_r7));\n    ɵngcc0.ɵɵproperty(\"ngClass\", item_r6.cssClasses)(\"tabindex\", ctx_r5._isActiveCell(rowIndex_r3, colIndex_r7) ? 0 : 0 - 1);\n    ɵngcc0.ɵɵattribute(\"aria-label\", item_r6.ariaLabel)(\"aria-disabled\", !item_r6.enabled || null)(\"aria-selected\", ctx_r5.selectedValue === item_r6.value);\n    ɵngcc0.ɵɵadvance(1);\n    ɵngcc0.ɵɵclassProp(\"mat-calendar-body-selected\", ctx_r5.selectedValue === item_r6.value)(\"mat-calendar-body-today\", ctx_r5.todayValue === item_r6.value);\n    ɵngcc0.ɵɵadvance(1);\n    ɵngcc0.ɵɵtextInterpolate1(\" \", item_r6.displayValue, \" \");\n} }\nfunction MatCalendarBody_tr_1_Template(rf, ctx) { if (rf & 1) {\n    ɵngcc0.ɵɵelementStart(0, \"tr\", 4);\n    ɵngcc0.ɵɵtemplate(1, MatCalendarBody_tr_1_td_1_Template, 2, 6, \"td\", 5);\n    ɵngcc0.ɵɵtemplate(2, MatCalendarBody_tr_1_td_2_Template, 3, 20, \"td\", 6);\n    ɵngcc0.ɵɵelementEnd();\n} if (rf & 2) {\n    const row_r2 = ctx.$implicit;\n    const rowIndex_r3 = ctx.index;\n    const ctx_r1 = ɵngcc0.ɵɵnextContext();\n    ɵngcc0.ɵɵadvance(1);\n    ɵngcc0.ɵɵproperty(\"ngIf\", rowIndex_r3 === 0 && ctx_r1._firstRowOffset);\n    ɵngcc0.ɵɵadvance(1);\n    ɵngcc0.ɵɵproperty(\"ngForOf\", row_r2);\n} }\nfunction MatMonthView_th_3_Template(rf, ctx) { if (rf & 1) {\n    ɵngcc0.ɵɵelementStart(0, \"th\", 5);\n    ɵngcc0.ɵɵtext(1);\n    ɵngcc0.ɵɵelementEnd();\n} if (rf & 2) {\n    const day_r1 = ctx.$implicit;\n    ɵngcc0.ɵɵattribute(\"aria-label\", day_r1.long);\n    ɵngcc0.ɵɵadvance(1);\n    ɵngcc0.ɵɵtextInterpolate(day_r1.narrow);\n} }\nconst _c1 = [\"*\"];\nfunction MatCalendar_ng_template_0_Template(rf, ctx) { }\nfunction MatCalendar_mat_month_view_2_Template(rf, ctx) { if (rf & 1) {\n    const _r5 = ɵngcc0.ɵɵgetCurrentView();\n    ɵngcc0.ɵɵelementStart(0, \"mat-month-view\", 5);\n    ɵngcc0.ɵɵlistener(\"activeDateChange\", function MatCalendar_mat_month_view_2_Template_mat_month_view_activeDateChange_0_listener($event) { ɵngcc0.ɵɵrestoreView(_r5); const ctx_r4 = ɵngcc0.ɵɵnextContext(); return ctx_r4.activeDate = $event; })(\"selectedChange\", function MatCalendar_mat_month_view_2_Template_mat_month_view_selectedChange_0_listener($event) { ɵngcc0.ɵɵrestoreView(_r5); const ctx_r6 = ɵngcc0.ɵɵnextContext(); return ctx_r6._dateSelected($event); })(\"_userSelection\", function MatCalendar_mat_month_view_2_Template_mat_month_view__userSelection_0_listener() { ɵngcc0.ɵɵrestoreView(_r5); const ctx_r7 = ɵngcc0.ɵɵnextContext(); return ctx_r7._userSelected(); });\n    ɵngcc0.ɵɵelementEnd();\n} if (rf & 2) {\n    const ctx_r1 = ɵngcc0.ɵɵnextContext();\n    ɵngcc0.ɵɵproperty(\"activeDate\", ctx_r1.activeDate)(\"selected\", ctx_r1.selected)(\"dateFilter\", ctx_r1.dateFilter)(\"maxDate\", ctx_r1.maxDate)(\"minDate\", ctx_r1.minDate)(\"dateClass\", ctx_r1.dateClass);\n} }\nfunction MatCalendar_mat_year_view_3_Template(rf, ctx) { if (rf & 1) {\n    const _r9 = ɵngcc0.ɵɵgetCurrentView();\n    ɵngcc0.ɵɵelementStart(0, \"mat-year-view\", 6);\n    ɵngcc0.ɵɵlistener(\"activeDateChange\", function MatCalendar_mat_year_view_3_Template_mat_year_view_activeDateChange_0_listener($event) { ɵngcc0.ɵɵrestoreView(_r9); const ctx_r8 = ɵngcc0.ɵɵnextContext(); return ctx_r8.activeDate = $event; })(\"monthSelected\", function MatCalendar_mat_year_view_3_Template_mat_year_view_monthSelected_0_listener($event) { ɵngcc0.ɵɵrestoreView(_r9); const ctx_r10 = ɵngcc0.ɵɵnextContext(); return ctx_r10._monthSelectedInYearView($event); })(\"selectedChange\", function MatCalendar_mat_year_view_3_Template_mat_year_view_selectedChange_0_listener($event) { ɵngcc0.ɵɵrestoreView(_r9); const ctx_r11 = ɵngcc0.ɵɵnextContext(); return ctx_r11._goToDateInView($event, \"month\"); });\n    ɵngcc0.ɵɵelementEnd();\n} if (rf & 2) {\n    const ctx_r2 = ɵngcc0.ɵɵnextContext();\n    ɵngcc0.ɵɵproperty(\"activeDate\", ctx_r2.activeDate)(\"selected\", ctx_r2.selected)(\"dateFilter\", ctx_r2.dateFilter)(\"maxDate\", ctx_r2.maxDate)(\"minDate\", ctx_r2.minDate);\n} }\nfunction MatCalendar_mat_multi_year_view_4_Template(rf, ctx) { if (rf & 1) {\n    const _r13 = ɵngcc0.ɵɵgetCurrentView();\n    ɵngcc0.ɵɵelementStart(0, \"mat-multi-year-view\", 7);\n    ɵngcc0.ɵɵlistener(\"activeDateChange\", function MatCalendar_mat_multi_year_view_4_Template_mat_multi_year_view_activeDateChange_0_listener($event) { ɵngcc0.ɵɵrestoreView(_r13); const ctx_r12 = ɵngcc0.ɵɵnextContext(); return ctx_r12.activeDate = $event; })(\"yearSelected\", function MatCalendar_mat_multi_year_view_4_Template_mat_multi_year_view_yearSelected_0_listener($event) { ɵngcc0.ɵɵrestoreView(_r13); const ctx_r14 = ɵngcc0.ɵɵnextContext(); return ctx_r14._yearSelectedInMultiYearView($event); })(\"selectedChange\", function MatCalendar_mat_multi_year_view_4_Template_mat_multi_year_view_selectedChange_0_listener($event) { ɵngcc0.ɵɵrestoreView(_r13); const ctx_r15 = ɵngcc0.ɵɵnextContext(); return ctx_r15._goToDateInView($event, \"year\"); });\n    ɵngcc0.ɵɵelementEnd();\n} if (rf & 2) {\n    const ctx_r3 = ɵngcc0.ɵɵnextContext();\n    ɵngcc0.ɵɵproperty(\"activeDate\", ctx_r3.activeDate)(\"selected\", ctx_r3.selected)(\"dateFilter\", ctx_r3.dateFilter)(\"maxDate\", ctx_r3.maxDate)(\"minDate\", ctx_r3.minDate);\n} }\nconst _c2 = [\"button\"];\nfunction MatDatepickerToggle__svg_svg_2_Template(rf, ctx) { if (rf & 1) {\n    ɵngcc0.ɵɵnamespaceSVG();\n    ɵngcc0.ɵɵelementStart(0, \"svg\", 3);\n    ɵngcc0.ɵɵelement(1, \"path\", 4);\n    ɵngcc0.ɵɵelementEnd();\n} }\nconst _c3 = [[[\"\", \"matDatepickerToggleIcon\", \"\"]]];\nconst _c4 = [\"[matDatepickerToggleIcon]\"];\nfunction createMissingDateImplError(provider) {\n    return Error(`MatDatepicker: No provider found for ${provider}. You must import one of the following ` +\n        `modules at your application root: MatNativeDateModule, MatMomentDateModule, or provide a ` +\n        `custom implementation.`);\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/datepicker/datepicker-intl.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Datepicker data that requires internationalization.\n */\nclass MatDatepickerIntl {\n    constructor() {\n        /**\n         * Stream that emits whenever the labels here are changed. Use this to notify\n         * components if the labels have changed after initialization.\n         */\n        this.changes = new Subject();\n        /**\n         * A label for the calendar popup (used by screen readers).\n         */\n        this.calendarLabel = 'Calendar';\n        /**\n         * A label for the button used to open the calendar popup (used by screen readers).\n         */\n        this.openCalendarLabel = 'Open calendar';\n        /**\n         * A label for the previous month button (used by screen readers).\n         */\n        this.prevMonthLabel = 'Previous month';\n        /**\n         * A label for the next month button (used by screen readers).\n         */\n        this.nextMonthLabel = 'Next month';\n        /**\n         * A label for the previous year button (used by screen readers).\n         */\n        this.prevYearLabel = 'Previous year';\n        /**\n         * A label for the next year button (used by screen readers).\n         */\n        this.nextYearLabel = 'Next year';\n        /**\n         * A label for the previous multi-year button (used by screen readers).\n         */\n        this.prevMultiYearLabel = 'Previous 20 years';\n        /**\n         * A label for the next multi-year button (used by screen readers).\n         */\n        this.nextMultiYearLabel = 'Next 20 years';\n        /**\n         * A label for the 'switch to month view' button (used by screen readers).\n         */\n        this.switchToMonthViewLabel = 'Choose date';\n        /**\n         * A label for the 'switch to year view' button (used by screen readers).\n         */\n        this.switchToMultiYearViewLabel = 'Choose month and year';\n    }\n    /**\n     * Formats a range of years.\n     * @param {?} start\n     * @param {?} end\n     * @return {?}\n     */\n    formatYearRange(start, end) {\n        return `${start} \\u2013 ${end}`;\n    }\n}\nMatDatepickerIntl.ɵfac = function MatDatepickerIntl_Factory(t) { return new (t || MatDatepickerIntl)(); };\n/** @nocollapse */ MatDatepickerIntl.ɵprov = ɵɵdefineInjectable({ factory: function MatDatepickerIntl_Factory() { return new MatDatepickerIntl(); }, token: MatDatepickerIntl, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatDatepickerIntl, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return []; }, null); })();\nif (false) {\n    /**\n     * Stream that emits whenever the labels here are changed. Use this to notify\n     * components if the labels have changed after initialization.\n     * @type {?}\n     */\n    MatDatepickerIntl.prototype.changes;\n    /**\n     * A label for the calendar popup (used by screen readers).\n     * @type {?}\n     */\n    MatDatepickerIntl.prototype.calendarLabel;\n    /**\n     * A label for the button used to open the calendar popup (used by screen readers).\n     * @type {?}\n     */\n    MatDatepickerIntl.prototype.openCalendarLabel;\n    /**\n     * A label for the previous month button (used by screen readers).\n     * @type {?}\n     */\n    MatDatepickerIntl.prototype.prevMonthLabel;\n    /**\n     * A label for the next month button (used by screen readers).\n     * @type {?}\n     */\n    MatDatepickerIntl.prototype.nextMonthLabel;\n    /**\n     * A label for the previous year button (used by screen readers).\n     * @type {?}\n     */\n    MatDatepickerIntl.prototype.prevYearLabel;\n    /**\n     * A label for the next year button (used by screen readers).\n     * @type {?}\n     */\n    MatDatepickerIntl.prototype.nextYearLabel;\n    /**\n     * A label for the previous multi-year button (used by screen readers).\n     * @type {?}\n     */\n    MatDatepickerIntl.prototype.prevMultiYearLabel;\n    /**\n     * A label for the next multi-year button (used by screen readers).\n     * @type {?}\n     */\n    MatDatepickerIntl.prototype.nextMultiYearLabel;\n    /**\n     * A label for the 'switch to month view' button (used by screen readers).\n     * @type {?}\n     */\n    MatDatepickerIntl.prototype.switchToMonthViewLabel;\n    /**\n     * A label for the 'switch to year view' button (used by screen readers).\n     * @type {?}\n     */\n    MatDatepickerIntl.prototype.switchToMultiYearViewLabel;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/datepicker/calendar-body.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * An internal class that represents the data corresponding to a single calendar cell.\n * \\@docs-private\n */\nclass MatCalendarCell {\n    /**\n     * @param {?} value\n     * @param {?} displayValue\n     * @param {?} ariaLabel\n     * @param {?} enabled\n     * @param {?=} cssClasses\n     */\n    constructor(value, displayValue, ariaLabel, enabled, cssClasses = {}) {\n        this.value = value;\n        this.displayValue = displayValue;\n        this.ariaLabel = ariaLabel;\n        this.enabled = enabled;\n        this.cssClasses = cssClasses;\n    }\n}\nif (false) {\n    /** @type {?} */\n    MatCalendarCell.prototype.value;\n    /** @type {?} */\n    MatCalendarCell.prototype.displayValue;\n    /** @type {?} */\n    MatCalendarCell.prototype.ariaLabel;\n    /** @type {?} */\n    MatCalendarCell.prototype.enabled;\n    /** @type {?} */\n    MatCalendarCell.prototype.cssClasses;\n}\n/**\n * An internal component used to display calendar data in a table.\n * \\@docs-private\n */\nclass MatCalendarBody {\n    /**\n     * @param {?} _elementRef\n     * @param {?} _ngZone\n     */\n    constructor(_elementRef, _ngZone) {\n        this._elementRef = _elementRef;\n        this._ngZone = _ngZone;\n        /**\n         * The number of columns in the table.\n         */\n        this.numCols = 7;\n        /**\n         * The cell number of the active cell in the table.\n         */\n        this.activeCell = 0;\n        /**\n         * The aspect ratio (width / height) to use for the cells in the table. This aspect ratio will be\n         * maintained even as the table resizes.\n         */\n        this.cellAspectRatio = 1;\n        /**\n         * Emits when a new value is selected.\n         */\n        this.selectedValueChange = new EventEmitter();\n    }\n    /**\n     * @param {?} cell\n     * @return {?}\n     */\n    _cellClicked(cell) {\n        if (cell.enabled) {\n            this.selectedValueChange.emit(cell.value);\n        }\n    }\n    /**\n     * @param {?} changes\n     * @return {?}\n     */\n    ngOnChanges(changes) {\n        /** @type {?} */\n        const columnChanges = changes['numCols'];\n        const { rows, numCols } = this;\n        if (changes['rows'] || columnChanges) {\n            this._firstRowOffset = rows && rows.length && rows[0].length ? numCols - rows[0].length : 0;\n        }\n        if (changes['cellAspectRatio'] || columnChanges || !this._cellPadding) {\n            this._cellPadding = `${50 * this.cellAspectRatio / numCols}%`;\n        }\n        if (columnChanges || !this._cellWidth) {\n            this._cellWidth = `${100 / numCols}%`;\n        }\n    }\n    /**\n     * @param {?} rowIndex\n     * @param {?} colIndex\n     * @return {?}\n     */\n    _isActiveCell(rowIndex, colIndex) {\n        /** @type {?} */\n        let cellNumber = rowIndex * this.numCols + colIndex;\n        // Account for the fact that the first row may not have as many cells.\n        if (rowIndex) {\n            cellNumber -= this._firstRowOffset;\n        }\n        return cellNumber == this.activeCell;\n    }\n    /**\n     * Focuses the active cell after the microtask queue is empty.\n     * @return {?}\n     */\n    _focusActiveCell() {\n        this._ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => {\n            this._ngZone.onStable.asObservable().pipe(take(1)).subscribe((/**\n             * @return {?}\n             */\n            () => {\n                /** @type {?} */\n                const activeCell = this._elementRef.nativeElement.querySelector('.mat-calendar-body-active');\n                if (activeCell) {\n                    activeCell.focus();\n                }\n            }));\n        }));\n    }\n}\nMatCalendarBody.ɵfac = function MatCalendarBody_Factory(t) { return new (t || MatCalendarBody)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone)); };\nMatCalendarBody.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatCalendarBody, selectors: [[\"\", \"mat-calendar-body\", \"\"]], hostAttrs: [\"role\", \"grid\", \"aria-readonly\", \"true\", 1, \"mat-calendar-body\"], inputs: { numCols: \"numCols\", activeCell: \"activeCell\", cellAspectRatio: \"cellAspectRatio\", label: \"label\", rows: \"rows\", todayValue: \"todayValue\", selectedValue: \"selectedValue\", labelMinRequiredCells: \"labelMinRequiredCells\" }, outputs: { selectedValueChange: \"selectedValueChange\" }, exportAs: [\"matCalendarBody\"], features: [ɵngcc0.ɵɵNgOnChangesFeature], attrs: _c0, decls: 2, vars: 2, consts: [[\"aria-hidden\", \"true\", 4, \"ngIf\"], [\"role\", \"row\", 4, \"ngFor\", \"ngForOf\"], [\"aria-hidden\", \"true\"], [1, \"mat-calendar-body-label\"], [\"role\", \"row\"], [\"aria-hidden\", \"true\", \"class\", \"mat-calendar-body-label\", 3, \"paddingTop\", \"paddingBottom\", 4, \"ngIf\"], [\"role\", \"gridcell\", \"class\", \"mat-calendar-body-cell mat-focus-indicator\", \"role\", \"button\", 3, \"ngClass\", \"tabindex\", \"mat-calendar-body-disabled\", \"mat-calendar-body-active\", \"width\", \"paddingTop\", \"paddingBottom\", \"click\", 4, \"ngFor\", \"ngForOf\"], [\"aria-hidden\", \"true\", 1, \"mat-calendar-body-label\"], [\"role\", \"gridcell\", \"role\", \"button\", 1, \"mat-calendar-body-cell\", \"mat-focus-indicator\", 3, \"ngClass\", \"tabindex\", \"click\"], [1, \"mat-calendar-body-cell-content\"]], template: function MatCalendarBody_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵtemplate(0, MatCalendarBody_tr_0_Template, 3, 6, \"tr\", 0);\n        ɵngcc0.ɵɵtemplate(1, MatCalendarBody_tr_1_Template, 3, 2, \"tr\", 1);\n    } if (rf & 2) {\n        ɵngcc0.ɵɵproperty(\"ngIf\", ctx._firstRowOffset < ctx.labelMinRequiredCells);\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵproperty(\"ngForOf\", ctx.rows);\n    } }, directives: [ɵngcc1.NgIf, ɵngcc1.NgForOf, ɵngcc1.NgClass], styles: [\".mat-calendar-body{min-width:224px}.mat-calendar-body-label{height:0;line-height:0;text-align:left;padding-left:4.7142857143%;padding-right:4.7142857143%}.mat-calendar-body-cell{position:relative;height:0;line-height:0;text-align:center;outline:none;cursor:pointer}.mat-calendar-body-disabled{cursor:default}.mat-calendar-body-cell-content{position:absolute;top:5%;left:5%;display:flex;align-items:center;justify-content:center;box-sizing:border-box;width:90%;height:90%;line-height:1;border-width:1px;border-style:solid;border-radius:999px}.cdk-high-contrast-active .mat-calendar-body-cell-content{border:none}.cdk-high-contrast-active .mat-datepicker-popup:not(:empty),.cdk-high-contrast-active .mat-calendar-body-selected{outline:solid 1px}.cdk-high-contrast-active .mat-calendar-body-today{outline:dotted 1px}.cdk-high-contrast-active .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected),.cdk-high-contrast-active .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected){outline:dotted 2px}[dir=rtl] .mat-calendar-body-label{text-align:right}@media(hover: none){.mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected){background-color:transparent}}\\n\"], encapsulation: 2, changeDetection: 0 });\n/** @nocollapse */\nMatCalendarBody.ctorParameters = () => [\n    { type: ElementRef },\n    { type: NgZone }\n];\nMatCalendarBody.propDecorators = {\n    label: [{ type: Input }],\n    rows: [{ type: Input }],\n    todayValue: [{ type: Input }],\n    selectedValue: [{ type: Input }],\n    labelMinRequiredCells: [{ type: Input }],\n    numCols: [{ type: Input }],\n    activeCell: [{ type: Input }],\n    cellAspectRatio: [{ type: Input }],\n    selectedValueChange: [{ type: Output }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatCalendarBody, [{\n        type: Component,\n        args: [{\n                selector: '[mat-calendar-body]',\n                template: \"<!--\\n  If there's not enough space in the first row, create a separate label row. We mark this row as\\n  aria-hidden because we don't want it to be read out as one of the weeks in the month.\\n-->\\n<tr *ngIf=\\\"_firstRowOffset < labelMinRequiredCells\\\" aria-hidden=\\\"true\\\">\\n  <td class=\\\"mat-calendar-body-label\\\"\\n      [attr.colspan]=\\\"numCols\\\"\\n      [style.paddingTop]=\\\"_cellPadding\\\"\\n      [style.paddingBottom]=\\\"_cellPadding\\\">\\n    {{label}}\\n  </td>\\n</tr>\\n\\n<!-- Create the first row separately so we can include a special spacer cell. -->\\n<tr *ngFor=\\\"let row of rows; let rowIndex = index\\\" role=\\\"row\\\">\\n  <!--\\n    We mark this cell as aria-hidden so it doesn't get read out as one of the days in the week.\\n    The aspect ratio of the table cells is maintained by setting the top and bottom padding as a\\n    percentage of the width (a variant of the trick described here:\\n    https://www.w3schools.com/howto/howto_css_aspect_ratio.asp).\\n  -->\\n  <td *ngIf=\\\"rowIndex === 0 && _firstRowOffset\\\"\\n      aria-hidden=\\\"true\\\"\\n      class=\\\"mat-calendar-body-label\\\"\\n      [attr.colspan]=\\\"_firstRowOffset\\\"\\n      [style.paddingTop]=\\\"_cellPadding\\\"\\n      [style.paddingBottom]=\\\"_cellPadding\\\">\\n    {{_firstRowOffset >= labelMinRequiredCells ? label : ''}}\\n  </td>\\n  <td *ngFor=\\\"let item of row; let colIndex = index\\\"\\n      role=\\\"gridcell\\\"\\n      class=\\\"mat-calendar-body-cell mat-focus-indicator\\\"\\n      [ngClass]=\\\"item.cssClasses\\\"\\n      [tabindex]=\\\"_isActiveCell(rowIndex, colIndex) ? 0 : -1\\\"\\n      [class.mat-calendar-body-disabled]=\\\"!item.enabled\\\"\\n      [class.mat-calendar-body-active]=\\\"_isActiveCell(rowIndex, colIndex)\\\"\\n      [attr.aria-label]=\\\"item.ariaLabel\\\"\\n      [attr.aria-disabled]=\\\"!item.enabled || null\\\"\\n      [attr.aria-selected]=\\\"selectedValue === item.value\\\"\\n      (click)=\\\"_cellClicked(item)\\\"\\n      [style.width]=\\\"_cellWidth\\\"\\n      [style.paddingTop]=\\\"_cellPadding\\\"\\n      role=\\\"button\\\"\\n      [style.paddingBottom]=\\\"_cellPadding\\\">\\n      <div class=\\\"mat-calendar-body-cell-content\\\"\\n        [class.mat-calendar-body-selected]=\\\"selectedValue === item.value\\\"\\n        [class.mat-calendar-body-today]=\\\"todayValue === item.value\\\">\\n        {{item.displayValue}}\\n      </div>\\n  </td>\\n</tr>\\n\",\n                host: {\n                    'class': 'mat-calendar-body',\n                    'role': 'grid',\n                    'aria-readonly': 'true'\n                },\n                exportAs: 'matCalendarBody',\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush,\n                styles: [\".mat-calendar-body{min-width:224px}.mat-calendar-body-label{height:0;line-height:0;text-align:left;padding-left:4.7142857143%;padding-right:4.7142857143%}.mat-calendar-body-cell{position:relative;height:0;line-height:0;text-align:center;outline:none;cursor:pointer}.mat-calendar-body-disabled{cursor:default}.mat-calendar-body-cell-content{position:absolute;top:5%;left:5%;display:flex;align-items:center;justify-content:center;box-sizing:border-box;width:90%;height:90%;line-height:1;border-width:1px;border-style:solid;border-radius:999px}.cdk-high-contrast-active .mat-calendar-body-cell-content{border:none}.cdk-high-contrast-active .mat-datepicker-popup:not(:empty),.cdk-high-contrast-active .mat-calendar-body-selected{outline:solid 1px}.cdk-high-contrast-active .mat-calendar-body-today{outline:dotted 1px}.cdk-high-contrast-active .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected),.cdk-high-contrast-active .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected){outline:dotted 2px}[dir=rtl] .mat-calendar-body-label{text-align:right}@media(hover: none){.mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected){background-color:transparent}}\\n\"]\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: ɵngcc0.NgZone }]; }, { numCols: [{\n            type: Input\n        }], activeCell: [{\n            type: Input\n        }], cellAspectRatio: [{\n            type: Input\n        }], selectedValueChange: [{\n            type: Output\n        }], label: [{\n            type: Input\n        }], rows: [{\n            type: Input\n        }], todayValue: [{\n            type: Input\n        }], selectedValue: [{\n            type: Input\n        }], labelMinRequiredCells: [{\n            type: Input\n        }] }); })();\nif (false) {\n    /**\n     * The label for the table. (e.g. \"Jan 2017\").\n     * @type {?}\n     */\n    MatCalendarBody.prototype.label;\n    /**\n     * The cells to display in the table.\n     * @type {?}\n     */\n    MatCalendarBody.prototype.rows;\n    /**\n     * The value in the table that corresponds to today.\n     * @type {?}\n     */\n    MatCalendarBody.prototype.todayValue;\n    /**\n     * The value in the table that is currently selected.\n     * @type {?}\n     */\n    MatCalendarBody.prototype.selectedValue;\n    /**\n     * The minimum number of free cells needed to fit the label in the first row.\n     * @type {?}\n     */\n    MatCalendarBody.prototype.labelMinRequiredCells;\n    /**\n     * The number of columns in the table.\n     * @type {?}\n     */\n    MatCalendarBody.prototype.numCols;\n    /**\n     * The cell number of the active cell in the table.\n     * @type {?}\n     */\n    MatCalendarBody.prototype.activeCell;\n    /**\n     * The aspect ratio (width / height) to use for the cells in the table. This aspect ratio will be\n     * maintained even as the table resizes.\n     * @type {?}\n     */\n    MatCalendarBody.prototype.cellAspectRatio;\n    /**\n     * Emits when a new value is selected.\n     * @type {?}\n     */\n    MatCalendarBody.prototype.selectedValueChange;\n    /**\n     * The number of blank cells to put at the beginning for the first row.\n     * @type {?}\n     */\n    MatCalendarBody.prototype._firstRowOffset;\n    /**\n     * Padding for the individual date cells.\n     * @type {?}\n     */\n    MatCalendarBody.prototype._cellPadding;\n    /**\n     * Width of an individual cell.\n     * @type {?}\n     */\n    MatCalendarBody.prototype._cellWidth;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatCalendarBody.prototype._elementRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatCalendarBody.prototype._ngZone;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/datepicker/month-view.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst DAYS_PER_WEEK = 7;\n/**\n * An internal component used to display a single month in the datepicker.\n * \\@docs-private\n * @template D\n */\nclass MatMonthView {\n    /**\n     * @param {?} _changeDetectorRef\n     * @param {?} _dateFormats\n     * @param {?} _dateAdapter\n     * @param {?=} _dir\n     */\n    constructor(_changeDetectorRef, _dateFormats, _dateAdapter, _dir) {\n        this._changeDetectorRef = _changeDetectorRef;\n        this._dateFormats = _dateFormats;\n        this._dateAdapter = _dateAdapter;\n        this._dir = _dir;\n        this._rerenderSubscription = Subscription.EMPTY;\n        /**\n         * Emits when a new date is selected.\n         */\n        this.selectedChange = new EventEmitter();\n        /**\n         * Emits when any date is selected.\n         */\n        this._userSelection = new EventEmitter();\n        /**\n         * Emits when any date is activated.\n         */\n        this.activeDateChange = new EventEmitter();\n        if (!this._dateAdapter) {\n            throw createMissingDateImplError('DateAdapter');\n        }\n        if (!this._dateFormats) {\n            throw createMissingDateImplError('MAT_DATE_FORMATS');\n        }\n        this._activeDate = this._dateAdapter.today();\n    }\n    /**\n     * The date to display in this month view (everything other than the month and year is ignored).\n     * @return {?}\n     */\n    get activeDate() { return this._activeDate; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set activeDate(value) {\n        /** @type {?} */\n        const oldActiveDate = this._activeDate;\n        /** @type {?} */\n        const validDate = this._getValidDateOrNull(this._dateAdapter.deserialize(value)) || this._dateAdapter.today();\n        this._activeDate = this._dateAdapter.clampDate(validDate, this.minDate, this.maxDate);\n        if (!this._hasSameMonthAndYear(oldActiveDate, this._activeDate)) {\n            this._init();\n        }\n    }\n    /**\n     * The currently selected date.\n     * @return {?}\n     */\n    get selected() { return this._selected; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set selected(value) {\n        this._selected = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n        this._selectedDate = this._getDateInCurrentMonth(this._selected);\n    }\n    /**\n     * The minimum selectable date.\n     * @return {?}\n     */\n    get minDate() { return this._minDate; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set minDate(value) {\n        this._minDate = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /**\n     * The maximum selectable date.\n     * @return {?}\n     */\n    get maxDate() { return this._maxDate; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set maxDate(value) {\n        this._maxDate = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterContentInit() {\n        this._rerenderSubscription = this._dateAdapter.localeChanges\n            .pipe(startWith(null))\n            .subscribe((/**\n         * @return {?}\n         */\n        () => this._init()));\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._rerenderSubscription.unsubscribe();\n    }\n    /**\n     * Handles when a new date is selected.\n     * @param {?} date\n     * @return {?}\n     */\n    _dateSelected(date) {\n        if (this._selectedDate != date) {\n            /** @type {?} */\n            const selectedYear = this._dateAdapter.getYear(this.activeDate);\n            /** @type {?} */\n            const selectedMonth = this._dateAdapter.getMonth(this.activeDate);\n            /** @type {?} */\n            const selectedDate = this._dateAdapter.createDate(selectedYear, selectedMonth, date);\n            this.selectedChange.emit(selectedDate);\n        }\n        this._userSelection.emit();\n    }\n    /**\n     * Handles keydown events on the calendar body when calendar is in month view.\n     * @param {?} event\n     * @return {?}\n     */\n    _handleCalendarBodyKeydown(event) {\n        // TODO(mmalerba): We currently allow keyboard navigation to disabled dates, but just prevent\n        // disabled ones from being selected. This may not be ideal, we should look into whether\n        // navigation should skip over disabled dates, and if so, how to implement that efficiently.\n        // TODO(mmalerba): We currently allow keyboard navigation to disabled dates, but just prevent\n        // disabled ones from being selected. This may not be ideal, we should look into whether\n        // navigation should skip over disabled dates, and if so, how to implement that efficiently.\n        /** @type {?} */\n        const oldActiveDate = this._activeDate;\n        /** @type {?} */\n        const isRtl = this._isRtl();\n        switch (event.keyCode) {\n            case LEFT_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate, isRtl ? 1 : -1);\n                break;\n            case RIGHT_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate, isRtl ? -1 : 1);\n                break;\n            case UP_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate, -7);\n                break;\n            case DOWN_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate, 7);\n                break;\n            case HOME:\n                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate, 1 - this._dateAdapter.getDate(this._activeDate));\n                break;\n            case END:\n                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate, (this._dateAdapter.getNumDaysInMonth(this._activeDate) -\n                    this._dateAdapter.getDate(this._activeDate)));\n                break;\n            case PAGE_UP:\n                this.activeDate = event.altKey ?\n                    this._dateAdapter.addCalendarYears(this._activeDate, -1) :\n                    this._dateAdapter.addCalendarMonths(this._activeDate, -1);\n                break;\n            case PAGE_DOWN:\n                this.activeDate = event.altKey ?\n                    this._dateAdapter.addCalendarYears(this._activeDate, 1) :\n                    this._dateAdapter.addCalendarMonths(this._activeDate, 1);\n                break;\n            case ENTER:\n            case SPACE:\n                if (!this.dateFilter || this.dateFilter(this._activeDate)) {\n                    this._dateSelected(this._dateAdapter.getDate(this._activeDate));\n                    this._userSelection.emit();\n                    // Prevent unexpected default actions such as form submission.\n                    event.preventDefault();\n                }\n                return;\n            default:\n                // Don't prevent default or focus active cell on keys that we don't explicitly handle.\n                return;\n        }\n        if (this._dateAdapter.compareDate(oldActiveDate, this.activeDate)) {\n            this.activeDateChange.emit(this.activeDate);\n        }\n        this._focusActiveCell();\n        // Prevent unexpected default actions such as form submission.\n        event.preventDefault();\n    }\n    /**\n     * Initializes this month view.\n     * @return {?}\n     */\n    _init() {\n        this._selectedDate = this._getDateInCurrentMonth(this.selected);\n        this._todayDate = this._getDateInCurrentMonth(this._dateAdapter.today());\n        this._monthLabel =\n            this._dateAdapter.getMonthNames('short')[this._dateAdapter.getMonth(this.activeDate)]\n                .toLocaleUpperCase();\n        /** @type {?} */\n        let firstOfMonth = this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), this._dateAdapter.getMonth(this.activeDate), 1);\n        this._firstWeekOffset =\n            (DAYS_PER_WEEK + this._dateAdapter.getDayOfWeek(firstOfMonth) -\n                this._dateAdapter.getFirstDayOfWeek()) % DAYS_PER_WEEK;\n        this._initWeekdays();\n        this._createWeekCells();\n        this._changeDetectorRef.markForCheck();\n    }\n    /**\n     * Focuses the active cell after the microtask queue is empty.\n     * @return {?}\n     */\n    _focusActiveCell() {\n        this._matCalendarBody._focusActiveCell();\n    }\n    /**\n     * Initializes the weekdays.\n     * @private\n     * @return {?}\n     */\n    _initWeekdays() {\n        /** @type {?} */\n        const firstDayOfWeek = this._dateAdapter.getFirstDayOfWeek();\n        /** @type {?} */\n        const narrowWeekdays = this._dateAdapter.getDayOfWeekNames('narrow');\n        /** @type {?} */\n        const longWeekdays = this._dateAdapter.getDayOfWeekNames('long');\n        // Rotate the labels for days of the week based on the configured first day of the week.\n        /** @type {?} */\n        let weekdays = longWeekdays.map((/**\n         * @param {?} long\n         * @param {?} i\n         * @return {?}\n         */\n        (long, i) => {\n            return { long, narrow: narrowWeekdays[i] };\n        }));\n        this._weekdays = weekdays.slice(firstDayOfWeek).concat(weekdays.slice(0, firstDayOfWeek));\n    }\n    /**\n     * Creates MatCalendarCells for the dates in this month.\n     * @private\n     * @return {?}\n     */\n    _createWeekCells() {\n        /** @type {?} */\n        const daysInMonth = this._dateAdapter.getNumDaysInMonth(this.activeDate);\n        /** @type {?} */\n        const dateNames = this._dateAdapter.getDateNames();\n        this._weeks = [[]];\n        for (let i = 0, cell = this._firstWeekOffset; i < daysInMonth; i++, cell++) {\n            if (cell == DAYS_PER_WEEK) {\n                this._weeks.push([]);\n                cell = 0;\n            }\n            /** @type {?} */\n            const date = this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), this._dateAdapter.getMonth(this.activeDate), i + 1);\n            /** @type {?} */\n            const enabled = this._shouldEnableDate(date);\n            /** @type {?} */\n            const ariaLabel = this._dateAdapter.format(date, this._dateFormats.display.dateA11yLabel);\n            /** @type {?} */\n            const cellClasses = this.dateClass ? this.dateClass(date) : undefined;\n            this._weeks[this._weeks.length - 1]\n                .push(new MatCalendarCell(i + 1, dateNames[i], ariaLabel, enabled, cellClasses));\n        }\n    }\n    /**\n     * Date filter for the month\n     * @private\n     * @param {?} date\n     * @return {?}\n     */\n    _shouldEnableDate(date) {\n        return !!date &&\n            (!this.minDate || this._dateAdapter.compareDate(date, this.minDate) >= 0) &&\n            (!this.maxDate || this._dateAdapter.compareDate(date, this.maxDate) <= 0) &&\n            (!this.dateFilter || this.dateFilter(date));\n    }\n    /**\n     * Gets the date in this month that the given Date falls on.\n     * Returns null if the given Date is in another month.\n     * @private\n     * @param {?} date\n     * @return {?}\n     */\n    _getDateInCurrentMonth(date) {\n        return date && this._hasSameMonthAndYear(date, this.activeDate) ?\n            this._dateAdapter.getDate(date) : null;\n    }\n    /**\n     * Checks whether the 2 dates are non-null and fall within the same month of the same year.\n     * @private\n     * @param {?} d1\n     * @param {?} d2\n     * @return {?}\n     */\n    _hasSameMonthAndYear(d1, d2) {\n        return !!(d1 && d2 && this._dateAdapter.getMonth(d1) == this._dateAdapter.getMonth(d2) &&\n            this._dateAdapter.getYear(d1) == this._dateAdapter.getYear(d2));\n    }\n    /**\n     * @private\n     * @param {?} obj The object to check.\n     * @return {?} The given object if it is both a date instance and valid, otherwise null.\n     */\n    _getValidDateOrNull(obj) {\n        return (this._dateAdapter.isDateInstance(obj) && this._dateAdapter.isValid(obj)) ? obj : null;\n    }\n    /**\n     * Determines whether the user has the RTL layout direction.\n     * @private\n     * @return {?}\n     */\n    _isRtl() {\n        return this._dir && this._dir.value === 'rtl';\n    }\n}\nMatMonthView.ɵfac = function MatMonthView_Factory(t) { return new (t || MatMonthView)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(MAT_DATE_FORMATS, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.DateAdapter, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc3.Directionality, 8)); };\nMatMonthView.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatMonthView, selectors: [[\"mat-month-view\"]], viewQuery: function MatMonthView_Query(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵviewQuery(MatCalendarBody, true);\n    } if (rf & 2) {\n        var _t;\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._matCalendarBody = _t.first);\n    } }, inputs: { activeDate: \"activeDate\", selected: \"selected\", minDate: \"minDate\", maxDate: \"maxDate\", dateFilter: \"dateFilter\", dateClass: \"dateClass\" }, outputs: { selectedChange: \"selectedChange\", _userSelection: \"_userSelection\", activeDateChange: \"activeDateChange\" }, exportAs: [\"matMonthView\"], decls: 7, vars: 7, consts: [[\"role\", \"presentation\", 1, \"mat-calendar-table\"], [1, \"mat-calendar-table-header\"], [\"scope\", \"col\", 4, \"ngFor\", \"ngForOf\"], [\"colspan\", \"7\", \"aria-hidden\", \"true\", 1, \"mat-calendar-table-header-divider\"], [\"mat-calendar-body\", \"\", 3, \"label\", \"rows\", \"todayValue\", \"selectedValue\", \"labelMinRequiredCells\", \"activeCell\", \"selectedValueChange\", \"keydown\"], [\"scope\", \"col\"]], template: function MatMonthView_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵelementStart(0, \"table\", 0);\n        ɵngcc0.ɵɵelementStart(1, \"thead\", 1);\n        ɵngcc0.ɵɵelementStart(2, \"tr\");\n        ɵngcc0.ɵɵtemplate(3, MatMonthView_th_3_Template, 2, 2, \"th\", 2);\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelementStart(4, \"tr\");\n        ɵngcc0.ɵɵelement(5, \"th\", 3);\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelementStart(6, \"tbody\", 4);\n        ɵngcc0.ɵɵlistener(\"selectedValueChange\", function MatMonthView_Template_tbody_selectedValueChange_6_listener($event) { return ctx._dateSelected($event); })(\"keydown\", function MatMonthView_Template_tbody_keydown_6_listener($event) { return ctx._handleCalendarBodyKeydown($event); });\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelementEnd();\n    } if (rf & 2) {\n        ɵngcc0.ɵɵadvance(3);\n        ɵngcc0.ɵɵproperty(\"ngForOf\", ctx._weekdays);\n        ɵngcc0.ɵɵadvance(3);\n        ɵngcc0.ɵɵproperty(\"label\", ctx._monthLabel)(\"rows\", ctx._weeks)(\"todayValue\", ctx._todayDate)(\"selectedValue\", ctx._selectedDate)(\"labelMinRequiredCells\", 3)(\"activeCell\", ctx._dateAdapter.getDate(ctx.activeDate) - 1);\n    } }, directives: [ɵngcc1.NgForOf, MatCalendarBody], encapsulation: 2, changeDetection: 0 });\n/** @nocollapse */\nMatMonthView.ctorParameters = () => [\n    { type: ChangeDetectorRef },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] },\n    { type: DateAdapter, decorators: [{ type: Optional }] },\n    { type: Directionality, decorators: [{ type: Optional }] }\n];\nMatMonthView.propDecorators = {\n    activeDate: [{ type: Input }],\n    selected: [{ type: Input }],\n    minDate: [{ type: Input }],\n    maxDate: [{ type: Input }],\n    dateFilter: [{ type: Input }],\n    dateClass: [{ type: Input }],\n    selectedChange: [{ type: Output }],\n    _userSelection: [{ type: Output }],\n    activeDateChange: [{ type: Output }],\n    _matCalendarBody: [{ type: ViewChild, args: [MatCalendarBody,] }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatMonthView, [{\n        type: Component,\n        args: [{\n                selector: 'mat-month-view',\n                template: \"<table class=\\\"mat-calendar-table\\\" role=\\\"presentation\\\">\\n  <thead class=\\\"mat-calendar-table-header\\\">\\n    <tr>\\n      <th scope=\\\"col\\\" *ngFor=\\\"let day of _weekdays\\\" [attr.aria-label]=\\\"day.long\\\">{{day.narrow}}</th>\\n    </tr>\\n    <tr><th class=\\\"mat-calendar-table-header-divider\\\" colspan=\\\"7\\\" aria-hidden=\\\"true\\\"></th></tr>\\n  </thead>\\n  <tbody mat-calendar-body\\n         [label]=\\\"_monthLabel\\\"\\n         [rows]=\\\"_weeks\\\"\\n         [todayValue]=\\\"_todayDate!\\\"\\n         [selectedValue]=\\\"_selectedDate!\\\"\\n         [labelMinRequiredCells]=\\\"3\\\"\\n         [activeCell]=\\\"_dateAdapter.getDate(activeDate) - 1\\\"\\n         (selectedValueChange)=\\\"_dateSelected($event)\\\"\\n         (keydown)=\\\"_handleCalendarBodyKeydown($event)\\\">\\n  </tbody>\\n</table>\\n\",\n                exportAs: 'matMonthView',\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush\n            }]\n    }], function () { return [{ type: ɵngcc0.ChangeDetectorRef }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MAT_DATE_FORMATS]\n            }] }, { type: ɵngcc2.DateAdapter, decorators: [{\n                type: Optional\n            }] }, { type: ɵngcc3.Directionality, decorators: [{\n                type: Optional\n            }] }]; }, { selectedChange: [{\n            type: Output\n        }], _userSelection: [{\n            type: Output\n        }], activeDateChange: [{\n            type: Output\n        }], activeDate: [{\n            type: Input\n        }], selected: [{\n            type: Input\n        }], minDate: [{\n            type: Input\n        }], maxDate: [{\n            type: Input\n        }], dateFilter: [{\n            type: Input\n        }], dateClass: [{\n            type: Input\n        }], _matCalendarBody: [{\n            type: ViewChild,\n            args: [MatCalendarBody]\n        }] }); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    MatMonthView.prototype._rerenderSubscription;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatMonthView.prototype._activeDate;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatMonthView.prototype._selected;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatMonthView.prototype._minDate;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatMonthView.prototype._maxDate;\n    /**\n     * Function used to filter which dates are selectable.\n     * @type {?}\n     */\n    MatMonthView.prototype.dateFilter;\n    /**\n     * Function that can be used to add custom CSS classes to dates.\n     * @type {?}\n     */\n    MatMonthView.prototype.dateClass;\n    /**\n     * Emits when a new date is selected.\n     * @type {?}\n     */\n    MatMonthView.prototype.selectedChange;\n    /**\n     * Emits when any date is selected.\n     * @type {?}\n     */\n    MatMonthView.prototype._userSelection;\n    /**\n     * Emits when any date is activated.\n     * @type {?}\n     */\n    MatMonthView.prototype.activeDateChange;\n    /**\n     * The body of calendar table\n     * @type {?}\n     */\n    MatMonthView.prototype._matCalendarBody;\n    /**\n     * The label for this month (e.g. \"January 2017\").\n     * @type {?}\n     */\n    MatMonthView.prototype._monthLabel;\n    /**\n     * Grid of calendar cells representing the dates of the month.\n     * @type {?}\n     */\n    MatMonthView.prototype._weeks;\n    /**\n     * The number of blank cells in the first row before the 1st of the month.\n     * @type {?}\n     */\n    MatMonthView.prototype._firstWeekOffset;\n    /**\n     * The date of the month that the currently selected Date falls on.\n     * Null if the currently selected Date is in another month.\n     * @type {?}\n     */\n    MatMonthView.prototype._selectedDate;\n    /**\n     * The date of the month that today falls on. Null if today is in another month.\n     * @type {?}\n     */\n    MatMonthView.prototype._todayDate;\n    /**\n     * The names of the weekdays.\n     * @type {?}\n     */\n    MatMonthView.prototype._weekdays;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatMonthView.prototype._changeDetectorRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatMonthView.prototype._dateFormats;\n    /** @type {?} */\n    MatMonthView.prototype._dateAdapter;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatMonthView.prototype._dir;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/datepicker/multi-year-view.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst yearsPerPage = 24;\n/** @type {?} */\nconst yearsPerRow = 4;\n/**\n * An internal component used to display a year selector in the datepicker.\n * \\@docs-private\n * @template D\n */\nclass MatMultiYearView {\n    /**\n     * @param {?} _changeDetectorRef\n     * @param {?} _dateAdapter\n     * @param {?=} _dir\n     */\n    constructor(_changeDetectorRef, _dateAdapter, _dir) {\n        this._changeDetectorRef = _changeDetectorRef;\n        this._dateAdapter = _dateAdapter;\n        this._dir = _dir;\n        this._rerenderSubscription = Subscription.EMPTY;\n        /**\n         * Emits when a new year is selected.\n         */\n        this.selectedChange = new EventEmitter();\n        /**\n         * Emits the selected year. This doesn't imply a change on the selected date\n         */\n        this.yearSelected = new EventEmitter();\n        /**\n         * Emits when any date is activated.\n         */\n        this.activeDateChange = new EventEmitter();\n        if (!this._dateAdapter) {\n            throw createMissingDateImplError('DateAdapter');\n        }\n        this._activeDate = this._dateAdapter.today();\n    }\n    /**\n     * The date to display in this multi-year view (everything other than the year is ignored).\n     * @return {?}\n     */\n    get activeDate() { return this._activeDate; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set activeDate(value) {\n        /** @type {?} */\n        let oldActiveDate = this._activeDate;\n        /** @type {?} */\n        const validDate = this._getValidDateOrNull(this._dateAdapter.deserialize(value)) || this._dateAdapter.today();\n        this._activeDate = this._dateAdapter.clampDate(validDate, this.minDate, this.maxDate);\n        if (!isSameMultiYearView(this._dateAdapter, oldActiveDate, this._activeDate, this.minDate, this.maxDate)) {\n            this._init();\n        }\n    }\n    /**\n     * The currently selected date.\n     * @return {?}\n     */\n    get selected() { return this._selected; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set selected(value) {\n        this._selected = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n        this._selectedYear = this._selected && this._dateAdapter.getYear(this._selected);\n    }\n    /**\n     * The minimum selectable date.\n     * @return {?}\n     */\n    get minDate() { return this._minDate; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set minDate(value) {\n        this._minDate = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /**\n     * The maximum selectable date.\n     * @return {?}\n     */\n    get maxDate() { return this._maxDate; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set maxDate(value) {\n        this._maxDate = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterContentInit() {\n        this._rerenderSubscription = this._dateAdapter.localeChanges\n            .pipe(startWith(null))\n            .subscribe((/**\n         * @return {?}\n         */\n        () => this._init()));\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._rerenderSubscription.unsubscribe();\n    }\n    /**\n     * Initializes this multi-year view.\n     * @return {?}\n     */\n    _init() {\n        this._todayYear = this._dateAdapter.getYear(this._dateAdapter.today());\n        // We want a range years such that we maximize the number of\n        // enabled dates visible at once. This prevents issues where the minimum year\n        // is the last item of a page OR the maximum year is the first item of a page.\n        // The offset from the active year to the \"slot\" for the starting year is the\n        // *actual* first rendered year in the multi-year view.\n        /** @type {?} */\n        const activeYear = this._dateAdapter.getYear(this._activeDate);\n        /** @type {?} */\n        const minYearOfPage = activeYear - getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate);\n        this._years = [];\n        for (let i = 0, row = []; i < yearsPerPage; i++) {\n            row.push(minYearOfPage + i);\n            if (row.length == yearsPerRow) {\n                this._years.push(row.map((/**\n                 * @param {?} year\n                 * @return {?}\n                 */\n                year => this._createCellForYear(year))));\n                row = [];\n            }\n        }\n        this._changeDetectorRef.markForCheck();\n    }\n    /**\n     * Handles when a new year is selected.\n     * @param {?} year\n     * @return {?}\n     */\n    _yearSelected(year) {\n        this.yearSelected.emit(this._dateAdapter.createDate(year, 0, 1));\n        /** @type {?} */\n        let month = this._dateAdapter.getMonth(this.activeDate);\n        /** @type {?} */\n        let daysInMonth = this._dateAdapter.getNumDaysInMonth(this._dateAdapter.createDate(year, month, 1));\n        this.selectedChange.emit(this._dateAdapter.createDate(year, month, Math.min(this._dateAdapter.getDate(this.activeDate), daysInMonth)));\n    }\n    /**\n     * Handles keydown events on the calendar body when calendar is in multi-year view.\n     * @param {?} event\n     * @return {?}\n     */\n    _handleCalendarBodyKeydown(event) {\n        /** @type {?} */\n        const oldActiveDate = this._activeDate;\n        /** @type {?} */\n        const isRtl = this._isRtl();\n        switch (event.keyCode) {\n            case LEFT_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, isRtl ? 1 : -1);\n                break;\n            case RIGHT_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, isRtl ? -1 : 1);\n                break;\n            case UP_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, -yearsPerRow);\n                break;\n            case DOWN_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, yearsPerRow);\n                break;\n            case HOME:\n                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, -getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate));\n                break;\n            case END:\n                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, yearsPerPage - getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate) - 1);\n                break;\n            case PAGE_UP:\n                this.activeDate =\n                    this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? -yearsPerPage * 10 : -yearsPerPage);\n                break;\n            case PAGE_DOWN:\n                this.activeDate =\n                    this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? yearsPerPage * 10 : yearsPerPage);\n                break;\n            case ENTER:\n            case SPACE:\n                this._yearSelected(this._dateAdapter.getYear(this._activeDate));\n                break;\n            default:\n                // Don't prevent default or focus active cell on keys that we don't explicitly handle.\n                return;\n        }\n        if (this._dateAdapter.compareDate(oldActiveDate, this.activeDate)) {\n            this.activeDateChange.emit(this.activeDate);\n        }\n        this._focusActiveCell();\n        // Prevent unexpected default actions such as form submission.\n        event.preventDefault();\n    }\n    /**\n     * @return {?}\n     */\n    _getActiveCell() {\n        return getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate);\n    }\n    /**\n     * Focuses the active cell after the microtask queue is empty.\n     * @return {?}\n     */\n    _focusActiveCell() {\n        this._matCalendarBody._focusActiveCell();\n    }\n    /**\n     * Creates an MatCalendarCell for the given year.\n     * @private\n     * @param {?} year\n     * @return {?}\n     */\n    _createCellForYear(year) {\n        /** @type {?} */\n        let yearName = this._dateAdapter.getYearName(this._dateAdapter.createDate(year, 0, 1));\n        return new MatCalendarCell(year, yearName, yearName, this._shouldEnableYear(year));\n    }\n    /**\n     * Whether the given year is enabled.\n     * @private\n     * @param {?} year\n     * @return {?}\n     */\n    _shouldEnableYear(year) {\n        // disable if the year is greater than maxDate lower than minDate\n        if (year === undefined || year === null ||\n            (this.maxDate && year > this._dateAdapter.getYear(this.maxDate)) ||\n            (this.minDate && year < this._dateAdapter.getYear(this.minDate))) {\n            return false;\n        }\n        // enable if it reaches here and there's no filter defined\n        if (!this.dateFilter) {\n            return true;\n        }\n        /** @type {?} */\n        const firstOfYear = this._dateAdapter.createDate(year, 0, 1);\n        // If any date in the year is enabled count the year as enabled.\n        for (let date = firstOfYear; this._dateAdapter.getYear(date) == year; date = this._dateAdapter.addCalendarDays(date, 1)) {\n            if (this.dateFilter(date)) {\n                return true;\n            }\n        }\n        return false;\n    }\n    /**\n     * @private\n     * @param {?} obj The object to check.\n     * @return {?} The given object if it is both a date instance and valid, otherwise null.\n     */\n    _getValidDateOrNull(obj) {\n        return (this._dateAdapter.isDateInstance(obj) && this._dateAdapter.isValid(obj)) ? obj : null;\n    }\n    /**\n     * Determines whether the user has the RTL layout direction.\n     * @private\n     * @return {?}\n     */\n    _isRtl() {\n        return this._dir && this._dir.value === 'rtl';\n    }\n}\nMatMultiYearView.ɵfac = function MatMultiYearView_Factory(t) { return new (t || MatMultiYearView)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.DateAdapter, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc3.Directionality, 8)); };\nMatMultiYearView.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatMultiYearView, selectors: [[\"mat-multi-year-view\"]], viewQuery: function MatMultiYearView_Query(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵviewQuery(MatCalendarBody, true);\n    } if (rf & 2) {\n        var _t;\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._matCalendarBody = _t.first);\n    } }, inputs: { activeDate: \"activeDate\", selected: \"selected\", minDate: \"minDate\", maxDate: \"maxDate\", dateFilter: \"dateFilter\" }, outputs: { selectedChange: \"selectedChange\", yearSelected: \"yearSelected\", activeDateChange: \"activeDateChange\" }, exportAs: [\"matMultiYearView\"], decls: 5, vars: 6, consts: [[\"role\", \"presentation\", 1, \"mat-calendar-table\"], [1, \"mat-calendar-table-header\"], [\"colspan\", \"4\", 1, \"mat-calendar-table-header-divider\"], [\"mat-calendar-body\", \"\", 3, \"rows\", \"todayValue\", \"selectedValue\", \"numCols\", \"cellAspectRatio\", \"activeCell\", \"selectedValueChange\", \"keydown\"]], template: function MatMultiYearView_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵelementStart(0, \"table\", 0);\n        ɵngcc0.ɵɵelementStart(1, \"thead\", 1);\n        ɵngcc0.ɵɵelementStart(2, \"tr\");\n        ɵngcc0.ɵɵelement(3, \"th\", 2);\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelementStart(4, \"tbody\", 3);\n        ɵngcc0.ɵɵlistener(\"selectedValueChange\", function MatMultiYearView_Template_tbody_selectedValueChange_4_listener($event) { return ctx._yearSelected($event); })(\"keydown\", function MatMultiYearView_Template_tbody_keydown_4_listener($event) { return ctx._handleCalendarBodyKeydown($event); });\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelementEnd();\n    } if (rf & 2) {\n        ɵngcc0.ɵɵadvance(4);\n        ɵngcc0.ɵɵproperty(\"rows\", ctx._years)(\"todayValue\", ctx._todayYear)(\"selectedValue\", ctx._selectedYear)(\"numCols\", 4)(\"cellAspectRatio\", 4 / 7)(\"activeCell\", ctx._getActiveCell());\n    } }, directives: [MatCalendarBody], encapsulation: 2, changeDetection: 0 });\n/** @nocollapse */\nMatMultiYearView.ctorParameters = () => [\n    { type: ChangeDetectorRef },\n    { type: DateAdapter, decorators: [{ type: Optional }] },\n    { type: Directionality, decorators: [{ type: Optional }] }\n];\nMatMultiYearView.propDecorators = {\n    activeDate: [{ type: Input }],\n    selected: [{ type: Input }],\n    minDate: [{ type: Input }],\n    maxDate: [{ type: Input }],\n    dateFilter: [{ type: Input }],\n    selectedChange: [{ type: Output }],\n    yearSelected: [{ type: Output }],\n    activeDateChange: [{ type: Output }],\n    _matCalendarBody: [{ type: ViewChild, args: [MatCalendarBody,] }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatMultiYearView, [{\n        type: Component,\n        args: [{\n                selector: 'mat-multi-year-view',\n                template: \"<table class=\\\"mat-calendar-table\\\" role=\\\"presentation\\\">\\n  <thead class=\\\"mat-calendar-table-header\\\">\\n    <tr><th class=\\\"mat-calendar-table-header-divider\\\" colspan=\\\"4\\\"></th></tr>\\n  </thead>\\n  <tbody mat-calendar-body\\n         [rows]=\\\"_years\\\"\\n         [todayValue]=\\\"_todayYear\\\"\\n         [selectedValue]=\\\"_selectedYear!\\\"\\n         [numCols]=\\\"4\\\"\\n         [cellAspectRatio]=\\\"4 / 7\\\"\\n         [activeCell]=\\\"_getActiveCell()\\\"\\n         (selectedValueChange)=\\\"_yearSelected($event)\\\"\\n         (keydown)=\\\"_handleCalendarBodyKeydown($event)\\\">\\n  </tbody>\\n</table>\\n\",\n                exportAs: 'matMultiYearView',\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush\n            }]\n    }], function () { return [{ type: ɵngcc0.ChangeDetectorRef }, { type: ɵngcc2.DateAdapter, decorators: [{\n                type: Optional\n            }] }, { type: ɵngcc3.Directionality, decorators: [{\n                type: Optional\n            }] }]; }, { selectedChange: [{\n            type: Output\n        }], yearSelected: [{\n            type: Output\n        }], activeDateChange: [{\n            type: Output\n        }], activeDate: [{\n            type: Input\n        }], selected: [{\n            type: Input\n        }], minDate: [{\n            type: Input\n        }], maxDate: [{\n            type: Input\n        }], dateFilter: [{\n            type: Input\n        }], _matCalendarBody: [{\n            type: ViewChild,\n            args: [MatCalendarBody]\n        }] }); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    MatMultiYearView.prototype._rerenderSubscription;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatMultiYearView.prototype._activeDate;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatMultiYearView.prototype._selected;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatMultiYearView.prototype._minDate;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatMultiYearView.prototype._maxDate;\n    /**\n     * A function used to filter which dates are selectable.\n     * @type {?}\n     */\n    MatMultiYearView.prototype.dateFilter;\n    /**\n     * Emits when a new year is selected.\n     * @type {?}\n     */\n    MatMultiYearView.prototype.selectedChange;\n    /**\n     * Emits the selected year. This doesn't imply a change on the selected date\n     * @type {?}\n     */\n    MatMultiYearView.prototype.yearSelected;\n    /**\n     * Emits when any date is activated.\n     * @type {?}\n     */\n    MatMultiYearView.prototype.activeDateChange;\n    /**\n     * The body of calendar table\n     * @type {?}\n     */\n    MatMultiYearView.prototype._matCalendarBody;\n    /**\n     * Grid of calendar cells representing the currently displayed years.\n     * @type {?}\n     */\n    MatMultiYearView.prototype._years;\n    /**\n     * The year that today falls on.\n     * @type {?}\n     */\n    MatMultiYearView.prototype._todayYear;\n    /**\n     * The year of the selected date. Null if the selected date is null.\n     * @type {?}\n     */\n    MatMultiYearView.prototype._selectedYear;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatMultiYearView.prototype._changeDetectorRef;\n    /** @type {?} */\n    MatMultiYearView.prototype._dateAdapter;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatMultiYearView.prototype._dir;\n}\n/**\n * @template D\n * @param {?} dateAdapter\n * @param {?} date1\n * @param {?} date2\n * @param {?} minDate\n * @param {?} maxDate\n * @return {?}\n */\nfunction isSameMultiYearView(dateAdapter, date1, date2, minDate, maxDate) {\n    /** @type {?} */\n    const year1 = dateAdapter.getYear(date1);\n    /** @type {?} */\n    const year2 = dateAdapter.getYear(date2);\n    /** @type {?} */\n    const startingYear = getStartingYear(dateAdapter, minDate, maxDate);\n    return Math.floor((year1 - startingYear) / yearsPerPage) ===\n        Math.floor((year2 - startingYear) / yearsPerPage);\n}\n/**\n * When the multi-year view is first opened, the active year will be in view.\n * So we compute how many years are between the active year and the *slot* where our\n * \"startingYear\" will render when paged into view.\n * @template D\n * @param {?} dateAdapter\n * @param {?} activeDate\n * @param {?} minDate\n * @param {?} maxDate\n * @return {?}\n */\nfunction getActiveOffset(dateAdapter, activeDate, minDate, maxDate) {\n    /** @type {?} */\n    const activeYear = dateAdapter.getYear(activeDate);\n    return euclideanModulo((activeYear - getStartingYear(dateAdapter, minDate, maxDate)), yearsPerPage);\n}\n/**\n * We pick a \"starting\" year such that either the maximum year would be at the end\n * or the minimum year would be at the beginning of a page.\n * @template D\n * @param {?} dateAdapter\n * @param {?} minDate\n * @param {?} maxDate\n * @return {?}\n */\nfunction getStartingYear(dateAdapter, minDate, maxDate) {\n    /** @type {?} */\n    let startingYear = 0;\n    if (maxDate) {\n        /** @type {?} */\n        const maxYear = dateAdapter.getYear(maxDate);\n        startingYear = maxYear - yearsPerPage + 1;\n    }\n    else if (minDate) {\n        startingYear = dateAdapter.getYear(minDate);\n    }\n    return startingYear;\n}\n/**\n * Gets remainder that is non-negative, even if first number is negative\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nfunction euclideanModulo(a, b) {\n    return (a % b + b) % b;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/datepicker/year-view.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * An internal component used to display a single year in the datepicker.\n * \\@docs-private\n * @template D\n */\nclass MatYearView {\n    /**\n     * @param {?} _changeDetectorRef\n     * @param {?} _dateFormats\n     * @param {?} _dateAdapter\n     * @param {?=} _dir\n     */\n    constructor(_changeDetectorRef, _dateFormats, _dateAdapter, _dir) {\n        this._changeDetectorRef = _changeDetectorRef;\n        this._dateFormats = _dateFormats;\n        this._dateAdapter = _dateAdapter;\n        this._dir = _dir;\n        this._rerenderSubscription = Subscription.EMPTY;\n        /**\n         * Emits when a new month is selected.\n         */\n        this.selectedChange = new EventEmitter();\n        /**\n         * Emits the selected month. This doesn't imply a change on the selected date\n         */\n        this.monthSelected = new EventEmitter();\n        /**\n         * Emits when any date is activated.\n         */\n        this.activeDateChange = new EventEmitter();\n        if (!this._dateAdapter) {\n            throw createMissingDateImplError('DateAdapter');\n        }\n        if (!this._dateFormats) {\n            throw createMissingDateImplError('MAT_DATE_FORMATS');\n        }\n        this._activeDate = this._dateAdapter.today();\n    }\n    /**\n     * The date to display in this year view (everything other than the year is ignored).\n     * @return {?}\n     */\n    get activeDate() { return this._activeDate; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set activeDate(value) {\n        /** @type {?} */\n        let oldActiveDate = this._activeDate;\n        /** @type {?} */\n        const validDate = this._getValidDateOrNull(this._dateAdapter.deserialize(value)) || this._dateAdapter.today();\n        this._activeDate = this._dateAdapter.clampDate(validDate, this.minDate, this.maxDate);\n        if (this._dateAdapter.getYear(oldActiveDate) !== this._dateAdapter.getYear(this._activeDate)) {\n            this._init();\n        }\n    }\n    /**\n     * The currently selected date.\n     * @return {?}\n     */\n    get selected() { return this._selected; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set selected(value) {\n        this._selected = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n        this._selectedMonth = this._getMonthInCurrentYear(this._selected);\n    }\n    /**\n     * The minimum selectable date.\n     * @return {?}\n     */\n    get minDate() { return this._minDate; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set minDate(value) {\n        this._minDate = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /**\n     * The maximum selectable date.\n     * @return {?}\n     */\n    get maxDate() { return this._maxDate; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set maxDate(value) {\n        this._maxDate = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterContentInit() {\n        this._rerenderSubscription = this._dateAdapter.localeChanges\n            .pipe(startWith(null))\n            .subscribe((/**\n         * @return {?}\n         */\n        () => this._init()));\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._rerenderSubscription.unsubscribe();\n    }\n    /**\n     * Handles when a new month is selected.\n     * @param {?} month\n     * @return {?}\n     */\n    _monthSelected(month) {\n        /** @type {?} */\n        const normalizedDate = this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), month, 1);\n        this.monthSelected.emit(normalizedDate);\n        /** @type {?} */\n        const daysInMonth = this._dateAdapter.getNumDaysInMonth(normalizedDate);\n        this.selectedChange.emit(this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), month, Math.min(this._dateAdapter.getDate(this.activeDate), daysInMonth)));\n    }\n    /**\n     * Handles keydown events on the calendar body when calendar is in year view.\n     * @param {?} event\n     * @return {?}\n     */\n    _handleCalendarBodyKeydown(event) {\n        // TODO(mmalerba): We currently allow keyboard navigation to disabled dates, but just prevent\n        // disabled ones from being selected. This may not be ideal, we should look into whether\n        // navigation should skip over disabled dates, and if so, how to implement that efficiently.\n        // TODO(mmalerba): We currently allow keyboard navigation to disabled dates, but just prevent\n        // disabled ones from being selected. This may not be ideal, we should look into whether\n        // navigation should skip over disabled dates, and if so, how to implement that efficiently.\n        /** @type {?} */\n        const oldActiveDate = this._activeDate;\n        /** @type {?} */\n        const isRtl = this._isRtl();\n        switch (event.keyCode) {\n            case LEFT_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate, isRtl ? 1 : -1);\n                break;\n            case RIGHT_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate, isRtl ? -1 : 1);\n                break;\n            case UP_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate, -4);\n                break;\n            case DOWN_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate, 4);\n                break;\n            case HOME:\n                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate, -this._dateAdapter.getMonth(this._activeDate));\n                break;\n            case END:\n                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate, 11 - this._dateAdapter.getMonth(this._activeDate));\n                break;\n            case PAGE_UP:\n                this.activeDate =\n                    this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? -10 : -1);\n                break;\n            case PAGE_DOWN:\n                this.activeDate =\n                    this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? 10 : 1);\n                break;\n            case ENTER:\n            case SPACE:\n                this._monthSelected(this._dateAdapter.getMonth(this._activeDate));\n                break;\n            default:\n                // Don't prevent default or focus active cell on keys that we don't explicitly handle.\n                return;\n        }\n        if (this._dateAdapter.compareDate(oldActiveDate, this.activeDate)) {\n            this.activeDateChange.emit(this.activeDate);\n        }\n        this._focusActiveCell();\n        // Prevent unexpected default actions such as form submission.\n        event.preventDefault();\n    }\n    /**\n     * Initializes this year view.\n     * @return {?}\n     */\n    _init() {\n        this._selectedMonth = this._getMonthInCurrentYear(this.selected);\n        this._todayMonth = this._getMonthInCurrentYear(this._dateAdapter.today());\n        this._yearLabel = this._dateAdapter.getYearName(this.activeDate);\n        /** @type {?} */\n        let monthNames = this._dateAdapter.getMonthNames('short');\n        // First row of months only contains 5 elements so we can fit the year label on the same row.\n        this._months = [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]].map((/**\n         * @param {?} row\n         * @return {?}\n         */\n        row => row.map((/**\n         * @param {?} month\n         * @return {?}\n         */\n        month => this._createCellForMonth(month, monthNames[month])))));\n        this._changeDetectorRef.markForCheck();\n    }\n    /**\n     * Focuses the active cell after the microtask queue is empty.\n     * @return {?}\n     */\n    _focusActiveCell() {\n        this._matCalendarBody._focusActiveCell();\n    }\n    /**\n     * Gets the month in this year that the given Date falls on.\n     * Returns null if the given Date is in another year.\n     * @private\n     * @param {?} date\n     * @return {?}\n     */\n    _getMonthInCurrentYear(date) {\n        return date && this._dateAdapter.getYear(date) == this._dateAdapter.getYear(this.activeDate) ?\n            this._dateAdapter.getMonth(date) : null;\n    }\n    /**\n     * Creates an MatCalendarCell for the given month.\n     * @private\n     * @param {?} month\n     * @param {?} monthName\n     * @return {?}\n     */\n    _createCellForMonth(month, monthName) {\n        /** @type {?} */\n        let ariaLabel = this._dateAdapter.format(this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), month, 1), this._dateFormats.display.monthYearA11yLabel);\n        return new MatCalendarCell(month, monthName.toLocaleUpperCase(), ariaLabel, this._shouldEnableMonth(month));\n    }\n    /**\n     * Whether the given month is enabled.\n     * @private\n     * @param {?} month\n     * @return {?}\n     */\n    _shouldEnableMonth(month) {\n        /** @type {?} */\n        const activeYear = this._dateAdapter.getYear(this.activeDate);\n        if (month === undefined || month === null ||\n            this._isYearAndMonthAfterMaxDate(activeYear, month) ||\n            this._isYearAndMonthBeforeMinDate(activeYear, month)) {\n            return false;\n        }\n        if (!this.dateFilter) {\n            return true;\n        }\n        /** @type {?} */\n        const firstOfMonth = this._dateAdapter.createDate(activeYear, month, 1);\n        // If any date in the month is enabled count the month as enabled.\n        for (let date = firstOfMonth; this._dateAdapter.getMonth(date) == month; date = this._dateAdapter.addCalendarDays(date, 1)) {\n            if (this.dateFilter(date)) {\n                return true;\n            }\n        }\n        return false;\n    }\n    /**\n     * Tests whether the combination month/year is after this.maxDate, considering\n     * just the month and year of this.maxDate\n     * @private\n     * @param {?} year\n     * @param {?} month\n     * @return {?}\n     */\n    _isYearAndMonthAfterMaxDate(year, month) {\n        if (this.maxDate) {\n            /** @type {?} */\n            const maxYear = this._dateAdapter.getYear(this.maxDate);\n            /** @type {?} */\n            const maxMonth = this._dateAdapter.getMonth(this.maxDate);\n            return year > maxYear || (year === maxYear && month > maxMonth);\n        }\n        return false;\n    }\n    /**\n     * Tests whether the combination month/year is before this.minDate, considering\n     * just the month and year of this.minDate\n     * @private\n     * @param {?} year\n     * @param {?} month\n     * @return {?}\n     */\n    _isYearAndMonthBeforeMinDate(year, month) {\n        if (this.minDate) {\n            /** @type {?} */\n            const minYear = this._dateAdapter.getYear(this.minDate);\n            /** @type {?} */\n            const minMonth = this._dateAdapter.getMonth(this.minDate);\n            return year < minYear || (year === minYear && month < minMonth);\n        }\n        return false;\n    }\n    /**\n     * @private\n     * @param {?} obj The object to check.\n     * @return {?} The given object if it is both a date instance and valid, otherwise null.\n     */\n    _getValidDateOrNull(obj) {\n        return (this._dateAdapter.isDateInstance(obj) && this._dateAdapter.isValid(obj)) ? obj : null;\n    }\n    /**\n     * Determines whether the user has the RTL layout direction.\n     * @private\n     * @return {?}\n     */\n    _isRtl() {\n        return this._dir && this._dir.value === 'rtl';\n    }\n}\nMatYearView.ɵfac = function MatYearView_Factory(t) { return new (t || MatYearView)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(MAT_DATE_FORMATS, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.DateAdapter, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc3.Directionality, 8)); };\nMatYearView.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatYearView, selectors: [[\"mat-year-view\"]], viewQuery: function MatYearView_Query(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵviewQuery(MatCalendarBody, true);\n    } if (rf & 2) {\n        var _t;\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._matCalendarBody = _t.first);\n    } }, inputs: { activeDate: \"activeDate\", selected: \"selected\", minDate: \"minDate\", maxDate: \"maxDate\", dateFilter: \"dateFilter\" }, outputs: { selectedChange: \"selectedChange\", monthSelected: \"monthSelected\", activeDateChange: \"activeDateChange\" }, exportAs: [\"matYearView\"], decls: 5, vars: 8, consts: [[\"role\", \"presentation\", 1, \"mat-calendar-table\"], [1, \"mat-calendar-table-header\"], [\"colspan\", \"4\", 1, \"mat-calendar-table-header-divider\"], [\"mat-calendar-body\", \"\", 3, \"label\", \"rows\", \"todayValue\", \"selectedValue\", \"labelMinRequiredCells\", \"numCols\", \"cellAspectRatio\", \"activeCell\", \"selectedValueChange\", \"keydown\"]], template: function MatYearView_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵelementStart(0, \"table\", 0);\n        ɵngcc0.ɵɵelementStart(1, \"thead\", 1);\n        ɵngcc0.ɵɵelementStart(2, \"tr\");\n        ɵngcc0.ɵɵelement(3, \"th\", 2);\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelementStart(4, \"tbody\", 3);\n        ɵngcc0.ɵɵlistener(\"selectedValueChange\", function MatYearView_Template_tbody_selectedValueChange_4_listener($event) { return ctx._monthSelected($event); })(\"keydown\", function MatYearView_Template_tbody_keydown_4_listener($event) { return ctx._handleCalendarBodyKeydown($event); });\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelementEnd();\n    } if (rf & 2) {\n        ɵngcc0.ɵɵadvance(4);\n        ɵngcc0.ɵɵproperty(\"label\", ctx._yearLabel)(\"rows\", ctx._months)(\"todayValue\", ctx._todayMonth)(\"selectedValue\", ctx._selectedMonth)(\"labelMinRequiredCells\", 2)(\"numCols\", 4)(\"cellAspectRatio\", 4 / 7)(\"activeCell\", ctx._dateAdapter.getMonth(ctx.activeDate));\n    } }, directives: [MatCalendarBody], encapsulation: 2, changeDetection: 0 });\n/** @nocollapse */\nMatYearView.ctorParameters = () => [\n    { type: ChangeDetectorRef },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] },\n    { type: DateAdapter, decorators: [{ type: Optional }] },\n    { type: Directionality, decorators: [{ type: Optional }] }\n];\nMatYearView.propDecorators = {\n    activeDate: [{ type: Input }],\n    selected: [{ type: Input }],\n    minDate: [{ type: Input }],\n    maxDate: [{ type: Input }],\n    dateFilter: [{ type: Input }],\n    selectedChange: [{ type: Output }],\n    monthSelected: [{ type: Output }],\n    activeDateChange: [{ type: Output }],\n    _matCalendarBody: [{ type: ViewChild, args: [MatCalendarBody,] }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatYearView, [{\n        type: Component,\n        args: [{\n                selector: 'mat-year-view',\n                template: \"<table class=\\\"mat-calendar-table\\\" role=\\\"presentation\\\">\\n  <thead class=\\\"mat-calendar-table-header\\\">\\n    <tr><th class=\\\"mat-calendar-table-header-divider\\\" colspan=\\\"4\\\"></th></tr>\\n  </thead>\\n  <tbody mat-calendar-body\\n         [label]=\\\"_yearLabel\\\"\\n         [rows]=\\\"_months\\\"\\n         [todayValue]=\\\"_todayMonth!\\\"\\n         [selectedValue]=\\\"_selectedMonth!\\\"\\n         [labelMinRequiredCells]=\\\"2\\\"\\n         [numCols]=\\\"4\\\"\\n         [cellAspectRatio]=\\\"4 / 7\\\"\\n         [activeCell]=\\\"_dateAdapter.getMonth(activeDate)\\\"\\n         (selectedValueChange)=\\\"_monthSelected($event)\\\"\\n         (keydown)=\\\"_handleCalendarBodyKeydown($event)\\\">\\n  </tbody>\\n</table>\\n\",\n                exportAs: 'matYearView',\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush\n            }]\n    }], function () { return [{ type: ɵngcc0.ChangeDetectorRef }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MAT_DATE_FORMATS]\n            }] }, { type: ɵngcc2.DateAdapter, decorators: [{\n                type: Optional\n            }] }, { type: ɵngcc3.Directionality, decorators: [{\n                type: Optional\n            }] }]; }, { selectedChange: [{\n            type: Output\n        }], monthSelected: [{\n            type: Output\n        }], activeDateChange: [{\n            type: Output\n        }], activeDate: [{\n            type: Input\n        }], selected: [{\n            type: Input\n        }], minDate: [{\n            type: Input\n        }], maxDate: [{\n            type: Input\n        }], dateFilter: [{\n            type: Input\n        }], _matCalendarBody: [{\n            type: ViewChild,\n            args: [MatCalendarBody]\n        }] }); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    MatYearView.prototype._rerenderSubscription;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatYearView.prototype._activeDate;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatYearView.prototype._selected;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatYearView.prototype._minDate;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatYearView.prototype._maxDate;\n    /**\n     * A function used to filter which dates are selectable.\n     * @type {?}\n     */\n    MatYearView.prototype.dateFilter;\n    /**\n     * Emits when a new month is selected.\n     * @type {?}\n     */\n    MatYearView.prototype.selectedChange;\n    /**\n     * Emits the selected month. This doesn't imply a change on the selected date\n     * @type {?}\n     */\n    MatYearView.prototype.monthSelected;\n    /**\n     * Emits when any date is activated.\n     * @type {?}\n     */\n    MatYearView.prototype.activeDateChange;\n    /**\n     * The body of calendar table\n     * @type {?}\n     */\n    MatYearView.prototype._matCalendarBody;\n    /**\n     * Grid of calendar cells representing the months of the year.\n     * @type {?}\n     */\n    MatYearView.prototype._months;\n    /**\n     * The label for this year (e.g. \"2017\").\n     * @type {?}\n     */\n    MatYearView.prototype._yearLabel;\n    /**\n     * The month in this year that today falls on. Null if today is in a different year.\n     * @type {?}\n     */\n    MatYearView.prototype._todayMonth;\n    /**\n     * The month in this year that the selected Date falls on.\n     * Null if the selected Date is in a different year.\n     * @type {?}\n     */\n    MatYearView.prototype._selectedMonth;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatYearView.prototype._changeDetectorRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatYearView.prototype._dateFormats;\n    /** @type {?} */\n    MatYearView.prototype._dateAdapter;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatYearView.prototype._dir;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/datepicker/calendar.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Default header for MatCalendar\n * @template D\n */\nclass MatCalendarHeader {\n    /**\n     * @param {?} _intl\n     * @param {?} calendar\n     * @param {?} _dateAdapter\n     * @param {?} _dateFormats\n     * @param {?} changeDetectorRef\n     */\n    constructor(_intl, calendar, _dateAdapter, _dateFormats, changeDetectorRef) {\n        this._intl = _intl;\n        this.calendar = calendar;\n        this._dateAdapter = _dateAdapter;\n        this._dateFormats = _dateFormats;\n        this.calendar.stateChanges.subscribe((/**\n         * @return {?}\n         */\n        () => changeDetectorRef.markForCheck()));\n    }\n    /**\n     * The label for the current calendar view.\n     * @return {?}\n     */\n    get periodButtonText() {\n        if (this.calendar.currentView == 'month') {\n            return this._dateAdapter\n                .format(this.calendar.activeDate, this._dateFormats.display.monthYearLabel)\n                .toLocaleUpperCase();\n        }\n        if (this.calendar.currentView == 'year') {\n            return this._dateAdapter.getYearName(this.calendar.activeDate);\n        }\n        // The offset from the active year to the \"slot\" for the starting year is the\n        // *actual* first rendered year in the multi-year view, and the last year is\n        // just yearsPerPage - 1 away.\n        /** @type {?} */\n        const activeYear = this._dateAdapter.getYear(this.calendar.activeDate);\n        /** @type {?} */\n        const minYearOfPage = activeYear - getActiveOffset(this._dateAdapter, this.calendar.activeDate, this.calendar.minDate, this.calendar.maxDate);\n        /** @type {?} */\n        const maxYearOfPage = minYearOfPage + yearsPerPage - 1;\n        /** @type {?} */\n        const minYearName = this._dateAdapter.getYearName(this._dateAdapter.createDate(minYearOfPage, 0, 1));\n        /** @type {?} */\n        const maxYearName = this._dateAdapter.getYearName(this._dateAdapter.createDate(maxYearOfPage, 0, 1));\n        return this._intl.formatYearRange(minYearName, maxYearName);\n    }\n    /**\n     * @return {?}\n     */\n    get periodButtonLabel() {\n        return this.calendar.currentView == 'month' ?\n            this._intl.switchToMultiYearViewLabel : this._intl.switchToMonthViewLabel;\n    }\n    /**\n     * The label for the previous button.\n     * @return {?}\n     */\n    get prevButtonLabel() {\n        return {\n            'month': this._intl.prevMonthLabel,\n            'year': this._intl.prevYearLabel,\n            'multi-year': this._intl.prevMultiYearLabel\n        }[this.calendar.currentView];\n    }\n    /**\n     * The label for the next button.\n     * @return {?}\n     */\n    get nextButtonLabel() {\n        return {\n            'month': this._intl.nextMonthLabel,\n            'year': this._intl.nextYearLabel,\n            'multi-year': this._intl.nextMultiYearLabel\n        }[this.calendar.currentView];\n    }\n    /**\n     * Handles user clicks on the period label.\n     * @return {?}\n     */\n    currentPeriodClicked() {\n        this.calendar.currentView = this.calendar.currentView == 'month' ? 'multi-year' : 'month';\n    }\n    /**\n     * Handles user clicks on the previous button.\n     * @return {?}\n     */\n    previousClicked() {\n        this.calendar.activeDate = this.calendar.currentView == 'month' ?\n            this._dateAdapter.addCalendarMonths(this.calendar.activeDate, -1) :\n            this._dateAdapter.addCalendarYears(this.calendar.activeDate, this.calendar.currentView == 'year' ? -1 : -yearsPerPage);\n    }\n    /**\n     * Handles user clicks on the next button.\n     * @return {?}\n     */\n    nextClicked() {\n        this.calendar.activeDate = this.calendar.currentView == 'month' ?\n            this._dateAdapter.addCalendarMonths(this.calendar.activeDate, 1) :\n            this._dateAdapter.addCalendarYears(this.calendar.activeDate, this.calendar.currentView == 'year' ? 1 : yearsPerPage);\n    }\n    /**\n     * Whether the previous period button is enabled.\n     * @return {?}\n     */\n    previousEnabled() {\n        if (!this.calendar.minDate) {\n            return true;\n        }\n        return !this.calendar.minDate ||\n            !this._isSameView(this.calendar.activeDate, this.calendar.minDate);\n    }\n    /**\n     * Whether the next period button is enabled.\n     * @return {?}\n     */\n    nextEnabled() {\n        return !this.calendar.maxDate ||\n            !this._isSameView(this.calendar.activeDate, this.calendar.maxDate);\n    }\n    /**\n     * Whether the two dates represent the same view in the current view mode (month or year).\n     * @private\n     * @param {?} date1\n     * @param {?} date2\n     * @return {?}\n     */\n    _isSameView(date1, date2) {\n        if (this.calendar.currentView == 'month') {\n            return this._dateAdapter.getYear(date1) == this._dateAdapter.getYear(date2) &&\n                this._dateAdapter.getMonth(date1) == this._dateAdapter.getMonth(date2);\n        }\n        if (this.calendar.currentView == 'year') {\n            return this._dateAdapter.getYear(date1) == this._dateAdapter.getYear(date2);\n        }\n        // Otherwise we are in 'multi-year' view.\n        return isSameMultiYearView(this._dateAdapter, date1, date2, this.calendar.minDate, this.calendar.maxDate);\n    }\n}\nMatCalendarHeader.ɵfac = function MatCalendarHeader_Factory(t) { return new (t || MatCalendarHeader)(ɵngcc0.ɵɵdirectiveInject(MatDatepickerIntl), ɵngcc0.ɵɵdirectiveInject(forwardRef(( /**\n                 * @return {?}\n                 */() => MatCalendar))), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.DateAdapter, 8), ɵngcc0.ɵɵdirectiveInject(MAT_DATE_FORMATS, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef)); };\nMatCalendarHeader.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatCalendarHeader, selectors: [[\"mat-calendar-header\"]], exportAs: [\"matCalendarHeader\"], ngContentSelectors: _c1, decls: 9, vars: 8, consts: [[1, \"mat-calendar-header\"], [1, \"mat-calendar-controls\"], [\"mat-button\", \"\", \"type\", \"button\", \"cdkAriaLive\", \"polite\", 1, \"mat-calendar-period-button\", 3, \"click\"], [1, \"mat-calendar-arrow\"], [1, \"mat-calendar-spacer\"], [\"mat-icon-button\", \"\", \"type\", \"button\", 1, \"mat-calendar-previous-button\", 3, \"disabled\", \"click\"], [\"mat-icon-button\", \"\", \"type\", \"button\", 1, \"mat-calendar-next-button\", 3, \"disabled\", \"click\"]], template: function MatCalendarHeader_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵprojectionDef();\n        ɵngcc0.ɵɵelementStart(0, \"div\", 0);\n        ɵngcc0.ɵɵelementStart(1, \"div\", 1);\n        ɵngcc0.ɵɵelementStart(2, \"button\", 2);\n        ɵngcc0.ɵɵlistener(\"click\", function MatCalendarHeader_Template_button_click_2_listener() { return ctx.currentPeriodClicked(); });\n        ɵngcc0.ɵɵtext(3);\n        ɵngcc0.ɵɵelement(4, \"div\", 3);\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelement(5, \"div\", 4);\n        ɵngcc0.ɵɵprojection(6);\n        ɵngcc0.ɵɵelementStart(7, \"button\", 5);\n        ɵngcc0.ɵɵlistener(\"click\", function MatCalendarHeader_Template_button_click_7_listener() { return ctx.previousClicked(); });\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelementStart(8, \"button\", 6);\n        ɵngcc0.ɵɵlistener(\"click\", function MatCalendarHeader_Template_button_click_8_listener() { return ctx.nextClicked(); });\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelementEnd();\n    } if (rf & 2) {\n        ɵngcc0.ɵɵadvance(2);\n        ɵngcc0.ɵɵattribute(\"aria-label\", ctx.periodButtonLabel);\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵtextInterpolate1(\" \", ctx.periodButtonText, \" \");\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵclassProp(\"mat-calendar-invert\", ctx.calendar.currentView != \"month\");\n        ɵngcc0.ɵɵadvance(3);\n        ɵngcc0.ɵɵproperty(\"disabled\", !ctx.previousEnabled());\n        ɵngcc0.ɵɵattribute(\"aria-label\", ctx.prevButtonLabel);\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵproperty(\"disabled\", !ctx.nextEnabled());\n        ɵngcc0.ɵɵattribute(\"aria-label\", ctx.nextButtonLabel);\n    } }, directives: [ɵngcc4.MatButton, ɵngcc5.CdkAriaLive], encapsulation: 2, changeDetection: 0 });\n/** @nocollapse */\nMatCalendarHeader.ctorParameters = () => [\n    { type: MatDatepickerIntl },\n    { type: MatCalendar, decorators: [{ type: Inject, args: [forwardRef((/**\n                     * @return {?}\n                     */\n                    () => MatCalendar)),] }] },\n    { type: DateAdapter, decorators: [{ type: Optional }] },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] },\n    { type: ChangeDetectorRef }\n];\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatCalendarHeader, [{\n        type: Component,\n        args: [{\n                selector: 'mat-calendar-header',\n                template: \"<div class=\\\"mat-calendar-header\\\">\\n  <div class=\\\"mat-calendar-controls\\\">\\n    <button mat-button type=\\\"button\\\" class=\\\"mat-calendar-period-button\\\"\\n            (click)=\\\"currentPeriodClicked()\\\" [attr.aria-label]=\\\"periodButtonLabel\\\"\\n            cdkAriaLive=\\\"polite\\\">\\n      {{periodButtonText}}\\n      <div class=\\\"mat-calendar-arrow\\\"\\n           [class.mat-calendar-invert]=\\\"calendar.currentView != 'month'\\\"></div>\\n    </button>\\n\\n    <div class=\\\"mat-calendar-spacer\\\"></div>\\n\\n    <ng-content></ng-content>\\n\\n    <button mat-icon-button type=\\\"button\\\" class=\\\"mat-calendar-previous-button\\\"\\n            [disabled]=\\\"!previousEnabled()\\\" (click)=\\\"previousClicked()\\\"\\n            [attr.aria-label]=\\\"prevButtonLabel\\\">\\n    </button>\\n\\n    <button mat-icon-button type=\\\"button\\\" class=\\\"mat-calendar-next-button\\\"\\n            [disabled]=\\\"!nextEnabled()\\\" (click)=\\\"nextClicked()\\\"\\n            [attr.aria-label]=\\\"nextButtonLabel\\\">\\n    </button>\\n  </div>\\n</div>\\n\",\n                exportAs: 'matCalendarHeader',\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush\n            }]\n    }], function () { return [{ type: MatDatepickerIntl }, { type: MatCalendar, decorators: [{\n                type: Inject,\n                args: [forwardRef(( /**\n                                     * @return {?}\n                                     */() => MatCalendar))]\n            }] }, { type: ɵngcc2.DateAdapter, decorators: [{\n                type: Optional\n            }] }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MAT_DATE_FORMATS]\n            }] }, { type: ɵngcc0.ChangeDetectorRef }]; }, null); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    MatCalendarHeader.prototype._intl;\n    /** @type {?} */\n    MatCalendarHeader.prototype.calendar;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatCalendarHeader.prototype._dateAdapter;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatCalendarHeader.prototype._dateFormats;\n}\n/**\n * A calendar that is used as part of the datepicker.\n * \\@docs-private\n * @template D\n */\nclass MatCalendar {\n    /**\n     * @param {?} _intl\n     * @param {?} _dateAdapter\n     * @param {?} _dateFormats\n     * @param {?} _changeDetectorRef\n     */\n    constructor(_intl, _dateAdapter, _dateFormats, _changeDetectorRef) {\n        this._dateAdapter = _dateAdapter;\n        this._dateFormats = _dateFormats;\n        this._changeDetectorRef = _changeDetectorRef;\n        /**\n         * Used for scheduling that focus should be moved to the active cell on the next tick.\n         * We need to schedule it, rather than do it immediately, because we have to wait\n         * for Angular to re-evaluate the view children.\n         */\n        this._moveFocusOnNextTick = false;\n        /**\n         * Whether the calendar should be started in month or year view.\n         */\n        this.startView = 'month';\n        /**\n         * Emits when the currently selected date changes.\n         */\n        this.selectedChange = new EventEmitter();\n        /**\n         * Emits the year chosen in multiyear view.\n         * This doesn't imply a change on the selected date.\n         */\n        this.yearSelected = new EventEmitter();\n        /**\n         * Emits the month chosen in year view.\n         * This doesn't imply a change on the selected date.\n         */\n        this.monthSelected = new EventEmitter();\n        /**\n         * Emits when any date is selected.\n         */\n        this._userSelection = new EventEmitter();\n        /**\n         * Emits whenever there is a state change that the header may need to respond to.\n         */\n        this.stateChanges = new Subject();\n        if (!this._dateAdapter) {\n            throw createMissingDateImplError('DateAdapter');\n        }\n        if (!this._dateFormats) {\n            throw createMissingDateImplError('MAT_DATE_FORMATS');\n        }\n        this._intlChanges = _intl.changes.subscribe((/**\n         * @return {?}\n         */\n        () => {\n            _changeDetectorRef.markForCheck();\n            this.stateChanges.next();\n        }));\n    }\n    /**\n     * A date representing the period (month or year) to start the calendar in.\n     * @return {?}\n     */\n    get startAt() { return this._startAt; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set startAt(value) {\n        this._startAt = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /**\n     * The currently selected date.\n     * @return {?}\n     */\n    get selected() { return this._selected; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set selected(value) {\n        this._selected = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /**\n     * The minimum selectable date.\n     * @return {?}\n     */\n    get minDate() { return this._minDate; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set minDate(value) {\n        this._minDate = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /**\n     * The maximum selectable date.\n     * @return {?}\n     */\n    get maxDate() { return this._maxDate; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set maxDate(value) {\n        this._maxDate = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /**\n     * The current active date. This determines which time period is shown and which date is\n     * highlighted when using keyboard navigation.\n     * @return {?}\n     */\n    get activeDate() { return this._clampedActiveDate; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set activeDate(value) {\n        this._clampedActiveDate = this._dateAdapter.clampDate(value, this.minDate, this.maxDate);\n        this.stateChanges.next();\n        this._changeDetectorRef.markForCheck();\n    }\n    /**\n     * Whether the calendar is in month view.\n     * @return {?}\n     */\n    get currentView() { return this._currentView; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set currentView(value) {\n        this._currentView = value;\n        this._moveFocusOnNextTick = true;\n        this._changeDetectorRef.markForCheck();\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterContentInit() {\n        this._calendarHeaderPortal = new ComponentPortal(this.headerComponent || MatCalendarHeader);\n        this.activeDate = this.startAt || this._dateAdapter.today();\n        // Assign to the private property since we don't want to move focus on init.\n        this._currentView = this.startView;\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterViewChecked() {\n        if (this._moveFocusOnNextTick) {\n            this._moveFocusOnNextTick = false;\n            this.focusActiveCell();\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._intlChanges.unsubscribe();\n        this.stateChanges.complete();\n    }\n    /**\n     * @param {?} changes\n     * @return {?}\n     */\n    ngOnChanges(changes) {\n        /** @type {?} */\n        const change = changes['minDate'] || changes['maxDate'] || changes['dateFilter'];\n        if (change && !change.firstChange) {\n            /** @type {?} */\n            const view = this._getCurrentViewComponent();\n            if (view) {\n                // We need to `detectChanges` manually here, because the `minDate`, `maxDate` etc. are\n                // passed down to the view via data bindings which won't be up-to-date when we call `_init`.\n                this._changeDetectorRef.detectChanges();\n                view._init();\n            }\n        }\n        this.stateChanges.next();\n    }\n    /**\n     * @return {?}\n     */\n    focusActiveCell() {\n        this._getCurrentViewComponent()._focusActiveCell();\n    }\n    /**\n     * Updates today's date after an update of the active date\n     * @return {?}\n     */\n    updateTodaysDate() {\n        /** @type {?} */\n        const currentView = this.currentView;\n        /** @type {?} */\n        let view;\n        if (currentView === 'month') {\n            view = this.monthView;\n        }\n        else if (currentView === 'year') {\n            view = this.yearView;\n        }\n        else {\n            view = this.multiYearView;\n        }\n        view._init();\n    }\n    /**\n     * Handles date selection in the month view.\n     * @param {?} date\n     * @return {?}\n     */\n    _dateSelected(date) {\n        if (date && !this._dateAdapter.sameDate(date, this.selected)) {\n            this.selectedChange.emit(date);\n        }\n    }\n    /**\n     * Handles year selection in the multiyear view.\n     * @param {?} normalizedYear\n     * @return {?}\n     */\n    _yearSelectedInMultiYearView(normalizedYear) {\n        this.yearSelected.emit(normalizedYear);\n    }\n    /**\n     * Handles month selection in the year view.\n     * @param {?} normalizedMonth\n     * @return {?}\n     */\n    _monthSelectedInYearView(normalizedMonth) {\n        this.monthSelected.emit(normalizedMonth);\n    }\n    /**\n     * @return {?}\n     */\n    _userSelected() {\n        this._userSelection.emit();\n    }\n    /**\n     * Handles year/month selection in the multi-year/year views.\n     * @param {?} date\n     * @param {?} view\n     * @return {?}\n     */\n    _goToDateInView(date, view) {\n        this.activeDate = date;\n        this.currentView = view;\n    }\n    /**\n     * @private\n     * @param {?} obj The object to check.\n     * @return {?} The given object if it is both a date instance and valid, otherwise null.\n     */\n    _getValidDateOrNull(obj) {\n        return (this._dateAdapter.isDateInstance(obj) && this._dateAdapter.isValid(obj)) ? obj : null;\n    }\n    /**\n     * Returns the component instance that corresponds to the current calendar view.\n     * @private\n     * @return {?}\n     */\n    _getCurrentViewComponent() {\n        return this.monthView || this.yearView || this.multiYearView;\n    }\n}\nMatCalendar.ɵfac = function MatCalendar_Factory(t) { return new (t || MatCalendar)(ɵngcc0.ɵɵdirectiveInject(MatDatepickerIntl), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.DateAdapter, 8), ɵngcc0.ɵɵdirectiveInject(MAT_DATE_FORMATS, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef)); };\nMatCalendar.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatCalendar, selectors: [[\"mat-calendar\"]], viewQuery: function MatCalendar_Query(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵviewQuery(MatMonthView, true);\n        ɵngcc0.ɵɵviewQuery(MatYearView, true);\n        ɵngcc0.ɵɵviewQuery(MatMultiYearView, true);\n    } if (rf & 2) {\n        var _t;\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.monthView = _t.first);\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.yearView = _t.first);\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.multiYearView = _t.first);\n    } }, hostAttrs: [1, \"mat-calendar\"], inputs: { startView: \"startView\", startAt: \"startAt\", selected: \"selected\", minDate: \"minDate\", maxDate: \"maxDate\", headerComponent: \"headerComponent\", dateFilter: \"dateFilter\", dateClass: \"dateClass\" }, outputs: { selectedChange: \"selectedChange\", yearSelected: \"yearSelected\", monthSelected: \"monthSelected\", _userSelection: \"_userSelection\" }, exportAs: [\"matCalendar\"], features: [ɵngcc0.ɵɵNgOnChangesFeature], decls: 5, vars: 5, consts: [[3, \"cdkPortalOutlet\"], [\"cdkMonitorSubtreeFocus\", \"\", \"tabindex\", \"-1\", 1, \"mat-calendar-content\", 3, \"ngSwitch\"], [3, \"activeDate\", \"selected\", \"dateFilter\", \"maxDate\", \"minDate\", \"dateClass\", \"activeDateChange\", \"selectedChange\", \"_userSelection\", 4, \"ngSwitchCase\"], [3, \"activeDate\", \"selected\", \"dateFilter\", \"maxDate\", \"minDate\", \"activeDateChange\", \"monthSelected\", \"selectedChange\", 4, \"ngSwitchCase\"], [3, \"activeDate\", \"selected\", \"dateFilter\", \"maxDate\", \"minDate\", \"activeDateChange\", \"yearSelected\", \"selectedChange\", 4, \"ngSwitchCase\"], [3, \"activeDate\", \"selected\", \"dateFilter\", \"maxDate\", \"minDate\", \"dateClass\", \"activeDateChange\", \"selectedChange\", \"_userSelection\"], [3, \"activeDate\", \"selected\", \"dateFilter\", \"maxDate\", \"minDate\", \"activeDateChange\", \"monthSelected\", \"selectedChange\"], [3, \"activeDate\", \"selected\", \"dateFilter\", \"maxDate\", \"minDate\", \"activeDateChange\", \"yearSelected\", \"selectedChange\"]], template: function MatCalendar_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵtemplate(0, MatCalendar_ng_template_0_Template, 0, 0, \"ng-template\", 0);\n        ɵngcc0.ɵɵelementStart(1, \"div\", 1);\n        ɵngcc0.ɵɵtemplate(2, MatCalendar_mat_month_view_2_Template, 1, 6, \"mat-month-view\", 2);\n        ɵngcc0.ɵɵtemplate(3, MatCalendar_mat_year_view_3_Template, 1, 5, \"mat-year-view\", 3);\n        ɵngcc0.ɵɵtemplate(4, MatCalendar_mat_multi_year_view_4_Template, 1, 5, \"mat-multi-year-view\", 4);\n        ɵngcc0.ɵɵelementEnd();\n    } if (rf & 2) {\n        ɵngcc0.ɵɵproperty(\"cdkPortalOutlet\", ctx._calendarHeaderPortal);\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵproperty(\"ngSwitch\", ctx.currentView);\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵproperty(\"ngSwitchCase\", \"month\");\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵproperty(\"ngSwitchCase\", \"year\");\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵproperty(\"ngSwitchCase\", \"multi-year\");\n    } }, directives: [ɵngcc6.CdkPortalOutlet, ɵngcc5.CdkMonitorFocus, ɵngcc1.NgSwitch, ɵngcc1.NgSwitchCase, MatMonthView,\n        MatYearView,\n        MatMultiYearView], styles: [\".mat-calendar{display:block}.mat-calendar-header{padding:8px 8px 0 8px}.mat-calendar-content{padding:0 8px 8px 8px;outline:none}.mat-calendar-controls{display:flex;margin:5% calc(33% / 7 - 16px)}.mat-calendar-controls .mat-icon-button:hover .mat-button-focus-overlay{opacity:.04}.mat-calendar-spacer{flex:1 1 auto}.mat-calendar-period-button{min-width:0}.mat-calendar-arrow{display:inline-block;width:0;height:0;border-left:5px solid transparent;border-right:5px solid transparent;border-top-width:5px;border-top-style:solid;margin:0 0 0 5px;vertical-align:middle}.mat-calendar-arrow.mat-calendar-invert{transform:rotate(180deg)}[dir=rtl] .mat-calendar-arrow{margin:0 5px 0 0}.mat-calendar-previous-button,.mat-calendar-next-button{position:relative}.mat-calendar-previous-button::after,.mat-calendar-next-button::after{top:0;left:0;right:0;bottom:0;position:absolute;content:\\\"\\\";margin:15.5px;border:0 solid currentColor;border-top-width:2px}[dir=rtl] .mat-calendar-previous-button,[dir=rtl] .mat-calendar-next-button{transform:rotate(180deg)}.mat-calendar-previous-button::after{border-left-width:2px;transform:translateX(2px) rotate(-45deg)}.mat-calendar-next-button::after{border-right-width:2px;transform:translateX(-2px) rotate(45deg)}.mat-calendar-table{border-spacing:0;border-collapse:collapse;width:100%}.mat-calendar-table-header th{text-align:center;padding:0 0 8px 0}.mat-calendar-table-header-divider{position:relative;height:1px}.mat-calendar-table-header-divider::after{content:\\\"\\\";position:absolute;top:0;left:-8px;right:-8px;height:1px}\\n\"], encapsulation: 2, changeDetection: 0 });\n/** @nocollapse */\nMatCalendar.ctorParameters = () => [\n    { type: MatDatepickerIntl },\n    { type: DateAdapter, decorators: [{ type: Optional }] },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] },\n    { type: ChangeDetectorRef }\n];\nMatCalendar.propDecorators = {\n    headerComponent: [{ type: Input }],\n    startAt: [{ type: Input }],\n    startView: [{ type: Input }],\n    selected: [{ type: Input }],\n    minDate: [{ type: Input }],\n    maxDate: [{ type: Input }],\n    dateFilter: [{ type: Input }],\n    dateClass: [{ type: Input }],\n    selectedChange: [{ type: Output }],\n    yearSelected: [{ type: Output }],\n    monthSelected: [{ type: Output }],\n    _userSelection: [{ type: Output }],\n    monthView: [{ type: ViewChild, args: [MatMonthView,] }],\n    yearView: [{ type: ViewChild, args: [MatYearView,] }],\n    multiYearView: [{ type: ViewChild, args: [MatMultiYearView,] }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatCalendar, [{\n        type: Component,\n        args: [{\n                selector: 'mat-calendar',\n                template: \"\\n<ng-template [cdkPortalOutlet]=\\\"_calendarHeaderPortal\\\"></ng-template>\\n\\n<div class=\\\"mat-calendar-content\\\" [ngSwitch]=\\\"currentView\\\" cdkMonitorSubtreeFocus tabindex=\\\"-1\\\">\\n  <mat-month-view\\n      *ngSwitchCase=\\\"'month'\\\"\\n      [(activeDate)]=\\\"activeDate\\\"\\n      [selected]=\\\"selected\\\"\\n      [dateFilter]=\\\"dateFilter\\\"\\n      [maxDate]=\\\"maxDate\\\"\\n      [minDate]=\\\"minDate\\\"\\n      [dateClass]=\\\"dateClass\\\"\\n      (selectedChange)=\\\"_dateSelected($event)\\\"\\n      (_userSelection)=\\\"_userSelected()\\\">\\n  </mat-month-view>\\n\\n  <mat-year-view\\n      *ngSwitchCase=\\\"'year'\\\"\\n      [(activeDate)]=\\\"activeDate\\\"\\n      [selected]=\\\"selected\\\"\\n      [dateFilter]=\\\"dateFilter\\\"\\n      [maxDate]=\\\"maxDate\\\"\\n      [minDate]=\\\"minDate\\\"\\n      (monthSelected)=\\\"_monthSelectedInYearView($event)\\\"\\n      (selectedChange)=\\\"_goToDateInView($event, 'month')\\\">\\n  </mat-year-view>\\n\\n  <mat-multi-year-view\\n      *ngSwitchCase=\\\"'multi-year'\\\"\\n      [(activeDate)]=\\\"activeDate\\\"\\n      [selected]=\\\"selected\\\"\\n      [dateFilter]=\\\"dateFilter\\\"\\n      [maxDate]=\\\"maxDate\\\"\\n      [minDate]=\\\"minDate\\\"\\n      (yearSelected)=\\\"_yearSelectedInMultiYearView($event)\\\"\\n      (selectedChange)=\\\"_goToDateInView($event, 'year')\\\">\\n  </mat-multi-year-view>\\n</div>\\n\",\n                host: {\n                    'class': 'mat-calendar'\n                },\n                exportAs: 'matCalendar',\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush,\n                styles: [\".mat-calendar{display:block}.mat-calendar-header{padding:8px 8px 0 8px}.mat-calendar-content{padding:0 8px 8px 8px;outline:none}.mat-calendar-controls{display:flex;margin:5% calc(33% / 7 - 16px)}.mat-calendar-controls .mat-icon-button:hover .mat-button-focus-overlay{opacity:.04}.mat-calendar-spacer{flex:1 1 auto}.mat-calendar-period-button{min-width:0}.mat-calendar-arrow{display:inline-block;width:0;height:0;border-left:5px solid transparent;border-right:5px solid transparent;border-top-width:5px;border-top-style:solid;margin:0 0 0 5px;vertical-align:middle}.mat-calendar-arrow.mat-calendar-invert{transform:rotate(180deg)}[dir=rtl] .mat-calendar-arrow{margin:0 5px 0 0}.mat-calendar-previous-button,.mat-calendar-next-button{position:relative}.mat-calendar-previous-button::after,.mat-calendar-next-button::after{top:0;left:0;right:0;bottom:0;position:absolute;content:\\\"\\\";margin:15.5px;border:0 solid currentColor;border-top-width:2px}[dir=rtl] .mat-calendar-previous-button,[dir=rtl] .mat-calendar-next-button{transform:rotate(180deg)}.mat-calendar-previous-button::after{border-left-width:2px;transform:translateX(2px) rotate(-45deg)}.mat-calendar-next-button::after{border-right-width:2px;transform:translateX(-2px) rotate(45deg)}.mat-calendar-table{border-spacing:0;border-collapse:collapse;width:100%}.mat-calendar-table-header th{text-align:center;padding:0 0 8px 0}.mat-calendar-table-header-divider{position:relative;height:1px}.mat-calendar-table-header-divider::after{content:\\\"\\\";position:absolute;top:0;left:-8px;right:-8px;height:1px}\\n\"]\n            }]\n    }], function () { return [{ type: MatDatepickerIntl }, { type: ɵngcc2.DateAdapter, decorators: [{\n                type: Optional\n            }] }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MAT_DATE_FORMATS]\n            }] }, { type: ɵngcc0.ChangeDetectorRef }]; }, { startView: [{\n            type: Input\n        }], selectedChange: [{\n            type: Output\n        }], yearSelected: [{\n            type: Output\n        }], monthSelected: [{\n            type: Output\n        }], _userSelection: [{\n            type: Output\n        }], startAt: [{\n            type: Input\n        }], selected: [{\n            type: Input\n        }], minDate: [{\n            type: Input\n        }], maxDate: [{\n            type: Input\n        }], headerComponent: [{\n            type: Input\n        }], dateFilter: [{\n            type: Input\n        }], dateClass: [{\n            type: Input\n        }], monthView: [{\n            type: ViewChild,\n            args: [MatMonthView]\n        }], yearView: [{\n            type: ViewChild,\n            args: [MatYearView]\n        }], multiYearView: [{\n            type: ViewChild,\n            args: [MatMultiYearView]\n        }] }); })();\nif (false) {\n    /**\n     * An input indicating the type of the header component, if set.\n     * @type {?}\n     */\n    MatCalendar.prototype.headerComponent;\n    /**\n     * A portal containing the header component type for this calendar.\n     * @type {?}\n     */\n    MatCalendar.prototype._calendarHeaderPortal;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatCalendar.prototype._intlChanges;\n    /**\n     * Used for scheduling that focus should be moved to the active cell on the next tick.\n     * We need to schedule it, rather than do it immediately, because we have to wait\n     * for Angular to re-evaluate the view children.\n     * @type {?}\n     * @private\n     */\n    MatCalendar.prototype._moveFocusOnNextTick;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatCalendar.prototype._startAt;\n    /**\n     * Whether the calendar should be started in month or year view.\n     * @type {?}\n     */\n    MatCalendar.prototype.startView;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatCalendar.prototype._selected;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatCalendar.prototype._minDate;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatCalendar.prototype._maxDate;\n    /**\n     * Function used to filter which dates are selectable.\n     * @type {?}\n     */\n    MatCalendar.prototype.dateFilter;\n    /**\n     * Function that can be used to add custom CSS classes to dates.\n     * @type {?}\n     */\n    MatCalendar.prototype.dateClass;\n    /**\n     * Emits when the currently selected date changes.\n     * @type {?}\n     */\n    MatCalendar.prototype.selectedChange;\n    /**\n     * Emits the year chosen in multiyear view.\n     * This doesn't imply a change on the selected date.\n     * @type {?}\n     */\n    MatCalendar.prototype.yearSelected;\n    /**\n     * Emits the month chosen in year view.\n     * This doesn't imply a change on the selected date.\n     * @type {?}\n     */\n    MatCalendar.prototype.monthSelected;\n    /**\n     * Emits when any date is selected.\n     * @type {?}\n     */\n    MatCalendar.prototype._userSelection;\n    /**\n     * Reference to the current month view component.\n     * @type {?}\n     */\n    MatCalendar.prototype.monthView;\n    /**\n     * Reference to the current year view component.\n     * @type {?}\n     */\n    MatCalendar.prototype.yearView;\n    /**\n     * Reference to the current multi-year view component.\n     * @type {?}\n     */\n    MatCalendar.prototype.multiYearView;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatCalendar.prototype._clampedActiveDate;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatCalendar.prototype._currentView;\n    /**\n     * Emits whenever there is a state change that the header may need to respond to.\n     * @type {?}\n     */\n    MatCalendar.prototype.stateChanges;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatCalendar.prototype._dateAdapter;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatCalendar.prototype._dateFormats;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatCalendar.prototype._changeDetectorRef;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/datepicker/datepicker-animations.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Animations used by the Material datepicker.\n * \\@docs-private\n * @type {?}\n */\nconst matDatepickerAnimations = {\n    /**\n     * Transforms the height of the datepicker's calendar.\n     */\n    transformPanel: trigger('transformPanel', [\n        state('void', style({\n            opacity: 0,\n            transform: 'scale(1, 0.8)'\n        })),\n        transition('void => enter', animate('120ms cubic-bezier(0, 0, 0.2, 1)', style({\n            opacity: 1,\n            transform: 'scale(1, 1)'\n        }))),\n        transition('* => void', animate('100ms linear', style({ opacity: 0 })))\n    ]),\n    /**\n     * Fades in the content of the calendar.\n     */\n    fadeInCalendar: trigger('fadeInCalendar', [\n        state('void', style({ opacity: 0 })),\n        state('enter', style({ opacity: 1 })),\n        // TODO(crisbeto): this animation should be removed since it isn't quite on spec, but we\n        // need to keep it until #12440 gets in, otherwise the exit animation will look glitchy.\n        transition('void => *', animate('120ms 100ms cubic-bezier(0.55, 0, 0.55, 0.2)'))\n    ])\n};\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/datepicker/datepicker.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Used to generate a unique ID for each datepicker instance.\n * @type {?}\n */\nlet datepickerUid = 0;\n/**\n * Injection token that determines the scroll handling while the calendar is open.\n * @type {?}\n */\nconst MAT_DATEPICKER_SCROLL_STRATEGY = new InjectionToken('mat-datepicker-scroll-strategy');\n/**\n * \\@docs-private\n * @param {?} overlay\n * @return {?}\n */\nfunction MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY(overlay) {\n    return (/**\n     * @return {?}\n     */\n    () => overlay.scrollStrategies.reposition());\n}\n/**\n * \\@docs-private\n * @type {?}\n */\nconst MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER = {\n    provide: MAT_DATEPICKER_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY,\n};\n// Boilerplate for applying mixins to MatDatepickerContent.\n/**\n * \\@docs-private\n */\nclass MatDatepickerContentBase {\n    /**\n     * @param {?} _elementRef\n     */\n    constructor(_elementRef) {\n        this._elementRef = _elementRef;\n    }\n}\nif (false) {\n    /** @type {?} */\n    MatDatepickerContentBase.prototype._elementRef;\n}\n/** @type {?} */\nconst _MatDatepickerContentMixinBase = mixinColor(MatDatepickerContentBase);\n/**\n * Component used as the content for the datepicker dialog and popup. We use this instead of using\n * MatCalendar directly as the content so we can control the initial focus. This also gives us a\n * place to put additional features of the popup that are not part of the calendar itself in the\n * future. (e.g. confirmation buttons).\n * \\@docs-private\n * @template D\n */\nclass MatDatepickerContent extends _MatDatepickerContentMixinBase {\n    /**\n     * @param {?} elementRef\n     * @param {?=} _changeDetectorRef\n     */\n    constructor(elementRef, _changeDetectorRef) {\n        super(elementRef);\n        this._changeDetectorRef = _changeDetectorRef;\n        /**\n         * Current state of the animation.\n         */\n        this._animationState = 'enter';\n        /**\n         * Emits when an animation has finished.\n         */\n        this._animationDone = new Subject();\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterViewInit() {\n        this._calendar.focusActiveCell();\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._animationDone.complete();\n    }\n    /**\n     * @return {?}\n     */\n    _startExitAnimation() {\n        this._animationState = 'void';\n        // @breaking-change 11.0.0 Remove null check for `_changeDetectorRef`.\n        if (this._changeDetectorRef) {\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n}\nMatDatepickerContent.ɵfac = function MatDatepickerContent_Factory(t) { return new (t || MatDatepickerContent)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef)); };\nMatDatepickerContent.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatDatepickerContent, selectors: [[\"mat-datepicker-content\"]], viewQuery: function MatDatepickerContent_Query(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵviewQuery(MatCalendar, true);\n    } if (rf & 2) {\n        var _t;\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._calendar = _t.first);\n    } }, hostAttrs: [1, \"mat-datepicker-content\"], hostVars: 3, hostBindings: function MatDatepickerContent_HostBindings(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵcomponentHostSyntheticListener(\"@transformPanel.done\", function MatDatepickerContent_animation_transformPanel_done_HostBindingHandler() { return ctx._animationDone.next(); });\n    } if (rf & 2) {\n        ɵngcc0.ɵɵupdateSyntheticHostBinding(\"@transformPanel\", ctx._animationState);\n        ɵngcc0.ɵɵclassProp(\"mat-datepicker-content-touch\", ctx.datepicker.touchUi);\n    } }, inputs: { color: \"color\" }, exportAs: [\"matDatepickerContent\"], features: [ɵngcc0.ɵɵInheritDefinitionFeature], decls: 1, vars: 11, consts: [[\"cdkTrapFocus\", \"\", 3, \"id\", \"ngClass\", \"startAt\", \"startView\", \"minDate\", \"maxDate\", \"dateFilter\", \"headerComponent\", \"selected\", \"dateClass\", \"selectedChange\", \"yearSelected\", \"monthSelected\", \"_userSelection\"]], template: function MatDatepickerContent_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵelementStart(0, \"mat-calendar\", 0);\n        ɵngcc0.ɵɵlistener(\"selectedChange\", function MatDatepickerContent_Template_mat_calendar_selectedChange_0_listener($event) { return ctx.datepicker.select($event); })(\"yearSelected\", function MatDatepickerContent_Template_mat_calendar_yearSelected_0_listener($event) { return ctx.datepicker._selectYear($event); })(\"monthSelected\", function MatDatepickerContent_Template_mat_calendar_monthSelected_0_listener($event) { return ctx.datepicker._selectMonth($event); })(\"_userSelection\", function MatDatepickerContent_Template_mat_calendar__userSelection_0_listener() { return ctx.datepicker.close(); });\n        ɵngcc0.ɵɵelementEnd();\n    } if (rf & 2) {\n        ɵngcc0.ɵɵproperty(\"id\", ctx.datepicker.id)(\"ngClass\", ctx.datepicker.panelClass)(\"startAt\", ctx.datepicker.startAt)(\"startView\", ctx.datepicker.startView)(\"minDate\", ctx.datepicker._minDate)(\"maxDate\", ctx.datepicker._maxDate)(\"dateFilter\", ctx.datepicker._dateFilter)(\"headerComponent\", ctx.datepicker.calendarHeaderComponent)(\"selected\", ctx.datepicker._selected)(\"dateClass\", ctx.datepicker.dateClass)(\"@fadeInCalendar\", \"enter\");\n    } }, directives: [MatCalendar, ɵngcc5.CdkTrapFocus, ɵngcc1.NgClass], styles: [\".mat-datepicker-content{display:block;border-radius:4px}.mat-datepicker-content .mat-calendar{width:296px;height:354px}.mat-datepicker-content-touch{display:block;max-height:80vh;overflow:auto;margin:-24px}.mat-datepicker-content-touch .mat-calendar{min-width:250px;min-height:312px;max-width:750px;max-height:788px}@media all and (orientation: landscape){.mat-datepicker-content-touch .mat-calendar{width:64vh;height:80vh}}@media all and (orientation: portrait){.mat-datepicker-content-touch .mat-calendar{width:80vw;height:100vw}}\\n\"], encapsulation: 2, data: { animation: [\n            matDatepickerAnimations.transformPanel,\n            matDatepickerAnimations.fadeInCalendar,\n        ] }, changeDetection: 0 });\n/** @nocollapse */\nMatDatepickerContent.ctorParameters = () => [\n    { type: ElementRef },\n    { type: ChangeDetectorRef }\n];\nMatDatepickerContent.propDecorators = {\n    _calendar: [{ type: ViewChild, args: [MatCalendar,] }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatDatepickerContent, [{\n        type: Component,\n        args: [{\n                selector: 'mat-datepicker-content',\n                template: \"<mat-calendar cdkTrapFocus\\n    [id]=\\\"datepicker.id\\\"\\n    [ngClass]=\\\"datepicker.panelClass\\\"\\n    [startAt]=\\\"datepicker.startAt\\\"\\n    [startView]=\\\"datepicker.startView\\\"\\n    [minDate]=\\\"datepicker._minDate\\\"\\n    [maxDate]=\\\"datepicker._maxDate\\\"\\n    [dateFilter]=\\\"datepicker._dateFilter\\\"\\n    [headerComponent]=\\\"datepicker.calendarHeaderComponent\\\"\\n    [selected]=\\\"datepicker._selected\\\"\\n    [dateClass]=\\\"datepicker.dateClass\\\"\\n    [@fadeInCalendar]=\\\"'enter'\\\"\\n    (selectedChange)=\\\"datepicker.select($event)\\\"\\n    (yearSelected)=\\\"datepicker._selectYear($event)\\\"\\n    (monthSelected)=\\\"datepicker._selectMonth($event)\\\"\\n    (_userSelection)=\\\"datepicker.close()\\\">\\n</mat-calendar>\\n\",\n                host: {\n                    'class': 'mat-datepicker-content',\n                    '[@transformPanel]': '_animationState',\n                    '(@transformPanel.done)': '_animationDone.next()',\n                    '[class.mat-datepicker-content-touch]': 'datepicker.touchUi'\n                },\n                animations: [\n                    matDatepickerAnimations.transformPanel,\n                    matDatepickerAnimations.fadeInCalendar,\n                ],\n                exportAs: 'matDatepickerContent',\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush,\n                inputs: ['color'],\n                styles: [\".mat-datepicker-content{display:block;border-radius:4px}.mat-datepicker-content .mat-calendar{width:296px;height:354px}.mat-datepicker-content-touch{display:block;max-height:80vh;overflow:auto;margin:-24px}.mat-datepicker-content-touch .mat-calendar{min-width:250px;min-height:312px;max-width:750px;max-height:788px}@media all and (orientation: landscape){.mat-datepicker-content-touch .mat-calendar{width:64vh;height:80vh}}@media all and (orientation: portrait){.mat-datepicker-content-touch .mat-calendar{width:80vw;height:100vw}}\\n\"]\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: ɵngcc0.ChangeDetectorRef }]; }, { _calendar: [{\n            type: ViewChild,\n            args: [MatCalendar]\n        }] }); })();\nif (false) {\n    /**\n     * Reference to the internal calendar component.\n     * @type {?}\n     */\n    MatDatepickerContent.prototype._calendar;\n    /**\n     * Reference to the datepicker that created the overlay.\n     * @type {?}\n     */\n    MatDatepickerContent.prototype.datepicker;\n    /**\n     * Whether the datepicker is above or below the input.\n     * @type {?}\n     */\n    MatDatepickerContent.prototype._isAbove;\n    /**\n     * Current state of the animation.\n     * @type {?}\n     */\n    MatDatepickerContent.prototype._animationState;\n    /**\n     * Emits when an animation has finished.\n     * @type {?}\n     */\n    MatDatepickerContent.prototype._animationDone;\n    /**\n     * @deprecated `_changeDetectorRef` parameter to become required.\n     * \\@breaking-change 11.0.0\n     * @type {?}\n     * @private\n     */\n    MatDatepickerContent.prototype._changeDetectorRef;\n}\n// TODO(mmalerba): We use a component instead of a directive here so the user can use implicit\n// template reference variables (e.g. #d vs #d=\"matDatepicker\"). We can change this to a directive\n// if angular adds support for `exportAs: '$implicit'` on directives.\n/**\n * Component responsible for managing the datepicker popup/dialog.\n * @template D\n */\nclass MatDatepicker {\n    /**\n     * @param {?} _dialog\n     * @param {?} _overlay\n     * @param {?} _ngZone\n     * @param {?} _viewContainerRef\n     * @param {?} scrollStrategy\n     * @param {?} _dateAdapter\n     * @param {?} _dir\n     * @param {?} _document\n     */\n    constructor(_dialog, _overlay, _ngZone, _viewContainerRef, scrollStrategy, _dateAdapter, _dir, _document) {\n        this._dialog = _dialog;\n        this._overlay = _overlay;\n        this._ngZone = _ngZone;\n        this._viewContainerRef = _viewContainerRef;\n        this._dateAdapter = _dateAdapter;\n        this._dir = _dir;\n        this._document = _document;\n        /**\n         * The view that the calendar should start in.\n         */\n        this.startView = 'month';\n        this._touchUi = false;\n        /**\n         * Emits selected year in multiyear view.\n         * This doesn't imply a change on the selected date.\n         */\n        this.yearSelected = new EventEmitter();\n        /**\n         * Emits selected month in year view.\n         * This doesn't imply a change on the selected date.\n         */\n        this.monthSelected = new EventEmitter();\n        /**\n         * Emits when the datepicker has been opened.\n         */\n        this.openedStream = new EventEmitter();\n        /**\n         * Emits when the datepicker has been closed.\n         */\n        this.closedStream = new EventEmitter();\n        this._opened = false;\n        /**\n         * The id for the datepicker calendar.\n         */\n        this.id = `mat-datepicker-${datepickerUid++}`;\n        this._validSelected = null;\n        /**\n         * The element that was focused before the datepicker was opened.\n         */\n        this._focusedElementBeforeOpen = null;\n        /**\n         * Subscription to value changes in the associated input element.\n         */\n        this._inputSubscription = Subscription.EMPTY;\n        /**\n         * Emits when the datepicker is disabled.\n         */\n        this._disabledChange = new Subject();\n        /**\n         * Emits new selected date when selected date changes.\n         */\n        this._selectedChanged = new Subject();\n        if (!this._dateAdapter) {\n            throw createMissingDateImplError('DateAdapter');\n        }\n        this._scrollStrategy = scrollStrategy;\n    }\n    /**\n     * The date to open the calendar to initially.\n     * @return {?}\n     */\n    get startAt() {\n        // If an explicit startAt is set we start there, otherwise we start at whatever the currently\n        // selected value is.\n        return this._startAt || (this._datepickerInput ? this._datepickerInput.value : null);\n    }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set startAt(value) {\n        this._startAt = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /**\n     * Color palette to use on the datepicker's calendar.\n     * @return {?}\n     */\n    get color() {\n        return this._color ||\n            (this._datepickerInput ? this._datepickerInput._getThemePalette() : undefined);\n    }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set color(value) {\n        this._color = value;\n    }\n    /**\n     * Whether the calendar UI is in touch mode. In touch mode the calendar opens in a dialog rather\n     * than a popup and elements have more padding to allow for bigger touch targets.\n     * @return {?}\n     */\n    get touchUi() { return this._touchUi; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set touchUi(value) {\n        this._touchUi = coerceBooleanProperty(value);\n    }\n    /**\n     * Whether the datepicker pop-up should be disabled.\n     * @return {?}\n     */\n    get disabled() {\n        return this._disabled === undefined && this._datepickerInput ?\n            this._datepickerInput.disabled : !!this._disabled;\n    }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set disabled(value) {\n        /** @type {?} */\n        const newValue = coerceBooleanProperty(value);\n        if (newValue !== this._disabled) {\n            this._disabled = newValue;\n            this._disabledChange.next(newValue);\n        }\n    }\n    /**\n     * Whether the calendar is open.\n     * @return {?}\n     */\n    get opened() { return this._opened; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set opened(value) { value ? this.open() : this.close(); }\n    /**\n     * The currently selected date.\n     * @return {?}\n     */\n    get _selected() { return this._validSelected; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set _selected(value) { this._validSelected = value; }\n    /**\n     * The minimum selectable date.\n     * @return {?}\n     */\n    get _minDate() {\n        return this._datepickerInput && this._datepickerInput.min;\n    }\n    /**\n     * The maximum selectable date.\n     * @return {?}\n     */\n    get _maxDate() {\n        return this._datepickerInput && this._datepickerInput.max;\n    }\n    /**\n     * @return {?}\n     */\n    get _dateFilter() {\n        return this._datepickerInput && this._datepickerInput._dateFilter;\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._destroyPopup();\n        this.close();\n        this._inputSubscription.unsubscribe();\n        this._disabledChange.complete();\n    }\n    /**\n     * Selects the given date\n     * @param {?} date\n     * @return {?}\n     */\n    select(date) {\n        /** @type {?} */\n        let oldValue = this._selected;\n        this._selected = date;\n        if (!this._dateAdapter.sameDate(oldValue, this._selected)) {\n            this._selectedChanged.next(date);\n        }\n    }\n    /**\n     * Emits the selected year in multiyear view\n     * @param {?} normalizedYear\n     * @return {?}\n     */\n    _selectYear(normalizedYear) {\n        this.yearSelected.emit(normalizedYear);\n    }\n    /**\n     * Emits selected month in year view\n     * @param {?} normalizedMonth\n     * @return {?}\n     */\n    _selectMonth(normalizedMonth) {\n        this.monthSelected.emit(normalizedMonth);\n    }\n    /**\n     * Register an input with this datepicker.\n     * @param {?} input The datepicker input to register with this datepicker.\n     * @return {?}\n     */\n    _registerInput(input) {\n        if (this._datepickerInput) {\n            throw Error('A MatDatepicker can only be associated with a single input.');\n        }\n        this._datepickerInput = input;\n        this._inputSubscription =\n            this._datepickerInput._valueChange.subscribe((/**\n             * @param {?} value\n             * @return {?}\n             */\n            (value) => this._selected = value));\n    }\n    /**\n     * Open the calendar.\n     * @return {?}\n     */\n    open() {\n        if (this._opened || this.disabled) {\n            return;\n        }\n        if (!this._datepickerInput) {\n            throw Error('Attempted to open an MatDatepicker with no associated input.');\n        }\n        if (this._document) {\n            this._focusedElementBeforeOpen = this._document.activeElement;\n        }\n        this.touchUi ? this._openAsDialog() : this._openAsPopup();\n        this._opened = true;\n        this.openedStream.emit();\n    }\n    /**\n     * Close the calendar.\n     * @return {?}\n     */\n    close() {\n        if (!this._opened) {\n            return;\n        }\n        if (this._popupComponentRef && this._popupRef) {\n            /** @type {?} */\n            const instance = this._popupComponentRef.instance;\n            instance._startExitAnimation();\n            instance._animationDone.pipe(take(1)).subscribe((/**\n             * @return {?}\n             */\n            () => this._destroyPopup()));\n        }\n        if (this._dialogRef) {\n            this._dialogRef.close();\n            this._dialogRef = null;\n        }\n        /** @type {?} */\n        const completeClose = (/**\n         * @return {?}\n         */\n        () => {\n            // The `_opened` could've been reset already if\n            // we got two events in quick succession.\n            if (this._opened) {\n                this._opened = false;\n                this.closedStream.emit();\n                this._focusedElementBeforeOpen = null;\n            }\n        });\n        if (this._focusedElementBeforeOpen &&\n            typeof this._focusedElementBeforeOpen.focus === 'function') {\n            // Because IE moves focus asynchronously, we can't count on it being restored before we've\n            // marked the datepicker as closed. If the event fires out of sequence and the element that\n            // we're refocusing opens the datepicker on focus, the user could be stuck with not being\n            // able to close the calendar at all. We work around it by making the logic, that marks\n            // the datepicker as closed, async as well.\n            this._focusedElementBeforeOpen.focus();\n            setTimeout(completeClose);\n        }\n        else {\n            completeClose();\n        }\n    }\n    /**\n     * Open the calendar as a dialog.\n     * @private\n     * @return {?}\n     */\n    _openAsDialog() {\n        // Usually this would be handled by `open` which ensures that we can only have one overlay\n        // open at a time, however since we reset the variables in async handlers some overlays\n        // may slip through if the user opens and closes multiple times in quick succession (e.g.\n        // by holding down the enter key).\n        if (this._dialogRef) {\n            this._dialogRef.close();\n        }\n        this._dialogRef = this._dialog.open(MatDatepickerContent, {\n            direction: this._dir ? this._dir.value : 'ltr',\n            viewContainerRef: this._viewContainerRef,\n            panelClass: 'mat-datepicker-dialog',\n            // These values are all the same as the defaults, but we set them explicitly so that the\n            // datepicker dialog behaves consistently even if the user changed the defaults.\n            hasBackdrop: true,\n            disableClose: false,\n            width: '',\n            height: '',\n            minWidth: '',\n            minHeight: '',\n            maxWidth: '80vw',\n            maxHeight: '',\n            position: {},\n            autoFocus: true,\n            // `MatDialog` has focus restoration built in, however we want to disable it since the\n            // datepicker also has focus restoration for dropdown mode. We want to do this, in order\n            // to ensure that the timing is consistent between dropdown and dialog modes since `MatDialog`\n            // restores focus when the animation is finished, but the datepicker does it immediately.\n            // Furthermore, this avoids any conflicts where the datepicker consumer might move focus\n            // inside the `closed` event which is dispatched immediately.\n            restoreFocus: false\n        });\n        this._dialogRef.afterClosed().subscribe((/**\n         * @return {?}\n         */\n        () => this.close()));\n        this._dialogRef.componentInstance.datepicker = this;\n        this._dialogRef.componentInstance.color = this.color;\n    }\n    /**\n     * Open the calendar as a popup.\n     * @private\n     * @return {?}\n     */\n    _openAsPopup() {\n        /** @type {?} */\n        const portal = new ComponentPortal(MatDatepickerContent, this._viewContainerRef);\n        this._destroyPopup();\n        this._createPopup();\n        /** @type {?} */\n        const ref = this._popupComponentRef = (/** @type {?} */ (this._popupRef)).attach(portal);\n        ref.instance.datepicker = this;\n        ref.instance.color = this.color;\n        // Update the position once the calendar has rendered.\n        this._ngZone.onStable.asObservable().pipe(take(1)).subscribe((/**\n         * @return {?}\n         */\n        () => {\n            (/** @type {?} */ (this._popupRef)).updatePosition();\n        }));\n    }\n    /**\n     * Create the popup.\n     * @private\n     * @return {?}\n     */\n    _createPopup() {\n        /** @type {?} */\n        const overlayConfig = new OverlayConfig({\n            positionStrategy: this._createPopupPositionStrategy(),\n            hasBackdrop: true,\n            backdropClass: 'mat-overlay-transparent-backdrop',\n            direction: this._dir,\n            scrollStrategy: this._scrollStrategy(),\n            panelClass: 'mat-datepicker-popup',\n        });\n        this._popupRef = this._overlay.create(overlayConfig);\n        this._popupRef.overlayElement.setAttribute('role', 'dialog');\n        merge(this._popupRef.backdropClick(), this._popupRef.detachments(), this._popupRef.keydownEvents().pipe(filter((/**\n         * @param {?} event\n         * @return {?}\n         */\n        event => {\n            // Closing on alt + up is only valid when there's an input associated with the datepicker.\n            return event.keyCode === ESCAPE ||\n                (this._datepickerInput && event.altKey && event.keyCode === UP_ARROW);\n        })))).subscribe((/**\n         * @param {?} event\n         * @return {?}\n         */\n        event => {\n            if (event) {\n                event.preventDefault();\n            }\n            this.close();\n        }));\n    }\n    /**\n     * Destroys the current popup overlay.\n     * @private\n     * @return {?}\n     */\n    _destroyPopup() {\n        if (this._popupRef) {\n            this._popupRef.dispose();\n            this._popupRef = this._popupComponentRef = null;\n        }\n    }\n    /**\n     * Create the popup PositionStrategy.\n     * @private\n     * @return {?}\n     */\n    _createPopupPositionStrategy() {\n        return this._overlay.position()\n            .flexibleConnectedTo(this._datepickerInput.getConnectedOverlayOrigin())\n            .withTransformOriginOn('.mat-datepicker-content')\n            .withFlexibleDimensions(false)\n            .withViewportMargin(8)\n            .withLockedPosition()\n            .withPositions([\n            {\n                originX: 'start',\n                originY: 'bottom',\n                overlayX: 'start',\n                overlayY: 'top'\n            },\n            {\n                originX: 'start',\n                originY: 'top',\n                overlayX: 'start',\n                overlayY: 'bottom'\n            },\n            {\n                originX: 'end',\n                originY: 'bottom',\n                overlayX: 'end',\n                overlayY: 'top'\n            },\n            {\n                originX: 'end',\n                originY: 'top',\n                overlayX: 'end',\n                overlayY: 'bottom'\n            }\n        ]);\n    }\n    /**\n     * @private\n     * @param {?} obj The object to check.\n     * @return {?} The given object if it is both a date instance and valid, otherwise null.\n     */\n    _getValidDateOrNull(obj) {\n        return (this._dateAdapter.isDateInstance(obj) && this._dateAdapter.isValid(obj)) ? obj : null;\n    }\n}\nMatDatepicker.ɵfac = function MatDatepicker_Factory(t) { return new (t || MatDatepicker)(ɵngcc0.ɵɵdirectiveInject(ɵngcc7.MatDialog), ɵngcc0.ɵɵdirectiveInject(ɵngcc8.Overlay), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(MAT_DATEPICKER_SCROLL_STRATEGY), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.DateAdapter, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc3.Directionality, 8), ɵngcc0.ɵɵdirectiveInject(DOCUMENT, 8)); };\nMatDatepicker.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatDatepicker, selectors: [[\"mat-datepicker\"]], inputs: { startView: \"startView\", startAt: \"startAt\", color: \"color\", touchUi: \"touchUi\", disabled: \"disabled\", opened: \"opened\", calendarHeaderComponent: \"calendarHeaderComponent\", panelClass: \"panelClass\", dateClass: \"dateClass\" }, outputs: { yearSelected: \"yearSelected\", monthSelected: \"monthSelected\", openedStream: \"opened\", closedStream: \"closed\" }, exportAs: [\"matDatepicker\"], decls: 0, vars: 0, template: function MatDatepicker_Template(rf, ctx) { }, encapsulation: 2, changeDetection: 0 });\n/** @nocollapse */\nMatDatepicker.ctorParameters = () => [\n    { type: MatDialog },\n    { type: Overlay },\n    { type: NgZone },\n    { type: ViewContainerRef },\n    { type: undefined, decorators: [{ type: Inject, args: [MAT_DATEPICKER_SCROLL_STRATEGY,] }] },\n    { type: DateAdapter, decorators: [{ type: Optional }] },\n    { type: Directionality, decorators: [{ type: Optional }] },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] }\n];\nMatDatepicker.propDecorators = {\n    calendarHeaderComponent: [{ type: Input }],\n    startAt: [{ type: Input }],\n    startView: [{ type: Input }],\n    color: [{ type: Input }],\n    touchUi: [{ type: Input }],\n    disabled: [{ type: Input }],\n    yearSelected: [{ type: Output }],\n    monthSelected: [{ type: Output }],\n    panelClass: [{ type: Input }],\n    dateClass: [{ type: Input }],\n    openedStream: [{ type: Output, args: ['opened',] }],\n    closedStream: [{ type: Output, args: ['closed',] }],\n    opened: [{ type: Input }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatDatepicker, [{\n        type: Component,\n        args: [{\n                selector: 'mat-datepicker',\n                template: '',\n                exportAs: 'matDatepicker',\n                changeDetection: ChangeDetectionStrategy.OnPush,\n                encapsulation: ViewEncapsulation.None\n            }]\n    }], function () { return [{ type: ɵngcc7.MatDialog }, { type: ɵngcc8.Overlay }, { type: ɵngcc0.NgZone }, { type: ɵngcc0.ViewContainerRef }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [MAT_DATEPICKER_SCROLL_STRATEGY]\n            }] }, { type: ɵngcc2.DateAdapter, decorators: [{\n                type: Optional\n            }] }, { type: ɵngcc3.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        }], disabled: [{\n            type: Input\n        }], opened: [{\n            type: Input\n        }], calendarHeaderComponent: [{\n            type: Input\n        }], panelClass: [{\n            type: Input\n        }], dateClass: [{\n            type: Input\n        }] }); })();\nif (false) {\n    /** @type {?} */\n    MatDatepicker.ngAcceptInputType_disabled;\n    /** @type {?} */\n    MatDatepicker.ngAcceptInputType_touchUi;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._scrollStrategy;\n    /**\n     * An input indicating the type of the custom header component for the calendar, if set.\n     * @type {?}\n     */\n    MatDatepicker.prototype.calendarHeaderComponent;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._startAt;\n    /**\n     * The view that the calendar should start in.\n     * @type {?}\n     */\n    MatDatepicker.prototype.startView;\n    /** @type {?} */\n    MatDatepicker.prototype._color;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._touchUi;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._disabled;\n    /**\n     * Emits selected year in multiyear view.\n     * This doesn't imply a change on the selected date.\n     * @type {?}\n     */\n    MatDatepicker.prototype.yearSelected;\n    /**\n     * Emits selected month in year view.\n     * This doesn't imply a change on the selected date.\n     * @type {?}\n     */\n    MatDatepicker.prototype.monthSelected;\n    /**\n     * Classes to be passed to the date picker panel. Supports the same syntax as `ngClass`.\n     * @type {?}\n     */\n    MatDatepicker.prototype.panelClass;\n    /**\n     * Function that can be used to add custom CSS classes to dates.\n     * @type {?}\n     */\n    MatDatepicker.prototype.dateClass;\n    /**\n     * Emits when the datepicker has been opened.\n     * @type {?}\n     */\n    MatDatepicker.prototype.openedStream;\n    /**\n     * Emits when the datepicker has been closed.\n     * @type {?}\n     */\n    MatDatepicker.prototype.closedStream;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._opened;\n    /**\n     * The id for the datepicker calendar.\n     * @type {?}\n     */\n    MatDatepicker.prototype.id;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._validSelected;\n    /**\n     * A reference to the overlay when the calendar is opened as a popup.\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._popupRef;\n    /**\n     * A reference to the dialog when the calendar is opened as a dialog.\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._dialogRef;\n    /**\n     * Reference to the component instantiated in popup mode.\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._popupComponentRef;\n    /**\n     * The element that was focused before the datepicker was opened.\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._focusedElementBeforeOpen;\n    /**\n     * Subscription to value changes in the associated input element.\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._inputSubscription;\n    /**\n     * The input element this datepicker is associated with.\n     * @type {?}\n     */\n    MatDatepicker.prototype._datepickerInput;\n    /**\n     * Emits when the datepicker is disabled.\n     * @type {?}\n     */\n    MatDatepicker.prototype._disabledChange;\n    /**\n     * Emits new selected date when selected date changes.\n     * @type {?}\n     */\n    MatDatepicker.prototype._selectedChanged;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._dialog;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._overlay;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._ngZone;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._viewContainerRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._dateAdapter;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._dir;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepicker.prototype._document;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/datepicker/datepicker-input.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * \\@docs-private\n * @type {?}\n */\nconst MAT_DATEPICKER_VALUE_ACCESSOR = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef((/**\n     * @return {?}\n     */\n    () => MatDatepickerInput)),\n    multi: true\n};\n/**\n * \\@docs-private\n * @type {?}\n */\nconst MAT_DATEPICKER_VALIDATORS = {\n    provide: NG_VALIDATORS,\n    useExisting: forwardRef((/**\n     * @return {?}\n     */\n    () => MatDatepickerInput)),\n    multi: true\n};\n/**\n * An event used for datepicker input and change events. We don't always have access to a native\n * input or change event because the event may have been triggered by the user clicking on the\n * calendar popup. For consistency, we always use MatDatepickerInputEvent instead.\n * @template D\n */\nclass MatDatepickerInputEvent {\n    /**\n     * @param {?} target\n     * @param {?} targetElement\n     */\n    constructor(target, targetElement) {\n        this.target = target;\n        this.targetElement = targetElement;\n        this.value = this.target.value;\n    }\n}\nif (false) {\n    /**\n     * The new value for the target datepicker input.\n     * @type {?}\n     */\n    MatDatepickerInputEvent.prototype.value;\n    /**\n     * Reference to the datepicker input component that emitted the event.\n     * @type {?}\n     */\n    MatDatepickerInputEvent.prototype.target;\n    /**\n     * Reference to the native input element associated with the datepicker input.\n     * @type {?}\n     */\n    MatDatepickerInputEvent.prototype.targetElement;\n}\n/**\n * Directive used to connect an input to a MatDatepicker.\n * @template D\n */\nclass MatDatepickerInput {\n    /**\n     * @param {?} _elementRef\n     * @param {?} _dateAdapter\n     * @param {?} _dateFormats\n     * @param {?} _formField\n     */\n    constructor(_elementRef, _dateAdapter, _dateFormats, _formField) {\n        this._elementRef = _elementRef;\n        this._dateAdapter = _dateAdapter;\n        this._dateFormats = _dateFormats;\n        this._formField = _formField;\n        /**\n         * Emits when a `change` event is fired on this `<input>`.\n         */\n        this.dateChange = new EventEmitter();\n        /**\n         * Emits when an `input` event is fired on this `<input>`.\n         */\n        this.dateInput = new EventEmitter();\n        /**\n         * Emits when the value changes (either due to user input or programmatic change).\n         */\n        this._valueChange = new EventEmitter();\n        /**\n         * Emits when the disabled state has changed\n         */\n        this._disabledChange = new EventEmitter();\n        this._onTouched = (/**\n         * @return {?}\n         */\n        () => { });\n        this._cvaOnChange = (/**\n         * @return {?}\n         */\n        () => { });\n        this._validatorOnChange = (/**\n         * @return {?}\n         */\n        () => { });\n        this._datepickerSubscription = Subscription.EMPTY;\n        this._localeSubscription = Subscription.EMPTY;\n        /**\n         * The form control validator for whether the input parses.\n         */\n        this._parseValidator = (/**\n         * @return {?}\n         */\n        () => {\n            return this._lastValueValid ?\n                null : { 'matDatepickerParse': { 'text': this._elementRef.nativeElement.value } };\n        });\n        /**\n         * The form control validator for the min date.\n         */\n        this._minValidator = (/**\n         * @param {?} control\n         * @return {?}\n         */\n        (control) => {\n            /** @type {?} */\n            const controlValue = this._getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n            return (!this.min || !controlValue ||\n                this._dateAdapter.compareDate(this.min, controlValue) <= 0) ?\n                null : { 'matDatepickerMin': { 'min': this.min, 'actual': controlValue } };\n        });\n        /**\n         * The form control validator for the max date.\n         */\n        this._maxValidator = (/**\n         * @param {?} control\n         * @return {?}\n         */\n        (control) => {\n            /** @type {?} */\n            const controlValue = this._getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n            return (!this.max || !controlValue ||\n                this._dateAdapter.compareDate(this.max, controlValue) >= 0) ?\n                null : { 'matDatepickerMax': { 'max': this.max, 'actual': controlValue } };\n        });\n        /**\n         * The form control validator for the date filter.\n         */\n        this._filterValidator = (/**\n         * @param {?} control\n         * @return {?}\n         */\n        (control) => {\n            /** @type {?} */\n            const controlValue = this._getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n            return !this._dateFilter || !controlValue || this._dateFilter(controlValue) ?\n                null : { 'matDatepickerFilter': true };\n        });\n        /**\n         * The combined form control validator for this input.\n         */\n        this._validator = Validators.compose([this._parseValidator, this._minValidator, this._maxValidator, this._filterValidator]);\n        /**\n         * Whether the last value set on the input was valid.\n         */\n        this._lastValueValid = false;\n        if (!this._dateAdapter) {\n            throw createMissingDateImplError('DateAdapter');\n        }\n        if (!this._dateFormats) {\n            throw createMissingDateImplError('MAT_DATE_FORMATS');\n        }\n        // Update the displayed date when the locale changes.\n        this._localeSubscription = _dateAdapter.localeChanges.subscribe((/**\n         * @return {?}\n         */\n        () => {\n            this.value = this.value;\n        }));\n    }\n    /**\n     * The datepicker that this input is associated with.\n     * @param {?} value\n     * @return {?}\n     */\n    set matDatepicker(value) {\n        if (!value) {\n            return;\n        }\n        this._datepicker = value;\n        this._datepicker._registerInput(this);\n        this._datepickerSubscription.unsubscribe();\n        this._datepickerSubscription = this._datepicker._selectedChanged.subscribe((/**\n         * @param {?} selected\n         * @return {?}\n         */\n        (selected) => {\n            this.value = selected;\n            this._cvaOnChange(selected);\n            this._onTouched();\n            this.dateInput.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));\n            this.dateChange.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));\n        }));\n    }\n    /**\n     * Function that can be used to filter out dates within the datepicker.\n     * @param {?} value\n     * @return {?}\n     */\n    set matDatepickerFilter(value) {\n        this._dateFilter = value;\n        this._validatorOnChange();\n    }\n    /**\n     * The value of the input.\n     * @return {?}\n     */\n    get value() { return this._value; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set value(value) {\n        value = this._dateAdapter.deserialize(value);\n        this._lastValueValid = !value || this._dateAdapter.isValid(value);\n        value = this._getValidDateOrNull(value);\n        /** @type {?} */\n        const oldDate = this.value;\n        this._value = value;\n        this._formatValue(value);\n        if (!this._dateAdapter.sameDate(oldDate, value)) {\n            this._valueChange.emit(value);\n        }\n    }\n    /**\n     * The minimum valid date.\n     * @return {?}\n     */\n    get min() { return this._min; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set min(value) {\n        this._min = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n        this._validatorOnChange();\n    }\n    /**\n     * The maximum valid date.\n     * @return {?}\n     */\n    get max() { return this._max; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set max(value) {\n        this._max = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n        this._validatorOnChange();\n    }\n    /**\n     * Whether the datepicker-input is disabled.\n     * @return {?}\n     */\n    get disabled() { return !!this._disabled; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set disabled(value) {\n        /** @type {?} */\n        const newValue = coerceBooleanProperty(value);\n        /** @type {?} */\n        const element = this._elementRef.nativeElement;\n        if (this._disabled !== newValue) {\n            this._disabled = newValue;\n            this._disabledChange.emit(newValue);\n        }\n        // We need to null check the `blur` method, because it's undefined during SSR.\n        // In Ivy static bindings are invoked earlier, before the element is attached to the DOM.\n        // This can cause an error to be thrown in some browsers (IE/Edge) which assert that the\n        // element has been inserted.\n        if (newValue && this._isInitialized && element.blur) {\n            // Normally, native input elements automatically blur if they turn disabled. This behavior\n            // is problematic, because it would mean that it triggers another change detection cycle,\n            // which then causes a changed after checked error if the input element was focused before.\n            element.blur();\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterViewInit() {\n        this._isInitialized = true;\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._datepickerSubscription.unsubscribe();\n        this._localeSubscription.unsubscribe();\n        this._valueChange.complete();\n        this._disabledChange.complete();\n    }\n    /**\n     * \\@docs-private\n     * @param {?} fn\n     * @return {?}\n     */\n    registerOnValidatorChange(fn) {\n        this._validatorOnChange = fn;\n    }\n    /**\n     * \\@docs-private\n     * @param {?} c\n     * @return {?}\n     */\n    validate(c) {\n        return this._validator ? this._validator(c) : null;\n    }\n    /**\n     * @deprecated\n     * \\@breaking-change 8.0.0 Use `getConnectedOverlayOrigin` instead\n     * @return {?}\n     */\n    getPopupConnectionElementRef() {\n        return this.getConnectedOverlayOrigin();\n    }\n    /**\n     * Gets the element that the datepicker popup should be connected to.\n     * @return {?} The element to connect the popup to.\n     */\n    getConnectedOverlayOrigin() {\n        return this._formField ? this._formField.getConnectedOverlayOrigin() : this._elementRef;\n    }\n    // Implemented as part of ControlValueAccessor.\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    writeValue(value) {\n        this.value = value;\n    }\n    // Implemented as part of ControlValueAccessor.\n    /**\n     * @param {?} fn\n     * @return {?}\n     */\n    registerOnChange(fn) {\n        this._cvaOnChange = fn;\n    }\n    // Implemented as part of ControlValueAccessor.\n    /**\n     * @param {?} fn\n     * @return {?}\n     */\n    registerOnTouched(fn) {\n        this._onTouched = fn;\n    }\n    // Implemented as part of ControlValueAccessor.\n    /**\n     * @param {?} isDisabled\n     * @return {?}\n     */\n    setDisabledState(isDisabled) {\n        this.disabled = isDisabled;\n    }\n    /**\n     * @param {?} event\n     * @return {?}\n     */\n    _onKeydown(event) {\n        /** @type {?} */\n        const isAltDownArrow = event.altKey && event.keyCode === DOWN_ARROW;\n        if (this._datepicker && isAltDownArrow && !this._elementRef.nativeElement.readOnly) {\n            this._datepicker.open();\n            event.preventDefault();\n        }\n    }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    _onInput(value) {\n        /** @type {?} */\n        const lastValueWasValid = this._lastValueValid;\n        /** @type {?} */\n        let date = this._dateAdapter.parse(value, this._dateFormats.parse.dateInput);\n        this._lastValueValid = !date || this._dateAdapter.isValid(date);\n        date = this._getValidDateOrNull(date);\n        if (!this._dateAdapter.sameDate(date, this._value)) {\n            this._value = date;\n            this._cvaOnChange(date);\n            this._valueChange.emit(date);\n            this.dateInput.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));\n        }\n        else if (lastValueWasValid !== this._lastValueValid) {\n            this._validatorOnChange();\n        }\n    }\n    /**\n     * @return {?}\n     */\n    _onChange() {\n        this.dateChange.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));\n    }\n    /**\n     * Returns the palette used by the input's form field, if any.\n     * @return {?}\n     */\n    _getThemePalette() {\n        return this._formField ? this._formField.color : undefined;\n    }\n    /**\n     * Handles blur events on the input.\n     * @return {?}\n     */\n    _onBlur() {\n        // Reformat the input only if we have a valid value.\n        if (this.value) {\n            this._formatValue(this.value);\n        }\n        this._onTouched();\n    }\n    /**\n     * Formats a value and sets it on the input element.\n     * @private\n     * @param {?} value\n     * @return {?}\n     */\n    _formatValue(value) {\n        this._elementRef.nativeElement.value =\n            value ? this._dateAdapter.format(value, this._dateFormats.display.dateInput) : '';\n    }\n    /**\n     * @private\n     * @param {?} obj The object to check.\n     * @return {?} The given object if it is both a date instance and valid, otherwise null.\n     */\n    _getValidDateOrNull(obj) {\n        return (this._dateAdapter.isDateInstance(obj) && this._dateAdapter.isValid(obj)) ? obj : null;\n    }\n}\nMatDatepickerInput.ɵfac = function MatDatepickerInput_Factory(t) { return new (t || MatDatepickerInput)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.DateAdapter, 8), ɵngcc0.ɵɵdirectiveInject(MAT_DATE_FORMATS, 8), ɵngcc0.ɵɵdirectiveInject(MAT_FORM_FIELD, 8)); };\nMatDatepickerInput.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatDatepickerInput, selectors: [[\"input\", \"matDatepicker\", \"\"]], hostVars: 5, hostBindings: function MatDatepickerInput_HostBindings(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵlistener(\"input\", function MatDatepickerInput_input_HostBindingHandler($event) { return ctx._onInput($event.target.value); })(\"change\", function MatDatepickerInput_change_HostBindingHandler() { return ctx._onChange(); })(\"blur\", function MatDatepickerInput_blur_HostBindingHandler() { return ctx._onBlur(); })(\"keydown\", function MatDatepickerInput_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\", matDatepicker: \"matDatepicker\", matDatepickerFilter: \"matDatepickerFilter\", min: \"min\", max: \"max\", disabled: \"disabled\" }, outputs: { dateChange: \"dateChange\", dateInput: \"dateInput\" }, exportAs: [\"matDatepickerInput\"], features: [ɵngcc0.ɵɵProvidersFeature([\n            MAT_DATEPICKER_VALUE_ACCESSOR,\n            MAT_DATEPICKER_VALIDATORS,\n            { provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: MatDatepickerInput },\n        ])] });\n/** @nocollapse */\nMatDatepickerInput.ctorParameters = () => [\n    { type: ElementRef },\n    { type: DateAdapter, decorators: [{ type: Optional }] },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] },\n    { type: MatFormField, decorators: [{ type: Optional }, { type: Inject, args: [MAT_FORM_FIELD,] }] }\n];\nMatDatepickerInput.propDecorators = {\n    matDatepicker: [{ type: Input }],\n    matDatepickerFilter: [{ type: Input }],\n    value: [{ type: Input }],\n    min: [{ type: Input }],\n    max: [{ type: Input }],\n    disabled: [{ type: Input }],\n    dateChange: [{ type: Output }],\n    dateInput: [{ type: Output }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatDatepickerInput, [{\n        type: Directive,\n        args: [{\n                selector: 'input[matDatepicker]',\n                providers: [\n                    MAT_DATEPICKER_VALUE_ACCESSOR,\n                    MAT_DATEPICKER_VALIDATORS,\n                    { provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: MatDatepickerInput },\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                    '(keydown)': '_onKeydown($event)'\n                },\n                exportAs: 'matDatepickerInput'\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: ɵngcc2.DateAdapter, decorators: [{\n                type: Optional\n            }] }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MAT_DATE_FORMATS]\n            }] }, { type: ɵngcc9.MatFormField, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MAT_FORM_FIELD]\n            }] }]; }, { dateChange: [{\n            type: Output\n        }], dateInput: [{\n            type: Output\n        }], value: [{\n            type: Input\n        }], matDatepicker: [{\n            type: Input\n        }], matDatepickerFilter: [{\n            type: Input\n        }], min: [{\n            type: Input\n        }], max: [{\n            type: Input\n        }], disabled: [{\n            type: Input\n        }] }); })();\nif (false) {\n    /** @type {?} */\n    MatDatepickerInput.ngAcceptInputType_value;\n    /** @type {?} */\n    MatDatepickerInput.ngAcceptInputType_disabled;\n    /**\n     * Whether the component has been initialized.\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._isInitialized;\n    /** @type {?} */\n    MatDatepickerInput.prototype._datepicker;\n    /** @type {?} */\n    MatDatepickerInput.prototype._dateFilter;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._value;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._min;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._max;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._disabled;\n    /**\n     * Emits when a `change` event is fired on this `<input>`.\n     * @type {?}\n     */\n    MatDatepickerInput.prototype.dateChange;\n    /**\n     * Emits when an `input` event is fired on this `<input>`.\n     * @type {?}\n     */\n    MatDatepickerInput.prototype.dateInput;\n    /**\n     * Emits when the value changes (either due to user input or programmatic change).\n     * @type {?}\n     */\n    MatDatepickerInput.prototype._valueChange;\n    /**\n     * Emits when the disabled state has changed\n     * @type {?}\n     */\n    MatDatepickerInput.prototype._disabledChange;\n    /** @type {?} */\n    MatDatepickerInput.prototype._onTouched;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._cvaOnChange;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._validatorOnChange;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._datepickerSubscription;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._localeSubscription;\n    /**\n     * The form control validator for whether the input parses.\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._parseValidator;\n    /**\n     * The form control validator for the min date.\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._minValidator;\n    /**\n     * The form control validator for the max date.\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._maxValidator;\n    /**\n     * The form control validator for the date filter.\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._filterValidator;\n    /**\n     * The combined form control validator for this input.\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._validator;\n    /**\n     * Whether the last value set on the input was valid.\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._lastValueValid;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._elementRef;\n    /** @type {?} */\n    MatDatepickerInput.prototype._dateAdapter;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._dateFormats;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepickerInput.prototype._formField;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/datepicker/datepicker-toggle.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Can be used to override the icon of a `matDatepickerToggle`.\n */\nclass MatDatepickerToggleIcon {\n}\nMatDatepickerToggleIcon.ɵfac = function MatDatepickerToggleIcon_Factory(t) { return new (t || MatDatepickerToggleIcon)(); };\nMatDatepickerToggleIcon.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatDatepickerToggleIcon, selectors: [[\"\", \"matDatepickerToggleIcon\", \"\"]] });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatDatepickerToggleIcon, [{\n        type: Directive,\n        args: [{\n                selector: '[matDatepickerToggleIcon]'\n            }]\n    }], null, null); })();\n/**\n * @template D\n */\nclass MatDatepickerToggle {\n    /**\n     * @param {?} _intl\n     * @param {?} _changeDetectorRef\n     * @param {?} defaultTabIndex\n     */\n    constructor(_intl, _changeDetectorRef, defaultTabIndex) {\n        this._intl = _intl;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._stateChanges = Subscription.EMPTY;\n        /** @type {?} */\n        const parsedTabIndex = Number(defaultTabIndex);\n        this.tabIndex = (parsedTabIndex || parsedTabIndex === 0) ? parsedTabIndex : null;\n    }\n    /**\n     * Whether the toggle button is disabled.\n     * @return {?}\n     */\n    get disabled() {\n        if (this._disabled === undefined && this.datepicker) {\n            return this.datepicker.disabled;\n        }\n        return !!this._disabled;\n    }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set disabled(value) {\n        this._disabled = coerceBooleanProperty(value);\n    }\n    /**\n     * @param {?} changes\n     * @return {?}\n     */\n    ngOnChanges(changes) {\n        if (changes['datepicker']) {\n            this._watchStateChanges();\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._stateChanges.unsubscribe();\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterContentInit() {\n        this._watchStateChanges();\n    }\n    /**\n     * @param {?} event\n     * @return {?}\n     */\n    _open(event) {\n        if (this.datepicker && !this.disabled) {\n            this.datepicker.open();\n            event.stopPropagation();\n        }\n    }\n    /**\n     * @private\n     * @return {?}\n     */\n    _watchStateChanges() {\n        /** @type {?} */\n        const datepickerDisabled = this.datepicker ? this.datepicker._disabledChange : of();\n        /** @type {?} */\n        const inputDisabled = this.datepicker && this.datepicker._datepickerInput ?\n            this.datepicker._datepickerInput._disabledChange : of();\n        /** @type {?} */\n        const datepickerToggled = this.datepicker ?\n            merge(this.datepicker.openedStream, this.datepicker.closedStream) :\n            of();\n        this._stateChanges.unsubscribe();\n        this._stateChanges = merge(this._intl.changes, datepickerDisabled, inputDisabled, datepickerToggled).subscribe((/**\n         * @return {?}\n         */\n        () => this._changeDetectorRef.markForCheck()));\n    }\n}\nMatDatepickerToggle.ɵfac = function MatDatepickerToggle_Factory(t) { return new (t || MatDatepickerToggle)(ɵngcc0.ɵɵdirectiveInject(MatDatepickerIntl), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵinjectAttribute('tabindex')); };\nMatDatepickerToggle.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatDatepickerToggle, selectors: [[\"mat-datepicker-toggle\"]], contentQueries: function MatDatepickerToggle_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {\n        ɵngcc0.ɵɵcontentQuery(dirIndex, MatDatepickerToggleIcon, true);\n    } if (rf & 2) {\n        var _t;\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._customIcon = _t.first);\n    } }, viewQuery: function MatDatepickerToggle_Query(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵviewQuery(_c2, true);\n    } if (rf & 2) {\n        var _t;\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._button = _t.first);\n    } }, hostAttrs: [1, \"mat-datepicker-toggle\"], hostVars: 7, hostBindings: function MatDatepickerToggle_HostBindings(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵlistener(\"focus\", function MatDatepickerToggle_focus_HostBindingHandler() { return ctx._button.focus(); });\n    } if (rf & 2) {\n        ɵngcc0.ɵɵattribute(\"tabindex\", ctx.disabled ? null : 0 - 1);\n        ɵngcc0.ɵɵclassProp(\"mat-datepicker-toggle-active\", ctx.datepicker && ctx.datepicker.opened)(\"mat-accent\", ctx.datepicker && ctx.datepicker.color === \"accent\")(\"mat-warn\", ctx.datepicker && ctx.datepicker.color === \"warn\");\n    } }, inputs: { tabIndex: \"tabIndex\", disabled: \"disabled\", datepicker: [\"for\", \"datepicker\"], disableRipple: \"disableRipple\" }, exportAs: [\"matDatepickerToggle\"], features: [ɵngcc0.ɵɵNgOnChangesFeature], ngContentSelectors: _c4, decls: 4, vars: 6, consts: [[\"mat-icon-button\", \"\", \"type\", \"button\", 3, \"disabled\", \"disableRipple\", \"click\"], [\"button\", \"\"], [\"class\", \"mat-datepicker-toggle-default-icon\", \"viewBox\", \"0 0 24 24\", \"width\", \"24px\", \"height\", \"24px\", \"fill\", \"currentColor\", \"focusable\", \"false\", 4, \"ngIf\"], [\"viewBox\", \"0 0 24 24\", \"width\", \"24px\", \"height\", \"24px\", \"fill\", \"currentColor\", \"focusable\", \"false\", 1, \"mat-datepicker-toggle-default-icon\"], [\"d\", \"M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V8h14v11zM7 10h5v5H7z\"]], template: function MatDatepickerToggle_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵprojectionDef(_c3);\n        ɵngcc0.ɵɵelementStart(0, \"button\", 0, 1);\n        ɵngcc0.ɵɵlistener(\"click\", function MatDatepickerToggle_Template_button_click_0_listener($event) { return ctx._open($event); });\n        ɵngcc0.ɵɵtemplate(2, MatDatepickerToggle__svg_svg_2_Template, 2, 0, \"svg\", 2);\n        ɵngcc0.ɵɵprojection(3);\n        ɵngcc0.ɵɵelementEnd();\n    } if (rf & 2) {\n        ɵngcc0.ɵɵproperty(\"disabled\", ctx.disabled)(\"disableRipple\", ctx.disableRipple);\n        ɵngcc0.ɵɵattribute(\"aria-haspopup\", ctx.datepicker ? \"dialog\" : null)(\"aria-label\", ctx._intl.openCalendarLabel)(\"tabindex\", ctx.disabled ? 0 - 1 : ctx.tabIndex);\n        ɵngcc0.ɵɵadvance(2);\n        ɵngcc0.ɵɵproperty(\"ngIf\", !ctx._customIcon);\n    } }, directives: [ɵngcc4.MatButton, ɵngcc1.NgIf], styles: [\".mat-form-field-appearance-legacy .mat-form-field-prefix .mat-datepicker-toggle-default-icon,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-datepicker-toggle-default-icon{width:1em}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-datepicker-toggle-default-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-datepicker-toggle-default-icon{display:block;width:1.5em;height:1.5em}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button .mat-datepicker-toggle-default-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button .mat-datepicker-toggle-default-icon{margin:auto}\\n\"], encapsulation: 2, changeDetection: 0 });\n/** @nocollapse */\nMatDatepickerToggle.ctorParameters = () => [\n    { type: MatDatepickerIntl },\n    { type: ChangeDetectorRef },\n    { type: String, decorators: [{ type: Attribute, args: ['tabindex',] }] }\n];\nMatDatepickerToggle.propDecorators = {\n    datepicker: [{ type: Input, args: ['for',] }],\n    tabIndex: [{ type: Input }],\n    disabled: [{ type: Input }],\n    disableRipple: [{ type: Input }],\n    _customIcon: [{ type: ContentChild, args: [MatDatepickerToggleIcon,] }],\n    _button: [{ type: ViewChild, args: ['button',] }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatDatepickerToggle, [{\n        type: Component,\n        args: [{\n                selector: 'mat-datepicker-toggle',\n                template: \"<button\\n  #button\\n  mat-icon-button\\n  type=\\\"button\\\"\\n  [attr.aria-haspopup]=\\\"datepicker ? 'dialog' : null\\\"\\n  [attr.aria-label]=\\\"_intl.openCalendarLabel\\\"\\n  [attr.tabindex]=\\\"disabled ? -1 : tabIndex\\\"\\n  [disabled]=\\\"disabled\\\"\\n  [disableRipple]=\\\"disableRipple\\\"\\n  (click)=\\\"_open($event)\\\">\\n\\n  <svg\\n    *ngIf=\\\"!_customIcon\\\"\\n    class=\\\"mat-datepicker-toggle-default-icon\\\"\\n    viewBox=\\\"0 0 24 24\\\"\\n    width=\\\"24px\\\"\\n    height=\\\"24px\\\"\\n    fill=\\\"currentColor\\\"\\n    focusable=\\\"false\\\">\\n    <path d=\\\"M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V8h14v11zM7 10h5v5H7z\\\"/>\\n  </svg>\\n\\n  <ng-content select=\\\"[matDatepickerToggleIcon]\\\"></ng-content>\\n</button>\\n\",\n                host: {\n                    'class': 'mat-datepicker-toggle',\n                    // Always set the tabindex to -1 so that it doesn't overlap with any custom tabindex the\n                    // consumer may have provided, while still being able to receive focus.\n                    '[attr.tabindex]': 'disabled ? null : -1',\n                    '[class.mat-datepicker-toggle-active]': 'datepicker && datepicker.opened',\n                    '[class.mat-accent]': 'datepicker && datepicker.color === \"accent\"',\n                    '[class.mat-warn]': 'datepicker && datepicker.color === \"warn\"',\n                    '(focus)': '_button.focus()'\n                },\n                exportAs: 'matDatepickerToggle',\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush,\n                styles: [\".mat-form-field-appearance-legacy .mat-form-field-prefix .mat-datepicker-toggle-default-icon,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-datepicker-toggle-default-icon{width:1em}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-datepicker-toggle-default-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-datepicker-toggle-default-icon{display:block;width:1.5em;height:1.5em}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button .mat-datepicker-toggle-default-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button .mat-datepicker-toggle-default-icon{margin:auto}\\n\"]\n            }]\n    }], function () { return [{ type: MatDatepickerIntl }, { type: ɵngcc0.ChangeDetectorRef }, { type: String, decorators: [{\n                type: Attribute,\n                args: ['tabindex']\n            }] }]; }, { tabIndex: [{\n            type: Input\n        }], disabled: [{\n            type: Input\n        }], datepicker: [{\n            type: Input,\n            args: ['for']\n        }], disableRipple: [{\n            type: Input\n        }], _customIcon: [{\n            type: ContentChild,\n            args: [MatDatepickerToggleIcon]\n        }], _button: [{\n            type: ViewChild,\n            args: ['button']\n        }] }); })();\nif (false) {\n    /** @type {?} */\n    MatDatepickerToggle.ngAcceptInputType_disabled;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepickerToggle.prototype._stateChanges;\n    /**\n     * Datepicker instance that the button will toggle.\n     * @type {?}\n     */\n    MatDatepickerToggle.prototype.datepicker;\n    /**\n     * Tabindex for the toggle.\n     * @type {?}\n     */\n    MatDatepickerToggle.prototype.tabIndex;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepickerToggle.prototype._disabled;\n    /**\n     * Whether ripples on the toggle should be disabled.\n     * @type {?}\n     */\n    MatDatepickerToggle.prototype.disableRipple;\n    /**\n     * Custom icon set by the consumer.\n     * @type {?}\n     */\n    MatDatepickerToggle.prototype._customIcon;\n    /**\n     * Underlying button element.\n     * @type {?}\n     */\n    MatDatepickerToggle.prototype._button;\n    /** @type {?} */\n    MatDatepickerToggle.prototype._intl;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatDatepickerToggle.prototype._changeDetectorRef;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/datepicker/datepicker-module.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass MatDatepickerModule {\n}\nMatDatepickerModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: MatDatepickerModule });\nMatDatepickerModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function MatDatepickerModule_Factory(t) { return new (t || MatDatepickerModule)(); }, providers: [\n        MatDatepickerIntl,\n        MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER,\n    ], imports: [[\n            CommonModule,\n            MatButtonModule,\n            MatDialogModule,\n            OverlayModule,\n            A11yModule,\n            PortalModule,\n        ],\n        CdkScrollableModule] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(MatDatepickerModule, { declarations: function () { return [MatCalendar,\n        MatCalendarBody,\n        MatDatepicker,\n        MatDatepickerContent,\n        MatDatepickerInput,\n        MatDatepickerToggle,\n        MatDatepickerToggleIcon,\n        MatMonthView,\n        MatYearView,\n        MatMultiYearView,\n        MatCalendarHeader]; }, imports: function () { return [CommonModule,\n        MatButtonModule,\n        MatDialogModule,\n        OverlayModule,\n        A11yModule,\n        PortalModule]; }, exports: function () { return [CdkScrollableModule,\n        MatCalendar,\n        MatCalendarBody,\n        MatDatepicker,\n        MatDatepickerContent,\n        MatDatepickerInput,\n        MatDatepickerToggle,\n        MatDatepickerToggleIcon,\n        MatMonthView,\n        MatYearView,\n        MatMultiYearView,\n        MatCalendarHeader]; } }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatDatepickerModule, [{\n        type: NgModule,\n        args: [{\n                imports: [\n                    CommonModule,\n                    MatButtonModule,\n                    MatDialogModule,\n                    OverlayModule,\n                    A11yModule,\n                    PortalModule,\n                ],\n                exports: [\n                    CdkScrollableModule,\n                    MatCalendar,\n                    MatCalendarBody,\n                    MatDatepicker,\n                    MatDatepickerContent,\n                    MatDatepickerInput,\n                    MatDatepickerToggle,\n                    MatDatepickerToggleIcon,\n                    MatMonthView,\n                    MatYearView,\n                    MatMultiYearView,\n                    MatCalendarHeader,\n                ],\n                declarations: [\n                    MatCalendar,\n                    MatCalendarBody,\n                    MatDatepicker,\n                    MatDatepickerContent,\n                    MatDatepickerInput,\n                    MatDatepickerToggle,\n                    MatDatepickerToggleIcon,\n                    MatMonthView,\n                    MatYearView,\n                    MatMultiYearView,\n                    MatCalendarHeader,\n                ],\n                providers: [\n                    MatDatepickerIntl,\n                    MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER,\n                ],\n                entryComponents: [\n                    MatDatepickerContent,\n                    MatCalendarHeader,\n                ]\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/datepicker/public-api.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 { MAT_DATEPICKER_SCROLL_STRATEGY, MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY, MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER, MAT_DATEPICKER_VALIDATORS, MAT_DATEPICKER_VALUE_ACCESSOR, MatCalendar, MatCalendarBody, MatCalendarCell, MatCalendarHeader, MatDatepicker, MatDatepickerContent, MatDatepickerInput, MatDatepickerInputEvent, MatDatepickerIntl, MatDatepickerModule, MatDatepickerToggle, MatDatepickerToggleIcon, MatMonthView, MatMultiYearView, MatYearView, matDatepickerAnimations, yearsPerPage, yearsPerRow };\n\n//# sourceMappingURL=datepicker.js.map","import { Version } from '@angular/core';\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/** Current version of the Angular Component Development Kit. */\nconst VERSION = new Version('9.2.2');\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nexport { VERSION };\n//# sourceMappingURL=cdk.js.map\n","import { Version, InjectionToken, isDevMode, NgModule, Optional, Inject, inject, LOCALE_ID, Injectable, ɵɵdefineInjectable, Directive, ElementRef, NgZone, Input, Component, ViewEncapsulation, ChangeDetectionStrategy, EventEmitter, ChangeDetectorRef, Output } from '@angular/core';\nimport { HighContrastModeDetector, isFakeMousedownFromScreenReader } from '@angular/cdk/a11y';\nimport { BidiModule } from '@angular/cdk/bidi';\nimport { VERSION as VERSION$2 } from '@angular/cdk';\nimport { DOCUMENT, CommonModule } from '@angular/common';\nimport { coerceBooleanProperty, coerceElement } from '@angular/cdk/coercion';\nimport { Subject, Observable } from 'rxjs';\nimport { Platform, PlatformModule, normalizePassiveListenerOptions } from '@angular/cdk/platform';\nimport { HammerGestureConfig } from '@angular/platform-browser';\nimport { startWith } from 'rxjs/operators';\nimport { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';\nimport { ENTER, SPACE, hasModifierKey } from '@angular/cdk/keycodes';\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/version.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Current version of Angular Material.\n * @type {?}\n */\nimport * as ɵngcc0 from '@angular/core';\nimport * as ɵngcc1 from '@angular/cdk/a11y';\nimport * as ɵngcc2 from '@angular/cdk/platform';\nimport * as ɵngcc3 from '@angular/common';\n\nconst _c0 = [\"*\", [[\"mat-option\"], [\"ng-container\"]]];\nconst _c1 = [\"*\", \"mat-option, ng-container\"];\nfunction MatOption_mat_pseudo_checkbox_0_Template(rf, ctx) { if (rf & 1) {\n    ɵngcc0.ɵɵelement(0, \"mat-pseudo-checkbox\", 3);\n} if (rf & 2) {\n    const ctx_r0 = ɵngcc0.ɵɵnextContext();\n    ɵngcc0.ɵɵproperty(\"state\", ctx_r0.selected ? \"checked\" : \"unchecked\")(\"disabled\", ctx_r0.disabled);\n} }\nconst _c2 = [\"*\"];\nconst VERSION = new Version('9.2.2');\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/animation/animation.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 * \\@docs-private\n */\nclass AnimationCurves {\n}\nAnimationCurves.STANDARD_CURVE = 'cubic-bezier(0.4,0.0,0.2,1)';\nAnimationCurves.DECELERATION_CURVE = 'cubic-bezier(0.0,0.0,0.2,1)';\nAnimationCurves.ACCELERATION_CURVE = 'cubic-bezier(0.4,0.0,1,1)';\nAnimationCurves.SHARP_CURVE = 'cubic-bezier(0.4,0.0,0.6,1)';\nif (false) {\n    /** @type {?} */\n    AnimationCurves.STANDARD_CURVE;\n    /** @type {?} */\n    AnimationCurves.DECELERATION_CURVE;\n    /** @type {?} */\n    AnimationCurves.ACCELERATION_CURVE;\n    /** @type {?} */\n    AnimationCurves.SHARP_CURVE;\n}\n/**\n * \\@docs-private\n */\nclass AnimationDurations {\n}\nAnimationDurations.COMPLEX = '375ms';\nAnimationDurations.ENTERING = '225ms';\nAnimationDurations.EXITING = '195ms';\nif (false) {\n    /** @type {?} */\n    AnimationDurations.COMPLEX;\n    /** @type {?} */\n    AnimationDurations.ENTERING;\n    /** @type {?} */\n    AnimationDurations.EXITING;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/common-behaviors/common-module.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n// Private version constant to circumvent test/build issues,\n// i.e. avoid core to depend on the @angular/material primary entry-point\n// Can be removed once the Material primary entry-point no longer\n// re-exports all secondary entry-points\n/** @type {?} */\nconst VERSION$1 = new Version('9.2.2');\n/**\n * \\@docs-private\n * @return {?}\n */\nfunction MATERIAL_SANITY_CHECKS_FACTORY() {\n    return true;\n}\n/**\n * Injection token that configures whether the Material sanity checks are enabled.\n * @type {?}\n */\nconst MATERIAL_SANITY_CHECKS = new InjectionToken('mat-sanity-checks', {\n    providedIn: 'root',\n    factory: MATERIAL_SANITY_CHECKS_FACTORY,\n});\n/**\n * Object that can be used to configure the sanity checks granularly.\n * @record\n */\nfunction GranularSanityChecks() { }\nif (false) {\n    /** @type {?} */\n    GranularSanityChecks.prototype.doctype;\n    /** @type {?} */\n    GranularSanityChecks.prototype.theme;\n    /** @type {?} */\n    GranularSanityChecks.prototype.version;\n    /**\n     * @deprecated No longer being used.\n     * \\@breaking-change 10.0.0\n     * @type {?}\n     */\n    GranularSanityChecks.prototype.hammer;\n}\n/**\n * Module that captures anything that should be loaded and/or run for *all* Angular Material\n * components. This includes Bidi, etc.\n *\n * This module should be imported to each top-level component module (e.g., MatTabsModule).\n */\nclass MatCommonModule {\n    /**\n     * @param {?} highContrastModeDetector\n     * @param {?} sanityChecks\n     * @param {?=} document\n     */\n    constructor(highContrastModeDetector, sanityChecks, \n    /** @breaking-change 11.0.0 make document required */\n    document) {\n        /**\n         * Whether we've done the global sanity checks (e.g. a theme is loaded, there is a doctype).\n         */\n        this._hasDoneGlobalChecks = false;\n        this._document = document;\n        // While A11yModule also does this, we repeat it here to avoid importing A11yModule\n        // in MatCommonModule.\n        highContrastModeDetector._applyBodyHighContrastModeCssClasses();\n        // Note that `_sanityChecks` is typed to `any`, because AoT\n        // throws an error if we use the `SanityChecks` type directly.\n        this._sanityChecks = sanityChecks;\n        if (!this._hasDoneGlobalChecks) {\n            this._checkDoctypeIsDefined();\n            this._checkThemeIsPresent();\n            this._checkCdkVersionMatch();\n            this._hasDoneGlobalChecks = true;\n        }\n    }\n    /**\n     * Access injected document if available or fallback to global document reference\n     * @private\n     * @return {?}\n     */\n    _getDocument() {\n        /** @type {?} */\n        const doc = this._document || document;\n        return typeof doc === 'object' && doc ? doc : null;\n    }\n    /**\n     * Use defaultView of injected document if available or fallback to global window reference\n     * @private\n     * @return {?}\n     */\n    _getWindow() {\n        /** @type {?} */\n        const doc = this._getDocument();\n        /** @type {?} */\n        const win = (doc === null || doc === void 0 ? void 0 : doc.defaultView) || window;\n        return typeof win === 'object' && win ? win : null;\n    }\n    /**\n     * Whether any sanity checks are enabled.\n     * @private\n     * @return {?}\n     */\n    _checksAreEnabled() {\n        return isDevMode() && !this._isTestEnv();\n    }\n    /**\n     * Whether the code is running in tests.\n     * @private\n     * @return {?}\n     */\n    _isTestEnv() {\n        /** @type {?} */\n        const window = (/** @type {?} */ (this._getWindow()));\n        return window && (window.__karma__ || window.jasmine);\n    }\n    /**\n     * @private\n     * @return {?}\n     */\n    _checkDoctypeIsDefined() {\n        /** @type {?} */\n        const isEnabled = this._checksAreEnabled() &&\n            (this._sanityChecks === true || ((/** @type {?} */ (this._sanityChecks))).doctype);\n        /** @type {?} */\n        const document = this._getDocument();\n        if (isEnabled && document && !document.doctype) {\n            console.warn('Current document does not have a doctype. This may cause ' +\n                'some Angular Material components not to behave as expected.');\n        }\n    }\n    /**\n     * @private\n     * @return {?}\n     */\n    _checkThemeIsPresent() {\n        // We need to assert that the `body` is defined, because these checks run very early\n        // and the `body` won't be defined if the consumer put their scripts in the `head`.\n        /** @type {?} */\n        const isDisabled = !this._checksAreEnabled() ||\n            (this._sanityChecks === false || !((/** @type {?} */ (this._sanityChecks))).theme);\n        /** @type {?} */\n        const document = this._getDocument();\n        if (isDisabled || !document || !document.body ||\n            typeof getComputedStyle !== 'function') {\n            return;\n        }\n        /** @type {?} */\n        const testElement = document.createElement('div');\n        testElement.classList.add('mat-theme-loaded-marker');\n        document.body.appendChild(testElement);\n        /** @type {?} */\n        const computedStyle = getComputedStyle(testElement);\n        // In some situations the computed style of the test element can be null. For example in\n        // Firefox, the computed style is null if an application is running inside of a hidden iframe.\n        // See: https://bugzilla.mozilla.org/show_bug.cgi?id=548397\n        if (computedStyle && computedStyle.display !== 'none') {\n            console.warn('Could not find Angular Material core theme. Most Material ' +\n                'components may not work as expected. For more info refer ' +\n                'to the theming guide: https://material.angular.io/guide/theming');\n        }\n        document.body.removeChild(testElement);\n    }\n    /**\n     * Checks whether the material version matches the cdk version\n     * @private\n     * @return {?}\n     */\n    _checkCdkVersionMatch() {\n        /** @type {?} */\n        const isEnabled = this._checksAreEnabled() &&\n            (this._sanityChecks === true || ((/** @type {?} */ (this._sanityChecks))).version);\n        if (isEnabled && VERSION$1.full !== VERSION$2.full) {\n            console.warn('The Angular Material version (' + VERSION$1.full + ') does not match ' +\n                'the Angular CDK version (' + VERSION$2.full + ').\\n' +\n                'Please ensure the versions of these two packages exactly match.');\n        }\n    }\n}\nMatCommonModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: MatCommonModule });\nMatCommonModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function MatCommonModule_Factory(t) { return new (t || MatCommonModule)(ɵngcc0.ɵɵinject(ɵngcc1.HighContrastModeDetector), ɵngcc0.ɵɵinject(MATERIAL_SANITY_CHECKS, 8), ɵngcc0.ɵɵinject(DOCUMENT, 8)); }, imports: [[BidiModule],\n        BidiModule] });\n/** @nocollapse */\nMatCommonModule.ctorParameters = () => [\n    { type: HighContrastModeDetector },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MATERIAL_SANITY_CHECKS,] }] },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] }\n];\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(MatCommonModule, { imports: function () { return [BidiModule]; }, exports: function () { return [BidiModule]; } }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatCommonModule, [{\n        type: NgModule,\n        args: [{\n                imports: [BidiModule],\n                exports: [BidiModule]\n            }]\n    }], function () { return [{ type: ɵngcc1.HighContrastModeDetector }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MATERIAL_SANITY_CHECKS]\n            }] }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [DOCUMENT]\n            }] }]; }, null); })();\nif (false) {\n    /**\n     * Whether we've done the global sanity checks (e.g. a theme is loaded, there is a doctype).\n     * @type {?}\n     * @private\n     */\n    MatCommonModule.prototype._hasDoneGlobalChecks;\n    /**\n     * Configured sanity checks.\n     * @type {?}\n     * @private\n     */\n    MatCommonModule.prototype._sanityChecks;\n    /**\n     * Used to reference correct document/window\n     * @type {?}\n     * @protected\n     */\n    MatCommonModule.prototype._document;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/common-behaviors/disabled.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * \\@docs-private\n * @record\n */\nfunction CanDisable() { }\nif (false) {\n    /**\n     * Whether the component is disabled.\n     * @type {?}\n     */\n    CanDisable.prototype.disabled;\n}\n/**\n * Mixin to augment a directive with a `disabled` property.\n * @template T\n * @param {?} base\n * @return {?}\n */\nfunction mixinDisabled(base) {\n    return class extends base {\n        /**\n         * @param {...?} args\n         */\n        constructor(...args) {\n            super(...args);\n            this._disabled = false;\n        }\n        /**\n         * @return {?}\n         */\n        get disabled() { return this._disabled; }\n        /**\n         * @param {?} value\n         * @return {?}\n         */\n        set disabled(value) { this._disabled = coerceBooleanProperty(value); }\n    };\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/common-behaviors/color.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 * \\@docs-private\n * @record\n */\nfunction CanColor() { }\nif (false) {\n    /**\n     * Theme color palette for the component.\n     * @type {?}\n     */\n    CanColor.prototype.color;\n}\n/**\n * \\@docs-private\n * @record\n */\nfunction HasElementRef() { }\nif (false) {\n    /** @type {?} */\n    HasElementRef.prototype._elementRef;\n}\n/**\n * Mixin to augment a directive with a `color` property.\n * @template T\n * @param {?} base\n * @param {?=} defaultColor\n * @return {?}\n */\nfunction mixinColor(base, defaultColor) {\n    return class extends base {\n        /**\n         * @param {...?} args\n         */\n        constructor(...args) {\n            super(...args);\n            // Set the default color that can be specified from the mixin.\n            this.color = defaultColor;\n        }\n        /**\n         * @return {?}\n         */\n        get color() { return this._color; }\n        /**\n         * @param {?} value\n         * @return {?}\n         */\n        set color(value) {\n            /** @type {?} */\n            const colorPalette = value || defaultColor;\n            if (colorPalette !== this._color) {\n                if (this._color) {\n                    this._elementRef.nativeElement.classList.remove(`mat-${this._color}`);\n                }\n                if (colorPalette) {\n                    this._elementRef.nativeElement.classList.add(`mat-${colorPalette}`);\n                }\n                this._color = colorPalette;\n            }\n        }\n    };\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/common-behaviors/disable-ripple.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * \\@docs-private\n * @record\n */\nfunction CanDisableRipple() { }\nif (false) {\n    /**\n     * Whether ripples are disabled.\n     * @type {?}\n     */\n    CanDisableRipple.prototype.disableRipple;\n}\n/**\n * Mixin to augment a directive with a `disableRipple` property.\n * @template T\n * @param {?} base\n * @return {?}\n */\nfunction mixinDisableRipple(base) {\n    return class extends base {\n        /**\n         * @param {...?} args\n         */\n        constructor(...args) {\n            super(...args);\n            this._disableRipple = false;\n        }\n        /**\n         * Whether the ripple effect is disabled or not.\n         * @return {?}\n         */\n        get disableRipple() { return this._disableRipple; }\n        /**\n         * @param {?} value\n         * @return {?}\n         */\n        set disableRipple(value) { this._disableRipple = coerceBooleanProperty(value); }\n    };\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/common-behaviors/tabindex.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 * \\@docs-private\n * @record\n */\nfunction HasTabIndex() { }\nif (false) {\n    /**\n     * Tabindex of the component.\n     * @type {?}\n     */\n    HasTabIndex.prototype.tabIndex;\n}\n/**\n * Mixin to augment a directive with a `tabIndex` property.\n * @template T\n * @param {?} base\n * @param {?=} defaultTabIndex\n * @return {?}\n */\nfunction mixinTabIndex(base, defaultTabIndex = 0) {\n    return class extends base {\n        /**\n         * @param {...?} args\n         */\n        constructor(...args) {\n            super(...args);\n            this._tabIndex = defaultTabIndex;\n        }\n        /**\n         * @return {?}\n         */\n        get tabIndex() { return this.disabled ? -1 : this._tabIndex; }\n        /**\n         * @param {?} value\n         * @return {?}\n         */\n        set tabIndex(value) {\n            // If the specified tabIndex value is null or undefined, fall back to the default value.\n            this._tabIndex = value != null ? value : defaultTabIndex;\n        }\n    };\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/common-behaviors/error-state.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * \\@docs-private\n * @record\n */\nfunction CanUpdateErrorState() { }\nif (false) {\n    /** @type {?} */\n    CanUpdateErrorState.prototype.stateChanges;\n    /** @type {?} */\n    CanUpdateErrorState.prototype.errorState;\n    /** @type {?} */\n    CanUpdateErrorState.prototype.errorStateMatcher;\n    /**\n     * @return {?}\n     */\n    CanUpdateErrorState.prototype.updateErrorState = function () { };\n}\n/**\n * \\@docs-private\n * @record\n */\nfunction HasErrorState() { }\nif (false) {\n    /** @type {?} */\n    HasErrorState.prototype._parentFormGroup;\n    /** @type {?} */\n    HasErrorState.prototype._parentForm;\n    /** @type {?} */\n    HasErrorState.prototype._defaultErrorStateMatcher;\n    /** @type {?} */\n    HasErrorState.prototype.ngControl;\n}\n/**\n * Mixin to augment a directive with updateErrorState method.\n * For component with `errorState` and need to update `errorState`.\n * @template T\n * @param {?} base\n * @return {?}\n */\nfunction mixinErrorState(base) {\n    return class extends base {\n        /**\n         * @param {...?} args\n         */\n        constructor(...args) {\n            super(...args);\n            /**\n             * Whether the component is in an error state.\n             */\n            this.errorState = false;\n            /**\n             * Stream that emits whenever the state of the input changes such that the wrapping\n             * `MatFormField` needs to run change detection.\n             */\n            this.stateChanges = new Subject();\n        }\n        /**\n         * @return {?}\n         */\n        updateErrorState() {\n            /** @type {?} */\n            const oldState = this.errorState;\n            /** @type {?} */\n            const parent = this._parentFormGroup || this._parentForm;\n            /** @type {?} */\n            const matcher = this.errorStateMatcher || this._defaultErrorStateMatcher;\n            /** @type {?} */\n            const control = this.ngControl ? (/** @type {?} */ (this.ngControl.control)) : null;\n            /** @type {?} */\n            const newState = matcher.isErrorState(control, parent);\n            if (newState !== oldState) {\n                this.errorState = newState;\n                this.stateChanges.next();\n            }\n        }\n    };\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/common-behaviors/initialized.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Mixin that adds an initialized property to a directive which, when subscribed to, will emit a\n * value once markInitialized has been called, which should be done during the ngOnInit function.\n * If the subscription is made after it has already been marked as initialized, then it will trigger\n * an emit immediately.\n * \\@docs-private\n * @record\n */\nfunction HasInitialized() { }\nif (false) {\n    /**\n     * Stream that emits once during the directive/component's ngOnInit.\n     * @type {?}\n     */\n    HasInitialized.prototype.initialized;\n    /**\n     * Sets the state as initialized and must be called during ngOnInit to notify subscribers that\n     * the directive has been initialized.\n     * \\@docs-private\n     * @type {?}\n     */\n    HasInitialized.prototype._markInitialized;\n}\n/**\n * Mixin to augment a directive with an initialized property that will emits when ngOnInit ends.\n * @template T\n * @param {?} base\n * @return {?}\n */\nfunction mixinInitialized(base) {\n    return class extends base {\n        /**\n         * @param {...?} args\n         */\n        constructor(...args) {\n            super(...args);\n            /**\n             * Whether this directive has been marked as initialized.\n             */\n            this._isInitialized = false;\n            /**\n             * List of subscribers that subscribed before the directive was initialized. Should be notified\n             * during _markInitialized. Set to null after pending subscribers are notified, and should\n             * not expect to be populated after.\n             */\n            this._pendingSubscribers = [];\n            /**\n             * Observable stream that emits when the directive initializes. If already initialized, the\n             * subscriber is stored to be notified once _markInitialized is called.\n             */\n            this.initialized = new Observable((/**\n             * @param {?} subscriber\n             * @return {?}\n             */\n            subscriber => {\n                // If initialized, immediately notify the subscriber. Otherwise store the subscriber to notify\n                // when _markInitialized is called.\n                if (this._isInitialized) {\n                    this._notifySubscriber(subscriber);\n                }\n                else {\n                    (/** @type {?} */ (this._pendingSubscribers)).push(subscriber);\n                }\n            }));\n        }\n        /**\n         * Marks the state as initialized and notifies pending subscribers. Should be called at the end\n         * of ngOnInit.\n         * \\@docs-private\n         * @return {?}\n         */\n        _markInitialized() {\n            if (this._isInitialized) {\n                throw Error('This directive has already been marked as initialized and ' +\n                    'should not be called twice.');\n            }\n            this._isInitialized = true;\n            (/** @type {?} */ (this._pendingSubscribers)).forEach(this._notifySubscriber);\n            this._pendingSubscribers = null;\n        }\n        /**\n         * Emits and completes the subscriber stream (should only emit once).\n         * @param {?} subscriber\n         * @return {?}\n         */\n        _notifySubscriber(subscriber) {\n            subscriber.next();\n            subscriber.complete();\n        }\n    };\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/common-behaviors/index.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/datetime/date-adapter.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * InjectionToken for datepicker that can be used to override default locale code.\n * @type {?}\n */\nconst MAT_DATE_LOCALE = new InjectionToken('MAT_DATE_LOCALE', {\n    providedIn: 'root',\n    factory: MAT_DATE_LOCALE_FACTORY,\n});\n/**\n * \\@docs-private\n * @return {?}\n */\nfunction MAT_DATE_LOCALE_FACTORY() {\n    return inject(LOCALE_ID);\n}\n/**\n * No longer needed since MAT_DATE_LOCALE has been changed to a scoped injectable.\n * If you are importing and providing this in your code you can simply remove it.\n * @deprecated\n * \\@breaking-change 8.0.0\n * @type {?}\n */\nconst MAT_DATE_LOCALE_PROVIDER = { provide: MAT_DATE_LOCALE, useExisting: LOCALE_ID };\n/**\n * Adapts type `D` to be usable as a date by cdk-based components that work with dates.\n * @abstract\n * @template D\n */\nclass DateAdapter {\n    constructor() {\n        this._localeChanges = new Subject();\n    }\n    /**\n     * A stream that emits when the locale changes.\n     * @return {?}\n     */\n    get localeChanges() { return this._localeChanges; }\n    /**\n     * Attempts to deserialize a value to a valid date object. This is different from parsing in that\n     * deserialize should only accept non-ambiguous, locale-independent formats (e.g. a ISO 8601\n     * string). The default implementation does not allow any deserialization, it simply checks that\n     * the given value is already a valid date object or null. The `<mat-datepicker>` will call this\n     * method on all of its `\\@Input()` properties that accept dates. It is therefore possible to\n     * support passing values from your backend directly to these properties by overriding this method\n     * to also deserialize the format used by your backend.\n     * @param {?} value The value to be deserialized into a date object.\n     * @return {?} The deserialized date object, either a valid date, null if the value can be\n     *     deserialized into a null date (e.g. the empty string), or an invalid date.\n     */\n    deserialize(value) {\n        if (value == null || this.isDateInstance(value) && this.isValid(value)) {\n            return value;\n        }\n        return this.invalid();\n    }\n    /**\n     * Sets the locale used for all dates.\n     * @param {?} locale The new locale.\n     * @return {?}\n     */\n    setLocale(locale) {\n        this.locale = locale;\n        this._localeChanges.next();\n    }\n    /**\n     * Compares two dates.\n     * @param {?} first The first date to compare.\n     * @param {?} second The second date to compare.\n     * @return {?} 0 if the dates are equal, a number less than 0 if the first date is earlier,\n     *     a number greater than 0 if the first date is later.\n     */\n    compareDate(first, second) {\n        return this.getYear(first) - this.getYear(second) ||\n            this.getMonth(first) - this.getMonth(second) ||\n            this.getDate(first) - this.getDate(second);\n    }\n    /**\n     * Checks if two dates are equal.\n     * @param {?} first The first date to check.\n     * @param {?} second The second date to check.\n     * @return {?} Whether the two dates are equal.\n     *     Null dates are considered equal to other null dates.\n     */\n    sameDate(first, second) {\n        if (first && second) {\n            /** @type {?} */\n            let firstValid = this.isValid(first);\n            /** @type {?} */\n            let secondValid = this.isValid(second);\n            if (firstValid && secondValid) {\n                return !this.compareDate(first, second);\n            }\n            return firstValid == secondValid;\n        }\n        return first == second;\n    }\n    /**\n     * Clamp the given date between min and max dates.\n     * @param {?} date The date to clamp.\n     * @param {?=} min The minimum value to allow. If null or omitted no min is enforced.\n     * @param {?=} max The maximum value to allow. If null or omitted no max is enforced.\n     * @return {?} `min` if `date` is less than `min`, `max` if date is greater than `max`,\n     *     otherwise `date`.\n     */\n    clampDate(date, min, max) {\n        if (min && this.compareDate(date, min) < 0) {\n            return min;\n        }\n        if (max && this.compareDate(date, max) > 0) {\n            return max;\n        }\n        return date;\n    }\n}\nif (false) {\n    /**\n     * The locale to use for all dates.\n     * @type {?}\n     * @protected\n     */\n    DateAdapter.prototype.locale;\n    /**\n     * @type {?}\n     * @protected\n     */\n    DateAdapter.prototype._localeChanges;\n    /**\n     * Gets the year component of the given date.\n     * @abstract\n     * @param {?} date The date to extract the year from.\n     * @return {?} The year component.\n     */\n    DateAdapter.prototype.getYear = function (date) { };\n    /**\n     * Gets the month component of the given date.\n     * @abstract\n     * @param {?} date The date to extract the month from.\n     * @return {?} The month component (0-indexed, 0 = January).\n     */\n    DateAdapter.prototype.getMonth = function (date) { };\n    /**\n     * Gets the date of the month component of the given date.\n     * @abstract\n     * @param {?} date The date to extract the date of the month from.\n     * @return {?} The month component (1-indexed, 1 = first of month).\n     */\n    DateAdapter.prototype.getDate = function (date) { };\n    /**\n     * Gets the day of the week component of the given date.\n     * @abstract\n     * @param {?} date The date to extract the day of the week from.\n     * @return {?} The month component (0-indexed, 0 = Sunday).\n     */\n    DateAdapter.prototype.getDayOfWeek = function (date) { };\n    /**\n     * Gets a list of names for the months.\n     * @abstract\n     * @param {?} style The naming style (e.g. long = 'January', short = 'Jan', narrow = 'J').\n     * @return {?} An ordered list of all month names, starting with January.\n     */\n    DateAdapter.prototype.getMonthNames = function (style) { };\n    /**\n     * Gets a list of names for the dates of the month.\n     * @abstract\n     * @return {?} An ordered list of all date of the month names, starting with '1'.\n     */\n    DateAdapter.prototype.getDateNames = function () { };\n    /**\n     * Gets a list of names for the days of the week.\n     * @abstract\n     * @param {?} style The naming style (e.g. long = 'Sunday', short = 'Sun', narrow = 'S').\n     * @return {?} An ordered list of all weekday names, starting with Sunday.\n     */\n    DateAdapter.prototype.getDayOfWeekNames = function (style) { };\n    /**\n     * Gets the name for the year of the given date.\n     * @abstract\n     * @param {?} date The date to get the year name for.\n     * @return {?} The name of the given year (e.g. '2017').\n     */\n    DateAdapter.prototype.getYearName = function (date) { };\n    /**\n     * Gets the first day of the week.\n     * @abstract\n     * @return {?} The first day of the week (0-indexed, 0 = Sunday).\n     */\n    DateAdapter.prototype.getFirstDayOfWeek = function () { };\n    /**\n     * Gets the number of days in the month of the given date.\n     * @abstract\n     * @param {?} date The date whose month should be checked.\n     * @return {?} The number of days in the month of the given date.\n     */\n    DateAdapter.prototype.getNumDaysInMonth = function (date) { };\n    /**\n     * Clones the given date.\n     * @abstract\n     * @param {?} date The date to clone\n     * @return {?} A new date equal to the given date.\n     */\n    DateAdapter.prototype.clone = function (date) { };\n    /**\n     * Creates a date with the given year, month, and date. Does not allow over/under-flow of the\n     * month and date.\n     * @abstract\n     * @param {?} year The full year of the date. (e.g. 89 means the year 89, not the year 1989).\n     * @param {?} month The month of the date (0-indexed, 0 = January). Must be an integer 0 - 11.\n     * @param {?} date The date of month of the date. Must be an integer 1 - length of the given month.\n     * @return {?} The new date, or null if invalid.\n     */\n    DateAdapter.prototype.createDate = function (year, month, date) { };\n    /**\n     * Gets today's date.\n     * @abstract\n     * @return {?} Today's date.\n     */\n    DateAdapter.prototype.today = function () { };\n    /**\n     * Parses a date from a user-provided value.\n     * @abstract\n     * @param {?} value The value to parse.\n     * @param {?} parseFormat The expected format of the value being parsed\n     *     (type is implementation-dependent).\n     * @return {?} The parsed date.\n     */\n    DateAdapter.prototype.parse = function (value, parseFormat) { };\n    /**\n     * Formats a date as a string according to the given format.\n     * @abstract\n     * @param {?} date The value to format.\n     * @param {?} displayFormat The format to use to display the date as a string.\n     * @return {?} The formatted date string.\n     */\n    DateAdapter.prototype.format = function (date, displayFormat) { };\n    /**\n     * Adds the given number of years to the date. Years are counted as if flipping 12 pages on the\n     * calendar for each year and then finding the closest date in the new month. For example when\n     * adding 1 year to Feb 29, 2016, the resulting date will be Feb 28, 2017.\n     * @abstract\n     * @param {?} date The date to add years to.\n     * @param {?} years The number of years to add (may be negative).\n     * @return {?} A new date equal to the given one with the specified number of years added.\n     */\n    DateAdapter.prototype.addCalendarYears = function (date, years) { };\n    /**\n     * Adds the given number of months to the date. Months are counted as if flipping a page on the\n     * calendar for each month and then finding the closest date in the new month. For example when\n     * adding 1 month to Jan 31, 2017, the resulting date will be Feb 28, 2017.\n     * @abstract\n     * @param {?} date The date to add months to.\n     * @param {?} months The number of months to add (may be negative).\n     * @return {?} A new date equal to the given one with the specified number of months added.\n     */\n    DateAdapter.prototype.addCalendarMonths = function (date, months) { };\n    /**\n     * Adds the given number of days to the date. Days are counted as if moving one cell on the\n     * calendar for each day.\n     * @abstract\n     * @param {?} date The date to add days to.\n     * @param {?} days The number of days to add (may be negative).\n     * @return {?} A new date equal to the given one with the specified number of days added.\n     */\n    DateAdapter.prototype.addCalendarDays = function (date, days) { };\n    /**\n     * Gets the RFC 3339 compatible string (https://tools.ietf.org/html/rfc3339) for the given date.\n     * This method is used to generate date strings that are compatible with native HTML attributes\n     * such as the `min` or `max` attribute of an `<input>`.\n     * @abstract\n     * @param {?} date The date to get the ISO date string for.\n     * @return {?} The ISO date string date string.\n     */\n    DateAdapter.prototype.toIso8601 = function (date) { };\n    /**\n     * Checks whether the given object is considered a date instance by this DateAdapter.\n     * @abstract\n     * @param {?} obj The object to check\n     * @return {?} Whether the object is a date instance.\n     */\n    DateAdapter.prototype.isDateInstance = function (obj) { };\n    /**\n     * Checks whether the given date is valid.\n     * @abstract\n     * @param {?} date The date to check.\n     * @return {?} Whether the date is valid.\n     */\n    DateAdapter.prototype.isValid = function (date) { };\n    /**\n     * Gets date instance that is not valid.\n     * @abstract\n     * @return {?} An invalid date.\n     */\n    DateAdapter.prototype.invalid = function () { };\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/datetime/date-formats.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst MAT_DATE_FORMATS = new InjectionToken('mat-date-formats');\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/datetime/native-date-adapter.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n// TODO(mmalerba): Remove when we no longer support safari 9.\n/**\n * Whether the browser supports the Intl API.\n * @type {?}\n */\nlet SUPPORTS_INTL_API;\n// We need a try/catch around the reference to `Intl`, because accessing it in some cases can\n// cause IE to throw. These cases are tied to particular versions of Windows and can happen if\n// the consumer is providing a polyfilled `Map`. See:\n// https://github.com/Microsoft/ChakraCore/issues/3189\n// https://github.com/angular/components/issues/15687\ntry {\n    SUPPORTS_INTL_API = typeof Intl != 'undefined';\n}\ncatch (_a) {\n    SUPPORTS_INTL_API = false;\n}\n/**\n * The default month names to use if Intl API is not available.\n * @type {?}\n */\nconst DEFAULT_MONTH_NAMES = {\n    'long': [\n        'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September',\n        'October', 'November', 'December'\n    ],\n    'short': ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],\n    'narrow': ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D']\n};\nconst ɵ0 = /**\n * @param {?} i\n * @return {?}\n */\ni => String(i + 1);\n/**\n * The default date names to use if Intl API is not available.\n * @type {?}\n */\nconst DEFAULT_DATE_NAMES = range(31, (ɵ0));\n/**\n * The default day of the week names to use if Intl API is not available.\n * @type {?}\n */\nconst DEFAULT_DAY_OF_WEEK_NAMES = {\n    'long': ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],\n    'short': ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],\n    'narrow': ['S', 'M', 'T', 'W', 'T', 'F', 'S']\n};\n/**\n * Matches strings that have the form of a valid RFC 3339 string\n * (https://tools.ietf.org/html/rfc3339). Note that the string may not actually be a valid date\n * because the regex will match strings an with out of bounds month, date, etc.\n * @type {?}\n */\nconst ISO_8601_REGEX = /^\\d{4}-\\d{2}-\\d{2}(?:T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|(?:(?:\\+|-)\\d{2}:\\d{2}))?)?$/;\n/**\n * Creates an array and fills it with values.\n * @template T\n * @param {?} length\n * @param {?} valueFunction\n * @return {?}\n */\nfunction range(length, valueFunction) {\n    /** @type {?} */\n    const valuesArray = Array(length);\n    for (let i = 0; i < length; i++) {\n        valuesArray[i] = valueFunction(i);\n    }\n    return valuesArray;\n}\n/**\n * Adapts the native JS Date for use with cdk-based components that work with dates.\n */\nclass NativeDateAdapter extends DateAdapter {\n    /**\n     * @param {?} matDateLocale\n     * @param {?} platform\n     */\n    constructor(matDateLocale, platform) {\n        super();\n        /**\n         * Whether to use `timeZone: 'utc'` with `Intl.DateTimeFormat` when formatting dates.\n         * Without this `Intl.DateTimeFormat` sometimes chooses the wrong timeZone, which can throw off\n         * the result. (e.g. in the en-US locale `new Date(1800, 7, 14).toLocaleDateString()`\n         * will produce `'8/13/1800'`.\n         *\n         * TODO(mmalerba): drop this variable. It's not being used in the code right now. We're now\n         * getting the string representation of a Date object from its utc representation. We're keeping\n         * it here for sometime, just for precaution, in case we decide to revert some of these changes\n         * though.\n         */\n        this.useUtcForDisplay = true;\n        super.setLocale(matDateLocale);\n        // IE does its own time zone correction, so we disable this on IE.\n        this.useUtcForDisplay = !platform.TRIDENT;\n        this._clampDate = platform.TRIDENT || platform.EDGE;\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    getYear(date) {\n        return date.getFullYear();\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    getMonth(date) {\n        return date.getMonth();\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    getDate(date) {\n        return date.getDate();\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    getDayOfWeek(date) {\n        return date.getDay();\n    }\n    /**\n     * @param {?} style\n     * @return {?}\n     */\n    getMonthNames(style) {\n        if (SUPPORTS_INTL_API) {\n            /** @type {?} */\n            const dtf = new Intl.DateTimeFormat(this.locale, { month: style, timeZone: 'utc' });\n            return range(12, (/**\n             * @param {?} i\n             * @return {?}\n             */\n            i => this._stripDirectionalityCharacters(this._format(dtf, new Date(2017, i, 1)))));\n        }\n        return DEFAULT_MONTH_NAMES[style];\n    }\n    /**\n     * @return {?}\n     */\n    getDateNames() {\n        if (SUPPORTS_INTL_API) {\n            /** @type {?} */\n            const dtf = new Intl.DateTimeFormat(this.locale, { day: 'numeric', timeZone: 'utc' });\n            return range(31, (/**\n             * @param {?} i\n             * @return {?}\n             */\n            i => this._stripDirectionalityCharacters(this._format(dtf, new Date(2017, 0, i + 1)))));\n        }\n        return DEFAULT_DATE_NAMES;\n    }\n    /**\n     * @param {?} style\n     * @return {?}\n     */\n    getDayOfWeekNames(style) {\n        if (SUPPORTS_INTL_API) {\n            /** @type {?} */\n            const dtf = new Intl.DateTimeFormat(this.locale, { weekday: style, timeZone: 'utc' });\n            return range(7, (/**\n             * @param {?} i\n             * @return {?}\n             */\n            i => this._stripDirectionalityCharacters(this._format(dtf, new Date(2017, 0, i + 1)))));\n        }\n        return DEFAULT_DAY_OF_WEEK_NAMES[style];\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    getYearName(date) {\n        if (SUPPORTS_INTL_API) {\n            /** @type {?} */\n            const dtf = new Intl.DateTimeFormat(this.locale, { year: 'numeric', timeZone: 'utc' });\n            return this._stripDirectionalityCharacters(this._format(dtf, date));\n        }\n        return String(this.getYear(date));\n    }\n    /**\n     * @return {?}\n     */\n    getFirstDayOfWeek() {\n        // We can't tell using native JS Date what the first day of the week is, we default to Sunday.\n        return 0;\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    getNumDaysInMonth(date) {\n        return this.getDate(this._createDateWithOverflow(this.getYear(date), this.getMonth(date) + 1, 0));\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    clone(date) {\n        return new Date(date.getTime());\n    }\n    /**\n     * @param {?} year\n     * @param {?} month\n     * @param {?} date\n     * @return {?}\n     */\n    createDate(year, month, date) {\n        // Check for invalid month and date (except upper bound on date which we have to check after\n        // creating the Date).\n        if (month < 0 || month > 11) {\n            throw Error(`Invalid month index \"${month}\". Month index has to be between 0 and 11.`);\n        }\n        if (date < 1) {\n            throw Error(`Invalid date \"${date}\". Date has to be greater than 0.`);\n        }\n        /** @type {?} */\n        let result = this._createDateWithOverflow(year, month, date);\n        // Check that the date wasn't above the upper bound for the month, causing the month to overflow\n        if (result.getMonth() != month) {\n            throw Error(`Invalid date \"${date}\" for month with index \"${month}\".`);\n        }\n        return result;\n    }\n    /**\n     * @return {?}\n     */\n    today() {\n        return new Date();\n    }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    parse(value) {\n        // We have no way using the native JS Date to set the parse format or locale, so we ignore these\n        // parameters.\n        if (typeof value == 'number') {\n            return new Date(value);\n        }\n        return value ? new Date(Date.parse(value)) : null;\n    }\n    /**\n     * @param {?} date\n     * @param {?} displayFormat\n     * @return {?}\n     */\n    format(date, displayFormat) {\n        if (!this.isValid(date)) {\n            throw Error('NativeDateAdapter: Cannot format invalid date.');\n        }\n        if (SUPPORTS_INTL_API) {\n            // On IE and Edge the i18n API will throw a hard error that can crash the entire app\n            // if we attempt to format a date whose year is less than 1 or greater than 9999.\n            if (this._clampDate && (date.getFullYear() < 1 || date.getFullYear() > 9999)) {\n                date = this.clone(date);\n                date.setFullYear(Math.max(1, Math.min(9999, date.getFullYear())));\n            }\n            displayFormat = Object.assign(Object.assign({}, displayFormat), { timeZone: 'utc' });\n            /** @type {?} */\n            const dtf = new Intl.DateTimeFormat(this.locale, displayFormat);\n            return this._stripDirectionalityCharacters(this._format(dtf, date));\n        }\n        return this._stripDirectionalityCharacters(date.toDateString());\n    }\n    /**\n     * @param {?} date\n     * @param {?} years\n     * @return {?}\n     */\n    addCalendarYears(date, years) {\n        return this.addCalendarMonths(date, years * 12);\n    }\n    /**\n     * @param {?} date\n     * @param {?} months\n     * @return {?}\n     */\n    addCalendarMonths(date, months) {\n        /** @type {?} */\n        let newDate = this._createDateWithOverflow(this.getYear(date), this.getMonth(date) + months, this.getDate(date));\n        // It's possible to wind up in the wrong month if the original month has more days than the new\n        // month. In this case we want to go to the last day of the desired month.\n        // Note: the additional + 12 % 12 ensures we end up with a positive number, since JS % doesn't\n        // guarantee this.\n        if (this.getMonth(newDate) != ((this.getMonth(date) + months) % 12 + 12) % 12) {\n            newDate = this._createDateWithOverflow(this.getYear(newDate), this.getMonth(newDate), 0);\n        }\n        return newDate;\n    }\n    /**\n     * @param {?} date\n     * @param {?} days\n     * @return {?}\n     */\n    addCalendarDays(date, days) {\n        return this._createDateWithOverflow(this.getYear(date), this.getMonth(date), this.getDate(date) + days);\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    toIso8601(date) {\n        return [\n            date.getUTCFullYear(),\n            this._2digit(date.getUTCMonth() + 1),\n            this._2digit(date.getUTCDate())\n        ].join('-');\n    }\n    /**\n     * Returns the given value if given a valid Date or null. Deserializes valid ISO 8601 strings\n     * (https://www.ietf.org/rfc/rfc3339.txt) into valid Dates and empty string into null. Returns an\n     * invalid date for all other values.\n     * @param {?} value\n     * @return {?}\n     */\n    deserialize(value) {\n        if (typeof value === 'string') {\n            if (!value) {\n                return null;\n            }\n            // The `Date` constructor accepts formats other than ISO 8601, so we need to make sure the\n            // string is the right format first.\n            if (ISO_8601_REGEX.test(value)) {\n                /** @type {?} */\n                let date = new Date(value);\n                if (this.isValid(date)) {\n                    return date;\n                }\n            }\n        }\n        return super.deserialize(value);\n    }\n    /**\n     * @param {?} obj\n     * @return {?}\n     */\n    isDateInstance(obj) {\n        return obj instanceof Date;\n    }\n    /**\n     * @param {?} date\n     * @return {?}\n     */\n    isValid(date) {\n        return !isNaN(date.getTime());\n    }\n    /**\n     * @return {?}\n     */\n    invalid() {\n        return new Date(NaN);\n    }\n    /**\n     * Creates a date but allows the month and date to overflow.\n     * @private\n     * @param {?} year\n     * @param {?} month\n     * @param {?} date\n     * @return {?}\n     */\n    _createDateWithOverflow(year, month, date) {\n        /** @type {?} */\n        const result = new Date(year, month, date);\n        // We need to correct for the fact that JS native Date treats years in range [0, 99] as\n        // abbreviations for 19xx.\n        if (year >= 0 && year < 100) {\n            result.setFullYear(this.getYear(result) - 1900);\n        }\n        return result;\n    }\n    /**\n     * Pads a number to make it two digits.\n     * @private\n     * @param {?} n The number to pad.\n     * @return {?} The padded number.\n     */\n    _2digit(n) {\n        return ('00' + n).slice(-2);\n    }\n    /**\n     * Strip out unicode LTR and RTL characters. Edge and IE insert these into formatted dates while\n     * other browsers do not. We remove them to make output consistent and because they interfere with\n     * date parsing.\n     * @private\n     * @param {?} str The string to strip direction characters from.\n     * @return {?} The stripped string.\n     */\n    _stripDirectionalityCharacters(str) {\n        return str.replace(/[\\u200e\\u200f]/g, '');\n    }\n    /**\n     * When converting Date object to string, javascript built-in functions may return wrong\n     * results because it applies its internal DST rules. The DST rules around the world change\n     * very frequently, and the current valid rule is not always valid in previous years though.\n     * We work around this problem building a new Date object which has its internal UTC\n     * representation with the local date and time.\n     * @private\n     * @param {?} dtf Intl.DateTimeFormat object, containg the desired string format. It must have\n     *    timeZone set to 'utc' to work fine.\n     * @param {?} date Date from which we want to get the string representation according to dtf\n     * @return {?} A Date object with its UTC representation based on the passed in date info\n     */\n    _format(dtf, date) {\n        /** @type {?} */\n        const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));\n        return dtf.format(d);\n    }\n}\nNativeDateAdapter.ɵfac = function NativeDateAdapter_Factory(t) { return new (t || NativeDateAdapter)(ɵngcc0.ɵɵinject(MAT_DATE_LOCALE, 8), ɵngcc0.ɵɵinject(ɵngcc2.Platform)); };\nNativeDateAdapter.ɵprov = ɵngcc0.ɵɵdefineInjectable({ token: NativeDateAdapter, factory: NativeDateAdapter.ɵfac });\n/** @nocollapse */\nNativeDateAdapter.ctorParameters = () => [\n    { type: String, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_LOCALE,] }] },\n    { type: Platform }\n];\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(NativeDateAdapter, [{\n        type: Injectable\n    }], function () { return [{ type: String, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MAT_DATE_LOCALE]\n            }] }, { type: ɵngcc2.Platform }]; }, null); })();\nif (false) {\n    /**\n     * Whether to clamp the date between 1 and 9999 to avoid IE and Edge errors.\n     * @type {?}\n     * @private\n     */\n    NativeDateAdapter.prototype._clampDate;\n    /**\n     * Whether to use `timeZone: 'utc'` with `Intl.DateTimeFormat` when formatting dates.\n     * Without this `Intl.DateTimeFormat` sometimes chooses the wrong timeZone, which can throw off\n     * the result. (e.g. in the en-US locale `new Date(1800, 7, 14).toLocaleDateString()`\n     * will produce `'8/13/1800'`.\n     *\n     * TODO(mmalerba): drop this variable. It's not being used in the code right now. We're now\n     * getting the string representation of a Date object from its utc representation. We're keeping\n     * it here for sometime, just for precaution, in case we decide to revert some of these changes\n     * though.\n     * @type {?}\n     */\n    NativeDateAdapter.prototype.useUtcForDisplay;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/datetime/native-date-formats.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/** @type {?} */\nconst MAT_NATIVE_DATE_FORMATS = {\n    parse: {\n        dateInput: null,\n    },\n    display: {\n        dateInput: { year: 'numeric', month: 'numeric', day: 'numeric' },\n        monthYearLabel: { year: 'numeric', month: 'short' },\n        dateA11yLabel: { year: 'numeric', month: 'long', day: 'numeric' },\n        monthYearA11yLabel: { year: 'numeric', month: 'long' },\n    }\n};\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/datetime/index.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass NativeDateModule {\n}\nNativeDateModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: NativeDateModule });\nNativeDateModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function NativeDateModule_Factory(t) { return new (t || NativeDateModule)(); }, providers: [\n        { provide: DateAdapter, useClass: NativeDateAdapter },\n    ], imports: [[PlatformModule]] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(NativeDateModule, { imports: function () { return [PlatformModule]; } }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(NativeDateModule, [{\n        type: NgModule,\n        args: [{\n                imports: [PlatformModule],\n                providers: [\n                    { provide: DateAdapter, useClass: NativeDateAdapter },\n                ]\n            }]\n    }], null, null); })();\nconst ɵ0$1 = MAT_NATIVE_DATE_FORMATS;\nclass MatNativeDateModule {\n}\nMatNativeDateModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: MatNativeDateModule });\nMatNativeDateModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function MatNativeDateModule_Factory(t) { return new (t || MatNativeDateModule)(); }, providers: [{ provide: MAT_DATE_FORMATS, useValue: ɵ0$1 }], imports: [[NativeDateModule]] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(MatNativeDateModule, { imports: [NativeDateModule] }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatNativeDateModule, [{\n        type: NgModule,\n        args: [{\n                imports: [NativeDateModule],\n                providers: [{ provide: MAT_DATE_FORMATS, useValue: ɵ0$1 }]\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/error/error-options.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Error state matcher that matches when a control is invalid and dirty.\n */\nclass ShowOnDirtyErrorStateMatcher {\n    /**\n     * @param {?} control\n     * @param {?} form\n     * @return {?}\n     */\n    isErrorState(control, form) {\n        return !!(control && control.invalid && (control.dirty || (form && form.submitted)));\n    }\n}\nShowOnDirtyErrorStateMatcher.ɵfac = function ShowOnDirtyErrorStateMatcher_Factory(t) { return new (t || ShowOnDirtyErrorStateMatcher)(); };\nShowOnDirtyErrorStateMatcher.ɵprov = ɵngcc0.ɵɵdefineInjectable({ token: ShowOnDirtyErrorStateMatcher, factory: ShowOnDirtyErrorStateMatcher.ɵfac });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(ShowOnDirtyErrorStateMatcher, [{\n        type: Injectable\n    }], null, null); })();\n/**\n * Provider that defines how form controls behave with regards to displaying error messages.\n */\nclass ErrorStateMatcher {\n    /**\n     * @param {?} control\n     * @param {?} form\n     * @return {?}\n     */\n    isErrorState(control, form) {\n        return !!(control && control.invalid && (control.touched || (form && form.submitted)));\n    }\n}\nErrorStateMatcher.ɵfac = function ErrorStateMatcher_Factory(t) { return new (t || ErrorStateMatcher)(); };\n/** @nocollapse */ ErrorStateMatcher.ɵprov = ɵɵdefineInjectable({ factory: function ErrorStateMatcher_Factory() { return new ErrorStateMatcher(); }, token: ErrorStateMatcher, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(ErrorStateMatcher, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/gestures/gesture-annotations.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 * Stripped-down HammerJS annotations to be used within Material, which are necessary,\n * because HammerJS is an optional dependency. For the full annotations see:\n * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/hammerjs/index.d.ts\n */\n/**\n * @deprecated No longer being used. To be removed.\n * \\@breaking-change 10.0.0\n * \\@docs-private\n * @record\n */\nfunction HammerInput() { }\nif (false) {\n    /** @type {?} */\n    HammerInput.prototype.preventDefault;\n    /** @type {?} */\n    HammerInput.prototype.deltaX;\n    /** @type {?} */\n    HammerInput.prototype.deltaY;\n    /** @type {?} */\n    HammerInput.prototype.center;\n}\n/**\n * @deprecated No longer being used. To be removed.\n * \\@breaking-change 10.0.0\n * \\@docs-private\n * @record\n */\nfunction HammerStatic() { }\nif (false) {\n    /** @type {?} */\n    HammerStatic.prototype.Pan;\n    /** @type {?} */\n    HammerStatic.prototype.Swipe;\n    /** @type {?} */\n    HammerStatic.prototype.Press;\n    /* Skipping unhandled member: new(element: HTMLElement | SVGElement, options?: any): HammerManager;*/\n}\n/**\n * @deprecated No longer being used. To be removed.\n * \\@breaking-change 10.0.0\n * \\@docs-private\n * @record\n */\nfunction Recognizer() { }\nif (false) {\n    /* Skipping unhandled member: new(options?: any): Recognizer;*/\n    /**\n     * @param {?} otherRecognizer\n     * @return {?}\n     */\n    Recognizer.prototype.recognizeWith = function (otherRecognizer) { };\n}\n/**\n * @deprecated No longer being used. To be removed.\n * \\@breaking-change 10.0.0\n * \\@docs-private\n * @record\n */\nfunction RecognizerStatic() { }\n/**\n * @deprecated No longer being used. To be removed.\n * \\@breaking-change 10.0.0\n * \\@docs-private\n * @record\n */\nfunction HammerInstance() { }\nif (false) {\n    /**\n     * @param {?} eventName\n     * @param {?} callback\n     * @return {?}\n     */\n    HammerInstance.prototype.on = function (eventName, callback) { };\n    /**\n     * @param {?} eventName\n     * @param {?} callback\n     * @return {?}\n     */\n    HammerInstance.prototype.off = function (eventName, callback) { };\n}\n/**\n * @deprecated No longer being used. To be removed.\n * \\@breaking-change 10.0.0\n * \\@docs-private\n * @record\n */\nfunction HammerManager() { }\nif (false) {\n    /**\n     * @param {?} recogniser\n     * @return {?}\n     */\n    HammerManager.prototype.add = function (recogniser) { };\n    /**\n     * @param {?} options\n     * @return {?}\n     */\n    HammerManager.prototype.set = function (options) { };\n    /**\n     * @param {?} event\n     * @param {?} data\n     * @return {?}\n     */\n    HammerManager.prototype.emit = function (event, data) { };\n    /**\n     * @param {?} events\n     * @param {?=} handler\n     * @return {?}\n     */\n    HammerManager.prototype.off = function (events, handler) { };\n    /**\n     * @param {?} events\n     * @param {?} handler\n     * @return {?}\n     */\n    HammerManager.prototype.on = function (events, handler) { };\n}\n/**\n * @deprecated No longer being used. To be removed.\n * \\@breaking-change 10.0.0\n * \\@docs-private\n * @record\n */\nfunction HammerOptions() { }\nif (false) {\n    /** @type {?|undefined} */\n    HammerOptions.prototype.cssProps;\n    /** @type {?|undefined} */\n    HammerOptions.prototype.domEvents;\n    /** @type {?|undefined} */\n    HammerOptions.prototype.enable;\n    /** @type {?|undefined} */\n    HammerOptions.prototype.preset;\n    /** @type {?|undefined} */\n    HammerOptions.prototype.touchAction;\n    /** @type {?|undefined} */\n    HammerOptions.prototype.recognizers;\n    /** @type {?|undefined} */\n    HammerOptions.prototype.inputClass;\n    /** @type {?|undefined} */\n    HammerOptions.prototype.inputTarget;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/gestures/gesture-config.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Injection token that can be used to provide options to the Hammerjs instance.\n * More info at http://hammerjs.github.io/api/.\n * @deprecated No longer being used. To be removed.\n * \\@breaking-change 10.0.0\n * @type {?}\n */\nconst MAT_HAMMER_OPTIONS = new InjectionToken('MAT_HAMMER_OPTIONS');\n/** @type {?} */\nconst ANGULAR_MATERIAL_SUPPORTED_HAMMER_GESTURES = [\n    'longpress',\n    'slide',\n    'slidestart',\n    'slideend',\n    'slideright',\n    'slideleft'\n];\nconst ɵ0$2 = /**\n * @return {?}\n */\n() => { }, ɵ1 = /**\n * @return {?}\n */\n() => { };\n/**\n * Fake HammerInstance that is used when a Hammer instance is requested when HammerJS has not\n * been loaded on the page.\n * @type {?}\n */\nconst noopHammerInstance = {\n    on: (ɵ0$2),\n    off: (ɵ1),\n};\n/**\n * Adjusts configuration of our gesture library, Hammer.\n * @deprecated No longer being used. To be removed.\n * \\@breaking-change 10.0.0\n */\nclass GestureConfig extends HammerGestureConfig {\n    /**\n     * @param {?=} _hammerOptions\n     * @param {?=} _commonModule\n     */\n    constructor(_hammerOptions, _commonModule) {\n        super();\n        this._hammerOptions = _hammerOptions;\n        /**\n         * List of new event names to add to the gesture support list\n         */\n        this.events = ANGULAR_MATERIAL_SUPPORTED_HAMMER_GESTURES;\n    }\n    /**\n     * Builds Hammer instance manually to add custom recognizers that match the Material Design spec.\n     *\n     * Our gesture names come from the Material Design gestures spec:\n     * https://material.io/design/#gestures-touch-mechanics\n     *\n     * More information on default recognizers can be found in Hammer docs:\n     * http://hammerjs.github.io/recognizer-pan/\n     * http://hammerjs.github.io/recognizer-press/\n     *\n     * @param {?} element Element to which to assign the new HammerJS gestures.\n     * @return {?} Newly-created HammerJS instance.\n     */\n    buildHammer(element) {\n        /** @type {?} */\n        const hammer = typeof window !== 'undefined' ? ((/** @type {?} */ (window))).Hammer : null;\n        if (!hammer) {\n            // If HammerJS is not loaded here, return the noop HammerInstance. This is necessary to\n            // ensure that omitting HammerJS completely will not cause any errors while *also* supporting\n            // the lazy-loading of HammerJS via the HAMMER_LOADER token introduced in Angular 6.1.\n            // Because we can't depend on HAMMER_LOADER's existance until 7.0, we have to always set\n            // `this.events` to the set we support, instead of conditionally setting it to `[]` if\n            // `HAMMER_LOADER` is present (and then throwing an Error here if `window.Hammer` is\n            // undefined).\n            // @breaking-change 8.0.0\n            return noopHammerInstance;\n        }\n        /** @type {?} */\n        const mc = new hammer(element, this._hammerOptions || undefined);\n        // Default Hammer Recognizers.\n        /** @type {?} */\n        const pan = new hammer.Pan();\n        /** @type {?} */\n        const swipe = new hammer.Swipe();\n        /** @type {?} */\n        const press = new hammer.Press();\n        // Notice that a HammerJS recognizer can only depend on one other recognizer once.\n        // Otherwise the previous `recognizeWith` will be dropped.\n        // TODO: Confirm threshold numbers with Material Design UX Team\n        /** @type {?} */\n        const slide = this._createRecognizer(pan, { event: 'slide', threshold: 0 }, swipe);\n        /** @type {?} */\n        const longpress = this._createRecognizer(press, { event: 'longpress', time: 500 });\n        // Overwrite the default `pan` event to use the swipe event.\n        pan.recognizeWith(swipe);\n        // Since the slide event threshold is set to zero, the slide recognizer can fire and\n        // accidentally reset the longpress recognizer. In order to make sure that the two\n        // recognizers can run simultaneously but don't affect each other, we allow the slide\n        // recognizer to recognize while a longpress is being processed.\n        // See: https://github.com/hammerjs/hammer.js/blob/master/src/manager.js#L123-L124\n        longpress.recognizeWith(slide);\n        // Add customized gestures to Hammer manager\n        mc.add([swipe, press, pan, slide, longpress]);\n        return (/** @type {?} */ (mc));\n    }\n    /**\n     * Creates a new recognizer, without affecting the default recognizers of HammerJS\n     * @private\n     * @param {?} base\n     * @param {?} options\n     * @param {...?} inheritances\n     * @return {?}\n     */\n    _createRecognizer(base, options, ...inheritances) {\n        /** @type {?} */\n        let recognizer = new ((/** @type {?} */ (base.constructor)))(options);\n        inheritances.push(base);\n        inheritances.forEach((/**\n         * @param {?} item\n         * @return {?}\n         */\n        item => recognizer.recognizeWith(item)));\n        return recognizer;\n    }\n}\nGestureConfig.ɵfac = function GestureConfig_Factory(t) { return new (t || GestureConfig)(ɵngcc0.ɵɵinject(MAT_HAMMER_OPTIONS, 8), ɵngcc0.ɵɵinject(MatCommonModule, 8)); };\nGestureConfig.ɵprov = ɵngcc0.ɵɵdefineInjectable({ token: GestureConfig, factory: GestureConfig.ɵfac });\n/** @nocollapse */\nGestureConfig.ctorParameters = () => [\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_HAMMER_OPTIONS,] }] },\n    { type: MatCommonModule, decorators: [{ type: Optional }] }\n];\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(GestureConfig, [{\n        type: Injectable\n    }], function () { return [{ type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MAT_HAMMER_OPTIONS]\n            }] }, { type: MatCommonModule, decorators: [{\n                type: Optional\n            }] }]; }, null); })();\nif (false) {\n    /**\n     * List of new event names to add to the gesture support list\n     * @type {?}\n     */\n    GestureConfig.prototype.events;\n    /**\n     * @type {?}\n     * @private\n     */\n    GestureConfig.prototype._hammerOptions;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/line/line.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Shared directive to count lines inside a text area, such as a list item.\n * Line elements can be extracted with a \\@ContentChildren(MatLine) query, then\n * counted by checking the query list's length.\n */\nclass MatLine {\n}\nMatLine.ɵfac = function MatLine_Factory(t) { return new (t || MatLine)(); };\nMatLine.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatLine, selectors: [[\"\", \"mat-line\", \"\"], [\"\", \"matLine\", \"\"]], hostAttrs: [1, \"mat-line\"] });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatLine, [{\n        type: Directive,\n        args: [{\n                selector: '[mat-line], [matLine]',\n                host: { 'class': 'mat-line' }\n            }]\n    }], null, null); })();\n/**\n * Helper that takes a query list of lines and sets the correct class on the host.\n * \\@docs-private\n * @param {?} lines\n * @param {?} element\n * @param {?=} prefix\n * @return {?}\n */\nfunction setLines(lines, element, prefix = 'mat') {\n    // Note: doesn't need to unsubscribe, because `changes`\n    // gets completed by Angular when the view is destroyed.\n    lines.changes.pipe(startWith(lines)).subscribe((/**\n     * @param {?} __0\n     * @return {?}\n     */\n    ({ length }) => {\n        setClass(element, `${prefix}-2-line`, false);\n        setClass(element, `${prefix}-3-line`, false);\n        setClass(element, `${prefix}-multi-line`, false);\n        if (length === 2 || length === 3) {\n            setClass(element, `${prefix}-${length}-line`, true);\n        }\n        else if (length > 3) {\n            setClass(element, `${prefix}-multi-line`, true);\n        }\n    }));\n}\n/**\n * Adds or removes a class from an element.\n * @param {?} element\n * @param {?} className\n * @param {?} isAdd\n * @return {?}\n */\nfunction setClass(element, className, isAdd) {\n    /** @type {?} */\n    const classList = element.nativeElement.classList;\n    isAdd ? classList.add(className) : classList.remove(className);\n}\n/**\n * Helper that takes a query list of lines and sets the correct class on the host.\n * \\@docs-private\n * @deprecated Use `setLines` instead.\n * \\@breaking-change 8.0.0\n */\nclass MatLineSetter {\n    /**\n     * @param {?} lines\n     * @param {?} element\n     */\n    constructor(lines, element) {\n        setLines(lines, element);\n    }\n}\nclass MatLineModule {\n}\nMatLineModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: MatLineModule });\nMatLineModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function MatLineModule_Factory(t) { return new (t || MatLineModule)(); }, imports: [[MatCommonModule],\n        MatCommonModule] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(MatLineModule, { declarations: [MatLine], imports: [MatCommonModule], exports: [MatLine,\n        MatCommonModule] }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatLineModule, [{\n        type: NgModule,\n        args: [{\n                imports: [MatCommonModule],\n                exports: [MatLine, MatCommonModule],\n                declarations: [MatLine]\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/ripple/ripple-ref.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/** @enum {number} */\nconst RippleState = {\n    FADING_IN: 0, VISIBLE: 1, FADING_OUT: 2, HIDDEN: 3,\n};\n/**\n * Reference to a previously launched ripple element.\n */\nclass RippleRef {\n    /**\n     * @param {?} _renderer\n     * @param {?} element\n     * @param {?} config\n     */\n    constructor(_renderer, element, config) {\n        this._renderer = _renderer;\n        this.element = element;\n        this.config = config;\n        /**\n         * Current state of the ripple.\n         */\n        this.state = 3 /* HIDDEN */;\n    }\n    /**\n     * Fades out the ripple element.\n     * @return {?}\n     */\n    fadeOut() {\n        this._renderer.fadeOutRipple(this);\n    }\n}\nif (false) {\n    /**\n     * Current state of the ripple.\n     * @type {?}\n     */\n    RippleRef.prototype.state;\n    /**\n     * @type {?}\n     * @private\n     */\n    RippleRef.prototype._renderer;\n    /**\n     * Reference to the ripple HTML element.\n     * @type {?}\n     */\n    RippleRef.prototype.element;\n    /**\n     * Ripple configuration used for the ripple.\n     * @type {?}\n     */\n    RippleRef.prototype.config;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/ripple/ripple-renderer.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Interface that describes the configuration for the animation of a ripple.\n * There are two animation phases with different durations for the ripples.\n * @record\n */\nfunction RippleAnimationConfig() { }\nif (false) {\n    /**\n     * Duration in milliseconds for the enter animation (expansion from point of contact).\n     * @type {?|undefined}\n     */\n    RippleAnimationConfig.prototype.enterDuration;\n    /**\n     * Duration in milliseconds for the exit animation (fade-out).\n     * @type {?|undefined}\n     */\n    RippleAnimationConfig.prototype.exitDuration;\n}\n/**\n * Interface that describes the target for launching ripples.\n * It defines the ripple configuration and disabled state for interaction ripples.\n * \\@docs-private\n * @record\n */\nfunction RippleTarget() { }\nif (false) {\n    /**\n     * Configuration for ripples that are launched on pointer down.\n     * @type {?}\n     */\n    RippleTarget.prototype.rippleConfig;\n    /**\n     * Whether ripples on pointer down should be disabled.\n     * @type {?}\n     */\n    RippleTarget.prototype.rippleDisabled;\n}\n/**\n * Default ripple animation configuration for ripples without an explicit\n * animation config specified.\n * @type {?}\n */\nconst defaultRippleAnimationConfig = {\n    enterDuration: 450,\n    exitDuration: 400\n};\n/**\n * Timeout for ignoring mouse events. Mouse events will be temporary ignored after touch\n * events to avoid synthetic mouse events.\n * @type {?}\n */\nconst ignoreMouseEventsTimeout = 800;\n/**\n * Options that apply to all the event listeners that are bound by the ripple renderer.\n * @type {?}\n */\nconst passiveEventOptions = normalizePassiveListenerOptions({ passive: true });\n/**\n * Events that signal that the pointer is down.\n * @type {?}\n */\nconst pointerDownEvents = ['mousedown', 'touchstart'];\n/**\n * Events that signal that the pointer is up.\n * @type {?}\n */\nconst pointerUpEvents = ['mouseup', 'mouseleave', 'touchend', 'touchcancel'];\n/**\n * Helper service that performs DOM manipulations. Not intended to be used outside this module.\n * The constructor takes a reference to the ripple directive's host element and a map of DOM\n * event handlers to be installed on the element that triggers ripple animations.\n * This will eventually become a custom renderer once Angular support exists.\n * \\@docs-private\n */\nclass RippleRenderer {\n    /**\n     * @param {?} _target\n     * @param {?} _ngZone\n     * @param {?} elementOrElementRef\n     * @param {?} platform\n     */\n    constructor(_target, _ngZone, elementOrElementRef, platform) {\n        this._target = _target;\n        this._ngZone = _ngZone;\n        /**\n         * Whether the pointer is currently down or not.\n         */\n        this._isPointerDown = false;\n        /**\n         * Set of currently active ripple references.\n         */\n        this._activeRipples = new Set();\n        /**\n         * Whether pointer-up event listeners have been registered.\n         */\n        this._pointerUpEventsRegistered = false;\n        // Only do anything if we're on the browser.\n        if (platform.isBrowser) {\n            this._containerElement = coerceElement(elementOrElementRef);\n        }\n    }\n    /**\n     * Fades in a ripple at the given coordinates.\n     * @param {?} x Coordinate within the element, along the X axis at which to start the ripple.\n     * @param {?} y Coordinate within the element, along the Y axis at which to start the ripple.\n     * @param {?=} config Extra ripple options.\n     * @return {?}\n     */\n    fadeInRipple(x, y, config = {}) {\n        /** @type {?} */\n        const containerRect = this._containerRect =\n            this._containerRect || this._containerElement.getBoundingClientRect();\n        /** @type {?} */\n        const animationConfig = Object.assign(Object.assign({}, defaultRippleAnimationConfig), config.animation);\n        if (config.centered) {\n            x = containerRect.left + containerRect.width / 2;\n            y = containerRect.top + containerRect.height / 2;\n        }\n        /** @type {?} */\n        const radius = config.radius || distanceToFurthestCorner(x, y, containerRect);\n        /** @type {?} */\n        const offsetX = x - containerRect.left;\n        /** @type {?} */\n        const offsetY = y - containerRect.top;\n        /** @type {?} */\n        const duration = animationConfig.enterDuration;\n        /** @type {?} */\n        const ripple = document.createElement('div');\n        ripple.classList.add('mat-ripple-element');\n        ripple.style.left = `${offsetX - radius}px`;\n        ripple.style.top = `${offsetY - radius}px`;\n        ripple.style.height = `${radius * 2}px`;\n        ripple.style.width = `${radius * 2}px`;\n        // If a custom color has been specified, set it as inline style. If no color is\n        // set, the default color will be applied through the ripple theme styles.\n        if (config.color != null) {\n            ripple.style.backgroundColor = config.color;\n        }\n        ripple.style.transitionDuration = `${duration}ms`;\n        this._containerElement.appendChild(ripple);\n        // By default the browser does not recalculate the styles of dynamically created\n        // ripple elements. This is critical because then the `scale` would not animate properly.\n        enforceStyleRecalculation(ripple);\n        ripple.style.transform = 'scale(1)';\n        // Exposed reference to the ripple that will be returned.\n        /** @type {?} */\n        const rippleRef = new RippleRef(this, ripple, config);\n        rippleRef.state = 0 /* FADING_IN */;\n        // Add the ripple reference to the list of all active ripples.\n        this._activeRipples.add(rippleRef);\n        if (!config.persistent) {\n            this._mostRecentTransientRipple = rippleRef;\n        }\n        // Wait for the ripple element to be completely faded in.\n        // Once it's faded in, the ripple can be hidden immediately if the mouse is released.\n        this._runTimeoutOutsideZone((/**\n         * @return {?}\n         */\n        () => {\n            /** @type {?} */\n            const isMostRecentTransientRipple = rippleRef === this._mostRecentTransientRipple;\n            rippleRef.state = 1 /* VISIBLE */;\n            // When the timer runs out while the user has kept their pointer down, we want to\n            // keep only the persistent ripples and the latest transient ripple. We do this,\n            // because we don't want stacked transient ripples to appear after their enter\n            // animation has finished.\n            if (!config.persistent && (!isMostRecentTransientRipple || !this._isPointerDown)) {\n                rippleRef.fadeOut();\n            }\n        }), duration);\n        return rippleRef;\n    }\n    /**\n     * Fades out a ripple reference.\n     * @param {?} rippleRef\n     * @return {?}\n     */\n    fadeOutRipple(rippleRef) {\n        /** @type {?} */\n        const wasActive = this._activeRipples.delete(rippleRef);\n        if (rippleRef === this._mostRecentTransientRipple) {\n            this._mostRecentTransientRipple = null;\n        }\n        // Clear out the cached bounding rect if we have no more ripples.\n        if (!this._activeRipples.size) {\n            this._containerRect = null;\n        }\n        // For ripples that are not active anymore, don't re-run the fade-out animation.\n        if (!wasActive) {\n            return;\n        }\n        /** @type {?} */\n        const rippleEl = rippleRef.element;\n        /** @type {?} */\n        const animationConfig = Object.assign(Object.assign({}, defaultRippleAnimationConfig), rippleRef.config.animation);\n        rippleEl.style.transitionDuration = `${animationConfig.exitDuration}ms`;\n        rippleEl.style.opacity = '0';\n        rippleRef.state = 2 /* FADING_OUT */;\n        // Once the ripple faded out, the ripple can be safely removed from the DOM.\n        this._runTimeoutOutsideZone((/**\n         * @return {?}\n         */\n        () => {\n            rippleRef.state = 3 /* HIDDEN */;\n            (/** @type {?} */ (rippleEl.parentNode)).removeChild(rippleEl);\n        }), animationConfig.exitDuration);\n    }\n    /**\n     * Fades out all currently active ripples.\n     * @return {?}\n     */\n    fadeOutAll() {\n        this._activeRipples.forEach((/**\n         * @param {?} ripple\n         * @return {?}\n         */\n        ripple => ripple.fadeOut()));\n    }\n    /**\n     * Sets up the trigger event listeners\n     * @param {?} elementOrElementRef\n     * @return {?}\n     */\n    setupTriggerEvents(elementOrElementRef) {\n        /** @type {?} */\n        const element = coerceElement(elementOrElementRef);\n        if (!element || element === this._triggerElement) {\n            return;\n        }\n        // Remove all previously registered event listeners from the trigger element.\n        this._removeTriggerEvents();\n        this._triggerElement = element;\n        this._registerEvents(pointerDownEvents);\n    }\n    /**\n     * Handles all registered events.\n     * \\@docs-private\n     * @param {?} event\n     * @return {?}\n     */\n    handleEvent(event) {\n        if (event.type === 'mousedown') {\n            this._onMousedown((/** @type {?} */ (event)));\n        }\n        else if (event.type === 'touchstart') {\n            this._onTouchStart((/** @type {?} */ (event)));\n        }\n        else {\n            this._onPointerUp();\n        }\n        // If pointer-up events haven't been registered yet, do so now.\n        // We do this on-demand in order to reduce the total number of event listeners\n        // registered by the ripples, which speeds up the rendering time for large UIs.\n        if (!this._pointerUpEventsRegistered) {\n            this._registerEvents(pointerUpEvents);\n            this._pointerUpEventsRegistered = true;\n        }\n    }\n    /**\n     * Function being called whenever the trigger is being pressed using mouse.\n     * @private\n     * @param {?} event\n     * @return {?}\n     */\n    _onMousedown(event) {\n        // Screen readers will fire fake mouse events for space/enter. Skip launching a\n        // ripple in this case for consistency with the non-screen-reader experience.\n        /** @type {?} */\n        const isFakeMousedown = isFakeMousedownFromScreenReader(event);\n        /** @type {?} */\n        const isSyntheticEvent = this._lastTouchStartEvent &&\n            Date.now() < this._lastTouchStartEvent + ignoreMouseEventsTimeout;\n        if (!this._target.rippleDisabled && !isFakeMousedown && !isSyntheticEvent) {\n            this._isPointerDown = true;\n            this.fadeInRipple(event.clientX, event.clientY, this._target.rippleConfig);\n        }\n    }\n    /**\n     * Function being called whenever the trigger is being pressed using touch.\n     * @private\n     * @param {?} event\n     * @return {?}\n     */\n    _onTouchStart(event) {\n        if (!this._target.rippleDisabled) {\n            // Some browsers fire mouse events after a `touchstart` event. Those synthetic mouse\n            // events will launch a second ripple if we don't ignore mouse events for a specific\n            // time after a touchstart event.\n            this._lastTouchStartEvent = Date.now();\n            this._isPointerDown = true;\n            // Use `changedTouches` so we skip any touches where the user put\n            // their finger down, but used another finger to tap the element again.\n            /** @type {?} */\n            const touches = event.changedTouches;\n            for (let i = 0; i < touches.length; i++) {\n                this.fadeInRipple(touches[i].clientX, touches[i].clientY, this._target.rippleConfig);\n            }\n        }\n    }\n    /**\n     * Function being called whenever the trigger is being released.\n     * @private\n     * @return {?}\n     */\n    _onPointerUp() {\n        if (!this._isPointerDown) {\n            return;\n        }\n        this._isPointerDown = false;\n        // Fade-out all ripples that are visible and not persistent.\n        this._activeRipples.forEach((/**\n         * @param {?} ripple\n         * @return {?}\n         */\n        ripple => {\n            // By default, only ripples that are completely visible will fade out on pointer release.\n            // If the `terminateOnPointerUp` option is set, ripples that still fade in will also fade out.\n            /** @type {?} */\n            const isVisible = ripple.state === 1 /* VISIBLE */ ||\n                ripple.config.terminateOnPointerUp && ripple.state === 0 /* FADING_IN */;\n            if (!ripple.config.persistent && isVisible) {\n                ripple.fadeOut();\n            }\n        }));\n    }\n    /**\n     * Runs a timeout outside of the Angular zone to avoid triggering the change detection.\n     * @private\n     * @param {?} fn\n     * @param {?=} delay\n     * @return {?}\n     */\n    _runTimeoutOutsideZone(fn, delay = 0) {\n        this._ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => setTimeout(fn, delay)));\n    }\n    /**\n     * Registers event listeners for a given list of events.\n     * @private\n     * @param {?} eventTypes\n     * @return {?}\n     */\n    _registerEvents(eventTypes) {\n        this._ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => {\n            eventTypes.forEach((/**\n             * @param {?} type\n             * @return {?}\n             */\n            (type) => {\n                (/** @type {?} */ (this._triggerElement)).addEventListener(type, this, passiveEventOptions);\n            }));\n        }));\n    }\n    /**\n     * Removes previously registered event listeners from the trigger element.\n     * @return {?}\n     */\n    _removeTriggerEvents() {\n        if (this._triggerElement) {\n            pointerDownEvents.forEach((/**\n             * @param {?} type\n             * @return {?}\n             */\n            (type) => {\n                (/** @type {?} */ (this._triggerElement)).removeEventListener(type, this, passiveEventOptions);\n            }));\n            if (this._pointerUpEventsRegistered) {\n                pointerUpEvents.forEach((/**\n                 * @param {?} type\n                 * @return {?}\n                 */\n                (type) => {\n                    (/** @type {?} */ (this._triggerElement)).removeEventListener(type, this, passiveEventOptions);\n                }));\n            }\n        }\n    }\n}\nif (false) {\n    /**\n     * Element where the ripples are being added to.\n     * @type {?}\n     * @private\n     */\n    RippleRenderer.prototype._containerElement;\n    /**\n     * Element which triggers the ripple elements on mouse events.\n     * @type {?}\n     * @private\n     */\n    RippleRenderer.prototype._triggerElement;\n    /**\n     * Whether the pointer is currently down or not.\n     * @type {?}\n     * @private\n     */\n    RippleRenderer.prototype._isPointerDown;\n    /**\n     * Set of currently active ripple references.\n     * @type {?}\n     * @private\n     */\n    RippleRenderer.prototype._activeRipples;\n    /**\n     * Latest non-persistent ripple that was triggered.\n     * @type {?}\n     * @private\n     */\n    RippleRenderer.prototype._mostRecentTransientRipple;\n    /**\n     * Time in milliseconds when the last touchstart event happened.\n     * @type {?}\n     * @private\n     */\n    RippleRenderer.prototype._lastTouchStartEvent;\n    /**\n     * Whether pointer-up event listeners have been registered.\n     * @type {?}\n     * @private\n     */\n    RippleRenderer.prototype._pointerUpEventsRegistered;\n    /**\n     * Cached dimensions of the ripple container. Set when the first\n     * ripple is shown and cleared once no more ripples are visible.\n     * @type {?}\n     * @private\n     */\n    RippleRenderer.prototype._containerRect;\n    /**\n     * @type {?}\n     * @private\n     */\n    RippleRenderer.prototype._target;\n    /**\n     * @type {?}\n     * @private\n     */\n    RippleRenderer.prototype._ngZone;\n}\n/**\n * Enforces a style recalculation of a DOM element by computing its styles.\n * @param {?} element\n * @return {?}\n */\nfunction enforceStyleRecalculation(element) {\n    // Enforce a style recalculation by calling `getComputedStyle` and accessing any property.\n    // Calling `getPropertyValue` is important to let optimizers know that this is not a noop.\n    // See: https://gist.github.com/paulirish/5d52fb081b3570c81e3a\n    window.getComputedStyle(element).getPropertyValue('opacity');\n}\n/**\n * Returns the distance from the point (x, y) to the furthest corner of a rectangle.\n * @param {?} x\n * @param {?} y\n * @param {?} rect\n * @return {?}\n */\nfunction distanceToFurthestCorner(x, y, rect) {\n    /** @type {?} */\n    const distX = Math.max(Math.abs(x - rect.left), Math.abs(x - rect.right));\n    /** @type {?} */\n    const distY = Math.max(Math.abs(y - rect.top), Math.abs(y - rect.bottom));\n    return Math.sqrt(distX * distX + distY * distY);\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/ripple/ripple.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Configurable options for `matRipple`.\n * @record\n */\nfunction RippleGlobalOptions() { }\nif (false) {\n    /**\n     * Whether ripples should be disabled. Ripples can be still launched manually by using\n     * the `launch()` method. Therefore focus indicators will still show up.\n     * @type {?|undefined}\n     */\n    RippleGlobalOptions.prototype.disabled;\n    /**\n     * Configuration for the animation duration of the ripples. There are two phases with different\n     * durations for the ripples. The animation durations will be overwritten if the\n     * `NoopAnimationsModule` is being used.\n     * @type {?|undefined}\n     */\n    RippleGlobalOptions.prototype.animation;\n    /**\n     * Whether ripples should start fading out immediately after the mouse or touch is released. By\n     * default, ripples will wait for the enter animation to complete and for mouse or touch release.\n     * @type {?|undefined}\n     */\n    RippleGlobalOptions.prototype.terminateOnPointerUp;\n}\n/**\n * Injection token that can be used to specify the global ripple options.\n * @type {?}\n */\nconst MAT_RIPPLE_GLOBAL_OPTIONS = new InjectionToken('mat-ripple-global-options');\nclass MatRipple {\n    /**\n     * @param {?} _elementRef\n     * @param {?} ngZone\n     * @param {?} platform\n     * @param {?=} globalOptions\n     * @param {?=} _animationMode\n     */\n    constructor(_elementRef, ngZone, platform, globalOptions, _animationMode) {\n        this._elementRef = _elementRef;\n        this._animationMode = _animationMode;\n        /**\n         * If set, the radius in pixels of foreground ripples when fully expanded. If unset, the radius\n         * will be the distance from the center of the ripple to the furthest corner of the host element's\n         * bounding rectangle.\n         */\n        this.radius = 0;\n        this._disabled = false;\n        /**\n         * Whether ripple directive is initialized and the input bindings are set.\n         */\n        this._isInitialized = false;\n        this._globalOptions = globalOptions || {};\n        this._rippleRenderer = new RippleRenderer(this, ngZone, _elementRef, platform);\n    }\n    /**\n     * Whether click events will not trigger the ripple. Ripples can be still launched manually\n     * by using the `launch()` method.\n     * @return {?}\n     */\n    get disabled() { return this._disabled; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set disabled(value) {\n        this._disabled = value;\n        this._setupTriggerEventsIfEnabled();\n    }\n    /**\n     * The element that triggers the ripple when click events are received.\n     * Defaults to the directive's host element.\n     * @return {?}\n     */\n    get trigger() { return this._trigger || this._elementRef.nativeElement; }\n    /**\n     * @param {?} trigger\n     * @return {?}\n     */\n    set trigger(trigger) {\n        this._trigger = trigger;\n        this._setupTriggerEventsIfEnabled();\n    }\n    /**\n     * @return {?}\n     */\n    ngOnInit() {\n        this._isInitialized = true;\n        this._setupTriggerEventsIfEnabled();\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._rippleRenderer._removeTriggerEvents();\n    }\n    /**\n     * Fades out all currently showing ripple elements.\n     * @return {?}\n     */\n    fadeOutAll() {\n        this._rippleRenderer.fadeOutAll();\n    }\n    /**\n     * Ripple configuration from the directive's input values.\n     * \\@docs-private Implemented as part of RippleTarget\n     * @return {?}\n     */\n    get rippleConfig() {\n        return {\n            centered: this.centered,\n            radius: this.radius,\n            color: this.color,\n            animation: Object.assign(Object.assign(Object.assign({}, this._globalOptions.animation), (this._animationMode === 'NoopAnimations' ? { enterDuration: 0, exitDuration: 0 } : {})), this.animation),\n            terminateOnPointerUp: this._globalOptions.terminateOnPointerUp,\n        };\n    }\n    /**\n     * Whether ripples on pointer-down are disabled or not.\n     * \\@docs-private Implemented as part of RippleTarget\n     * @return {?}\n     */\n    get rippleDisabled() {\n        return this.disabled || !!this._globalOptions.disabled;\n    }\n    /**\n     * Sets up the trigger event listeners if ripples are enabled.\n     * @private\n     * @return {?}\n     */\n    _setupTriggerEventsIfEnabled() {\n        if (!this.disabled && this._isInitialized) {\n            this._rippleRenderer.setupTriggerEvents(this.trigger);\n        }\n    }\n    /**\n     * Launches a manual ripple at the specified coordinated or just by the ripple config.\n     * @param {?} configOrX\n     * @param {?=} y\n     * @param {?=} config\n     * @return {?}\n     */\n    launch(configOrX, y = 0, config) {\n        if (typeof configOrX === 'number') {\n            return this._rippleRenderer.fadeInRipple(configOrX, y, Object.assign(Object.assign({}, this.rippleConfig), config));\n        }\n        else {\n            return this._rippleRenderer.fadeInRipple(0, 0, Object.assign(Object.assign({}, this.rippleConfig), configOrX));\n        }\n    }\n}\nMatRipple.ɵfac = function MatRipple_Factory(t) { return new (t || MatRipple)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.Platform), ɵngcc0.ɵɵdirectiveInject(MAT_RIPPLE_GLOBAL_OPTIONS, 8), ɵngcc0.ɵɵdirectiveInject(ANIMATION_MODULE_TYPE, 8)); };\nMatRipple.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: MatRipple, selectors: [[\"\", \"mat-ripple\", \"\"], [\"\", \"matRipple\", \"\"]], hostAttrs: [1, \"mat-ripple\"], hostVars: 2, hostBindings: function MatRipple_HostBindings(rf, ctx) { if (rf & 2) {\n        ɵngcc0.ɵɵclassProp(\"mat-ripple-unbounded\", ctx.unbounded);\n    } }, inputs: { radius: [\"matRippleRadius\", \"radius\"], disabled: [\"matRippleDisabled\", \"disabled\"], trigger: [\"matRippleTrigger\", \"trigger\"], color: [\"matRippleColor\", \"color\"], unbounded: [\"matRippleUnbounded\", \"unbounded\"], centered: [\"matRippleCentered\", \"centered\"], animation: [\"matRippleAnimation\", \"animation\"] }, exportAs: [\"matRipple\"] });\n/** @nocollapse */\nMatRipple.ctorParameters = () => [\n    { type: ElementRef },\n    { type: NgZone },\n    { type: Platform },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_RIPPLE_GLOBAL_OPTIONS,] }] },\n    { type: String, decorators: [{ type: Optional }, { type: Inject, args: [ANIMATION_MODULE_TYPE,] }] }\n];\nMatRipple.propDecorators = {\n    color: [{ type: Input, args: ['matRippleColor',] }],\n    unbounded: [{ type: Input, args: ['matRippleUnbounded',] }],\n    centered: [{ type: Input, args: ['matRippleCentered',] }],\n    radius: [{ type: Input, args: ['matRippleRadius',] }],\n    animation: [{ type: Input, args: ['matRippleAnimation',] }],\n    disabled: [{ type: Input, args: ['matRippleDisabled',] }],\n    trigger: [{ type: Input, args: ['matRippleTrigger',] }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatRipple, [{\n        type: Directive,\n        args: [{\n                selector: '[mat-ripple], [matRipple]',\n                exportAs: 'matRipple',\n                host: {\n                    'class': 'mat-ripple',\n                    '[class.mat-ripple-unbounded]': 'unbounded'\n                }\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: ɵngcc0.NgZone }, { type: ɵngcc2.Platform }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MAT_RIPPLE_GLOBAL_OPTIONS]\n            }] }, { type: String, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [ANIMATION_MODULE_TYPE]\n            }] }]; }, { radius: [{\n            type: Input,\n            args: ['matRippleRadius']\n        }], disabled: [{\n            type: Input,\n            args: ['matRippleDisabled']\n        }], trigger: [{\n            type: Input,\n            args: ['matRippleTrigger']\n        }], color: [{\n            type: Input,\n            args: ['matRippleColor']\n        }], unbounded: [{\n            type: Input,\n            args: ['matRippleUnbounded']\n        }], centered: [{\n            type: Input,\n            args: ['matRippleCentered']\n        }], animation: [{\n            type: Input,\n            args: ['matRippleAnimation']\n        }] }); })();\nif (false) {\n    /**\n     * Custom color for all ripples.\n     * @type {?}\n     */\n    MatRipple.prototype.color;\n    /**\n     * Whether the ripples should be visible outside the component's bounds.\n     * @type {?}\n     */\n    MatRipple.prototype.unbounded;\n    /**\n     * Whether the ripple always originates from the center of the host element's bounds, rather\n     * than originating from the location of the click event.\n     * @type {?}\n     */\n    MatRipple.prototype.centered;\n    /**\n     * If set, the radius in pixels of foreground ripples when fully expanded. If unset, the radius\n     * will be the distance from the center of the ripple to the furthest corner of the host element's\n     * bounding rectangle.\n     * @type {?}\n     */\n    MatRipple.prototype.radius;\n    /**\n     * Configuration for the ripple animation. Allows modifying the enter and exit animation\n     * duration of the ripples. The animation durations will be overwritten if the\n     * `NoopAnimationsModule` is being used.\n     * @type {?}\n     */\n    MatRipple.prototype.animation;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatRipple.prototype._disabled;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatRipple.prototype._trigger;\n    /**\n     * Renderer for the ripple DOM manipulations.\n     * @type {?}\n     * @private\n     */\n    MatRipple.prototype._rippleRenderer;\n    /**\n     * Options that are set globally for all ripples.\n     * @type {?}\n     * @private\n     */\n    MatRipple.prototype._globalOptions;\n    /**\n     * Whether ripple directive is initialized and the input bindings are set.\n     * @type {?}\n     * @private\n     */\n    MatRipple.prototype._isInitialized;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatRipple.prototype._elementRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatRipple.prototype._animationMode;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/ripple/index.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass MatRippleModule {\n}\nMatRippleModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: MatRippleModule });\nMatRippleModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function MatRippleModule_Factory(t) { return new (t || MatRippleModule)(); }, imports: [[MatCommonModule, PlatformModule],\n        MatCommonModule] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(MatRippleModule, { declarations: function () { return [MatRipple]; }, imports: function () { return [MatCommonModule,\n        PlatformModule]; }, exports: function () { return [MatRipple,\n        MatCommonModule]; } }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatRippleModule, [{\n        type: NgModule,\n        args: [{\n                imports: [MatCommonModule, PlatformModule],\n                exports: [MatRipple, MatCommonModule],\n                declarations: [MatRipple]\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/selection/pseudo-checkbox/pseudo-checkbox.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Component that shows a simplified checkbox without including any kind of \"real\" checkbox.\n * Meant to be used when the checkbox is purely decorative and a large number of them will be\n * included, such as for the options in a multi-select. Uses no SVGs or complex animations.\n * Note that theming is meant to be handled by the parent element, e.g.\n * `mat-primary .mat-pseudo-checkbox`.\n *\n * Note that this component will be completely invisible to screen-reader users. This is *not*\n * interchangeable with `<mat-checkbox>` and should *not* be used if the user would directly\n * interact with the checkbox. The pseudo-checkbox should only be used as an implementation detail\n * of more complex components that appropriately handle selected / checked state.\n * \\@docs-private\n */\nclass MatPseudoCheckbox {\n    /**\n     * @param {?=} _animationMode\n     */\n    constructor(_animationMode) {\n        this._animationMode = _animationMode;\n        /**\n         * Display state of the checkbox.\n         */\n        this.state = 'unchecked';\n        /**\n         * Whether the checkbox is disabled.\n         */\n        this.disabled = false;\n    }\n}\nMatPseudoCheckbox.ɵfac = function MatPseudoCheckbox_Factory(t) { return new (t || MatPseudoCheckbox)(ɵngcc0.ɵɵdirectiveInject(ANIMATION_MODULE_TYPE, 8)); };\nMatPseudoCheckbox.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatPseudoCheckbox, selectors: [[\"mat-pseudo-checkbox\"]], hostAttrs: [1, \"mat-pseudo-checkbox\"], hostVars: 8, hostBindings: function MatPseudoCheckbox_HostBindings(rf, ctx) { if (rf & 2) {\n        ɵngcc0.ɵɵclassProp(\"mat-pseudo-checkbox-indeterminate\", ctx.state === \"indeterminate\")(\"mat-pseudo-checkbox-checked\", ctx.state === \"checked\")(\"mat-pseudo-checkbox-disabled\", ctx.disabled)(\"_mat-animation-noopable\", ctx._animationMode === \"NoopAnimations\");\n    } }, inputs: { state: \"state\", disabled: \"disabled\" }, decls: 0, vars: 0, template: function MatPseudoCheckbox_Template(rf, ctx) { }, styles: [\".mat-pseudo-checkbox{width:16px;height:16px;border:2px solid;border-radius:2px;cursor:pointer;display:inline-block;vertical-align:middle;box-sizing:border-box;position:relative;flex-shrink:0;transition:border-color 90ms cubic-bezier(0, 0, 0.2, 0.1),background-color 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox::after{position:absolute;opacity:0;content:\\\"\\\";border-bottom:2px solid currentColor;transition:opacity 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox.mat-pseudo-checkbox-checked,.mat-pseudo-checkbox.mat-pseudo-checkbox-indeterminate{border-color:transparent}._mat-animation-noopable.mat-pseudo-checkbox{transition:none;animation:none}._mat-animation-noopable.mat-pseudo-checkbox::after{transition:none}.mat-pseudo-checkbox-disabled{cursor:default}.mat-pseudo-checkbox-indeterminate::after{top:5px;left:1px;width:10px;opacity:1;border-radius:2px}.mat-pseudo-checkbox-checked::after{top:2.4px;left:1px;width:8px;height:3px;border-left:2px solid currentColor;transform:rotate(-45deg);opacity:1;box-sizing:content-box}\\n\"], encapsulation: 2, changeDetection: 0 });\n/** @nocollapse */\nMatPseudoCheckbox.ctorParameters = () => [\n    { type: String, decorators: [{ type: Optional }, { type: Inject, args: [ANIMATION_MODULE_TYPE,] }] }\n];\nMatPseudoCheckbox.propDecorators = {\n    state: [{ type: Input }],\n    disabled: [{ type: Input }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatPseudoCheckbox, [{\n        type: Component,\n        args: [{\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush,\n                selector: 'mat-pseudo-checkbox',\n                template: '',\n                host: {\n                    'class': 'mat-pseudo-checkbox',\n                    '[class.mat-pseudo-checkbox-indeterminate]': 'state === \"indeterminate\"',\n                    '[class.mat-pseudo-checkbox-checked]': 'state === \"checked\"',\n                    '[class.mat-pseudo-checkbox-disabled]': 'disabled',\n                    '[class._mat-animation-noopable]': '_animationMode === \"NoopAnimations\"'\n                },\n                styles: [\".mat-pseudo-checkbox{width:16px;height:16px;border:2px solid;border-radius:2px;cursor:pointer;display:inline-block;vertical-align:middle;box-sizing:border-box;position:relative;flex-shrink:0;transition:border-color 90ms cubic-bezier(0, 0, 0.2, 0.1),background-color 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox::after{position:absolute;opacity:0;content:\\\"\\\";border-bottom:2px solid currentColor;transition:opacity 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox.mat-pseudo-checkbox-checked,.mat-pseudo-checkbox.mat-pseudo-checkbox-indeterminate{border-color:transparent}._mat-animation-noopable.mat-pseudo-checkbox{transition:none;animation:none}._mat-animation-noopable.mat-pseudo-checkbox::after{transition:none}.mat-pseudo-checkbox-disabled{cursor:default}.mat-pseudo-checkbox-indeterminate::after{top:5px;left:1px;width:10px;opacity:1;border-radius:2px}.mat-pseudo-checkbox-checked::after{top:2.4px;left:1px;width:8px;height:3px;border-left:2px solid currentColor;transform:rotate(-45deg);opacity:1;box-sizing:content-box}\\n\"]\n            }]\n    }], function () { return [{ type: String, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [ANIMATION_MODULE_TYPE]\n            }] }]; }, { state: [{\n            type: Input\n        }], disabled: [{\n            type: Input\n        }] }); })();\nif (false) {\n    /**\n     * Display state of the checkbox.\n     * @type {?}\n     */\n    MatPseudoCheckbox.prototype.state;\n    /**\n     * Whether the checkbox is disabled.\n     * @type {?}\n     */\n    MatPseudoCheckbox.prototype.disabled;\n    /** @type {?} */\n    MatPseudoCheckbox.prototype._animationMode;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/selection/index.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass MatPseudoCheckboxModule {\n}\nMatPseudoCheckboxModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: MatPseudoCheckboxModule });\nMatPseudoCheckboxModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function MatPseudoCheckboxModule_Factory(t) { return new (t || MatPseudoCheckboxModule)(); } });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(MatPseudoCheckboxModule, { declarations: [MatPseudoCheckbox], exports: [MatPseudoCheckbox] }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatPseudoCheckboxModule, [{\n        type: NgModule,\n        args: [{\n                exports: [MatPseudoCheckbox],\n                declarations: [MatPseudoCheckbox]\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/option/optgroup.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n// Boilerplate for applying mixins to MatOptgroup.\n/**\n * \\@docs-private\n */\nclass MatOptgroupBase {\n}\n/** @type {?} */\nconst _MatOptgroupMixinBase = mixinDisabled(MatOptgroupBase);\n// Counter for unique group ids.\n/** @type {?} */\nlet _uniqueOptgroupIdCounter = 0;\n/**\n * Component that is used to group instances of `mat-option`.\n */\nclass MatOptgroup extends _MatOptgroupMixinBase {\n    constructor() {\n        super(...arguments);\n        /**\n         * Unique id for the underlying label.\n         */\n        this._labelId = `mat-optgroup-label-${_uniqueOptgroupIdCounter++}`;\n    }\n}\nMatOptgroup.ɵfac = function MatOptgroup_Factory(t) { return ɵMatOptgroup_BaseFactory(t || MatOptgroup); };\nMatOptgroup.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatOptgroup, selectors: [[\"mat-optgroup\"]], hostAttrs: [\"role\", \"group\", 1, \"mat-optgroup\"], hostVars: 4, hostBindings: function MatOptgroup_HostBindings(rf, ctx) { if (rf & 2) {\n        ɵngcc0.ɵɵattribute(\"aria-disabled\", ctx.disabled.toString())(\"aria-labelledby\", ctx._labelId);\n        ɵngcc0.ɵɵclassProp(\"mat-optgroup-disabled\", ctx.disabled);\n    } }, inputs: { disabled: \"disabled\", label: \"label\" }, exportAs: [\"matOptgroup\"], features: [ɵngcc0.ɵɵInheritDefinitionFeature], ngContentSelectors: _c1, decls: 4, vars: 2, consts: [[1, \"mat-optgroup-label\", 3, \"id\"]], template: function MatOptgroup_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵprojectionDef(_c0);\n        ɵngcc0.ɵɵelementStart(0, \"label\", 0);\n        ɵngcc0.ɵɵtext(1);\n        ɵngcc0.ɵɵprojection(2);\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵprojection(3, 1);\n    } if (rf & 2) {\n        ɵngcc0.ɵɵproperty(\"id\", ctx._labelId);\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵtextInterpolate1(\"\", ctx.label, \" \");\n    } }, styles: [\".mat-optgroup-label{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;line-height:48px;height:48px;padding:0 16px;text-align:left;text-decoration:none;max-width:100%;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:default}.mat-optgroup-label[disabled]{cursor:default}[dir=rtl] .mat-optgroup-label{text-align:right}.mat-optgroup-label .mat-icon{margin-right:16px;vertical-align:middle}.mat-optgroup-label .mat-icon svg{vertical-align:top}[dir=rtl] .mat-optgroup-label .mat-icon{margin-left:16px;margin-right:0}\\n\"], encapsulation: 2, changeDetection: 0 });\nMatOptgroup.propDecorators = {\n    label: [{ type: Input }]\n};\nconst ɵMatOptgroup_BaseFactory = ɵngcc0.ɵɵgetInheritedFactory(MatOptgroup);\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatOptgroup, [{\n        type: Component,\n        args: [{\n                selector: 'mat-optgroup',\n                exportAs: 'matOptgroup',\n                template: \"<label class=\\\"mat-optgroup-label\\\" [id]=\\\"_labelId\\\">{{ label }} <ng-content></ng-content></label>\\n<ng-content select=\\\"mat-option, ng-container\\\"></ng-content>\\n\",\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush,\n                inputs: ['disabled'],\n                host: {\n                    'class': 'mat-optgroup',\n                    'role': 'group',\n                    '[class.mat-optgroup-disabled]': 'disabled',\n                    '[attr.aria-disabled]': 'disabled.toString()',\n                    '[attr.aria-labelledby]': '_labelId'\n                },\n                styles: [\".mat-optgroup-label{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;line-height:48px;height:48px;padding:0 16px;text-align:left;text-decoration:none;max-width:100%;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:default}.mat-optgroup-label[disabled]{cursor:default}[dir=rtl] .mat-optgroup-label{text-align:right}.mat-optgroup-label .mat-icon{margin-right:16px;vertical-align:middle}.mat-optgroup-label .mat-icon svg{vertical-align:top}[dir=rtl] .mat-optgroup-label .mat-icon{margin-left:16px;margin-right:0}\\n\"]\n            }]\n    }], null, { label: [{\n            type: Input\n        }] }); })();\nif (false) {\n    /** @type {?} */\n    MatOptgroup.ngAcceptInputType_disabled;\n    /**\n     * Label for the option group.\n     * @type {?}\n     */\n    MatOptgroup.prototype.label;\n    /**\n     * Unique id for the underlying label.\n     * @type {?}\n     */\n    MatOptgroup.prototype._labelId;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/option/option.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Option IDs need to be unique across components, so this counter exists outside of\n * the component definition.\n * @type {?}\n */\nlet _uniqueIdCounter = 0;\n/**\n * Event object emitted by MatOption when selected or deselected.\n */\nclass MatOptionSelectionChange {\n    /**\n     * @param {?} source\n     * @param {?=} isUserInput\n     */\n    constructor(source, isUserInput = false) {\n        this.source = source;\n        this.isUserInput = isUserInput;\n    }\n}\nif (false) {\n    /**\n     * Reference to the option that emitted the event.\n     * @type {?}\n     */\n    MatOptionSelectionChange.prototype.source;\n    /**\n     * Whether the change in the option's value was a result of a user action.\n     * @type {?}\n     */\n    MatOptionSelectionChange.prototype.isUserInput;\n}\n/**\n * Describes a parent component that manages a list of options.\n * Contains properties that the options can inherit.\n * \\@docs-private\n * @record\n */\nfunction MatOptionParentComponent() { }\nif (false) {\n    /** @type {?|undefined} */\n    MatOptionParentComponent.prototype.disableRipple;\n    /** @type {?|undefined} */\n    MatOptionParentComponent.prototype.multiple;\n}\n/**\n * Injection token used to provide the parent component to options.\n * @type {?}\n */\nconst MAT_OPTION_PARENT_COMPONENT = new InjectionToken('MAT_OPTION_PARENT_COMPONENT');\n/**\n * Single option inside of a `<mat-select>` element.\n */\nclass MatOption {\n    /**\n     * @param {?} _element\n     * @param {?} _changeDetectorRef\n     * @param {?} _parent\n     * @param {?} group\n     */\n    constructor(_element, _changeDetectorRef, _parent, group) {\n        this._element = _element;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._parent = _parent;\n        this.group = group;\n        this._selected = false;\n        this._active = false;\n        this._disabled = false;\n        this._mostRecentViewValue = '';\n        /**\n         * The unique ID of the option.\n         */\n        this.id = `mat-option-${_uniqueIdCounter++}`;\n        /**\n         * Event emitted when the option is selected or deselected.\n         */\n        // tslint:disable-next-line:no-output-on-prefix\n        this.onSelectionChange = new EventEmitter();\n        /**\n         * Emits when the state of the option changes and any parents have to be notified.\n         */\n        this._stateChanges = new Subject();\n    }\n    /**\n     * Whether the wrapping component is in multiple selection mode.\n     * @return {?}\n     */\n    get multiple() { return this._parent && this._parent.multiple; }\n    /**\n     * Whether or not the option is currently selected.\n     * @return {?}\n     */\n    get selected() { return this._selected; }\n    /**\n     * Whether the option is disabled.\n     * @return {?}\n     */\n    get disabled() { return (this.group && this.group.disabled) || this._disabled; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set disabled(value) { this._disabled = coerceBooleanProperty(value); }\n    /**\n     * Whether ripples for the option are disabled.\n     * @return {?}\n     */\n    get disableRipple() { return this._parent && this._parent.disableRipple; }\n    /**\n     * Whether or not the option is currently active and ready to be selected.\n     * An active option displays styles as if it is focused, but the\n     * focus is actually retained somewhere else. This comes in handy\n     * for components like autocomplete where focus must remain on the input.\n     * @return {?}\n     */\n    get active() {\n        return this._active;\n    }\n    /**\n     * The displayed value of the option. It is necessary to show the selected option in the\n     * select's trigger.\n     * @return {?}\n     */\n    get viewValue() {\n        // TODO(kara): Add input property alternative for node envs.\n        return (this._getHostElement().textContent || '').trim();\n    }\n    /**\n     * Selects the option.\n     * @return {?}\n     */\n    select() {\n        if (!this._selected) {\n            this._selected = true;\n            this._changeDetectorRef.markForCheck();\n            this._emitSelectionChangeEvent();\n        }\n    }\n    /**\n     * Deselects the option.\n     * @return {?}\n     */\n    deselect() {\n        if (this._selected) {\n            this._selected = false;\n            this._changeDetectorRef.markForCheck();\n            this._emitSelectionChangeEvent();\n        }\n    }\n    /**\n     * Sets focus onto this option.\n     * @param {?=} _origin\n     * @param {?=} options\n     * @return {?}\n     */\n    focus(_origin, options) {\n        // Note that we aren't using `_origin`, but we need to keep it because some internal consumers\n        // use `MatOption` in a `FocusKeyManager` and we need it to match `FocusableOption`.\n        /** @type {?} */\n        const element = this._getHostElement();\n        if (typeof element.focus === 'function') {\n            element.focus(options);\n        }\n    }\n    /**\n     * This method sets display styles on the option to make it appear\n     * active. This is used by the ActiveDescendantKeyManager so key\n     * events will display the proper options as active on arrow key events.\n     * @return {?}\n     */\n    setActiveStyles() {\n        if (!this._active) {\n            this._active = true;\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n    /**\n     * This method removes display styles on the option that made it appear\n     * active. This is used by the ActiveDescendantKeyManager so key\n     * events will display the proper options as active on arrow key events.\n     * @return {?}\n     */\n    setInactiveStyles() {\n        if (this._active) {\n            this._active = false;\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n    /**\n     * Gets the label to be used when determining whether the option should be focused.\n     * @return {?}\n     */\n    getLabel() {\n        return this.viewValue;\n    }\n    /**\n     * Ensures the option is selected when activated from the keyboard.\n     * @param {?} event\n     * @return {?}\n     */\n    _handleKeydown(event) {\n        if ((event.keyCode === ENTER || event.keyCode === SPACE) && !hasModifierKey(event)) {\n            this._selectViaInteraction();\n            // Prevent the page from scrolling down and form submits.\n            event.preventDefault();\n        }\n    }\n    /**\n     * `Selects the option while indicating the selection came from the user. Used to\n     * determine if the select's view -> model callback should be invoked.`\n     * @return {?}\n     */\n    _selectViaInteraction() {\n        if (!this.disabled) {\n            this._selected = this.multiple ? !this._selected : true;\n            this._changeDetectorRef.markForCheck();\n            this._emitSelectionChangeEvent(true);\n        }\n    }\n    /**\n     * Gets the `aria-selected` value for the option. We explicitly omit the `aria-selected`\n     * attribute from single-selection, unselected options. Including the `aria-selected=\"false\"`\n     * attributes adds a significant amount of noise to screen-reader users without providing useful\n     * information.\n     * @return {?}\n     */\n    _getAriaSelected() {\n        return this.selected || (this.multiple ? false : null);\n    }\n    /**\n     * Returns the correct tabindex for the option depending on disabled state.\n     * @return {?}\n     */\n    _getTabIndex() {\n        return this.disabled ? '-1' : '0';\n    }\n    /**\n     * Gets the host DOM element.\n     * @return {?}\n     */\n    _getHostElement() {\n        return this._element.nativeElement;\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterViewChecked() {\n        // Since parent components could be using the option's label to display the selected values\n        // (e.g. `mat-select`) and they don't have a way of knowing if the option's label has changed\n        // we have to check for changes in the DOM ourselves and dispatch an event. These checks are\n        // relatively cheap, however we still limit them only to selected options in order to avoid\n        // hitting the DOM too often.\n        if (this._selected) {\n            /** @type {?} */\n            const viewValue = this.viewValue;\n            if (viewValue !== this._mostRecentViewValue) {\n                this._mostRecentViewValue = viewValue;\n                this._stateChanges.next();\n            }\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._stateChanges.complete();\n    }\n    /**\n     * Emits the selection change event.\n     * @private\n     * @param {?=} isUserInput\n     * @return {?}\n     */\n    _emitSelectionChangeEvent(isUserInput = false) {\n        this.onSelectionChange.emit(new MatOptionSelectionChange(this, isUserInput));\n    }\n}\nMatOption.ɵfac = function MatOption_Factory(t) { return new (t || MatOption)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(MAT_OPTION_PARENT_COMPONENT, 8), ɵngcc0.ɵɵdirectiveInject(MatOptgroup, 8)); };\nMatOption.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MatOption, selectors: [[\"mat-option\"]], hostAttrs: [\"role\", \"option\", 1, \"mat-option\", \"mat-focus-indicator\"], hostVars: 12, hostBindings: function MatOption_HostBindings(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵlistener(\"click\", function MatOption_click_HostBindingHandler() { return ctx._selectViaInteraction(); })(\"keydown\", function MatOption_keydown_HostBindingHandler($event) { return ctx._handleKeydown($event); });\n    } if (rf & 2) {\n        ɵngcc0.ɵɵhostProperty(\"id\", ctx.id);\n        ɵngcc0.ɵɵattribute(\"tabindex\", ctx._getTabIndex())(\"aria-selected\", ctx._getAriaSelected())(\"aria-disabled\", ctx.disabled.toString());\n        ɵngcc0.ɵɵclassProp(\"mat-selected\", ctx.selected)(\"mat-option-multiple\", ctx.multiple)(\"mat-active\", ctx.active)(\"mat-option-disabled\", ctx.disabled);\n    } }, inputs: { id: \"id\", disabled: \"disabled\", value: \"value\" }, outputs: { onSelectionChange: \"onSelectionChange\" }, exportAs: [\"matOption\"], ngContentSelectors: _c2, decls: 4, vars: 3, consts: [[\"class\", \"mat-option-pseudo-checkbox\", 3, \"state\", \"disabled\", 4, \"ngIf\"], [1, \"mat-option-text\"], [\"mat-ripple\", \"\", 1, \"mat-option-ripple\", 3, \"matRippleTrigger\", \"matRippleDisabled\"], [1, \"mat-option-pseudo-checkbox\", 3, \"state\", \"disabled\"]], template: function MatOption_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵprojectionDef();\n        ɵngcc0.ɵɵtemplate(0, MatOption_mat_pseudo_checkbox_0_Template, 1, 2, \"mat-pseudo-checkbox\", 0);\n        ɵngcc0.ɵɵelementStart(1, \"span\", 1);\n        ɵngcc0.ɵɵprojection(2);\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelement(3, \"div\", 2);\n    } if (rf & 2) {\n        ɵngcc0.ɵɵproperty(\"ngIf\", ctx.multiple);\n        ɵngcc0.ɵɵadvance(3);\n        ɵngcc0.ɵɵproperty(\"matRippleTrigger\", ctx._getHostElement())(\"matRippleDisabled\", ctx.disabled || ctx.disableRipple);\n    } }, directives: [ɵngcc3.NgIf, MatRipple,\n        MatPseudoCheckbox], styles: [\".mat-option{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;line-height:48px;height:48px;padding:0 16px;text-align:left;text-decoration:none;max-width:100%;position:relative;cursor:pointer;outline:none;display:flex;flex-direction:row;max-width:100%;box-sizing:border-box;align-items:center;-webkit-tap-highlight-color:transparent}.mat-option[disabled]{cursor:default}[dir=rtl] .mat-option{text-align:right}.mat-option .mat-icon{margin-right:16px;vertical-align:middle}.mat-option .mat-icon svg{vertical-align:top}[dir=rtl] .mat-option .mat-icon{margin-left:16px;margin-right:0}.mat-option[aria-disabled=true]{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:default}.mat-optgroup .mat-option:not(.mat-option-multiple){padding-left:32px}[dir=rtl] .mat-optgroup .mat-option:not(.mat-option-multiple){padding-left:16px;padding-right:32px}.cdk-high-contrast-active .mat-option{margin:0 1px}.cdk-high-contrast-active .mat-option.mat-active{border:solid 1px currentColor;margin:0}.mat-option-text{display:inline-block;flex-grow:1;overflow:hidden;text-overflow:ellipsis}.mat-option .mat-option-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.cdk-high-contrast-active .mat-option .mat-option-ripple{opacity:.5}.mat-option-pseudo-checkbox{margin-right:8px}[dir=rtl] .mat-option-pseudo-checkbox{margin-left:8px;margin-right:0}\\n\"], encapsulation: 2, changeDetection: 0 });\n/** @nocollapse */\nMatOption.ctorParameters = () => [\n    { type: ElementRef },\n    { type: ChangeDetectorRef },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_OPTION_PARENT_COMPONENT,] }] },\n    { type: MatOptgroup, decorators: [{ type: Optional }] }\n];\nMatOption.propDecorators = {\n    value: [{ type: Input }],\n    id: [{ type: Input }],\n    disabled: [{ type: Input }],\n    onSelectionChange: [{ type: Output }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatOption, [{\n        type: Component,\n        args: [{\n                selector: 'mat-option',\n                exportAs: 'matOption',\n                host: {\n                    'role': 'option',\n                    '[attr.tabindex]': '_getTabIndex()',\n                    '[class.mat-selected]': 'selected',\n                    '[class.mat-option-multiple]': 'multiple',\n                    '[class.mat-active]': 'active',\n                    '[id]': 'id',\n                    '[attr.aria-selected]': '_getAriaSelected()',\n                    '[attr.aria-disabled]': 'disabled.toString()',\n                    '[class.mat-option-disabled]': 'disabled',\n                    '(click)': '_selectViaInteraction()',\n                    '(keydown)': '_handleKeydown($event)',\n                    'class': 'mat-option mat-focus-indicator'\n                },\n                template: \"<mat-pseudo-checkbox *ngIf=\\\"multiple\\\" class=\\\"mat-option-pseudo-checkbox\\\"\\n    [state]=\\\"selected ? 'checked' : 'unchecked'\\\" [disabled]=\\\"disabled\\\"></mat-pseudo-checkbox>\\n\\n<span class=\\\"mat-option-text\\\"><ng-content></ng-content></span>\\n\\n<div class=\\\"mat-option-ripple\\\" mat-ripple\\n     [matRippleTrigger]=\\\"_getHostElement()\\\"\\n     [matRippleDisabled]=\\\"disabled || disableRipple\\\">\\n</div>\\n\",\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush,\n                styles: [\".mat-option{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;line-height:48px;height:48px;padding:0 16px;text-align:left;text-decoration:none;max-width:100%;position:relative;cursor:pointer;outline:none;display:flex;flex-direction:row;max-width:100%;box-sizing:border-box;align-items:center;-webkit-tap-highlight-color:transparent}.mat-option[disabled]{cursor:default}[dir=rtl] .mat-option{text-align:right}.mat-option .mat-icon{margin-right:16px;vertical-align:middle}.mat-option .mat-icon svg{vertical-align:top}[dir=rtl] .mat-option .mat-icon{margin-left:16px;margin-right:0}.mat-option[aria-disabled=true]{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:default}.mat-optgroup .mat-option:not(.mat-option-multiple){padding-left:32px}[dir=rtl] .mat-optgroup .mat-option:not(.mat-option-multiple){padding-left:16px;padding-right:32px}.cdk-high-contrast-active .mat-option{margin:0 1px}.cdk-high-contrast-active .mat-option.mat-active{border:solid 1px currentColor;margin:0}.mat-option-text{display:inline-block;flex-grow:1;overflow:hidden;text-overflow:ellipsis}.mat-option .mat-option-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.cdk-high-contrast-active .mat-option .mat-option-ripple{opacity:.5}.mat-option-pseudo-checkbox{margin-right:8px}[dir=rtl] .mat-option-pseudo-checkbox{margin-left:8px;margin-right:0}\\n\"]\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: ɵngcc0.ChangeDetectorRef }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [MAT_OPTION_PARENT_COMPONENT]\n            }] }, { type: MatOptgroup, decorators: [{\n                type: Optional\n            }] }]; }, { id: [{\n            type: Input\n        }], onSelectionChange: [{\n            type: Output\n        }], disabled: [{\n            type: Input\n        }], value: [{\n            type: Input\n        }] }); })();\nif (false) {\n    /** @type {?} */\n    MatOption.ngAcceptInputType_disabled;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatOption.prototype._selected;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatOption.prototype._active;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatOption.prototype._disabled;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatOption.prototype._mostRecentViewValue;\n    /**\n     * The form value of the option.\n     * @type {?}\n     */\n    MatOption.prototype.value;\n    /**\n     * The unique ID of the option.\n     * @type {?}\n     */\n    MatOption.prototype.id;\n    /**\n     * Event emitted when the option is selected or deselected.\n     * @type {?}\n     */\n    MatOption.prototype.onSelectionChange;\n    /**\n     * Emits when the state of the option changes and any parents have to be notified.\n     * @type {?}\n     */\n    MatOption.prototype._stateChanges;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatOption.prototype._element;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatOption.prototype._changeDetectorRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    MatOption.prototype._parent;\n    /** @type {?} */\n    MatOption.prototype.group;\n}\n/**\n * Counts the amount of option group labels that precede the specified option.\n * \\@docs-private\n * @param {?} optionIndex Index of the option at which to start counting.\n * @param {?} options Flat list of all of the options.\n * @param {?} optionGroups Flat list of all of the option groups.\n * @return {?}\n */\nfunction _countGroupLabelsBeforeOption(optionIndex, options, optionGroups) {\n    if (optionGroups.length) {\n        /** @type {?} */\n        let optionsArray = options.toArray();\n        /** @type {?} */\n        let groups = optionGroups.toArray();\n        /** @type {?} */\n        let groupCounter = 0;\n        for (let i = 0; i < optionIndex + 1; i++) {\n            if (optionsArray[i].group && optionsArray[i].group === groups[groupCounter]) {\n                groupCounter++;\n            }\n        }\n        return groupCounter;\n    }\n    return 0;\n}\n/**\n * Determines the position to which to scroll a panel in order for an option to be into view.\n * \\@docs-private\n * @param {?} optionIndex Index of the option to be scrolled into the view.\n * @param {?} optionHeight Height of the options.\n * @param {?} currentScrollPosition Current scroll position of the panel.\n * @param {?} panelHeight Height of the panel.\n * @return {?}\n */\nfunction _getOptionScrollPosition(optionIndex, optionHeight, currentScrollPosition, panelHeight) {\n    /** @type {?} */\n    const optionOffset = optionIndex * optionHeight;\n    if (optionOffset < currentScrollPosition) {\n        return optionOffset;\n    }\n    if (optionOffset + optionHeight > currentScrollPosition + panelHeight) {\n        return Math.max(0, optionOffset - panelHeight + optionHeight);\n    }\n    return currentScrollPosition;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/option/index.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass MatOptionModule {\n}\nMatOptionModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: MatOptionModule });\nMatOptionModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function MatOptionModule_Factory(t) { return new (t || MatOptionModule)(); }, imports: [[MatRippleModule, CommonModule, MatPseudoCheckboxModule]] });\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(MatOptionModule, { declarations: function () { return [MatOption,\n        MatOptgroup]; }, imports: function () { return [MatRippleModule,\n        CommonModule,\n        MatPseudoCheckboxModule]; }, exports: function () { return [MatOption,\n        MatOptgroup]; } }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(MatOptionModule, [{\n        type: NgModule,\n        args: [{\n                imports: [MatRippleModule, CommonModule, MatPseudoCheckboxModule],\n                exports: [MatOption, MatOptgroup],\n                declarations: [MatOption, MatOptgroup]\n            }]\n    }], null, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/label/label-options.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * InjectionToken that can be used to specify the global label options.\n * @deprecated Use `MAT_FORM_FIELD_DEFAULT_OPTIONS` injection token from\n *     `\\@angular/material/form-field` instead.\n * \\@breaking-change 11.0.0\n * @type {?}\n */\nconst MAT_LABEL_GLOBAL_OPTIONS = new InjectionToken('mat-label-global-options');\n/**\n * Configurable options for floating labels.\n * @deprecated Use `MatFormFieldDefaultOptions` from `\\@angular/material/form-field` instead.\n * \\@breaking-change 11.0.0\n * @record\n */\nfunction LabelOptions() { }\nif (false) {\n    /**\n     * Whether the label should float `always`, `never`, or `auto` (only when necessary).\n     * Default behavior is assumed to be `auto`.\n     * @type {?|undefined}\n     */\n    LabelOptions.prototype.float;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/month-constants.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 * When constructing a Date, the month is zero-based. This can be confusing, since people are\n * used to seeing them one-based. So we create these aliases to make writing the tests easier.\n * \\@docs-private\n * \\@breaking-change 8.0.0 Remove this with V8 since it was only targeted for testing.\n * @type {?}\n */\nconst JAN = 0;\n/** @type {?} */\nconst FEB = 1;\n/** @type {?} */\nconst MAR = 2;\n/** @type {?} */\nconst APR = 3;\n/** @type {?} */\nconst MAY = 4;\n/** @type {?} */\nconst JUN = 5;\n/** @type {?} */\nconst JUL = 6;\n/** @type {?} */\nconst AUG = 7;\n/** @type {?} */\nconst SEP = 8;\n/** @type {?} */\nconst OCT = 9;\n/** @type {?} */\nconst NOV = 10;\n/** @type {?} */\nconst DEC = 11;\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/material/core/public-api.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 { APR, AUG, AnimationCurves, AnimationDurations, DEC, DateAdapter, ErrorStateMatcher, FEB, GestureConfig, JAN, JUL, JUN, MAR, MATERIAL_SANITY_CHECKS, MAT_DATE_FORMATS, MAT_DATE_LOCALE, MAT_DATE_LOCALE_FACTORY, MAT_DATE_LOCALE_PROVIDER, MAT_HAMMER_OPTIONS, MAT_LABEL_GLOBAL_OPTIONS, MAT_NATIVE_DATE_FORMATS, MAT_OPTION_PARENT_COMPONENT, MAT_RIPPLE_GLOBAL_OPTIONS, MAY, MatCommonModule, MatLine, MatLineModule, MatLineSetter, MatNativeDateModule, MatOptgroup, MatOption, MatOptionModule, MatOptionSelectionChange, MatPseudoCheckbox, MatPseudoCheckboxModule, MatRipple, MatRippleModule, NOV, NativeDateAdapter, NativeDateModule, OCT, RippleRef, RippleRenderer, SEP, ShowOnDirtyErrorStateMatcher, VERSION, _countGroupLabelsBeforeOption, _getOptionScrollPosition, defaultRippleAnimationConfig, mixinColor, mixinDisableRipple, mixinDisabled, mixinErrorState, mixinInitialized, mixinTabIndex, setLines, MATERIAL_SANITY_CHECKS_FACTORY as ɵangular_material_src_material_core_core_a };\n\n//# sourceMappingURL=core.js.map","import { Subscriber } from '../Subscriber';\nimport { async } from '../scheduler/async';\nexport function debounceTime(dueTime, scheduler = async) {\n    return (source) => source.lift(new DebounceTimeOperator(dueTime, scheduler));\n}\nclass DebounceTimeOperator {\n    constructor(dueTime, scheduler) {\n        this.dueTime = dueTime;\n        this.scheduler = scheduler;\n    }\n    call(subscriber, source) {\n        return source.subscribe(new DebounceTimeSubscriber(subscriber, this.dueTime, this.scheduler));\n    }\n}\nclass DebounceTimeSubscriber extends Subscriber {\n    constructor(destination, dueTime, scheduler) {\n        super(destination);\n        this.dueTime = dueTime;\n        this.scheduler = scheduler;\n        this.debouncedSubscription = null;\n        this.lastValue = null;\n        this.hasValue = false;\n    }\n    _next(value) {\n        this.clearDebounce();\n        this.lastValue = value;\n        this.hasValue = true;\n        this.add(this.debouncedSubscription = this.scheduler.schedule(dispatchNext, this.dueTime, this));\n    }\n    _complete() {\n        this.debouncedNext();\n        this.destination.complete();\n    }\n    debouncedNext() {\n        this.clearDebounce();\n        if (this.hasValue) {\n            const { lastValue } = this;\n            this.lastValue = null;\n            this.hasValue = false;\n            this.destination.next(lastValue);\n        }\n    }\n    clearDebounce() {\n        const debouncedSubscription = this.debouncedSubscription;\n        if (debouncedSubscription !== null) {\n            this.remove(debouncedSubscription);\n            debouncedSubscription.unsubscribe();\n            this.debouncedSubscription = null;\n        }\n    }\n}\nfunction dispatchNext(subscriber) {\n    subscriber.debouncedNext();\n}\n//# sourceMappingURL=debounceTime.js.map","import { Component, OnInit, Input, Output, EventEmitter } from '@angular/core';\r\n\r\n@Component({\r\n    selector: 'shared-link',\r\n    templateUrl: './link.shared.component.html',\r\n    styleUrls: ['./link.shared.component.scss']\r\n})\r\nexport class LinkComponent implements OnInit {\r\n    @Input() public mobile: boolean = false;\r\n    @Input() public emphasis: boolean = true;\r\n    @Input() public inverted: boolean = false;\r\n    @Input() public label: string;\r\n    @Input() public icon: string;\r\n    @Input() public size: OLO.Components.LINK_SIZE = null;\r\n    @Input() public disabled: boolean = false;\r\n    @Input() public isAsync: boolean = false;\r\n    @Input() public title: string = '';\r\n    @Input() public role: string = 'button';\r\n\r\n    /* For routerLink */\r\n    @Input() public routerLink: string | any[];\r\n    @Input() public queryParams: { [k: string]: any; };\r\n    @Input() public fragment: string;\r\n    @Input() public queryParamsHandling: any; /* QueryParamsHandling */\r\n    @Input() public preserveFragment: boolean;\r\n    @Input() public skipLocationChange: boolean;\r\n    @Input() public replaceUrl: boolean;\r\n    @Input() public state?: { [k: string]: any; };\r\n\r\n    @Output() public onClick: EventEmitter<Event> = new EventEmitter(this.isAsync);\r\n\r\n    constructor() { }\r\n\r\n    ngOnInit(): void { }\r\n\r\n    public btnClick($event: Event): void {\r\n        if (this.disabled) {\r\n            $event.preventDefault();\r\n            return;\r\n        }\r\n\r\n        this.onClick.emit($event);\r\n    }\r\n}\r\n","<ng-template #content>\r\n    <span class=\"link__inner\">\r\n\r\n        <span class=\"link__icon\" *ngIf=\"icon\">\r\n            <shared-icon class=\"link__icon-obj\" [icon]=\"icon\"></shared-icon>\r\n        </span>\r\n\r\n        <span class=\"link__bd\" [ngClass]=\"{'-mobile-hidden': mobile}\">\r\n            <span class=\"link__label\" *ngIf=\"label\">\r\n                {{label}}\r\n            </span>\r\n            <span class=\"link__content\">\r\n                <ng-content></ng-content>\r\n            </span>\r\n        </span>\r\n    </span>\r\n</ng-template>\r\n\r\n<ng-template #button>\r\n    <button class=\"link -type-button{{size ? ' -size-'+size : ''}}\" type=\"button\" (click)=\"btnClick($event)\"\r\n        [disabled]=\"disabled\" [title]=\"title\" [attr.role]=\"role\"\r\n        [ngClass]=\"{'is-disabled': disabled, '-emphasis': emphasis, '-inverted': inverted}\">\r\n        <ng-container *ngTemplateOutlet=\"content\"></ng-container>\r\n    </button>\r\n</ng-template>\r\n\r\n<ng-template #link>\r\n    <a class=\"link -type-link{{size ? ' -size-'+size : ''}}\" [routerLink]=\"routerLink\" [title]=\"title\"\r\n        [ngClass]=\"{'is-disabled': disabled, '-emphasis': emphasis, '-inverted': inverted}\">\r\n        <ng-container *ngTemplateOutlet=\"content\"></ng-container>\r\n    </a>\r\n</ng-template>\r\n\r\n<ng-container *ngTemplateOutlet=\"routerLink ? link : button\"></ng-container>","import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\n\r\nimport { LoadersSpinnerComponent } from './loaders-spinner.shared.component';\r\n\r\n@NgModule({\r\n    declarations: [\r\n        LoadersSpinnerComponent\r\n    ],\r\n    imports: [\r\n        CommonModule\r\n    ],\r\n    exports: [\r\n        LoadersSpinnerComponent\r\n    ],\r\n    providers: [],\r\n})\r\nexport class LoadersForSpinnerModule { }\r\n","export * from './loaders-spinner.shared.module';\r\n","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 <object> element as non-tabbable.\n            if ((this._platform.BLINK || this._platform.WEBKIT) && frameType === 'object') {\n                return false;\n            }\n            // Webkit and Blink disable tabbing to an element inside of an invisible frame.\n            if ((this._platform.BLINK || this._platform.WEBKIT) && !this.isVisible(frameElement)) {\n                return false;\n            }\n        }\n        /** @type {?} */\n        let nodeName = element.nodeName.toLowerCase();\n        /** @type {?} */\n        let tabIndexValue = getTabIndexValue(element);\n        if (element.hasAttribute('contenteditable')) {\n            return tabIndexValue !== -1;\n        }\n        if (nodeName === 'iframe') {\n            // The frames may be tabbable depending on content, but it's not possibly to reliably\n            // investigate the content of the frames.\n            return false;\n        }\n        if (nodeName === 'audio') {\n            if (!element.hasAttribute('controls')) {\n                // By default an <audio> element without the controls enabled is not tabbable.\n                return false;\n            }\n            else if (this._platform.BLINK) {\n                // In Blink <audio controls> elements are always tabbable.\n                return true;\n            }\n        }\n        if (nodeName === 'video') {\n            if (!element.hasAttribute('controls') && this._platform.TRIDENT) {\n                // In Trident a <video> element without the controls enabled is not tabbable.\n                return false;\n            }\n            else if (this._platform.BLINK || this._platform.FIREFOX) {\n                // In Chrome and Firefox <video controls> elements are always tabbable.\n                return true;\n            }\n        }\n        if (nodeName === 'object' && (this._platform.BLINK || this._platform.WEBKIT)) {\n            // In all Blink and WebKit based browsers <object> elements are never tabbable.\n            return false;\n        }\n        // In iOS the browser only considers some specific elements as tabbable.\n        if (this._platform.WEBKIT && this._platform.IOS && !isPotentiallyTabbableIOS(element)) {\n            return false;\n        }\n        return element.tabIndex >= 0;\n    }\n    /**\n     * Gets whether an element can be focused by the user.\n     *\n     * @param {?} element Element to be checked.\n     * @return {?} Whether the element is focusable.\n     */\n    isFocusable(element) {\n        // Perform checks in order of left to most expensive.\n        // Again, naive approach that does not capture many edge cases and browser quirks.\n        return isPotentiallyFocusable(element) && !this.isDisabled(element) && this.isVisible(element);\n    }\n}\nInteractivityChecker.ɵfac = function InteractivityChecker_Factory(t) { return new (t || InteractivityChecker)(ɵngcc0.ɵɵinject(ɵngcc1.Platform)); };\n/** @nocollapse */\nInteractivityChecker.ctorParameters = () => [\n    { type: Platform }\n];\n/** @nocollapse */ InteractivityChecker.ɵprov = ɵɵdefineInjectable({ factory: function InteractivityChecker_Factory() { return new InteractivityChecker(ɵɵinject(Platform)); }, token: InteractivityChecker, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(InteractivityChecker, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: ɵngcc1.Platform }]; }, null); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    InteractivityChecker.prototype._platform;\n}\n/**\n * Returns the frame element from a window object. Since browsers like MS Edge throw errors if\n * the frameElement property is being accessed from a different host address, this property\n * should be accessed carefully.\n * @param {?} window\n * @return {?}\n */\nfunction getFrameElement(window) {\n    try {\n        return (/** @type {?} */ (window.frameElement));\n    }\n    catch (_a) {\n        return null;\n    }\n}\n/**\n * Checks whether the specified element has any geometry / rectangles.\n * @param {?} element\n * @return {?}\n */\nfunction hasGeometry(element) {\n    // Use logic from jQuery to check for an invisible element.\n    // See https://github.com/jquery/jquery/blob/master/src/css/hiddenVisibleSelectors.js#L12\n    return !!(element.offsetWidth || element.offsetHeight ||\n        (typeof element.getClientRects === 'function' && element.getClientRects().length));\n}\n/**\n * Gets whether an element's\n * @param {?} element\n * @return {?}\n */\nfunction isNativeFormElement(element) {\n    /** @type {?} */\n    let nodeName = element.nodeName.toLowerCase();\n    return nodeName === 'input' ||\n        nodeName === 'select' ||\n        nodeName === 'button' ||\n        nodeName === 'textarea';\n}\n/**\n * Gets whether an element is an `<input type=\"hidden\">`.\n * @param {?} element\n * @return {?}\n */\nfunction isHiddenInput(element) {\n    return isInputElement(element) && element.type == 'hidden';\n}\n/**\n * Gets whether an element is an anchor that has an href attribute.\n * @param {?} element\n * @return {?}\n */\nfunction isAnchorWithHref(element) {\n    return isAnchorElement(element) && element.hasAttribute('href');\n}\n/**\n * Gets whether an element is an input element.\n * @param {?} element\n * @return {?}\n */\nfunction isInputElement(element) {\n    return element.nodeName.toLowerCase() == 'input';\n}\n/**\n * Gets whether an element is an anchor element.\n * @param {?} element\n * @return {?}\n */\nfunction isAnchorElement(element) {\n    return element.nodeName.toLowerCase() == 'a';\n}\n/**\n * Gets whether an element has a valid tabindex.\n * @param {?} element\n * @return {?}\n */\nfunction hasValidTabIndex(element) {\n    if (!element.hasAttribute('tabindex') || element.tabIndex === undefined) {\n        return false;\n    }\n    /** @type {?} */\n    let tabIndex = element.getAttribute('tabindex');\n    // IE11 parses tabindex=\"\" as the value \"-32768\"\n    if (tabIndex == '-32768') {\n        return false;\n    }\n    return !!(tabIndex && !isNaN(parseInt(tabIndex, 10)));\n}\n/**\n * Returns the parsed tabindex from the element attributes instead of returning the\n * evaluated tabindex from the browsers defaults.\n * @param {?} element\n * @return {?}\n */\nfunction getTabIndexValue(element) {\n    if (!hasValidTabIndex(element)) {\n        return null;\n    }\n    // See browser issue in Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054\n    /** @type {?} */\n    const tabIndex = parseInt(element.getAttribute('tabindex') || '', 10);\n    return isNaN(tabIndex) ? -1 : tabIndex;\n}\n/**\n * Checks whether the specified element is potentially tabbable on iOS\n * @param {?} element\n * @return {?}\n */\nfunction isPotentiallyTabbableIOS(element) {\n    /** @type {?} */\n    let nodeName = element.nodeName.toLowerCase();\n    /** @type {?} */\n    let inputType = nodeName === 'input' && ((/** @type {?} */ (element))).type;\n    return inputType === 'text'\n        || inputType === 'password'\n        || nodeName === 'select'\n        || nodeName === 'textarea';\n}\n/**\n * Gets whether an element is potentially focusable without taking current visible/disabled state\n * into account.\n * @param {?} element\n * @return {?}\n */\nfunction isPotentiallyFocusable(element) {\n    // Inputs are potentially focusable *unless* they're type=\"hidden\".\n    if (isHiddenInput(element)) {\n        return false;\n    }\n    return isNativeFormElement(element) ||\n        isAnchorWithHref(element) ||\n        element.hasAttribute('contenteditable') ||\n        hasValidTabIndex(element);\n}\n/**\n * Gets the parent window of a DOM node with regards of being inside of an iframe.\n * @param {?} node\n * @return {?}\n */\nfunction getWindow(node) {\n    // ownerDocument is null if `node` itself *is* a document.\n    return node.ownerDocument && node.ownerDocument.defaultView || window;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/focus-trap/focus-trap.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Class that allows for trapping focus within a DOM element.\n *\n * This class currently uses a relatively simple approach to focus trapping.\n * It assumes that the tab order is the same as DOM order, which is not necessarily true.\n * Things like `tabIndex > 0`, flex `order`, and shadow roots can cause to two to misalign.\n *\n * @deprecated Use `ConfigurableFocusTrap` instead.\n * \\@breaking-change for 11.0.0 Remove this class.\n */\nclass FocusTrap {\n    /**\n     * @param {?} _element\n     * @param {?} _checker\n     * @param {?} _ngZone\n     * @param {?} _document\n     * @param {?=} deferAnchors\n     */\n    constructor(_element, _checker, _ngZone, _document, deferAnchors = false) {\n        this._element = _element;\n        this._checker = _checker;\n        this._ngZone = _ngZone;\n        this._document = _document;\n        this._hasAttached = false;\n        // Event listeners for the anchors. Need to be regular functions so that we can unbind them later.\n        this.startAnchorListener = (/**\n         * @return {?}\n         */\n        () => this.focusLastTabbableElement());\n        this.endAnchorListener = (/**\n         * @return {?}\n         */\n        () => this.focusFirstTabbableElement());\n        this._enabled = true;\n        if (!deferAnchors) {\n            this.attachAnchors();\n        }\n    }\n    /**\n     * Whether the focus trap is active.\n     * @return {?}\n     */\n    get enabled() { return this._enabled; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set enabled(value) {\n        this._enabled = value;\n        if (this._startAnchor && this._endAnchor) {\n            this._toggleAnchorTabIndex(value, this._startAnchor);\n            this._toggleAnchorTabIndex(value, this._endAnchor);\n        }\n    }\n    /**\n     * Destroys the focus trap by cleaning up the anchors.\n     * @return {?}\n     */\n    destroy() {\n        /** @type {?} */\n        const startAnchor = this._startAnchor;\n        /** @type {?} */\n        const endAnchor = this._endAnchor;\n        if (startAnchor) {\n            startAnchor.removeEventListener('focus', this.startAnchorListener);\n            if (startAnchor.parentNode) {\n                startAnchor.parentNode.removeChild(startAnchor);\n            }\n        }\n        if (endAnchor) {\n            endAnchor.removeEventListener('focus', this.endAnchorListener);\n            if (endAnchor.parentNode) {\n                endAnchor.parentNode.removeChild(endAnchor);\n            }\n        }\n        this._startAnchor = this._endAnchor = null;\n    }\n    /**\n     * Inserts the anchors into the DOM. This is usually done automatically\n     * in the constructor, but can be deferred for cases like directives with `*ngIf`.\n     * @return {?} Whether the focus trap managed to attach successfuly. This may not be the case\n     * if the target element isn't currently in the DOM.\n     */\n    attachAnchors() {\n        // If we're not on the browser, there can be no focus to trap.\n        if (this._hasAttached) {\n            return true;\n        }\n        this._ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => {\n            if (!this._startAnchor) {\n                this._startAnchor = this._createAnchor();\n                (/** @type {?} */ (this._startAnchor)).addEventListener('focus', this.startAnchorListener);\n            }\n            if (!this._endAnchor) {\n                this._endAnchor = this._createAnchor();\n                (/** @type {?} */ (this._endAnchor)).addEventListener('focus', this.endAnchorListener);\n            }\n        }));\n        if (this._element.parentNode) {\n            this._element.parentNode.insertBefore((/** @type {?} */ (this._startAnchor)), this._element);\n            this._element.parentNode.insertBefore((/** @type {?} */ (this._endAnchor)), this._element.nextSibling);\n            this._hasAttached = true;\n        }\n        return this._hasAttached;\n    }\n    /**\n     * Waits for the zone to stabilize, then either focuses the first element that the\n     * user specified, or the first tabbable element.\n     * @return {?} Returns a promise that resolves with a boolean, depending\n     * on whether focus was moved successfuly.\n     */\n    focusInitialElementWhenReady() {\n        return new Promise((/**\n         * @param {?} resolve\n         * @return {?}\n         */\n        resolve => {\n            this._executeOnStable((/**\n             * @return {?}\n             */\n            () => resolve(this.focusInitialElement())));\n        }));\n    }\n    /**\n     * Waits for the zone to stabilize, then focuses\n     * the first tabbable element within the focus trap region.\n     * @return {?} Returns a promise that resolves with a boolean, depending\n     * on whether focus was moved successfuly.\n     */\n    focusFirstTabbableElementWhenReady() {\n        return new Promise((/**\n         * @param {?} resolve\n         * @return {?}\n         */\n        resolve => {\n            this._executeOnStable((/**\n             * @return {?}\n             */\n            () => resolve(this.focusFirstTabbableElement())));\n        }));\n    }\n    /**\n     * Waits for the zone to stabilize, then focuses\n     * the last tabbable element within the focus trap region.\n     * @return {?} Returns a promise that resolves with a boolean, depending\n     * on whether focus was moved successfuly.\n     */\n    focusLastTabbableElementWhenReady() {\n        return new Promise((/**\n         * @param {?} resolve\n         * @return {?}\n         */\n        resolve => {\n            this._executeOnStable((/**\n             * @return {?}\n             */\n            () => resolve(this.focusLastTabbableElement())));\n        }));\n    }\n    /**\n     * Get the specified boundary element of the trapped region.\n     * @private\n     * @param {?} bound The boundary to get (start or end of trapped region).\n     * @return {?} The boundary element.\n     */\n    _getRegionBoundary(bound) {\n        // Contains the deprecated version of selector, for temporary backwards comparability.\n        /** @type {?} */\n        let markers = (/** @type {?} */ (this._element.querySelectorAll(`[cdk-focus-region-${bound}], ` +\n            `[cdkFocusRegion${bound}], ` +\n            `[cdk-focus-${bound}]`)));\n        for (let i = 0; i < markers.length; i++) {\n            // @breaking-change 8.0.0\n            if (markers[i].hasAttribute(`cdk-focus-${bound}`)) {\n                console.warn(`Found use of deprecated attribute 'cdk-focus-${bound}', ` +\n                    `use 'cdkFocusRegion${bound}' instead. The deprecated ` +\n                    `attribute will be removed in 8.0.0.`, markers[i]);\n            }\n            else if (markers[i].hasAttribute(`cdk-focus-region-${bound}`)) {\n                console.warn(`Found use of deprecated attribute 'cdk-focus-region-${bound}', ` +\n                    `use 'cdkFocusRegion${bound}' instead. The deprecated attribute ` +\n                    `will be removed in 8.0.0.`, markers[i]);\n            }\n        }\n        if (bound == 'start') {\n            return markers.length ? markers[0] : this._getFirstTabbableElement(this._element);\n        }\n        return markers.length ?\n            markers[markers.length - 1] : this._getLastTabbableElement(this._element);\n    }\n    /**\n     * Focuses the element that should be focused when the focus trap is initialized.\n     * @return {?} Whether focus was moved successfuly.\n     */\n    focusInitialElement() {\n        // Contains the deprecated version of selector, for temporary backwards comparability.\n        /** @type {?} */\n        const redirectToElement = (/** @type {?} */ (this._element.querySelector(`[cdk-focus-initial], ` +\n            `[cdkFocusInitial]`)));\n        if (redirectToElement) {\n            // @breaking-change 8.0.0\n            if (redirectToElement.hasAttribute(`cdk-focus-initial`)) {\n                console.warn(`Found use of deprecated attribute 'cdk-focus-initial', ` +\n                    `use 'cdkFocusInitial' instead. The deprecated attribute ` +\n                    `will be removed in 8.0.0`, redirectToElement);\n            }\n            // Warn the consumer if the element they've pointed to\n            // isn't focusable, when not in production mode.\n            if (isDevMode() && !this._checker.isFocusable(redirectToElement)) {\n                console.warn(`Element matching '[cdkFocusInitial]' is not focusable.`, redirectToElement);\n            }\n            redirectToElement.focus();\n            return true;\n        }\n        return this.focusFirstTabbableElement();\n    }\n    /**\n     * Focuses the first tabbable element within the focus trap region.\n     * @return {?} Whether focus was moved successfuly.\n     */\n    focusFirstTabbableElement() {\n        /** @type {?} */\n        const redirectToElement = this._getRegionBoundary('start');\n        if (redirectToElement) {\n            redirectToElement.focus();\n        }\n        return !!redirectToElement;\n    }\n    /**\n     * Focuses the last tabbable element within the focus trap region.\n     * @return {?} Whether focus was moved successfuly.\n     */\n    focusLastTabbableElement() {\n        /** @type {?} */\n        const redirectToElement = this._getRegionBoundary('end');\n        if (redirectToElement) {\n            redirectToElement.focus();\n        }\n        return !!redirectToElement;\n    }\n    /**\n     * Checks whether the focus trap has successfuly been attached.\n     * @return {?}\n     */\n    hasAttached() {\n        return this._hasAttached;\n    }\n    /**\n     * Get the first tabbable element from a DOM subtree (inclusive).\n     * @private\n     * @param {?} root\n     * @return {?}\n     */\n    _getFirstTabbableElement(root) {\n        if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {\n            return root;\n        }\n        // Iterate in DOM order. Note that IE doesn't have `children` for SVG so we fall\n        // back to `childNodes` which includes text nodes, comments etc.\n        /** @type {?} */\n        let children = root.children || root.childNodes;\n        for (let i = 0; i < children.length; i++) {\n            /** @type {?} */\n            let tabbableChild = children[i].nodeType === this._document.ELEMENT_NODE ?\n                this._getFirstTabbableElement((/** @type {?} */ (children[i]))) :\n                null;\n            if (tabbableChild) {\n                return tabbableChild;\n            }\n        }\n        return null;\n    }\n    /**\n     * Get the last tabbable element from a DOM subtree (inclusive).\n     * @private\n     * @param {?} root\n     * @return {?}\n     */\n    _getLastTabbableElement(root) {\n        if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {\n            return root;\n        }\n        // Iterate in reverse DOM order.\n        /** @type {?} */\n        let children = root.children || root.childNodes;\n        for (let i = children.length - 1; i >= 0; i--) {\n            /** @type {?} */\n            let tabbableChild = children[i].nodeType === this._document.ELEMENT_NODE ?\n                this._getLastTabbableElement((/** @type {?} */ (children[i]))) :\n                null;\n            if (tabbableChild) {\n                return tabbableChild;\n            }\n        }\n        return null;\n    }\n    /**\n     * Creates an anchor element.\n     * @private\n     * @return {?}\n     */\n    _createAnchor() {\n        /** @type {?} */\n        const anchor = this._document.createElement('div');\n        this._toggleAnchorTabIndex(this._enabled, anchor);\n        anchor.classList.add('cdk-visually-hidden');\n        anchor.classList.add('cdk-focus-trap-anchor');\n        anchor.setAttribute('aria-hidden', 'true');\n        return anchor;\n    }\n    /**\n     * Toggles the `tabindex` of an anchor, based on the enabled state of the focus trap.\n     * @private\n     * @param {?} isEnabled Whether the focus trap is enabled.\n     * @param {?} anchor Anchor on which to toggle the tabindex.\n     * @return {?}\n     */\n    _toggleAnchorTabIndex(isEnabled, anchor) {\n        // Remove the tabindex completely, rather than setting it to -1, because if the\n        // element has a tabindex, the user might still hit it when navigating with the arrow keys.\n        isEnabled ? anchor.setAttribute('tabindex', '0') : anchor.removeAttribute('tabindex');\n    }\n    /**\n     * Toggles the`tabindex` of both anchors to either trap Tab focus or allow it to escape.\n     * @protected\n     * @param {?} enabled\n     * @return {?}\n     */\n    toggleAnchors(enabled) {\n        if (this._startAnchor && this._endAnchor) {\n            this._toggleAnchorTabIndex(enabled, this._startAnchor);\n            this._toggleAnchorTabIndex(enabled, this._endAnchor);\n        }\n    }\n    /**\n     * Executes a function when the zone is stable.\n     * @private\n     * @param {?} fn\n     * @return {?}\n     */\n    _executeOnStable(fn) {\n        if (this._ngZone.isStable) {\n            fn();\n        }\n        else {\n            this._ngZone.onStable.asObservable().pipe(take(1)).subscribe(fn);\n        }\n    }\n}\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    FocusTrap.prototype._startAnchor;\n    /**\n     * @type {?}\n     * @private\n     */\n    FocusTrap.prototype._endAnchor;\n    /**\n     * @type {?}\n     * @private\n     */\n    FocusTrap.prototype._hasAttached;\n    /**\n     * @type {?}\n     * @protected\n     */\n    FocusTrap.prototype.startAnchorListener;\n    /**\n     * @type {?}\n     * @protected\n     */\n    FocusTrap.prototype.endAnchorListener;\n    /**\n     * @type {?}\n     * @protected\n     */\n    FocusTrap.prototype._enabled;\n    /** @type {?} */\n    FocusTrap.prototype._element;\n    /**\n     * @type {?}\n     * @private\n     */\n    FocusTrap.prototype._checker;\n    /** @type {?} */\n    FocusTrap.prototype._ngZone;\n    /** @type {?} */\n    FocusTrap.prototype._document;\n}\n/**\n * Factory that allows easy instantiation of focus traps.\n * @deprecated Use `ConfigurableFocusTrapFactory` instead.\n * \\@breaking-change for 11.0.0 Remove this class.\n */\nclass FocusTrapFactory {\n    /**\n     * @param {?} _checker\n     * @param {?} _ngZone\n     * @param {?} _document\n     */\n    constructor(_checker, _ngZone, _document) {\n        this._checker = _checker;\n        this._ngZone = _ngZone;\n        this._document = _document;\n    }\n    /**\n     * Creates a focus-trapped region around the given element.\n     * @param {?} element The element around which focus will be trapped.\n     * @param {?=} deferCaptureElements Defers the creation of focus-capturing elements to be done\n     *     manually by the user.\n     * @return {?} The created focus trap instance.\n     */\n    create(element, deferCaptureElements = false) {\n        return new FocusTrap(element, this._checker, this._ngZone, this._document, deferCaptureElements);\n    }\n}\nFocusTrapFactory.ɵfac = function FocusTrapFactory_Factory(t) { return new (t || FocusTrapFactory)(ɵngcc0.ɵɵinject(InteractivityChecker), ɵngcc0.ɵɵinject(ɵngcc0.NgZone), ɵngcc0.ɵɵinject(DOCUMENT)); };\n/** @nocollapse */\nFocusTrapFactory.ctorParameters = () => [\n    { type: InteractivityChecker },\n    { type: NgZone },\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }\n];\n/** @nocollapse */ FocusTrapFactory.ɵprov = ɵɵdefineInjectable({ factory: function FocusTrapFactory_Factory() { return new FocusTrapFactory(ɵɵinject(InteractivityChecker), ɵɵinject(NgZone), ɵɵinject(DOCUMENT)); }, token: FocusTrapFactory, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(FocusTrapFactory, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: InteractivityChecker }, { type: ɵngcc0.NgZone }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }]; }, null); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    FocusTrapFactory.prototype._document;\n    /**\n     * @type {?}\n     * @private\n     */\n    FocusTrapFactory.prototype._checker;\n    /**\n     * @type {?}\n     * @private\n     */\n    FocusTrapFactory.prototype._ngZone;\n}\n/**\n * Directive for trapping focus within a region.\n */\nclass CdkTrapFocus {\n    /**\n     * @param {?} _elementRef\n     * @param {?} _focusTrapFactory\n     * @param {?} _document\n     */\n    constructor(_elementRef, _focusTrapFactory, _document) {\n        this._elementRef = _elementRef;\n        this._focusTrapFactory = _focusTrapFactory;\n        /**\n         * Previously focused element to restore focus to upon destroy when using autoCapture.\n         */\n        this._previouslyFocusedElement = null;\n        this._document = _document;\n        this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);\n    }\n    /**\n     * Whether the focus trap is active.\n     * @return {?}\n     */\n    get enabled() { return this.focusTrap.enabled; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set enabled(value) { this.focusTrap.enabled = coerceBooleanProperty(value); }\n    /**\n     * Whether the directive should automatially move focus into the trapped region upon\n     * initialization and return focus to the previous activeElement upon destruction.\n     * @return {?}\n     */\n    get autoCapture() { return this._autoCapture; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set autoCapture(value) { this._autoCapture = coerceBooleanProperty(value); }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this.focusTrap.destroy();\n        // If we stored a previously focused element when using autoCapture, return focus to that\n        // element now that the trapped region is being destroyed.\n        if (this._previouslyFocusedElement) {\n            this._previouslyFocusedElement.focus();\n            this._previouslyFocusedElement = null;\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterContentInit() {\n        this.focusTrap.attachAnchors();\n        if (this.autoCapture) {\n            this._previouslyFocusedElement = (/** @type {?} */ (this._document.activeElement));\n            this.focusTrap.focusInitialElementWhenReady();\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngDoCheck() {\n        if (!this.focusTrap.hasAttached()) {\n            this.focusTrap.attachAnchors();\n        }\n    }\n}\nCdkTrapFocus.ɵfac = function CdkTrapFocus_Factory(t) { return new (t || CdkTrapFocus)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(FocusTrapFactory), ɵngcc0.ɵɵdirectiveInject(DOCUMENT)); };\nCdkTrapFocus.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: CdkTrapFocus, selectors: [[\"\", \"cdkTrapFocus\", \"\"]], inputs: { enabled: [\"cdkTrapFocus\", \"enabled\"], autoCapture: [\"cdkTrapFocusAutoCapture\", \"autoCapture\"] }, exportAs: [\"cdkTrapFocus\"] });\n/** @nocollapse */\nCdkTrapFocus.ctorParameters = () => [\n    { type: ElementRef },\n    { type: FocusTrapFactory },\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }\n];\nCdkTrapFocus.propDecorators = {\n    enabled: [{ type: Input, args: ['cdkTrapFocus',] }],\n    autoCapture: [{ type: Input, args: ['cdkTrapFocusAutoCapture',] }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(CdkTrapFocus, [{\n        type: Directive,\n        args: [{\n                selector: '[cdkTrapFocus]',\n                exportAs: 'cdkTrapFocus'\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: FocusTrapFactory }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }]; }, { enabled: [{\n            type: Input,\n            args: ['cdkTrapFocus']\n        }], autoCapture: [{\n            type: Input,\n            args: ['cdkTrapFocusAutoCapture']\n        }] }); })();\nif (false) {\n    /** @type {?} */\n    CdkTrapFocus.ngAcceptInputType_enabled;\n    /** @type {?} */\n    CdkTrapFocus.ngAcceptInputType_autoCapture;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkTrapFocus.prototype._document;\n    /**\n     * Underlying FocusTrap instance.\n     * @type {?}\n     */\n    CdkTrapFocus.prototype.focusTrap;\n    /**\n     * Previously focused element to restore focus to upon destroy when using autoCapture.\n     * @type {?}\n     * @private\n     */\n    CdkTrapFocus.prototype._previouslyFocusedElement;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkTrapFocus.prototype._autoCapture;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkTrapFocus.prototype._elementRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkTrapFocus.prototype._focusTrapFactory;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/focus-trap/configurable-focus-trap.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Class that allows for trapping focus within a DOM element.\n *\n * This class uses a strategy pattern that determines how it traps focus.\n * See FocusTrapInertStrategy.\n */\nclass ConfigurableFocusTrap extends FocusTrap {\n    /**\n     * @param {?} _element\n     * @param {?} _checker\n     * @param {?} _ngZone\n     * @param {?} _document\n     * @param {?} _focusTrapManager\n     * @param {?} _inertStrategy\n     * @param {?} config\n     */\n    constructor(_element, _checker, _ngZone, _document, _focusTrapManager, _inertStrategy, config) {\n        super(_element, _checker, _ngZone, _document, config.defer);\n        this._focusTrapManager = _focusTrapManager;\n        this._inertStrategy = _inertStrategy;\n        this._focusTrapManager.register(this);\n    }\n    /**\n     * Whether the FocusTrap is enabled.\n     * @return {?}\n     */\n    get enabled() { return this._enabled; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set enabled(value) {\n        this._enabled = value;\n        if (this._enabled) {\n            this._focusTrapManager.register(this);\n        }\n        else {\n            this._focusTrapManager.deregister(this);\n        }\n    }\n    /**\n     * Notifies the FocusTrapManager that this FocusTrap will be destroyed.\n     * @return {?}\n     */\n    destroy() {\n        this._focusTrapManager.deregister(this);\n        super.destroy();\n    }\n    /**\n     * \\@docs-private Implemented as part of ManagedFocusTrap.\n     * @return {?}\n     */\n    _enable() {\n        this._inertStrategy.preventFocus(this);\n        this.toggleAnchors(true);\n    }\n    /**\n     * \\@docs-private Implemented as part of ManagedFocusTrap.\n     * @return {?}\n     */\n    _disable() {\n        this._inertStrategy.allowFocus(this);\n        this.toggleAnchors(false);\n    }\n}\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    ConfigurableFocusTrap.prototype._focusTrapManager;\n    /**\n     * @type {?}\n     * @private\n     */\n    ConfigurableFocusTrap.prototype._inertStrategy;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/focus-trap/polyfill.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 * IE 11 compatible closest implementation that is able to start from non-Element Nodes.\n * @param {?} element\n * @param {?} selector\n * @return {?}\n */\nfunction closest(element, selector) {\n    if (!(element instanceof Node)) {\n        return null;\n    }\n    /** @type {?} */\n    let curr = element;\n    while (curr != null && !(curr instanceof Element)) {\n        curr = curr.parentNode;\n    }\n    return curr && (/** @type {?} */ ((hasNativeClosest ?\n        curr.closest(selector) : polyfillClosest(curr, selector))));\n}\n/**\n * Polyfill for browsers without Element.closest.\n * @param {?} element\n * @param {?} selector\n * @return {?}\n */\nfunction polyfillClosest(element, selector) {\n    /** @type {?} */\n    let curr = element;\n    while (curr != null && !(curr instanceof Element && matches(curr, selector))) {\n        curr = curr.parentNode;\n    }\n    return (/** @type {?} */ ((curr || null)));\n}\n/** @type {?} */\nconst hasNativeClosest = typeof Element != 'undefined' && !!Element.prototype.closest;\n/**\n * IE 11 compatible matches implementation.\n * @param {?} element\n * @param {?} selector\n * @return {?}\n */\nfunction matches(element, selector) {\n    return element.matches ?\n        element.matches(selector) :\n        ((/** @type {?} */ (element)))['msMatchesSelector'](selector);\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/focus-trap/event-listener-inert-strategy.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Lightweight FocusTrapInertStrategy that adds a document focus event\n * listener to redirect focus back inside the FocusTrap.\n */\nclass EventListenerFocusTrapInertStrategy {\n    constructor() {\n        /**\n         * Focus event handler.\n         */\n        this._listener = null;\n    }\n    /**\n     * Adds a document event listener that keeps focus inside the FocusTrap.\n     * @param {?} focusTrap\n     * @return {?}\n     */\n    preventFocus(focusTrap) {\n        // Ensure there's only one listener per document\n        if (this._listener) {\n            focusTrap._document.removeEventListener('focus', (/** @type {?} */ (this._listener)), true);\n        }\n        this._listener = (/**\n         * @param {?} e\n         * @return {?}\n         */\n        (e) => this._trapFocus(focusTrap, e));\n        focusTrap._ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => {\n            focusTrap._document.addEventListener('focus', (/** @type {?} */ (this._listener)), true);\n        }));\n    }\n    /**\n     * Removes the event listener added in preventFocus.\n     * @param {?} focusTrap\n     * @return {?}\n     */\n    allowFocus(focusTrap) {\n        if (!this._listener) {\n            return;\n        }\n        focusTrap._document.removeEventListener('focus', (/** @type {?} */ (this._listener)), true);\n        this._listener = null;\n    }\n    /**\n     * Refocuses the first element in the FocusTrap if the focus event target was outside\n     * the FocusTrap.\n     *\n     * This is an event listener callback. The event listener is added in runOutsideAngular,\n     * so all this code runs outside Angular as well.\n     * @private\n     * @param {?} focusTrap\n     * @param {?} event\n     * @return {?}\n     */\n    _trapFocus(focusTrap, event) {\n        /** @type {?} */\n        const target = (/** @type {?} */ (event.target));\n        /** @type {?} */\n        const focusTrapRoot = focusTrap._element;\n        // Don't refocus if target was in an overlay, because the overlay might be associated\n        // with an element inside the FocusTrap, ex. mat-select.\n        if (!focusTrapRoot.contains(target) && closest(target, 'div.cdk-overlay-pane') === null) {\n            // Some legacy FocusTrap usages have logic that focuses some element on the page\n            // just before FocusTrap is destroyed. For backwards compatibility, wait\n            // to be sure FocusTrap is still enabled before refocusing.\n            setTimeout((/**\n             * @return {?}\n             */\n            () => {\n                // Check whether focus wasn't put back into the focus trap while the timeout was pending.\n                if (focusTrap.enabled && !focusTrapRoot.contains(focusTrap._document.activeElement)) {\n                    focusTrap.focusFirstTabbableElement();\n                }\n            }));\n        }\n    }\n}\nif (false) {\n    /**\n     * Focus event handler.\n     * @type {?}\n     * @private\n     */\n    EventListenerFocusTrapInertStrategy.prototype._listener;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/focus-trap/configurable-focus-trap-config.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 * Configuration for creating a ConfigurableFocusTrap.\n */\nclass ConfigurableFocusTrapConfig {\n    constructor() {\n        /**\n         * Whether to defer the creation of FocusTrap elements to be\n         * done manually by the user. Default is to create them\n         * automatically.\n         */\n        this.defer = false;\n    }\n}\nif (false) {\n    /**\n     * Whether to defer the creation of FocusTrap elements to be\n     * done manually by the user. Default is to create them\n     * automatically.\n     * @type {?}\n     */\n    ConfigurableFocusTrapConfig.prototype.defer;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/focus-trap/focus-trap-inert-strategy.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * The injection token used to specify the inert strategy.\n * @type {?}\n */\nconst FOCUS_TRAP_INERT_STRATEGY = new InjectionToken('FOCUS_TRAP_INERT_STRATEGY');\n/**\n * A strategy that dictates how FocusTrap should prevent elements\n * outside of the FocusTrap from being focused.\n * @record\n */\nfunction FocusTrapInertStrategy() { }\nif (false) {\n    /**\n     * Makes all elements outside focusTrap unfocusable.\n     * @param {?} focusTrap\n     * @return {?}\n     */\n    FocusTrapInertStrategy.prototype.preventFocus = function (focusTrap) { };\n    /**\n     * Reverts elements made unfocusable by preventFocus to their previous state.\n     * @param {?} focusTrap\n     * @return {?}\n     */\n    FocusTrapInertStrategy.prototype.allowFocus = function (focusTrap) { };\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/focus-trap/focus-trap-manager.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * A FocusTrap managed by FocusTrapManager.\n * Implemented by ConfigurableFocusTrap to avoid circular dependency.\n * @record\n */\nfunction ManagedFocusTrap() { }\nif (false) {\n    /**\n     * @return {?}\n     */\n    ManagedFocusTrap.prototype._enable = function () { };\n    /**\n     * @return {?}\n     */\n    ManagedFocusTrap.prototype._disable = function () { };\n    /**\n     * @return {?}\n     */\n    ManagedFocusTrap.prototype.focusInitialElementWhenReady = function () { };\n}\n/**\n * Injectable that ensures only the most recently enabled FocusTrap is active.\n */\nclass FocusTrapManager {\n    constructor() {\n        // A stack of the FocusTraps on the page. Only the FocusTrap at the\n        // top of the stack is active.\n        this._focusTrapStack = [];\n    }\n    /**\n     * Disables the FocusTrap at the top of the stack, and then pushes\n     * the new FocusTrap onto the stack.\n     * @param {?} focusTrap\n     * @return {?}\n     */\n    register(focusTrap) {\n        // Dedupe focusTraps that register multiple times.\n        this._focusTrapStack = this._focusTrapStack.filter((/**\n         * @param {?} ft\n         * @return {?}\n         */\n        (ft) => ft !== focusTrap));\n        /** @type {?} */\n        let stack = this._focusTrapStack;\n        if (stack.length) {\n            stack[stack.length - 1]._disable();\n        }\n        stack.push(focusTrap);\n        focusTrap._enable();\n    }\n    /**\n     * Removes the FocusTrap from the stack, and activates the\n     * FocusTrap that is the new top of the stack.\n     * @param {?} focusTrap\n     * @return {?}\n     */\n    deregister(focusTrap) {\n        focusTrap._disable();\n        /** @type {?} */\n        const stack = this._focusTrapStack;\n        /** @type {?} */\n        const i = stack.indexOf(focusTrap);\n        if (i !== -1) {\n            stack.splice(i, 1);\n            if (stack.length) {\n                stack[stack.length - 1]._enable();\n            }\n        }\n    }\n}\nFocusTrapManager.ɵfac = function FocusTrapManager_Factory(t) { return new (t || FocusTrapManager)(); };\n/** @nocollapse */ FocusTrapManager.ɵprov = ɵɵdefineInjectable({ factory: function FocusTrapManager_Factory() { return new FocusTrapManager(); }, token: FocusTrapManager, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(FocusTrapManager, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return []; }, null); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    FocusTrapManager.prototype._focusTrapStack;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/focus-trap/configurable-focus-trap-factory.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Factory that allows easy instantiation of configurable focus traps.\n */\nclass ConfigurableFocusTrapFactory {\n    /**\n     * @param {?} _checker\n     * @param {?} _ngZone\n     * @param {?} _focusTrapManager\n     * @param {?} _document\n     * @param {?=} _inertStrategy\n     */\n    constructor(_checker, _ngZone, _focusTrapManager, _document, _inertStrategy) {\n        this._checker = _checker;\n        this._ngZone = _ngZone;\n        this._focusTrapManager = _focusTrapManager;\n        this._document = _document;\n        // TODO split up the strategies into different modules, similar to DateAdapter.\n        this._inertStrategy = _inertStrategy || new EventListenerFocusTrapInertStrategy();\n    }\n    /**\n     * @param {?} element\n     * @param {?=} config\n     * @return {?}\n     */\n    create(element, config = new ConfigurableFocusTrapConfig()) {\n        /** @type {?} */\n        let configObject;\n        if (typeof config === 'boolean') {\n            configObject = new ConfigurableFocusTrapConfig();\n            configObject.defer = config;\n        }\n        else {\n            configObject = config;\n        }\n        return new ConfigurableFocusTrap(element, this._checker, this._ngZone, this._document, this._focusTrapManager, this._inertStrategy, configObject);\n    }\n}\nConfigurableFocusTrapFactory.ɵfac = function ConfigurableFocusTrapFactory_Factory(t) { return new (t || ConfigurableFocusTrapFactory)(ɵngcc0.ɵɵinject(InteractivityChecker), ɵngcc0.ɵɵinject(ɵngcc0.NgZone), ɵngcc0.ɵɵinject(FocusTrapManager), ɵngcc0.ɵɵinject(DOCUMENT), ɵngcc0.ɵɵinject(FOCUS_TRAP_INERT_STRATEGY, 8)); };\n/** @nocollapse */\nConfigurableFocusTrapFactory.ctorParameters = () => [\n    { type: InteractivityChecker },\n    { type: NgZone },\n    { type: FocusTrapManager },\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [FOCUS_TRAP_INERT_STRATEGY,] }] }\n];\n/** @nocollapse */ ConfigurableFocusTrapFactory.ɵprov = ɵɵdefineInjectable({ factory: function ConfigurableFocusTrapFactory_Factory() { return new ConfigurableFocusTrapFactory(ɵɵinject(InteractivityChecker), ɵɵinject(NgZone), ɵɵinject(FocusTrapManager), ɵɵinject(DOCUMENT), ɵɵinject(FOCUS_TRAP_INERT_STRATEGY, 8)); }, token: ConfigurableFocusTrapFactory, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(ConfigurableFocusTrapFactory, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: InteractivityChecker }, { type: ɵngcc0.NgZone }, { type: FocusTrapManager }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [FOCUS_TRAP_INERT_STRATEGY]\n            }] }]; }, null); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    ConfigurableFocusTrapFactory.prototype._document;\n    /**\n     * @type {?}\n     * @private\n     */\n    ConfigurableFocusTrapFactory.prototype._inertStrategy;\n    /**\n     * @type {?}\n     * @private\n     */\n    ConfigurableFocusTrapFactory.prototype._checker;\n    /**\n     * @type {?}\n     * @private\n     */\n    ConfigurableFocusTrapFactory.prototype._ngZone;\n    /**\n     * @type {?}\n     * @private\n     */\n    ConfigurableFocusTrapFactory.prototype._focusTrapManager;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/live-announcer/live-announcer-tokens.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst LIVE_ANNOUNCER_ELEMENT_TOKEN = new InjectionToken('liveAnnouncerElement', {\n    providedIn: 'root',\n    factory: LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY,\n});\n/**\n * \\@docs-private\n * @return {?}\n */\nfunction LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY() {\n    return null;\n}\n/**\n * Object that can be used to configure the default options for the LiveAnnouncer.\n * @record\n */\nfunction LiveAnnouncerDefaultOptions() { }\nif (false) {\n    /**\n     * Default politeness for the announcements.\n     * @type {?|undefined}\n     */\n    LiveAnnouncerDefaultOptions.prototype.politeness;\n    /**\n     * Default duration for the announcement messages.\n     * @type {?|undefined}\n     */\n    LiveAnnouncerDefaultOptions.prototype.duration;\n}\n/**\n * Injection token that can be used to configure the default options for the LiveAnnouncer.\n * @type {?}\n */\nconst LIVE_ANNOUNCER_DEFAULT_OPTIONS = new InjectionToken('LIVE_ANNOUNCER_DEFAULT_OPTIONS');\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/live-announcer/live-announcer.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass LiveAnnouncer {\n    /**\n     * @param {?} elementToken\n     * @param {?} _ngZone\n     * @param {?} _document\n     * @param {?=} _defaultOptions\n     */\n    constructor(elementToken, _ngZone, _document, _defaultOptions) {\n        this._ngZone = _ngZone;\n        this._defaultOptions = _defaultOptions;\n        // We inject the live element and document as `any` because the constructor signature cannot\n        // reference browser globals (HTMLElement, Document) on non-browser environments, since having\n        // a class decorator causes TypeScript to preserve the constructor signature types.\n        this._document = _document;\n        this._liveElement = elementToken || this._createLiveElement();\n    }\n    /**\n     * @param {?} message\n     * @param {...?} args\n     * @return {?}\n     */\n    announce(message, ...args) {\n        /** @type {?} */\n        const defaultOptions = this._defaultOptions;\n        /** @type {?} */\n        let politeness;\n        /** @type {?} */\n        let duration;\n        if (args.length === 1 && typeof args[0] === 'number') {\n            duration = args[0];\n        }\n        else {\n            [politeness, duration] = args;\n        }\n        this.clear();\n        clearTimeout(this._previousTimeout);\n        if (!politeness) {\n            politeness =\n                (defaultOptions && defaultOptions.politeness) ? defaultOptions.politeness : 'polite';\n        }\n        if (duration == null && defaultOptions) {\n            duration = defaultOptions.duration;\n        }\n        // TODO: ensure changing the politeness works on all environments we support.\n        this._liveElement.setAttribute('aria-live', politeness);\n        // This 100ms timeout is necessary for some browser + screen-reader combinations:\n        // - Both JAWS and NVDA over IE11 will not announce anything without a non-zero timeout.\n        // - With Chrome and IE11 with NVDA or JAWS, a repeated (identical) message won't be read a\n        //   second time without clearing and then using a non-zero delay.\n        // (using JAWS 17 at time of this writing).\n        return this._ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => {\n            return new Promise((/**\n             * @param {?} resolve\n             * @return {?}\n             */\n            resolve => {\n                clearTimeout(this._previousTimeout);\n                this._previousTimeout = setTimeout((/**\n                 * @return {?}\n                 */\n                () => {\n                    this._liveElement.textContent = message;\n                    resolve();\n                    if (typeof duration === 'number') {\n                        this._previousTimeout = setTimeout((/**\n                         * @return {?}\n                         */\n                        () => this.clear()), duration);\n                    }\n                }), 100);\n            }));\n        }));\n    }\n    /**\n     * Clears the current text from the announcer element. Can be used to prevent\n     * screen readers from reading the text out again while the user is going\n     * through the page landmarks.\n     * @return {?}\n     */\n    clear() {\n        if (this._liveElement) {\n            this._liveElement.textContent = '';\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        clearTimeout(this._previousTimeout);\n        if (this._liveElement && this._liveElement.parentNode) {\n            this._liveElement.parentNode.removeChild(this._liveElement);\n            this._liveElement = (/** @type {?} */ (null));\n        }\n    }\n    /**\n     * @private\n     * @return {?}\n     */\n    _createLiveElement() {\n        /** @type {?} */\n        const elementClass = 'cdk-live-announcer-element';\n        /** @type {?} */\n        const previousElements = this._document.getElementsByClassName(elementClass);\n        /** @type {?} */\n        const liveEl = this._document.createElement('div');\n        // Remove any old containers. This can happen when coming in from a server-side-rendered page.\n        for (let i = 0; i < previousElements.length; i++) {\n            (/** @type {?} */ (previousElements[i].parentNode)).removeChild(previousElements[i]);\n        }\n        liveEl.classList.add(elementClass);\n        liveEl.classList.add('cdk-visually-hidden');\n        liveEl.setAttribute('aria-atomic', 'true');\n        liveEl.setAttribute('aria-live', 'polite');\n        this._document.body.appendChild(liveEl);\n        return liveEl;\n    }\n}\nLiveAnnouncer.ɵfac = function LiveAnnouncer_Factory(t) { return new (t || LiveAnnouncer)(ɵngcc0.ɵɵinject(LIVE_ANNOUNCER_ELEMENT_TOKEN, 8), ɵngcc0.ɵɵinject(ɵngcc0.NgZone), ɵngcc0.ɵɵinject(DOCUMENT), ɵngcc0.ɵɵinject(LIVE_ANNOUNCER_DEFAULT_OPTIONS, 8)); };\n/** @nocollapse */\nLiveAnnouncer.ctorParameters = () => [\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [LIVE_ANNOUNCER_ELEMENT_TOKEN,] }] },\n    { type: NgZone },\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [LIVE_ANNOUNCER_DEFAULT_OPTIONS,] }] }\n];\n/** @nocollapse */ LiveAnnouncer.ɵprov = ɵɵdefineInjectable({ factory: function LiveAnnouncer_Factory() { return new LiveAnnouncer(ɵɵinject(LIVE_ANNOUNCER_ELEMENT_TOKEN, 8), ɵɵinject(NgZone), ɵɵinject(DOCUMENT), ɵɵinject(LIVE_ANNOUNCER_DEFAULT_OPTIONS, 8)); }, token: LiveAnnouncer, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(LiveAnnouncer, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [LIVE_ANNOUNCER_ELEMENT_TOKEN]\n            }] }, { type: ɵngcc0.NgZone }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [LIVE_ANNOUNCER_DEFAULT_OPTIONS]\n            }] }]; }, null); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    LiveAnnouncer.prototype._liveElement;\n    /**\n     * @type {?}\n     * @private\n     */\n    LiveAnnouncer.prototype._document;\n    /**\n     * @type {?}\n     * @private\n     */\n    LiveAnnouncer.prototype._previousTimeout;\n    /**\n     * @type {?}\n     * @private\n     */\n    LiveAnnouncer.prototype._ngZone;\n    /**\n     * @type {?}\n     * @private\n     */\n    LiveAnnouncer.prototype._defaultOptions;\n}\n/**\n * A directive that works similarly to aria-live, but uses the LiveAnnouncer to ensure compatibility\n * with a wider range of browsers and screen readers.\n */\nclass CdkAriaLive {\n    /**\n     * @param {?} _elementRef\n     * @param {?} _liveAnnouncer\n     * @param {?} _contentObserver\n     * @param {?} _ngZone\n     */\n    constructor(_elementRef, _liveAnnouncer, _contentObserver, _ngZone) {\n        this._elementRef = _elementRef;\n        this._liveAnnouncer = _liveAnnouncer;\n        this._contentObserver = _contentObserver;\n        this._ngZone = _ngZone;\n        this._politeness = 'off';\n    }\n    /**\n     * The aria-live politeness level to use when announcing messages.\n     * @return {?}\n     */\n    get politeness() { return this._politeness; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set politeness(value) {\n        this._politeness = value === 'polite' || value === 'assertive' ? value : 'off';\n        if (this._politeness === 'off') {\n            if (this._subscription) {\n                this._subscription.unsubscribe();\n                this._subscription = null;\n            }\n        }\n        else if (!this._subscription) {\n            this._subscription = this._ngZone.runOutsideAngular((/**\n             * @return {?}\n             */\n            () => {\n                return this._contentObserver\n                    .observe(this._elementRef)\n                    .subscribe((/**\n                 * @return {?}\n                 */\n                () => {\n                    // Note that we use textContent here, rather than innerText, in order to avoid a reflow.\n                    /** @type {?} */\n                    const elementText = this._elementRef.nativeElement.textContent;\n                    // The `MutationObserver` fires also for attribute\n                    // changes which we don't want to announce.\n                    if (elementText !== this._previousAnnouncedText) {\n                        this._liveAnnouncer.announce(elementText, this._politeness);\n                        this._previousAnnouncedText = elementText;\n                    }\n                }));\n            }));\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        if (this._subscription) {\n            this._subscription.unsubscribe();\n        }\n    }\n}\nCdkAriaLive.ɵfac = function CdkAriaLive_Factory(t) { return new (t || CdkAriaLive)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(LiveAnnouncer), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.ContentObserver), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone)); };\nCdkAriaLive.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: CdkAriaLive, selectors: [[\"\", \"cdkAriaLive\", \"\"]], inputs: { politeness: [\"cdkAriaLive\", \"politeness\"] }, exportAs: [\"cdkAriaLive\"] });\n/** @nocollapse */\nCdkAriaLive.ctorParameters = () => [\n    { type: ElementRef },\n    { type: LiveAnnouncer },\n    { type: ContentObserver },\n    { type: NgZone }\n];\nCdkAriaLive.propDecorators = {\n    politeness: [{ type: Input, args: ['cdkAriaLive',] }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(CdkAriaLive, [{\n        type: Directive,\n        args: [{\n                selector: '[cdkAriaLive]',\n                exportAs: 'cdkAriaLive'\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: LiveAnnouncer }, { type: ɵngcc2.ContentObserver }, { type: ɵngcc0.NgZone }]; }, { politeness: [{\n            type: Input,\n            args: ['cdkAriaLive']\n        }] }); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkAriaLive.prototype._politeness;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkAriaLive.prototype._previousAnnouncedText;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkAriaLive.prototype._subscription;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkAriaLive.prototype._elementRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkAriaLive.prototype._liveAnnouncer;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkAriaLive.prototype._contentObserver;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkAriaLive.prototype._ngZone;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/fake-mousedown.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 * Screenreaders will often fire fake mousedown events when a focusable element\n * is activated using the keyboard. We can typically distinguish between these faked\n * mousedown events and real mousedown events using the \"buttons\" property. While\n * real mousedowns will indicate the mouse button that was pressed (e.g. \"1\" for\n * the left mouse button), faked mousedowns will usually set the property value to 0.\n * @param {?} event\n * @return {?}\n */\nfunction isFakeMousedownFromScreenReader(event) {\n    return event.buttons === 0;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/focus-monitor/focus-monitor.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n// This is the value used by AngularJS Material. Through trial and error (on iPhone 6S) they found\n// that a value of around 650ms seems appropriate.\n/** @type {?} */\nconst TOUCH_BUFFER_MS = 650;\n/**\n * Corresponds to the options that can be passed to the native `focus` event.\n * via https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus\n * @record\n */\nfunction FocusOptions() { }\nif (false) {\n    /**\n     * Whether the browser should scroll to the element when it is focused.\n     * @type {?|undefined}\n     */\n    FocusOptions.prototype.preventScroll;\n}\n/** @enum {number} */\nconst FocusMonitorDetectionMode = {\n    /**\n     * Any mousedown, keydown, or touchstart event that happened in the previous\n     * tick or the current tick will be used to assign a focus event's origin (to\n     * either mouse, keyboard, or touch). This is the default option.\n     */\n    IMMEDIATE: 0,\n    /**\n     * A focus event's origin is always attributed to the last corresponding\n     * mousedown, keydown, or touchstart event, no matter how long ago it occured.\n     */\n    EVENTUAL: 1,\n};\n/**\n * Injectable service-level options for FocusMonitor.\n * @record\n */\nfunction FocusMonitorOptions() { }\nif (false) {\n    /** @type {?|undefined} */\n    FocusMonitorOptions.prototype.detectionMode;\n}\n/**\n * InjectionToken for FocusMonitorOptions.\n * @type {?}\n */\nconst FOCUS_MONITOR_DEFAULT_OPTIONS = new InjectionToken('cdk-focus-monitor-default-options');\n/**\n * Event listener options that enable capturing and also\n * mark the listener as passive if the browser supports it.\n * @type {?}\n */\nconst captureEventListenerOptions = normalizePassiveListenerOptions({\n    passive: true,\n    capture: true\n});\n/**\n * Monitors mouse and keyboard events to determine the cause of focus events.\n */\nclass FocusMonitor {\n    /**\n     * @param {?} _ngZone\n     * @param {?} _platform\n     * @param {?} document\n     * @param {?} options\n     */\n    constructor(_ngZone, _platform, \n    /** @breaking-change 11.0.0 make document required */\n    document, options) {\n        this._ngZone = _ngZone;\n        this._platform = _platform;\n        /**\n         * The focus origin that the next focus event is a result of.\n         */\n        this._origin = null;\n        /**\n         * Whether the window has just been focused.\n         */\n        this._windowFocused = false;\n        /**\n         * Map of elements being monitored to their info.\n         */\n        this._elementInfo = new Map();\n        /**\n         * The number of elements currently being monitored.\n         */\n        this._monitoredElementCount = 0;\n        /**\n         * Keeps track of the root nodes to which we've currently bound a focus/blur handler,\n         * as well as the number of monitored elements that they contain. We have to treat focus/blur\n         * handlers differently from the rest of the events, because the browser won't emit events\n         * to the document when focus moves inside of a shadow root.\n         */\n        this._rootNodeFocusListenerCount = new Map();\n        /**\n         * Event listener for `keydown` events on the document.\n         * Needs to be an arrow function in order to preserve the context when it gets bound.\n         */\n        this._documentKeydownListener = (/**\n         * @return {?}\n         */\n        () => {\n            // On keydown record the origin and clear any touch event that may be in progress.\n            this._lastTouchTarget = null;\n            this._setOriginForCurrentEventQueue('keyboard');\n        });\n        /**\n         * Event listener for `mousedown` events on the document.\n         * Needs to be an arrow function in order to preserve the context when it gets bound.\n         */\n        this._documentMousedownListener = (/**\n         * @param {?} event\n         * @return {?}\n         */\n        (event) => {\n            // On mousedown record the origin only if there is not touch\n            // target, since a mousedown can happen as a result of a touch event.\n            if (!this._lastTouchTarget) {\n                // In some cases screen readers fire fake `mousedown` events instead of `keydown`.\n                // Resolve the focus source to `keyboard` if we detect one of them.\n                /** @type {?} */\n                const source = isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse';\n                this._setOriginForCurrentEventQueue(source);\n            }\n        });\n        /**\n         * Event listener for `touchstart` events on the document.\n         * Needs to be an arrow function in order to preserve the context when it gets bound.\n         */\n        this._documentTouchstartListener = (/**\n         * @param {?} event\n         * @return {?}\n         */\n        (event) => {\n            // When the touchstart event fires the focus event is not yet in the event queue. This means\n            // we can't rely on the trick used above (setting timeout of 1ms). Instead we wait 650ms to\n            // see if a focus happens.\n            if (this._touchTimeoutId != null) {\n                clearTimeout(this._touchTimeoutId);\n            }\n            this._lastTouchTarget = getTarget(event);\n            this._touchTimeoutId = setTimeout((/**\n             * @return {?}\n             */\n            () => this._lastTouchTarget = null), TOUCH_BUFFER_MS);\n        });\n        /**\n         * Event listener for `focus` events on the window.\n         * Needs to be an arrow function in order to preserve the context when it gets bound.\n         */\n        this._windowFocusListener = (/**\n         * @return {?}\n         */\n        () => {\n            // Make a note of when the window regains focus, so we can\n            // restore the origin info for the focused element.\n            this._windowFocused = true;\n            this._windowFocusTimeoutId = setTimeout((/**\n             * @return {?}\n             */\n            () => this._windowFocused = false));\n        });\n        /**\n         * Event listener for `focus` and 'blur' events on the document.\n         * Needs to be an arrow function in order to preserve the context when it gets bound.\n         */\n        this._rootNodeFocusAndBlurListener = (/**\n         * @param {?} event\n         * @return {?}\n         */\n        (event) => {\n            /** @type {?} */\n            const target = getTarget(event);\n            /** @type {?} */\n            const handler = event.type === 'focus' ? this._onFocus : this._onBlur;\n            // We need to walk up the ancestor chain in order to support `checkChildren`.\n            for (let element = target; element; element = element.parentElement) {\n                handler.call(this, (/** @type {?} */ (event)), element);\n            }\n        });\n        this._document = document;\n        this._detectionMode = (options === null || options === void 0 ? void 0 : options.detectionMode) || 0 /* IMMEDIATE */;\n    }\n    /**\n     * @param {?} element\n     * @param {?=} checkChildren\n     * @return {?}\n     */\n    monitor(element, checkChildren = false) {\n        // Do nothing if we're not on the browser platform.\n        if (!this._platform.isBrowser) {\n            return of(null);\n        }\n        /** @type {?} */\n        const nativeElement = coerceElement(element);\n        // If the element is inside the shadow DOM, we need to bind our focus/blur listeners to\n        // the shadow root, rather than the `document`, because the browser won't emit focus events\n        // to the `document`, if focus is moving within the same shadow root.\n        /** @type {?} */\n        const rootNode = ((/** @type {?} */ (_getShadowRoot(nativeElement)))) || this._getDocument();\n        // Check if we're already monitoring this element.\n        if (this._elementInfo.has(nativeElement)) {\n            /** @type {?} */\n            const cachedInfo = (/** @type {?} */ (this._elementInfo.get(nativeElement)));\n            cachedInfo.checkChildren = checkChildren;\n            return cachedInfo.subject.asObservable();\n        }\n        // Create monitored element info.\n        /** @type {?} */\n        const info = {\n            checkChildren: checkChildren,\n            subject: new Subject(),\n            rootNode\n        };\n        this._elementInfo.set(nativeElement, info);\n        this._registerGlobalListeners(info);\n        return info.subject.asObservable();\n    }\n    /**\n     * @param {?} element\n     * @return {?}\n     */\n    stopMonitoring(element) {\n        /** @type {?} */\n        const nativeElement = coerceElement(element);\n        /** @type {?} */\n        const elementInfo = this._elementInfo.get(nativeElement);\n        if (elementInfo) {\n            elementInfo.subject.complete();\n            this._setClasses(nativeElement);\n            this._elementInfo.delete(nativeElement);\n            this._removeGlobalListeners(elementInfo);\n        }\n    }\n    /**\n     * @param {?} element\n     * @param {?} origin\n     * @param {?=} options\n     * @return {?}\n     */\n    focusVia(element, origin, options) {\n        /** @type {?} */\n        const nativeElement = coerceElement(element);\n        this._setOriginForCurrentEventQueue(origin);\n        // `focus` isn't available on the server\n        if (typeof nativeElement.focus === 'function') {\n            // Cast the element to `any`, because the TS typings don't have the `options` parameter yet.\n            ((/** @type {?} */ (nativeElement))).focus(options);\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._elementInfo.forEach((/**\n         * @param {?} _info\n         * @param {?} element\n         * @return {?}\n         */\n        (_info, element) => this.stopMonitoring(element)));\n    }\n    /**\n     * Access injected document if available or fallback to global document reference\n     * @private\n     * @return {?}\n     */\n    _getDocument() {\n        return this._document || document;\n    }\n    /**\n     * Use defaultView of injected document if available or fallback to global window reference\n     * @private\n     * @return {?}\n     */\n    _getWindow() {\n        /** @type {?} */\n        const doc = this._getDocument();\n        return doc.defaultView || window;\n    }\n    /**\n     * @private\n     * @param {?} element\n     * @param {?} className\n     * @param {?} shouldSet\n     * @return {?}\n     */\n    _toggleClass(element, className, shouldSet) {\n        if (shouldSet) {\n            element.classList.add(className);\n        }\n        else {\n            element.classList.remove(className);\n        }\n    }\n    /**\n     * @private\n     * @param {?} event\n     * @return {?}\n     */\n    _getFocusOrigin(event) {\n        // If we couldn't detect a cause for the focus event, it's due to one of three reasons:\n        // 1) The window has just regained focus, in which case we want to restore the focused state of\n        //    the element from before the window blurred.\n        // 2) It was caused by a touch event, in which case we mark the origin as 'touch'.\n        // 3) The element was programmatically focused, in which case we should mark the origin as\n        //    'program'.\n        if (this._origin) {\n            return this._origin;\n        }\n        if (this._windowFocused && this._lastFocusOrigin) {\n            return this._lastFocusOrigin;\n        }\n        else if (this._wasCausedByTouch(event)) {\n            return 'touch';\n        }\n        else {\n            return 'program';\n        }\n    }\n    /**\n     * Sets the focus classes on the element based on the given focus origin.\n     * @private\n     * @param {?} element The element to update the classes on.\n     * @param {?=} origin The focus origin.\n     * @return {?}\n     */\n    _setClasses(element, origin) {\n        this._toggleClass(element, 'cdk-focused', !!origin);\n        this._toggleClass(element, 'cdk-touch-focused', origin === 'touch');\n        this._toggleClass(element, 'cdk-keyboard-focused', origin === 'keyboard');\n        this._toggleClass(element, 'cdk-mouse-focused', origin === 'mouse');\n        this._toggleClass(element, 'cdk-program-focused', origin === 'program');\n    }\n    /**\n     * Sets the origin and schedules an async function to clear it at the end of the event queue.\n     * If the detection mode is 'eventual', the origin is never cleared.\n     * @private\n     * @param {?} origin The origin to set.\n     * @return {?}\n     */\n    _setOriginForCurrentEventQueue(origin) {\n        this._ngZone.runOutsideAngular((/**\n         * @return {?}\n         */\n        () => {\n            this._origin = origin;\n            if (this._detectionMode === 0 /* IMMEDIATE */) {\n                // Sometimes the focus origin won't be valid in Firefox because Firefox seems to focus *one*\n                // tick after the interaction event fired. To ensure the focus origin is always correct,\n                // the focus origin will be determined at the beginning of the next tick.\n                this._originTimeoutId = setTimeout((/**\n                 * @return {?}\n                 */\n                () => this._origin = null), 1);\n            }\n        }));\n    }\n    /**\n     * Checks whether the given focus event was caused by a touchstart event.\n     * @private\n     * @param {?} event The focus event to check.\n     * @return {?} Whether the event was caused by a touch.\n     */\n    _wasCausedByTouch(event) {\n        // Note(mmalerba): This implementation is not quite perfect, there is a small edge case.\n        // Consider the following dom structure:\n        //\n        // <div #parent tabindex=\"0\" cdkFocusClasses>\n        //   <div #child (click)=\"#parent.focus()\"></div>\n        // </div>\n        //\n        // If the user touches the #child element and the #parent is programmatically focused as a\n        // result, this code will still consider it to have been caused by the touch event and will\n        // apply the cdk-touch-focused class rather than the cdk-program-focused class. This is a\n        // relatively small edge-case that can be worked around by using\n        // focusVia(parentEl, 'program') to focus the parent element.\n        //\n        // If we decide that we absolutely must handle this case correctly, we can do so by listening\n        // for the first focus event after the touchstart, and then the first blur event after that\n        // focus event. When that blur event fires we know that whatever follows is not a result of the\n        // touchstart.\n        /** @type {?} */\n        const focusTarget = getTarget(event);\n        return this._lastTouchTarget instanceof Node && focusTarget instanceof Node &&\n            (focusTarget === this._lastTouchTarget || focusTarget.contains(this._lastTouchTarget));\n    }\n    /**\n     * Handles focus events on a registered element.\n     * @private\n     * @param {?} event The focus event.\n     * @param {?} element The monitored element.\n     * @return {?}\n     */\n    _onFocus(event, element) {\n        // NOTE(mmalerba): We currently set the classes based on the focus origin of the most recent\n        // focus event affecting the monitored element. If we want to use the origin of the first event\n        // instead we should check for the cdk-focused class here and return if the element already has\n        // it. (This only matters for elements that have includesChildren = true).\n        // NOTE(mmalerba): We currently set the classes based on the focus origin of the most recent\n        // focus event affecting the monitored element. If we want to use the origin of the first event\n        // instead we should check for the cdk-focused class here and return if the element already has\n        // it. (This only matters for elements that have includesChildren = true).\n        // If we are not counting child-element-focus as focused, make sure that the event target is the\n        // monitored element itself.\n        /** @type {?} */\n        const elementInfo = this._elementInfo.get(element);\n        if (!elementInfo || (!elementInfo.checkChildren && element !== getTarget(event))) {\n            return;\n        }\n        /** @type {?} */\n        const origin = this._getFocusOrigin(event);\n        this._setClasses(element, origin);\n        this._emitOrigin(elementInfo.subject, origin);\n        this._lastFocusOrigin = origin;\n    }\n    /**\n     * Handles blur events on a registered element.\n     * @param {?} event The blur event.\n     * @param {?} element The monitored element.\n     * @return {?}\n     */\n    _onBlur(event, element) {\n        // If we are counting child-element-focus as focused, make sure that we aren't just blurring in\n        // order to focus another child of the monitored element.\n        /** @type {?} */\n        const elementInfo = this._elementInfo.get(element);\n        if (!elementInfo || (elementInfo.checkChildren && event.relatedTarget instanceof Node &&\n            element.contains(event.relatedTarget))) {\n            return;\n        }\n        this._setClasses(element);\n        this._emitOrigin(elementInfo.subject, null);\n    }\n    /**\n     * @private\n     * @param {?} subject\n     * @param {?} origin\n     * @return {?}\n     */\n    _emitOrigin(subject, origin) {\n        this._ngZone.run((/**\n         * @return {?}\n         */\n        () => subject.next(origin)));\n    }\n    /**\n     * @private\n     * @param {?} elementInfo\n     * @return {?}\n     */\n    _registerGlobalListeners(elementInfo) {\n        if (!this._platform.isBrowser) {\n            return;\n        }\n        /** @type {?} */\n        const rootNode = elementInfo.rootNode;\n        /** @type {?} */\n        const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode) || 0;\n        if (!rootNodeFocusListeners) {\n            this._ngZone.runOutsideAngular((/**\n             * @return {?}\n             */\n            () => {\n                rootNode.addEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);\n                rootNode.addEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);\n            }));\n        }\n        this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners + 1);\n        // Register global listeners when first element is monitored.\n        if (++this._monitoredElementCount === 1) {\n            // Note: we listen to events in the capture phase so we\n            // can detect them even if the user stops propagation.\n            this._ngZone.runOutsideAngular((/**\n             * @return {?}\n             */\n            () => {\n                /** @type {?} */\n                const document = this._getDocument();\n                /** @type {?} */\n                const window = this._getWindow();\n                document.addEventListener('keydown', this._documentKeydownListener, captureEventListenerOptions);\n                document.addEventListener('mousedown', this._documentMousedownListener, captureEventListenerOptions);\n                document.addEventListener('touchstart', this._documentTouchstartListener, captureEventListenerOptions);\n                window.addEventListener('focus', this._windowFocusListener);\n            }));\n        }\n    }\n    /**\n     * @private\n     * @param {?} elementInfo\n     * @return {?}\n     */\n    _removeGlobalListeners(elementInfo) {\n        /** @type {?} */\n        const rootNode = elementInfo.rootNode;\n        if (this._rootNodeFocusListenerCount.has(rootNode)) {\n            /** @type {?} */\n            const rootNodeFocusListeners = (/** @type {?} */ (this._rootNodeFocusListenerCount.get(rootNode)));\n            if (rootNodeFocusListeners > 1) {\n                this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners - 1);\n            }\n            else {\n                rootNode.removeEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);\n                rootNode.removeEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);\n                this._rootNodeFocusListenerCount.delete(rootNode);\n            }\n        }\n        // Unregister global listeners when last element is unmonitored.\n        if (!--this._monitoredElementCount) {\n            /** @type {?} */\n            const document = this._getDocument();\n            /** @type {?} */\n            const window = this._getWindow();\n            document.removeEventListener('keydown', this._documentKeydownListener, captureEventListenerOptions);\n            document.removeEventListener('mousedown', this._documentMousedownListener, captureEventListenerOptions);\n            document.removeEventListener('touchstart', this._documentTouchstartListener, captureEventListenerOptions);\n            window.removeEventListener('focus', this._windowFocusListener);\n            // Clear timeouts for all potentially pending timeouts to prevent the leaks.\n            clearTimeout(this._windowFocusTimeoutId);\n            clearTimeout(this._touchTimeoutId);\n            clearTimeout(this._originTimeoutId);\n        }\n    }\n}\nFocusMonitor.ɵfac = function FocusMonitor_Factory(t) { return new (t || FocusMonitor)(ɵngcc0.ɵɵinject(ɵngcc0.NgZone), ɵngcc0.ɵɵinject(ɵngcc1.Platform), ɵngcc0.ɵɵinject(DOCUMENT, 8), ɵngcc0.ɵɵinject(FOCUS_MONITOR_DEFAULT_OPTIONS, 8)); };\n/** @nocollapse */\nFocusMonitor.ctorParameters = () => [\n    { type: NgZone },\n    { type: Platform },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [FOCUS_MONITOR_DEFAULT_OPTIONS,] }] }\n];\n/** @nocollapse */ FocusMonitor.ɵprov = ɵɵdefineInjectable({ factory: function FocusMonitor_Factory() { return new FocusMonitor(ɵɵinject(NgZone), ɵɵinject(Platform), ɵɵinject(DOCUMENT, 8), ɵɵinject(FOCUS_MONITOR_DEFAULT_OPTIONS, 8)); }, token: FocusMonitor, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(FocusMonitor, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: ɵngcc0.NgZone }, { type: ɵngcc1.Platform }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [DOCUMENT]\n            }] }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [FOCUS_MONITOR_DEFAULT_OPTIONS]\n            }] }]; }, null); })();\nif (false) {\n    /**\n     * The focus origin that the next focus event is a result of.\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._origin;\n    /**\n     * The FocusOrigin of the last focus event tracked by the FocusMonitor.\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._lastFocusOrigin;\n    /**\n     * Whether the window has just been focused.\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._windowFocused;\n    /**\n     * The target of the last touch event.\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._lastTouchTarget;\n    /**\n     * The timeout id of the touch timeout, used to cancel timeout later.\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._touchTimeoutId;\n    /**\n     * The timeout id of the window focus timeout.\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._windowFocusTimeoutId;\n    /**\n     * The timeout id of the origin clearing timeout.\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._originTimeoutId;\n    /**\n     * Map of elements being monitored to their info.\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._elementInfo;\n    /**\n     * The number of elements currently being monitored.\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._monitoredElementCount;\n    /**\n     * Keeps track of the root nodes to which we've currently bound a focus/blur handler,\n     * as well as the number of monitored elements that they contain. We have to treat focus/blur\n     * handlers differently from the rest of the events, because the browser won't emit events\n     * to the document when focus moves inside of a shadow root.\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._rootNodeFocusListenerCount;\n    /**\n     * The specified detection mode, used for attributing the origin of a focus\n     * event.\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._detectionMode;\n    /**\n     * Event listener for `keydown` events on the document.\n     * Needs to be an arrow function in order to preserve the context when it gets bound.\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._documentKeydownListener;\n    /**\n     * Event listener for `mousedown` events on the document.\n     * Needs to be an arrow function in order to preserve the context when it gets bound.\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._documentMousedownListener;\n    /**\n     * Event listener for `touchstart` events on the document.\n     * Needs to be an arrow function in order to preserve the context when it gets bound.\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._documentTouchstartListener;\n    /**\n     * Event listener for `focus` events on the window.\n     * Needs to be an arrow function in order to preserve the context when it gets bound.\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._windowFocusListener;\n    /**\n     * Used to reference correct document/window\n     * @type {?}\n     * @protected\n     */\n    FocusMonitor.prototype._document;\n    /**\n     * Event listener for `focus` and 'blur' events on the document.\n     * Needs to be an arrow function in order to preserve the context when it gets bound.\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._rootNodeFocusAndBlurListener;\n    /**\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._ngZone;\n    /**\n     * @type {?}\n     * @private\n     */\n    FocusMonitor.prototype._platform;\n}\n/**\n * Gets the target of an event, accounting for Shadow DOM.\n * @param {?} event\n * @return {?}\n */\nfunction getTarget(event) {\n    // If an event is bound outside the Shadow DOM, the `event.target` will\n    // point to the shadow root so we have to use `composedPath` instead.\n    return (/** @type {?} */ ((event.composedPath ? event.composedPath()[0] : event.target)));\n}\n/**\n * Directive that determines how a particular element was focused (via keyboard, mouse, touch, or\n * programmatically) and adds corresponding classes to the element.\n *\n * There are two variants of this directive:\n * 1) cdkMonitorElementFocus: does not consider an element to be focused if one of its children is\n *    focused.\n * 2) cdkMonitorSubtreeFocus: considers an element focused if it or any of its children are focused.\n */\nclass CdkMonitorFocus {\n    /**\n     * @param {?} _elementRef\n     * @param {?} _focusMonitor\n     */\n    constructor(_elementRef, _focusMonitor) {\n        this._elementRef = _elementRef;\n        this._focusMonitor = _focusMonitor;\n        this.cdkFocusChange = new EventEmitter();\n        this._monitorSubscription = this._focusMonitor.monitor(this._elementRef, this._elementRef.nativeElement.hasAttribute('cdkMonitorSubtreeFocus'))\n            .subscribe((/**\n         * @param {?} origin\n         * @return {?}\n         */\n        origin => this.cdkFocusChange.emit(origin)));\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._focusMonitor.stopMonitoring(this._elementRef);\n        this._monitorSubscription.unsubscribe();\n    }\n}\nCdkMonitorFocus.ɵfac = function CdkMonitorFocus_Factory(t) { return new (t || CdkMonitorFocus)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(FocusMonitor)); };\nCdkMonitorFocus.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: CdkMonitorFocus, selectors: [[\"\", \"cdkMonitorElementFocus\", \"\"], [\"\", \"cdkMonitorSubtreeFocus\", \"\"]], outputs: { cdkFocusChange: \"cdkFocusChange\" } });\n/** @nocollapse */\nCdkMonitorFocus.ctorParameters = () => [\n    { type: ElementRef },\n    { type: FocusMonitor }\n];\nCdkMonitorFocus.propDecorators = {\n    cdkFocusChange: [{ type: Output }]\n};\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(CdkMonitorFocus, [{\n        type: Directive,\n        args: [{\n                selector: '[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]'\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: FocusMonitor }]; }, { cdkFocusChange: [{\n            type: Output\n        }] }); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkMonitorFocus.prototype._monitorSubscription;\n    /** @type {?} */\n    CdkMonitorFocus.prototype.cdkFocusChange;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkMonitorFocus.prototype._elementRef;\n    /**\n     * @type {?}\n     * @private\n     */\n    CdkMonitorFocus.prototype._focusMonitor;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/high-contrast-mode/high-contrast-mode-detector.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @enum {number} */\nconst HighContrastMode = {\n    NONE: 0,\n    BLACK_ON_WHITE: 1,\n    WHITE_ON_BLACK: 2,\n};\n/**\n * CSS class applied to the document body when in black-on-white high-contrast mode.\n * @type {?}\n */\nconst BLACK_ON_WHITE_CSS_CLASS = 'cdk-high-contrast-black-on-white';\n/**\n * CSS class applied to the document body when in white-on-black high-contrast mode.\n * @type {?}\n */\nconst WHITE_ON_BLACK_CSS_CLASS = 'cdk-high-contrast-white-on-black';\n/**\n * CSS class applied to the document body when in high-contrast mode.\n * @type {?}\n */\nconst HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS = 'cdk-high-contrast-active';\n/**\n * Service to determine whether the browser is currently in a high-contrast-mode environment.\n *\n * Microsoft Windows supports an accessibility feature called \"High Contrast Mode\". This mode\n * changes the appearance of all applications, including web applications, to dramatically increase\n * contrast.\n *\n * IE, Edge, and Firefox currently support this mode. Chrome does not support Windows High Contrast\n * Mode. This service does not detect high-contrast mode as added by the Chrome \"High Contrast\"\n * browser extension.\n */\nclass HighContrastModeDetector {\n    /**\n     * @param {?} _platform\n     * @param {?} document\n     */\n    constructor(_platform, document) {\n        this._platform = _platform;\n        this._document = document;\n    }\n    /**\n     * Gets the current high-contrast-mode for the page.\n     * @return {?}\n     */\n    getHighContrastMode() {\n        if (!this._platform.isBrowser) {\n            return 0 /* NONE */;\n        }\n        // Create a test element with an arbitrary background-color that is neither black nor\n        // white; high-contrast mode will coerce the color to either black or white. Also ensure that\n        // appending the test element to the DOM does not affect layout by absolutely positioning it\n        /** @type {?} */\n        const testElement = this._document.createElement('div');\n        testElement.style.backgroundColor = 'rgb(1,2,3)';\n        testElement.style.position = 'absolute';\n        this._document.body.appendChild(testElement);\n        // Get the computed style for the background color, collapsing spaces to normalize between\n        // browsers. Once we get this color, we no longer need the test element. Access the `window`\n        // via the document so we can fake it in tests. Note that we have extra null checks, because\n        // this logic will likely run during app bootstrap and throwing can break the entire app.\n        /** @type {?} */\n        const documentWindow = this._document.defaultView || window;\n        /** @type {?} */\n        const computedStyle = (documentWindow && documentWindow.getComputedStyle) ?\n            documentWindow.getComputedStyle(testElement) : null;\n        /** @type {?} */\n        const computedColor = (computedStyle && computedStyle.backgroundColor || '').replace(/ /g, '');\n        this._document.body.removeChild(testElement);\n        switch (computedColor) {\n            case 'rgb(0,0,0)': return 2 /* WHITE_ON_BLACK */;\n            case 'rgb(255,255,255)': return 1 /* BLACK_ON_WHITE */;\n        }\n        return 0 /* NONE */;\n    }\n    /**\n     * Applies CSS classes indicating high-contrast mode to document body (browser-only).\n     * @return {?}\n     */\n    _applyBodyHighContrastModeCssClasses() {\n        if (this._platform.isBrowser && this._document.body) {\n            /** @type {?} */\n            const bodyClasses = this._document.body.classList;\n            // IE11 doesn't support `classList` operations with multiple arguments\n            bodyClasses.remove(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS);\n            bodyClasses.remove(BLACK_ON_WHITE_CSS_CLASS);\n            bodyClasses.remove(WHITE_ON_BLACK_CSS_CLASS);\n            /** @type {?} */\n            const mode = this.getHighContrastMode();\n            if (mode === 1 /* BLACK_ON_WHITE */) {\n                bodyClasses.add(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS);\n                bodyClasses.add(BLACK_ON_WHITE_CSS_CLASS);\n            }\n            else if (mode === 2 /* WHITE_ON_BLACK */) {\n                bodyClasses.add(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS);\n                bodyClasses.add(WHITE_ON_BLACK_CSS_CLASS);\n            }\n        }\n    }\n}\nHighContrastModeDetector.ɵfac = function HighContrastModeDetector_Factory(t) { return new (t || HighContrastModeDetector)(ɵngcc0.ɵɵinject(ɵngcc1.Platform), ɵngcc0.ɵɵinject(DOCUMENT)); };\n/** @nocollapse */\nHighContrastModeDetector.ctorParameters = () => [\n    { type: Platform },\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }\n];\n/** @nocollapse */ HighContrastModeDetector.ɵprov = ɵɵdefineInjectable({ factory: function HighContrastModeDetector_Factory() { return new HighContrastModeDetector(ɵɵinject(Platform), ɵɵinject(DOCUMENT)); }, token: HighContrastModeDetector, providedIn: \"root\" });\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(HighContrastModeDetector, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: ɵngcc1.Platform }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }]; }, null); })();\nif (false) {\n    /**\n     * @type {?}\n     * @private\n     */\n    HighContrastModeDetector.prototype._document;\n    /**\n     * @type {?}\n     * @private\n     */\n    HighContrastModeDetector.prototype._platform;\n}\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/a11y-module.ts\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass A11yModule {\n    /**\n     * @param {?} highContrastModeDetector\n     */\n    constructor(highContrastModeDetector) {\n        highContrastModeDetector._applyBodyHighContrastModeCssClasses();\n    }\n}\nA11yModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: A11yModule });\nA11yModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function A11yModule_Factory(t) { return new (t || A11yModule)(ɵngcc0.ɵɵinject(HighContrastModeDetector)); }, imports: [[PlatformModule, ObserversModule]] });\n/** @nocollapse */\nA11yModule.ctorParameters = () => [\n    { type: HighContrastModeDetector }\n];\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(A11yModule, { declarations: function () { return [CdkAriaLive,\n        CdkTrapFocus,\n        CdkMonitorFocus]; }, imports: function () { return [PlatformModule, ObserversModule]; }, exports: function () { return [CdkAriaLive,\n        CdkTrapFocus,\n        CdkMonitorFocus]; } }); })();\n/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(A11yModule, [{\n        type: NgModule,\n        args: [{\n                imports: [PlatformModule, ObserversModule],\n                declarations: [CdkAriaLive, CdkTrapFocus, CdkMonitorFocus],\n                exports: [CdkAriaLive, CdkTrapFocus, CdkMonitorFocus]\n            }]\n    }], function () { return [{ type: HighContrastModeDetector }]; }, null); })();\n\n/**\n * @fileoverview added by tsickle\n * Generated from: src/cdk/a11y/public-api.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 { A11yModule, ActiveDescendantKeyManager, AriaDescriber, CDK_DESCRIBEDBY_HOST_ATTRIBUTE, CDK_DESCRIBEDBY_ID_PREFIX, CdkAriaLive, CdkMonitorFocus, CdkTrapFocus, ConfigurableFocusTrap, ConfigurableFocusTrapFactory, EventListenerFocusTrapInertStrategy, FOCUS_MONITOR_DEFAULT_OPTIONS, FOCUS_TRAP_INERT_STRATEGY, FocusKeyManager, FocusMonitor, FocusTrap, FocusTrapFactory, HighContrastModeDetector, InteractivityChecker, LIVE_ANNOUNCER_DEFAULT_OPTIONS, LIVE_ANNOUNCER_ELEMENT_TOKEN, LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY, ListKeyManager, LiveAnnouncer, MESSAGES_CONTAINER_ID, TOUCH_BUFFER_MS, isFakeMousedownFromScreenReader, FocusTrapManager as ɵangular_material_src_cdk_a11y_a11y_a, ConfigurableFocusTrapConfig as ɵangular_material_src_cdk_a11y_a11y_b };\n\n//# sourceMappingURL=a11y.js.map","import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\n\r\nimport { IconComponent } from './icon.shared.component';\r\n\r\n@NgModule({\r\n    declarations: [\r\n        IconComponent,\r\n    ],\r\n    imports: [CommonModule],\r\n    exports: [\r\n        IconComponent,\r\n    ],\r\n    providers: [],\r\n})\r\nexport class IconModule { }\r\n","import { Component, Input } from '@angular/core';\r\n\r\n@Component({\r\n    selector: 'shared-icon',\r\n    templateUrl: './icon.shared.component.html',\r\n    styleUrls: ['./icon.shared.component.scss']\r\n})\r\nexport class IconComponent {\r\n    @Input() public icon: string;\r\n}\r\n","<div class=\"icon {{icon ? ' -icon-'+icon : ''}}\"></div>"]}