{"version":3,"file":"default-src_app_services_shared-methods_service_ts-src_app_services_user_service_ts-src_app_s-e432cc.js","mappings":"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","names":["SharedMethodsService","constructor","router","dialog","this","formatDate","param","d","Date","month","getMonth","day","getDate","year","getFullYear","length","join","formatDateWithTime","date","String","padStart","formatDateWithTime2","hours","getHours","minutes","getMinutes","Number","ChangeDateFormate","dob","split","formatDateForInterviewPerforma","logOut","sessionStorage","clear","navigate","allowOnlyDigits","event","inputChar","fromCharCode","charCode","keyCode","test","preventDefault","allowDigitsWithSpecialChar","specialChar","pattern","RegExp","allowOnlyAlphaNumeric","allowAlphaNumericWithSpecialChar","replace","allowOnlyAlphabets","sortArrayObject","objectToSort","parameterName","sort","a","b","fa","toLowerCase","fb","convertToBase64","file","Promise","resolve","reject","reader","FileReader","readAsDataURL","onload","base64String","result","substring","indexOf","onerror","error","filterList","list","key","value","filter","item","isLeapYearCheck","date365DaysAfter","currentDate","currentYear","setFullYear","setDate","formattedDate","toISOString","console","log","_angular_core__WEBPACK_IMPORTED_MODULE_0__","factory","UserService","http","window","btoa","createHeaders","basicAuthHeaderString","getItem","_angular_common_http__WEBPACK_IMPORTED_MODULE_1__","apiKey","Authorization","createHeadersCandidate","getLoggedInUsers","userDetails","userType","headers","url","src_environments_environment__WEBPACK_IMPORTED_MODULE_0__","managerRefNo","aadhaarNumber","get","getMaster","phaseNo","getPostalCode","pincode","getAadhar","aadharno","registrationNo","loadId","regno","updateId","req","post","loadPersonalDetails","savePersonalDetails","updatePersonalDetails","phase","getLoggedInRegisterUser","existingUserDetails","registerNumber","aadharNo","getQualificationDetails","regNo","pushQualificationDetails","getFamilyDetails","Phase","pushFamilyDetails","getExperienceDetails","pushExperienceDetails","appUserName","loadEMR","updateEMR","adminFilterTrnLoadMasters","staffCode","adminFilterTrnLoadData","trn","div","tc","fromDate","toDate","getAdminFilterTrnViaAadhaar","aadhaarNo","getRPTInterviewPerformaTrn","regNos","getRPTInterviewPerformaNewPer","getUserProfile","getUserRole","approveRecords","data","updateTraining","updateDivision","getAttendanceMarkerMasters","getAttendanceMarkerTrn","level","getAttendanceMarkingData","trnNo","saveMarkedAttendance","adminLogin","formData","username","password","setItem","body","USERID","PASSWD","getOrgEvalMasters","getOrgEvalLoadTraining","getOrgEvalLoadCandidate","trnPeriod","getOrgEvalLoadEvaluation","getOrgEvalRemoveEvaluation","tCode","getOrganizerEvaluation","trnCode","orgCode","divCode","getOrgEvalSaveEvaluation","reqBody","getIntAssgnLoadCandidate","division","group","action","round","getIntAssgnLoadGrpDetails","getIntAssgnCreateGroup","groupName","allowedCandidate","getIntAssgnTransferCandidate","trainingPrd","getIntAssgnRemoveCandidate","getOrgMasterLoadMasters","groupMaintenanceLoadGroups","getDocumentList","M_CODE","uploadDocuments","payload","FormData","forEach","append","name","JSON","stringify","listdata","removedFiles","set","onFinalSave","onHRFinalSave","getFCList","getMastersJCFC","pageName","getRecordJCFC","candidateCode","saveRecordsJCFC","saveRecordsJCEXP","getJoineeListFC","getPostalCodeJCFC","pinCode","getManagerJCFC","getFCCandidateList","trnDate","itapNo","getExpCandidateList","getAppointmentLetterData","candidateCodeList","getOrganizerEvaluationFC","canCode","directApplicant","adminFilterDivisionLoadMasters","adminFilterDivisionLoadTableData","empCode","adminFilterDivisionSaveUpdateTableData","varDivision","varRole","varEmpName","varActive","updateID","bankMasterGet","funcForSaveBankMasterDetail","CRTD_BY","_reqParam","Array","funcForSaveIFSCMasterDetail","funcForGetIFSC","bankId","loadCandidate","loadRecord","candidateRecord","loadMasters","loadPostalCode","candidateSaveData","SaveFL","firstLine","T_CODE","salaryMasterLoad","salaryMasterGetLoad","matData","designation","state","hq","funForUnlockRecord","adminFilterTrnPreJoiningLoadMasters","_angular_core__WEBPACK_IMPORTED_MODULE_2__","SharedModule","_angular_common__WEBPACK_IMPORTED_MODULE_1__","_angular_material_chips__WEBPACK_IMPORTED_MODULE_2__","_angular_material_checkbox__WEBPACK_IMPORTED_MODULE_3__","_angular_material_icon__WEBPACK_IMPORTED_MODULE_4__","_angular_material_button__WEBPACK_IMPORTED_MODULE_5__","_angular_material_select__WEBPACK_IMPORTED_MODULE_6__","_angular_material_radio__WEBPACK_IMPORTED_MODULE_7__","_angular_material_autocomplete__WEBPACK_IMPORTED_MODULE_8__","_angular_material_table__WEBPACK_IMPORTED_MODULE_9__","_angular_material_expansion__WEBPACK_IMPORTED_MODULE_10__","_angular_material_progress_bar__WEBPACK_IMPORTED_MODULE_11__","_angular_material_tooltip__WEBPACK_IMPORTED_MODULE_12__","forkJoin","args","resultSelector","popResultSelector","sources","keys","argsArgArrayOrObject","Observable","subscriber","complete","values","remainingCompletions","remainingEmissions","sourceIndex","hasValue","innerFrom","subscribe","createOperatorSubscriber","undefined","next","createObject","pipe","mapOneOrManyArgs","delayWhen","delayDurationSelector","subscriptionDelay","source","concat","take","ignoreElements","operate","noop","mergeMap","index","mapTo","delay","due","scheduler","asyncScheduler","duration","timer","BaseControlValueAccessor","_renderer","_elementRef","onChange","_","onTouched","setProperty","nativeElement","registerOnTouched","fn","registerOnChange","setDisabledState","isDisabled","ɵfac","i0","ɵdir","BuiltInControlValueAccessor","t","features","NG_VALUE_ACCESSOR","InjectionToken","CHECKBOX_VALUE_ACCESSOR","provide","useExisting","forwardRef","CheckboxControlValueAccessor","multi","writeValue","selectors","ctx","DEFAULT_VALUE_ACCESSOR","DefaultValueAccessor","COMPOSITION_BUFFER_MODE","renderer","elementRef","_compositionMode","super","_composing","_isAndroid","userAgent","ɵgetDOM","getUserAgent","normalizedValue","_handleInput","_compositionStart","_compositionEnd","isEmptyInputValue","isArray","hasValidLength","NG_VALIDATORS","NG_ASYNC_VALIDATORS","EMAIL_REGEXP","Validators","static","min","minValidator","max","maxValidator","control","requiredValidator","requiredTrueValidator","emailValidator","minLength","minLengthValidator","maxLength","maxLengthValidator","patternValidator","validators","compose","composeAsync","parseFloat","isNaN","actual","required","email","minlength","requiredLength","actualLength","maxlength","nullValidator","regex","regexStr","charAt","toString","requiredPattern","actualValue","isPresent","o","toObservable","obs","ɵisPromise","from","mergeErrors","arrayOfErrors","res","errors","Object","executeValidators","map","validator","normalizeValidators","isValidatorFn","validate","c","presentValidators","composeValidators","observables","composeAsyncValidators","mergeValidators","controlValidators","dirValidator","getControlValidators","_rawValidators","getControlAsyncValidators","_rawAsyncValidators","makeValidatorsArray","hasValidator","includes","addValidators","currentValidators","current","validatorsToAdd","v","push","removeValidators","AbstractControlDirective","_onDestroyCallbacks","valid","invalid","pending","disabled","enabled","pristine","dirty","touched","status","untouched","statusChanges","valueChanges","path","_setValidators","_composedValidatorFn","_setAsyncValidators","_composedAsyncValidatorFn","asyncValidator","_registerOnDestroy","_invokeOnDestroyCallbacks","reset","hasError","errorCode","getError","ControlContainer","formDirective","NgControl","arguments","_parent","valueAccessor","AbstractControlStatus","cd","_cd","isTouched","isUntouched","isPristine","isDirty","isValid","isInvalid","isPending","isSubmitted","submitted","NgControlStatus","NgControlStatusGroup","VALID","INVALID","PENDING","DISABLED","pickValidators","validatorOrOpts","isOptionsObj","coerceToValidator","pickAsyncValidators","asyncValidators","coerceToAsyncValidator","assertControlPresent","parent","isGroup","controls","ɵRuntimeError","assertAllValuesPresent","_forEachChild","AbstractControl","_pendingDirty","_hasOwnPendingAsyncValidator","_pendingTouched","_onCollectionChange","_onDisabledChange","validatorFn","asyncValidatorFn","updateOn","_updateOn","setValidators","setAsyncValidators","addAsyncValidators","removeAsyncValidators","hasAsyncValidator","clearValidators","clearAsyncValidators","markAsTouched","opts","onlySelf","markAllAsTouched","markAsUntouched","_updateTouched","markAsDirty","markAsPristine","_updatePristine","markAsPending","emitEvent","emit","disable","skipPristineCheck","_parentMarkedDirty","_updateValue","_updateAncestors","changeFn","enable","updateValueAndValidity","setParent","getRawValue","_setInitialStatus","_cancelExistingSubscription","_runValidator","_calculateStatus","_runAsyncValidator","_updateTreeValidity","ctrl","_allControlsDisabled","_asyncValidationSubscription","setErrors","unsubscribe","_updateControlsErrors","currPath","reduce","_find","root","x","_initObservables","EventEmitter","_anyControlsHaveStatus","_anyControls","_anyControlsDirty","_anyControlsTouched","_registerOnCollectionChange","_setUpdateStrategy","parentDirty","FormGroup","_setUpControls","registerControl","addControl","options","removeControl","setControl","contains","controlName","hasOwnProperty","setValue","patchValue","_reduceChildren","acc","_syncPendingControls","subtreeUpdated","updated","child","cb","_reduceValue","condition","entries","initValue","FormRecord","controlPath","setUpControl","dir","setUpValidators","setUpViewChangePipeline","newValue","_pendingValue","_pendingChange","updateControl","setUpModelChangePipeline","emitModelEvent","viewToModelUpdate","_unregisterOnChange","setUpBlurPipeline","setUpDisabledChangeHandler","onDisabledChange","registerOnDisabledChange","_unregisterOnDisabledChange","cleanUpControl","validateControlPresenceOnChange","cleanUpValidators","registerOnValidatorChange","onValidatorChange","isControlUpdated","updatedValidators","updatedAsyncValidators","emitModelToViewChange","setUpFormContainer","isPropertyUpdated","changes","viewModel","change","model","isFirstChange","is","currentValue","syncPendingControls","form","directives","selectValueAccessor","valueAccessors","defaultAccessor","builtinAccessor","customAccessor","isBuiltInAccessor","getPrototypeOf","formDirectiveProvider$1","NgForm","resolvedPromise$1","_directives","Set","ngSubmit","ngAfterViewInit","then","container","_findContainer","add","getControl","delete","addFormGroup","removeFormGroup","getFormGroup","updateModel","onSubmit","$event","target","method","onReset","resetForm","pop","removeListItem","el","splice","isFormControlState","formState","FormControl","defaultValue","_onChange","_applyFormState","nonNullable","initialValueIsDefault","emitViewToModelChange","AbstractFormGroupDirective","ngOnInit","_checkParentType","ngOnDestroy","modelGroupProvider","NgModelGroup","formControlBinding$1","NgModel","resolvedPromise","_changeDetectorRef","_registered","update","ngOnChanges","_checkForErrors","_checkName","oldName","previousValue","_getPath","_setUpControl","_updateDisabled","_isStandalone","_setUpStandalone","standalone","markForCheck","disabledValue","ɵcoerceToBoolean","ChangeDetectorRef","ɵNgNoValidate","NUMBER_VALUE_ACCESSOR","NumberValueAccessor","RADIO_VALUE_ACCESSOR","RadioControlValueAccessor","RadioControlRegistryModule","ɵmod","ɵinj","RadioControlRegistry","_accessors","accessor","remove","i","select","_isSameGroup","fireUncheck","controlPair","_control","ɵprov","_registry","_injector","_state","_fn","formControlName","RANGE_VALUE_ACCESSOR","RangeValueAccessor","NG_MODEL_WITH_FORM_CONTROL_WARNING","formControlBinding","FormControlDirective","_ngModelWarningConfig","_ngModelWarningSent","_isControlChanged","previousForm","_ngModelWarningSentOnce","formDirectiveProvider","FormGroupDirective","_updateDomValue","_checkFormPresent","_updateValidators","_updateRegistrations","_oldForm","removeListItem$1","_setUpFormContainer","_cleanUpFormContainer","addFormArray","removeFormArray","getFormArray","oldCtrl","newCtrl","cleanUpFormContainer","formGroupNameProvider","FormGroupName","_hasInvalidParent","formArrayNameProvider","FormArrayName","controlNameBinding","FormControlName","_added","SELECT_VALUE_ACCESSOR","SelectControlValueAccessor","_buildValueString$1","id","slice","_optionMap","Map","_idCounter","_compareWith","compareWith","valueString","_getOptionId","_getOptionValue","_registerOption","_extractId$1","has","NgSelectOption","_element","_select","ngValue","_setElementValue","SELECT_MULTIPLE_VALUE_ACCESSOR","SelectMultipleControlValueAccessor","_buildValueString","optionSelectedStateSetter","ids","opt","_setSelected","element","selected","selectedOptions","val","_value","_extractId","ɵNgSelectMultipleOption","toInteger","parseInt","toFloat","AbstractValidatorDirective","_validator","inputName","input","normalizeInput","_enabled","createValidator","MAX_VALIDATOR","MaxValidator","MIN_VALIDATOR","MinValidator","REQUIRED_VALIDATOR","RequiredValidator","CHECKBOX_REQUIRED_VALIDATOR","CheckboxRequiredValidator","EMAIL_VALIDATOR","EmailValidator","MIN_LENGTH_VALIDATOR","MinLengthValidator","MAX_LENGTH_VALIDATOR","MaxLengthValidator","PATTERN_VALIDATOR","PatternValidator","ɵInternalFormsSharedModule","FormsModule","ReactiveFormsModule","ngModule","providers","useValue","warnOnNgModelWithFormControl","FormArray","at","_adjustIndex","_registerControl","insert","removeAt","adjustedIndex","some","isAbstractControlOptions","FormBuilder","useNonNullable","nnfb","reducedControls","_reduceControls","newOptions","record","array","createdControls","_createControl","NonNullableFormBuilder","inject","UntypedFormBuilder","controlsConfig","Version","_uniqueAutocompleteIdCounter","MatAutocompleteSelectedEvent","option","_MatAutocompleteMixinBase","mixinDisableRipple","MAT_AUTOCOMPLETE_DEFAULT_OPTIONS","providedIn","MAT_AUTOCOMPLETE_DEFAULT_OPTIONS_FACTORY","autoActiveFirstOption","_MatAutocompleteBase","defaults","platform","_activeOptionChanges","Subscription","showPanel","_isOpen","displayWith","optionSelected","opened","closed","optionActivated","_classList","inertGroups","SAFARI","_autoActiveFirstOption","isOpen","coerceBooleanProperty","classList","coerceStringArray","className","_setVisibilityClasses","ngAfterContentInit","_keyManager","ActiveDescendantKeyManager","withWrap","toArray","_setVisibility","_setScrollTop","scrollTop","panel","_getScrollTop","_emitSelectEvent","_getPanelAriaLabelledby","labelId","ariaLabel","labelExpression","ariaLabelledby","_visibleClass","_hiddenClass","i1","viewQuery","TemplateRef","_c0","_t","MatAutocomplete","ɵcmp","dirIndex","MAT_OPTGROUP","MatOption","MAT_OPTION_PARENT_COMPONENT","ngContentSelectors","i2","styles","_MatAutocompleteOriginBase","MatAutocompleteOrigin","MAT_AUTOCOMPLETE_SCROLL_STRATEGY","MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER","deps","Overlay","useFactory","MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY","overlay","scrollStrategies","reposition","MAT_AUTOCOMPLETE_VALUE_ACCESSOR","MatAutocompleteTrigger","_MatAutocompleteTriggerBase","_overlay","_viewContainerRef","_zone","scrollStrategy","_dir","_formField","_document","_viewportRuler","_defaults","_componentDestroyed","_autocompleteDisabled","_manuallyFloatingLabel","_viewportSubscription","_canOpenOnNextFocus","_closeKeyEventStream","Subject","_windowBlurHandler","activeElement","panelOpen","_onTouched","position","autocompleteAttribute","_overlayAttached","optionSelections","defer","autocomplete","startWith","switchMap","merge","onSelectionChange","onStable","_scrollStrategy","autocompleteDisabled","_getWindow","runOutsideAngular","addEventListener","_positionStrategy","_setStrategyPositions","_overlayRef","updatePosition","removeEventListener","_destroyPanel","openPanel","_attachOverlay","_floatLabel","closePanel","_resetLabel","run","hasAttached","detach","_closingActionsSubscription","detectChanges","panelClosingActions","tabOut","_getOutsideClickStream","detachments","of","MatOptionSelectionChange","activeOption","activeItem","fromEvent","clickTarget","_getEventTarget","formField","customOrigin","connectedTo","overlayElement","_setTriggerValue","_handleKeydown","hasModifier","hasModifierKey","ESCAPE","ENTER","_selectViaInteraction","_resetActiveItem","prevActiveItem","isArrowKey","UP_ARROW","DOWN_ARROW","TAB","onKeydown","_canOpen","_scrollToOption","activeItemIndex","type","_previousValue","_handleFocus","_handleClick","shouldAnimate","floatLabel","_animateAndLockLabel","_subscribeToClosingActions","firstStable","optionChanges","tap","reapplyLastPosition","wasOpen","_setValueAndClose","dispose","inputValue","_clearPreviousSelectedOption","focus","skip","deselect","overlayRef","setOrigin","_getConnectedElement","updateSize","width","_getPanelWidth","_portal","TemplatePortal","template","getLabelId","create","_getOverlayConfig","keydownEvents","stopPropagation","attach","OverlayConfig","positionStrategy","_getOverlayPosition","direction","panelClass","overlayPanelClass","strategy","flexibleConnectedTo","withFlexibleDimensions","withPush","belowPositions","originX","originY","overlayX","overlayY","_aboveClass","abovePositions","positions","withPositions","getConnectedOverlayOrigin","panelWidth","_getHostWidth","getBoundingClientRect","setFirstItemActive","setActiveItem","readOnly","defaultView","labelCount","_countGroupLabelsBeforeOption","optionGroups","_getHostElement","newScrollPosition","_getOptionScrollPosition","offsetTop","offsetHeight","i1$1","i2$1","MAT_FORM_FIELD","DOCUMENT","i3","inputs","MatAutocompleteModule","imports","OverlayModule","MatOptionModule","MatCommonModule","CommonModule","CdkScrollableModule","MAT_CHECKBOX_DEFAULT_OPTIONS","MAT_CHECKBOX_DEFAULT_OPTIONS_FACTORY","color","clickAction","nextUniqueId","MAT_CHECKBOX_CONTROL_VALUE_ACCESSOR","MatCheckbox","MatCheckboxChange","_MatCheckboxBase","mixinTabIndex","mixinColor","mixinDisabled","_focusMonitor","_ngZone","tabIndex","_animationMode","_options","_uniqueId","labelPosition","indeterminateChange","_currentAnimationClass","_currentCheckState","_controlValueAccessorChangeFn","_checked","_disabled","_indeterminate","defaultColor","inputId","_required","monitor","focusOrigin","_syncIndeterminate","ngAfterViewChecked","stopMonitoring","checked","indeterminate","changed","_transitionCheckState","_isRippleDisabled","disableRipple","_onLabelTextChange","_getAriaChecked","newState","oldState","_getAnimationClassForCheckStateTransition","animationClass","setTimeout","_emitChangeEvent","_inputElement","toggle","_onInputClick","origin","focusVia","_onInteractionEvent","animSuffix","nativeCheckbox","ANIMATION_MODULE_TYPE","MatRipple","MAT_CHECKBOX_REQUIRED_VALIDATOR","MatCheckboxRequiredValidator","_MatCheckboxRequiredValidatorModule","MatCheckboxModule","MatRippleModule","ObserversModule","MAT_CHIP_REMOVE","MAT_CHIP_AVATAR","MAT_CHIP_TRAILING_ICON","_MatChipMixinBase","MatChipBase","MatChipAvatar","MatChipTrailingIcon","MatChip","globalRippleOptions","animationMode","_hasFocus","chipListSelectable","_chipListMultiple","_chipListDisabled","_selected","_selectable","_removable","_onFocus","_onBlur","selectionChange","destroyed","removed","_addHostClassName","_chipRippleTarget","createElement","appendChild","_chipRipple","RippleRenderer","setupTriggerEvents","rippleConfig","_animationsDisabled","rippleDisabled","coercedValue","_dispatchSelectionChange","textContent","selectable","removable","ariaSelected","basicChipAttrName","hasAttribute","tagName","chip","_removeTriggerEvents","selectViaInteraction","toggleSelected","isUserInput","DELETE","BACKSPACE","SPACE","_blur","MAT_RIPPLE_GLOBAL_OPTIONS","MatChipRemove","_parentChip","nodeName","setAttribute","parentChip","MAT_CHIPS_DEFAULT_OPTIONS","_MatChipListBase","mixinErrorState","_defaultErrorStateMatcher","_parentForm","_parentFormGroup","ngControl","nextUniqueId$1","MatChipListChange","MatChipList","controlType","_lastDestroyedChipIndex","_destroyed","_uid","_tabIndex","_userTabIndex","_multiple","o1","o2","ariaOrientation","valueChange","multiple","_selectionModel","role","empty","_syncChipsState","_initializeSelection","_chipInput","stateChanges","placeholder","_placeholder","focused","_hasFocusedChip","chips","shouldLabelFloat","chipSelectionChanges","chipFocusChanges","chipBlurChanges","chipRemoveChanges","FocusKeyManager","withVerticalOrientation","withHomeAndEnd","withHorizontalOrientation","takeUntil","_allowFocusEscape","_resetChips","_updateTabIndex","_updateFocusForDestroyedChips","SelectionModel","ngDoCheck","updateErrorState","_dropSubscriptions","registerInput","inputElement","setDescribedByIds","_ariaDescribedby","_setSelectionByValue","onContainerClick","_originatesFromChip","_focusInput","_keydown","newChipIndex","Math","_isValidIndex","_clearSelection","_selectValue","_sortValues","correspondingChip","find","_propagateChanges","fallbackValue","valueToEmit","_markAsTouched","_listenToChipsFocus","_listenToChipsSelection","_listenToChipsRemoved","_chipFocusSubscription","_chipBlurSubscription","_chipSelectionSubscription","_chipRemoveSubscription","isSelected","chipIndex","updateActiveItem","currentElement","parentElement","MatFormFieldControl","MatChipInput","_defaultOptions","_addOnBlur","separatorKeyCodes","chipEnd","chipList","_chipList","addOnBlur","_focusLastChipOnBackspace","setLastItemActive","_emitChipEnd","_keyup","_focus","_isSeparatorKey","chipInput","_onInput","MatChipsModule","ErrorStateMatcher","_r9","ctx_r8","day_r1","_r5","ctx_r4","ctx_r6","_r8","ctx_r7","ctx_r9","ctx_r10","_r12","ctx_r11","ctx_r13","ctx_r14","MatDatepickerIntl","calendarLabel","openCalendarLabel","closeCalendarLabel","prevMonthLabel","nextMonthLabel","prevYearLabel","nextYearLabel","prevMultiYearLabel","nextMultiYearLabel","switchToMonthViewLabel","switchToMultiYearViewLabel","formatYearRange","start","end","MatCalendarCell","displayValue","cssClasses","compareValue","rawValue","MatCalendarBody","numCols","activeCell","isRange","cellAspectRatio","previewStart","previewEnd","selectedValueChange","previewChange","_enterHandler","_skipNextFocus","cell","_getCellFromElement","_leaveHandler","_cellClicked","_isSelected","startValue","endValue","columnChanges","rows","_firstRowOffset","_cellPadding","_cellWidth","_isActiveCell","rowIndex","colIndex","cellNumber","_focusActiveCell","movePreview","querySelector","_isRangeStart","isStart","_isRangeEnd","isEnd","_isInRange","isInRange","_isComparisonStart","comparisonStart","comparisonEnd","_isComparisonBridgeStart","previousCell","previousRow","_isComparisonBridgeEnd","_isComparisonEnd","nextCell","nextRow","_isInComparisonRange","_isComparisonIdentical","_isPreviewStart","_isPreviewEnd","_isInPreview","isTableCell","parentNode","row","getAttribute","col","node","rangeEnabled","attrs","DateRange","MatDateSelectionModel","selection","_adapter","_selectionChanged","selectionChanged","updateSelection","oldValue","_isValidDateInstance","isDateInstance","MatSingleDateSelectionModel","adapter","isComplete","clone","MatRangeDateSelectionModel","compareDate","MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER","Optional","SkipSelf","DateAdapter","MAT_SINGLE_DATE_SELECTION_MODEL_FACTORY","MAT_RANGE_DATE_SELECTION_MODEL_PROVIDER","MAT_RANGE_DATE_SELECTION_MODEL_FACTORY","MAT_DATE_RANGE_SELECTION_STRATEGY","DefaultMatCalendarRangeStrategy","_dateAdapter","selectionFinished","currentRange","createPreview","activeDate","MAT_CALENDAR_RANGE_STRATEGY_PROVIDER","MAT_CALENDAR_RANGE_STRATEGY_PROVIDER_FACTORY","MatMonthView","_dateFormats","_rangeStrategy","_rerenderSubscription","selectedChange","_userSelection","activeDateChange","_activeDate","today","oldActiveDate","validDate","getValidDateOrNull","deserialize","clampDate","minDate","maxDate","_hasSameMonthAndYear","_init","_setRanges","_minDate","_maxDate","localeChanges","comparisonChange","firstChange","_dateSelected","selectedYear","getYear","selectedMonth","selectedDate","createDate","rangeStartDate","rangeEndDate","_getDateInCurrentMonth","_previewStart","_previewEnd","_handleCalendarBodyKeydown","isRtl","_isRtl","LEFT_ARROW","addCalendarDays","RIGHT_ARROW","HOME","END","getNumDaysInMonth","PAGE_UP","altKey","addCalendarYears","addCalendarMonths","PAGE_DOWN","_selectionKeyPressed","_canSelect","_handleCalendarBodyKeyup","_todayDate","_getCellCompareValue","_monthLabel","display","monthLabel","format","getMonthNames","toLocaleUpperCase","firstOfMonth","_firstWeekOffset","getDayOfWeek","getFirstDayOfWeek","_initWeekdays","_createWeekCells","_matCalendarBody","_previewChanged","previewRange","firstDayOfWeek","narrowWeekdays","getDayOfWeekNames","weekdays","long","narrow","_weekdays","daysInMonth","dateNames","getDateNames","_weeks","_shouldEnableDate","dateA11yLabel","cellClasses","dateClass","dateFilter","d1","d2","getTime","selectedValue","_rangeStart","_rangeEnd","_isRange","_comparisonRangeStart","_comparisonRangeEnd","MAT_DATE_FORMATS","decls","encapsulation","MatMultiYearView","yearSelected","isSameMultiYearView","_setSelectedYear","_todayYear","minYearOfPage","getActiveOffset","_years","_createCellForYear","_yearSelected","yearsPerPage","_getActiveCell","yearName","getYearName","_shouldEnableYear","_selectedYear","dateAdapter","date1","date2","year1","year2","startingYear","getStartingYear","floor","euclideanModulo","MatYearView","monthSelected","_setSelectedMonth","_monthSelected","normalizedDate","_todayMonth","_getMonthInCurrentYear","_yearLabel","monthNames","_months","_createCellForMonth","monthName","monthYearA11yLabel","_shouldEnableMonth","activeYear","_isYearAndMonthAfterMaxDate","_isYearAndMonthBeforeMinDate","maxYear","maxMonth","minYear","minMonth","_selectedMonth","uniqueId","MatCalendarHeader","_intl","calendar","changeDetectorRef","_buttonDescriptionId","periodButtonText","currentView","monthYearLabel","maxYearOfPage","minYearName","maxYearName","periodButtonLabel","prevButtonLabel","nextButtonLabel","currentPeriodClicked","previousClicked","nextClicked","previousEnabled","_isSameView","nextEnabled","MatCalendar","_moveFocusOnNextTick","startView","viewChanged","_intlChanges","startAt","_startAt","_clampedActiveDate","_currentView","viewChangedResult","_calendarHeaderPortal","ComponentPortal","headerComponent","focusActiveCell","minDateChange","sameDate","maxDateChange","view","_getCurrentViewComponent","updateTodaysDate","_yearSelectedInMultiYearView","normalizedYear","_monthSelectedInYearView","normalizedMonth","_goToDateInView","monthView","yearView","multiYearView","i7","i8","matDatepickerAnimations","transformPanel","trigger","transition","animate","keyframes","style","opacity","transform","fadeInCalendar","datepickerUid","MAT_DATEPICKER_SCROLL_STRATEGY","MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER","MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY","_MatDatepickerContentBase","MatDatepickerContent","_globalModel","_rangeSelectionStrategy","intl","_subscriptions","_animationDone","_actionsPortal","_closeButtonText","_model","_animationState","datepicker","touchUi","_calendar","_handleUserSelection","newSelection","close","_startExitAnimation","_getSelected","_applyPendingSelection","changeDetection","MatDatepickerBase","_inputStateChanges","_touchUi","xPosition","yPosition","_restoreFocus","openedStream","closedStream","_opened","_focusedElementBeforeOpen","_backdropHarnessClass","datepickerInput","getStartValue","_color","getThemePalette","restoreFocus","_panelClass","open","_getMinDate","_getMaxDate","_getDateFilter","positionChange","getConfig","FlexibleConnectedPositionStrategy","_setConnectedPositions","_destroyOverlay","_selectYear","_selectMonth","_viewChanged","registerActions","portal","removeActions","_getFocusedElementPierceShadowDom","_openOverlay","_componentRef","instance","completeClose","_forwardContentValues","_dialogLabelId","getOverlayLabelId","isDialog","_getDialogStrategy","_getDropdownStrategy","hasBackdrop","backdropClass","block","_getCloseStream","global","centerHorizontally","centerVertically","withTransformOriginOn","withViewportMargin","withLockedPosition","primaryX","secondaryX","primaryY","secondaryY","backdropClick","i9","MatDatepicker","MatDatepickerInputEvent","targetElement","MatDatepickerInputBase","dateChange","dateInput","_validatorOnChange","_cvaOnChange","_valueChangesSubscription","_localeSubscription","_parseValidator","_lastValueValid","matDatepickerParse","text","_filterValidator","controlValue","_matchesFilter","matDatepickerFilter","_minValidator","matDatepickerMin","_maxValidator","matDatepickerMax","_assignValueProgrammatically","_getValueFromModel","_parentDisabled","_isInitialized","blur","_getValidators","_registerModel","_assignValue","_shouldHandleChangeEvent","_isValidValue","_formatValue","dateInputsHaveChanged","_onKeydown","_openPopup","lastValueWasValid","parse","hasChanged","_assignValueToModel","MAT_DATEPICKER_VALUE_ACCESSOR","MatDatepickerInput","MAT_DATEPICKER_VALIDATORS","dateFormats","_closedSubscription","matDatepicker","_datepicker","_min","validValue","_max","_dateFilter","wasMatchingValue","modelValue","MAT_INPUT_VALUE_ACCESSOR","MatDatepickerToggleIcon","MatDatepickerToggle","defaultTabIndex","_stateChanges","parsedTabIndex","_watchStateChanges","_open","datepickerStateChanged","inputStateChanged","datepickerToggled","_c2","_c3","MAT_DATE_RANGE_INPUT_PARENT","MatDateRangeInputPartBase","_rangeInput","InjectFlags","isEmpty","_getPlaceholder","_handleChildValueChange","_openDatepicker","_groupDisabled","_startInput","_endInput","i2$2","_MatDateRangeInputBase","MatStartDate","rangeInput","defaultErrorStateMatcher","injector","parentForm","parentFormGroup","_startValidator","matStartDateInvalid","range","getMirrorValue","MatEndDate","_endValidator","matEndDateInvalid","MatDateRangeInput","_ariaDescribedBy","separator","rangePicker","_rangePicker","wasMatchingStart","wasMatchingEnd","_revalidate","errorState","startEmpty","endEmpty","_getInputMirrorValue","_shouldHidePlaceholders","_shouldHideSeparator","_shouldLabelFloat","_getAriaLabelledby","_hasFloatingLabel","_labelId","_updateFocus","_c5","MatDateRangePicker","MatDatepickerApply","_applySelection","MatDatepickerCancel","MatDatepickerActions","_template","isAttached","MatDatepickerModule","MatButtonModule","A11yModule","PortalModule","nextId$1","CDK_ACCORDION","CdkAccordion","_openCloseAllActions","_multi","openAll","closeAll","nextId","CdkAccordionItem","accordion","_expansionDispatcher","_openCloseAllSubscription","expandedChange","_expanded","_removeUniqueSelectionListener","listen","accordionId","expanded","_subscribeToOpenCloseAllActions","notify","CdkAccordionModule","MAT_ACCORDION","EXPANSION_PANEL_ANIMATION_TIMING","matExpansionAnimations","indicatorRotate","bodyExpansion","height","visibility","MatExpansionPanelContent","MAT_EXPANSION_PANEL_DEFAULT_OPTIONS","MatExpansionPanel","_uniqueSelectionDispatcher","defaultOptions","_hideToggle","afterExpand","afterCollapse","_inputChanges","_headerId","_bodyAnimationDone","distinctUntilChanged","y","fromState","toState","hideToggle","togglePosition","_togglePosition","_hasSpacing","displayMode","_getExpandedState","_lazyContent","_containsFocus","_body","focusedElement","bodyElement","_c1","MatExpansionPanelActionRow","_MatExpansionPanelHeaderMixinBase","MatExpansionPanelHeaderBase","MatExpansionPanelHeader","_parentChangeSubscription","accordionHideToggleChange","EMPTY","expandedHeight","collapsedHeight","_toggle","_isExpanded","_getPanelId","_getTogglePosition","_showToggle","_getHeaderHeight","isExpanded","_handleHeaderKeydown","_handleHeaderFocus","MatExpansionPanelDescription","MatExpansionPanelTitle","MatAccordion","_ownHeaders","QueryList","show","_headers","header","notifyOnChanges","destroy","MatExpansionModule","_r10","ctx_r12","_r16","ctx_r15","ctx_r17","nextUniqueId$2","MAT_ERROR","MatError","ariaLive","matFormFieldAnimations","transitionMessages","_MAT_HINT","MatHint","align","MatLabel","MatPlaceholder","MAT_PREFIX","MatPrefix","MAT_SUFFIX","MatSuffix","_MatFormFieldBase","MAT_FORM_FIELD_DEFAULT_OPTIONS","MatFormField","_platform","_outlineGapCalculationNeededImmediately","_outlineGapCalculationNeededOnStable","_showAlwaysAnimate","_subscriptAnimationState","_hintLabel","_hintLabelId","_getDefaultFloatLabelState","_animationsEnabled","appearance","_hideRequiredMarker","hideRequiredMarker","_appearance","_shouldAlwaysFloat","_canLabelFloat","hintLabel","_processHints","_explicitFormFieldControl","_controlNonStatic","_controlStatic","_connectionContainerRef","_validateControlChild","_validatePlaceholders","_syncDescribedByIds","updateOutlineGap","_prefixChildren","_suffixChildren","_hintChildren","_errorChildren","requestAnimationFrame","ngAfterContentChecked","_shouldForward","prop","_hasPlaceholder","_placeholderChild","_hasLabel","_labelChildNonStatic","_labelChildStatic","_hideControlPlaceholder","_getDisplayedMessages","_label","_validateHints","userAriaDescribedBy","startHint","hint","endHint","labelEl","outlineStartSelector","outlineGapSelector","isBrowser","children","trim","gapElements","querySelectorAll","_isAttachedToDOM","startWidth","gapWidth","startEls","gapEls","containerRect","containerStart","_getStartEnd","labelChildren","labelStart","labelWidth","offsetWidth","abs","outlineGapPadding","rect","right","left","getRootNode","rootNode","document","documentElement","i4","MatFormFieldModule","policy","trustedHTMLFromString","html","getPolicy","ttWindow","trustedTypes","createPolicy","createHTML","s","getMatIconNameNotFoundError","iconName","Error","getMatIconFailedToSanitizeUrlError","getMatIconFailedToSanitizeLiteralError","literal","SvgIconConfig","svgText","MatIconRegistry","_httpClient","_sanitizer","_errorHandler","_svgIconConfigs","_iconSetConfigs","_cachedIconsByUrl","_inProgressUrlFetches","_fontCssClassesByAlias","_resolvers","_defaultFontSetClass","addSvgIcon","addSvgIconInNamespace","addSvgIconLiteral","addSvgIconLiteralInNamespace","namespace","_addSvgIconConfig","addSvgIconResolver","resolver","cleanLiteral","sanitize","SecurityContext","trustedLiteral","addSvgIconSet","addSvgIconSetInNamespace","addSvgIconSetLiteral","addSvgIconSetLiteralInNamespace","_addSvgIconSetConfig","registerFontClassAlias","alias","classNameForFontAlias","setDefaultFontSetClass","getDefaultFontSetClass","getSvgIconFromUrl","safeUrl","cachedIcon","cloneSvg","_loadSvgIconFromConfig","svg","getNamedSvgIcon","iconKey","config","_getSvgFromConfig","_getIconConfigFromResolvers","iconSetConfigs","_getSvgFromIconSetConfigs","throwError","_svgElementFromConfig","namedIcon","_extractIconWithNameFromAnySet","iconSetFetchRequests","iconSetConfig","_loadSvgIconSetFromConfig","catchError","err","errorMessage","message","handleError","foundIcon","_extractSvgIconFromSet","_fetchIcon","iconSet","iconSource","iconElement","cloneNode","removeAttribute","_setSvgAttributes","_toSvgElement","_svgElementFromString","str","innerHTML","attributes","childNodes","nodeType","ELEMENT_NODE","viewBox","iconConfig","withCredentials","getMatIconNoHttpProviderError","inProgressFetch","responseType","finalize","share","configNamespace","svgElement","HttpClient","DomSanitizer","ErrorHandler","_MatIconBase","MAT_ICON_LOCATION","MAT_ICON_LOCATION_FACTORY","_location","location","getPathname","pathname","search","funcIriAttributes","funcIriAttributeSelector","attr","funcIriPattern","MatIcon","_iconRegistry","ariaHidden","_inline","_currentIconFetch","inline","svgIcon","_svgIcon","_updateSvgIcon","_clearSvgElement","fontSet","_fontSet","_cleanupFontValue","_updateFontIconClasses","fontIcon","_fontIcon","_splitIconName","parts","cachedElements","_elementsWithExternalReferences","size","newPath","_previousPath","_prependPathToReferences","_usingFontIcon","_setSvgElement","_cacheChildrenWithExternalReferences","layoutElement","childCount","elem","fontSetClass","_previousFontSetClass","_previousFontIconClass","elements","elementsWithFuncIri","elementWithReference","match","rawName","_svgNamespace","_svgName","MatIconModule","listenerOptions","normalizePassiveListenerOptions","passive","AutofillMonitor","_monitoredElements","elementOrRef","coerceElement","info","subject","cssClass","listener","animationName","isAutofilled","unlisten","_info","CdkAutofill","_autofillMonitor","cdkAutofill","CdkTextareaAutosize","_previousMinRows","_isViewInited","_handleFocusEvent","_textareaElement","minRows","_minRows","coerceNumberProperty","_setMinHeight","maxRows","_maxRows","_setMaxHeight","resizeToFitContent","_cachedPlaceholderHeight","_cacheTextareaPlaceholderHeight","minHeight","_cachedLineHeight","maxHeight","_initialHeight","auditTime","_cacheTextareaLineHeight","textareaClone","border","padding","overflow","clientHeight","_measureScrollHeight","previousMargin","marginBottom","isFirefox","FIREFOX","needsMarginFiller","measuringClass","scrollHeight","force","textarea","_scrollToCaretPosition","_noopInputHandler","_getDocument","selectionStart","selectionEnd","isStopped","setSelectionRange","TextFieldModule","MAT_INPUT_INVALID_TYPES","_MatInputBase","MatInput","inputValueAccessor","ngZone","autofilled","_type","_readonly","_neverEmptyInputTypes","getSupportedInputTypes","_iOSKeyupListener","_inputValueAccessor","_previousNativeValue","IOS","_isServer","_isNativeSelect","_isTextarea","_isInFormField","_id","_validateType","readonly","_dirtyCheckNativeValue","_dirtyCheckPlaceholder","_focusChanged","isFocused","_previousPlaceholder","_isNeverEmpty","_isBadInput","validity","badInput","selectElement","firstOption","selectedIndex","label","_isInlineSelect","MatInputModule","_MatProgressBarBase","MAT_PROGRESS_BAR_LOCATION","MAT_PROGRESS_BAR_LOCATION_FACTORY","MAT_PROGRESS_BAR_DEFAULT_OPTIONS","progressbarId","MatProgressBar","_isNoopAnimation","_bufferValue","animationEnd","_animationEndSubscription","mode","_rectangleFillValue","clamp","bufferValue","_primaryTransform","_bufferTransform","_primaryValueBar","e","observers","MatProgressBarModule","MAT_RADIO_DEFAULT_OPTIONS","MAT_RADIO_DEFAULT_OPTIONS_FACTORY","MAT_RADIO_GROUP_CONTROL_VALUE_ACCESSOR","MatRadioGroup","MatRadioChange","MAT_RADIO_GROUP","_MatRadioGroupBase","_changeDetector","_name","_labelPosition","_updateRadioButtonNames","_markRadiosForCheck","_updateSelectedRadioFromValue","_checkSelectedRadioButton","_touch","_radios","radio","_markForCheck","isAlreadySelected","MatRadioButton","_MatRadioButtonMixinBase","MatRadioButtonBase","_MatRadioButtonBase","radioGroup","_radioDispatcher","_providerOverride","_noopAnimations","newCheckedState","_setDisabled","_onInputInteraction","groupValueChanged","_previousTabIndex","changeDetector","focusMonitor","radioDispatcher","providerOverride","MatRadioModule","ctx_r2","ctx_r5","matSelectAnimations","transformPanelWrap","query","animateChild","optional","minWidth","SELECT_PANEL_MAX_HEIGHT","SELECT_PANEL_PADDING_X","MAT_SELECT_SCROLL_STRATEGY","MAT_SELECT_CONFIG","MAT_SELECT_SCROLL_STRATEGY_PROVIDER","MAT_SELECT_SCROLL_STRATEGY_PROVIDER_FACTORY","MatSelectChange","_MatSelectMixinBase","MAT_SELECT_TRIGGER","MatSelectTrigger","_MatSelectBase","_parentFormField","scrollStrategyFactory","_liveAnnouncer","_panelOpen","_triggerAriaLabelledBy","_destroy","_valueId","_panelDoneAnimatingStream","_overlayPanelClass","_focused","_disableOptionCentering","disableOptionCentering","optionSelectionChanges","openedChange","_openedStream","_closedStream","typeaheadDebounceInterval","_typeaheadDebounceInterval","_scrollStrategyFactory","_panelDoneAnimating","_initKeyManager","added","_resetOptions","newAriaLabelledby","_getTriggerAriaLabelledby","_previousControl","withTypeAhead","_highlightCorrectOption","triggerValue","viewValue","reverse","_handleOpenKeydown","_handleClosedKeydown","isOpenKey","manager","isTyping","previouslySelectedOption","selectedOption","announce","A","ctrlKey","hasDeselectedOptions","previouslyFocusedIndex","shiftKey","_onAttached","_overlayDir","_positioningSettled","_getPanelTheme","setInactiveStyles","_selectOptionByValue","correspondingOption","withAllowedModifierKeys","_scrollOptionIntoView","changedOrDestroyed","_onSelect","wasSelected","sortComparator","_getChangeEvent","_getAriaActiveDescendant","i5","CdkConnectedOverlay","MatSelect","_scrollTop","_triggerFontSize","_transformOrigin","_offsetY","_positions","_calculateOverlayScroll","scrollBuffer","maxScroll","itemHeight","_getItemHeight","optimalScrollPosition","_triggerRect","getComputedStyle","fontSize","_calculateOverlayPosition","_calculateOverlayOffsetX","offsetX","overlayRect","viewportSize","getViewportSize","paddingWidth","SELECT_MULTIPLE_PANEL_PADDING_X","first","leftOverflow","rightOverflow","_calculateOverlayOffsetY","optionHeightAdjustment","maxOptionsDisplayed","optionOffsetFromPanelTop","_getItemCount","_checkOverlayWithinViewport","topSpaceAvailable","top","bottomSpaceAvailable","bottom","panelHeightTop","panelHeightBottom","_adjustPanelUp","_adjustPanelDown","_getOriginBasedOnOption","distanceBelowViewport","distanceAboveViewport","items","panelHeight","selectedOptionOffset","MatSelectModule","mixinHasStickyInput","base","_sticky","_hasStickyChanged","sticky","prevValue","hasStickyChanged","resetStickyChanged","CDK_TABLE","TEXT_COLUMN_OPTIONS","CdkCellDef","CdkHeaderCellDef","CdkFooterCellDef","_CdkColumnDefBase","CdkColumnDefBase","CdkColumnDef","_table","_stickyEnd","_setNameInput","stickyEnd","_updateColumnCssClassName","_columnCssClassName","cssClassFriendlyName","BaseCdkCell","columnDef","CdkHeaderCell","CdkFooterCell","tableRole","CdkCell","_Schedule","tasks","endTasks","_COALESCED_STYLE_SCHEDULER","_CoalescedStyleScheduler","_currentSchedule","schedule","task","_createScheduleIfNeeded","scheduleEnd","_getScheduleObservable","isStable","BaseRowDef","_differs","_columnsDiffer","columns","diff","getColumnsDiff","extractCellTemplate","column","CdkHeaderRowDef","headerCell","CdkFooterRowDef","footerCell","_CdkHeaderRowDefBase","CdkHeaderRowDefBase","_CdkFooterRowDefBase","CdkFooterRowDefBase","CdkRowDef","CdkCellOutlet","_viewContainer","mostRecentCellOutlet","CdkHeaderRow","CdkFooterRow","CdkRow","CdkNoDataRow","templateRef","_contentClassName","STICKY_DIRECTIONS","StickyStyler","_isNativeHtmlTable","_stickCellCss","_coalescedStyleScheduler","_isBrowser","_needsPositionStickyOnElement","_positionListener","_cachedCellWidths","_borderCellCss","clearStickyPositioning","stickyDirections","elementsToClear","_removeStickyStyle","updateStickyColumns","stickyStartStates","stickyEndStates","recalculateCellWidths","stickyColumnsUpdated","sizes","stickyEndColumnsUpdated","firstRow","numCells","cellWidths","_getCellWidths","startPositions","_getStickyStartColumnPositions","endPositions","_getStickyEndColumnPositions","lastStickyStart","lastIndexOf","firstStickyEnd","_addStickyStyle","stickRows","rowsToStick","stickyStates","states","stickyOffsets","stickyCellHeights","elementsToStick","stickyOffset","borderedRowIndex","offset","isBorderedRowIndex","stickyHeaderRowsUpdated","offsets","stickyFooterRowsUpdated","updateStickyFooterContainer","tableElement","tfoot","zIndex","_getCalculatedZIndex","dirValue","isBorderElement","cssText","zIndexIncrements","firstRowCells","widths","nextPosition","STICKY_POSITIONING_LISTENER","CdkRecycleRows","_VIEW_REPEATER_STRATEGY","useClass","_RecycleViewRepeaterStrategy","DataRowOutlet","viewContainer","HeaderRowOutlet","FooterRowOutlet","NoDataRowOutlet","CdkTable","_viewRepeater","_stickyPositioningListener","_onDestroy","_columnDefsByName","_customColumnDefs","_customRowDefs","_customHeaderRowDefs","_customFooterRowDefs","_headerRowDefChanged","_footerRowDefChanged","_stickyColumnStylesNeedReset","_forceRecalculateCellWidths","_cachedRenderRowsMap","stickyCssClass","needsPositionStickyOnElement","_isShowingNoDataRow","_multiTemplateDataRows","_fixedLayout","contentChanged","viewChange","BehaviorSubject","MAX_VALUE","trackBy","_trackByFn","dataSource","_dataSource","_switchDataSource","multiTemplateDataRows","_rowOutlet","_forceRenderDataRows","updateStickyColumnStyles","fixedLayout","_setupStickyStyler","_applyNativeTableSections","_dataDiffer","_i","dataRow","dataIndex","_cacheRowDefs","_cacheColumnDefs","_headerRowDefs","_footerRowDefs","_rowDefs","rowDefsChanged","_renderUpdatedColumns","_forceRenderHeaderRows","_forceRenderFooterRows","_renderChangeSubscription","_observeRenderChanges","_checkStickyStates","_headerRowOutlet","_footerRowOutlet","def","_defaultRowDef","isDataSource","disconnect","renderRows","_renderRows","_getAllRenderRows","_updateNoDataRow","applyChanges","_adjustedPreviousIndex","currentIndex","_getEmbeddedViewArgs","operation","context","_renderCellTemplateForItem","rowDef","_updateRowIndexContext","forEachIdentityChange","$implicit","NgZone","addColumnDef","removeColumnDef","addRowDef","removeRowDef","addHeaderRowDef","headerRowDef","removeHeaderRowDef","addFooterRowDef","footerRowDef","removeFooterRowDef","setNoDataRow","noDataRow","_customNoDataRow","updateStickyHeaderRowStyles","headerRows","_getRenderedRows","thead","_stickyStyler","updateStickyFooterRowStyles","footerRows","dataRows","headerRow","_addStickyColumnStyles","footerRow","prevCachedRenderRows","_data","renderRowsForData","_getRenderRowsForData","WeakMap","j","renderRow","cache","_getRowDefs","cachedRenderRows","shift","mergeArrayAndSet","_getOwnDefs","_contentColumnDefs","_contentHeaderRowDefs","_contentFooterRowDefs","_contentRowDefs","defaultRowDefs","when","columnsDiffReducer","dataColumnsChanged","headerColumnsChanged","footerColumnsChanged","dataStream","connect","isObservable","_renderRow","columnDefs","columnName","rowOutlet","renderedRows","viewRef","rootNodes","rowDefs","outlet","createEmbeddedView","cellTemplate","_getCellTemplates","renderIndex","count","last","even","odd","columnId","documentFragment","createDocumentFragment","sections","tag","outlets","_noDataRowOutlet","section","stickyCheckReducer","_noDataRow","shouldShow","_DisposeViewRepeaterStrategy","CdkTextColumn","justify","_syncColumnDefName","headerText","_createDefaultHeaderText","dataAccessor","defaultDataAccessor","defaultHeaderTextTransform","toUpperCase","CdkTableModule","ScrollingModule","MatRecycleRows","MatTable","table_c0","MatCellDef","MatHeaderCellDef","MatFooterCellDef","MatColumnDef","MatHeaderCell","MatFooterCell","MatCell","MatHeaderRowDef","MatFooterRowDef","MatRowDef","MatHeaderRow","MatFooterRow","MatRow","MatNoDataRow","MatTextColumn","MatTableModule","_MatTableDataSource","DataSource","initialData","_renderData","_filter","_internalPageChanges","_renderChangesSubscription","sortingDataAccessor","sortHeaderId","_isNumberValue","numberValue","sortData","active","valueA","valueB","valueAType","valueBType","comparatorResult","filterPredicate","dataStr","currentTerm","transformedFilter","_updateChangeSubscription","_filterData","_sort","paginator","_paginator","sortChange","initialized","pageChange","page","filteredData","combineLatest","orderedData","_orderData","paginatedData","_pageData","obj","_updatePaginator","startIndex","pageIndex","pageSize","filteredDataLength","lastPageIndex","ceil","newPageIndex","MatTableDataSource","PANEL_CLASS","passiveListenerOptions","MAT_TOOLTIP_SCROLL_STRATEGY","MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER","MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY","scrollThrottle","MAT_TOOLTIP_DEFAULT_OPTIONS","MAT_TOOLTIP_DEFAULT_OPTIONS_FACTORY","showDelay","hideDelay","touchendHideDelay","_MatTooltipBase","_scrollDispatcher","_ariaDescriber","_position","_viewInitialized","_pointerExitEventsInitialized","_viewportMargin","_cssClassPrefix","_showDelay","_hideDelay","touchGestures","_message","_passiveListeners","_updatePosition","_tooltipInstance","hide","_setupPointerEnterEventsIfNeeded","_mouseLeaveHideDelay","removeDescription","_isTooltipVisible","_updateTooltipMessage","describe","tooltipClass","_tooltipClass","_setTooltipClass","clearTimeout","_touchstartTimeout","_showTimeoutId","_hideTimeoutId","_createOverlay","_detach","_tooltipComponent","_triggerElement","afterHidden","isVisible","scrollableAncestors","getAncestorScrollContainers","withScrollableContainers","positionChanges","_updateCurrentPositionClass","connectionPair","scrollableViewProperties","isOverlayClipped","outsidePointerEvents","_handleBodyInteraction","disableTooltipInteractivity","addPanelClass","_getOrigin","_addOffset","main","fallback","isLtr","originPosition","_invertPosition","overlayPosition","onMicrotaskEmpty","newPosition","_currentPosition","classPrefix","removePanelClass","_platformSupportsMouseEvents","_setupPointerExitEventsIfNeeded","_disableNativeGesturesIfNecessary","_addListeners","exitListeners","newTarget","relatedTarget","_wheelListener","touchendListener","listeners","ANDROID","elementUnderPointer","elementFromPoint","clientX","clientY","gestures","userSelect","msUserSelect","webkitUserSelect","MozUserSelect","draggable","webkitUserDrag","touchAction","webkitTapHighlightColor","MatTooltip","scrollDispatcher","viewContainerRef","ariaDescriber","TooltipComponent","_TooltipComponentBase","_visibility","_closeOnInteraction","_isVisible","_onHide","_toggleVisibility","_handleMouseLeave","_onShow","_handleAnimationEnd","_showAnimation","_hideAnimation","_finalizeAnimation","toVisible","tooltip","_tooltip","showClass","hideClass","getPropertyValue","_breakpointObserver","_isHandset","observe","Breakpoints","i6","hostVars","MatTooltipModule","tooltipState"],"sourceRoot":"webpack:///","sources":["./src/app/services/shared-methods.service.ts","./src/app/services/user.service.ts","./src/app/shared-components/shared.module.ts","./node_modules/rxjs/dist/esm/internal/observable/forkJoin.js","./node_modules/rxjs/dist/esm/internal/operators/delayWhen.js","./node_modules/rxjs/dist/esm/internal/operators/ignoreElements.js","./node_modules/rxjs/dist/esm/internal/operators/delay.js","./node_modules/@angular/forms/fesm2020/forms.mjs","./node_modules/@angular/material/fesm2020/autocomplete.mjs","./node_modules/@angular/material/fesm2020/checkbox.mjs","./node_modules/@angular/material/fesm2020/chips.mjs","./node_modules/@angular/material/fesm2020/datepicker.mjs","./node_modules/@angular/cdk/fesm2020/accordion.mjs","./node_modules/@angular/material/fesm2020/expansion.mjs","./node_modules/@angular/material/fesm2020/form-field.mjs","./node_modules/@angular/material/fesm2020/icon.mjs","./node_modules/@angular/cdk/fesm2020/text-field.mjs","./node_modules/@angular/material/fesm2020/input.mjs","./node_modules/@angular/material/fesm2020/progress-bar.mjs","./node_modules/@angular/material/fesm2020/radio.mjs","./node_modules/@angular/material/fesm2020/select.mjs","./node_modules/@angular/cdk/fesm2020/table.mjs","./node_modules/@angular/material/fesm2020/table.mjs","./node_modules/@angular/material/fesm2020/tooltip.mjs"],"sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { MatDialog } from '@angular/material/dialog';\r\nimport { Router } from '@angular/router';\r\n \r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class SharedMethodsService {\r\n \r\n  constructor(\r\n    private router: Router,\r\n    private dialog: MatDialog,\r\n  ) { }\r\n \r\n  /****************************** FORMATTED DATES ******************************/\r\n  // FORMAT MM-dd-yyyy\r\n  formatDate(param?: any) {\r\n    let d\r\n    if (param) d = param\r\n    else d = new Date();\r\n    let month = '' + (d.getMonth() + 1);\r\n    let day = '' + d.getDate();\r\n    const year = d.getFullYear();\r\n    if (month.length < 2) month = '0' + month;\r\n    if (day.length < 2) day = '0' + day;\r\n    return [year, month, day].join('-');\r\n  }\r\n  // FORMAT DATE IN dd-MM-yyyy HH:MM:SS\r\n  formatDateWithTime(date: any) {\r\n    if (!(date instanceof Date)) return 'Invalid Date';\r\n    const year = date.getFullYear();\r\n    const month = String(date.getMonth() + 1).padStart(2, '0'); // Months are zero-based\r\n    const day = String(date.getDate()).padStart(2, '0');\r\n    const formattedDate = `${month}-${day}-${year}`; // ${hours}:${minutes}:${seconds}\r\n    return formattedDate;\r\n  }\r\n  // FORMAT DATE IN dd-MM-yyyy HH:MM AM/PM\r\n  formatDateWithTime2(date: any) {\r\n    if (!(date instanceof Date)) return 'Invalid Date';\r\n    const year = date.getFullYear();\r\n    const month = String(date.getMonth() + 1).padStart(2, '0'); // Months are zero-based\r\n    const day = String(date.getDate()).padStart(2, '0');\r\n    const hours = String(date.getHours()).padStart(2, '0');\r\n    const minutes = String(date.getMinutes()).padStart(2, '0');\r\n    // const seconds = String(date.getSeconds()).padStart(2, '0');\r\n    const formattedDate = Number(hours) >= 12 ? `${Number(month)}/${Number(day)}/${year}, ${hours}:${minutes} PM` : `${Number(month)}/${Number(day)}/${year}, ${hours}:${minutes} AM`; // ${hours}:${minutes}:${seconds}\r\n    return formattedDate;\r\n  }\r\n  // FORMAT DATE IN dd-MM-yyyy\r\n  ChangeDateFormate(dob: string) {\r\n    const day = dob.split('-')[0];\r\n    const month = dob.split('-')[1];\r\n    const year = dob.split('-')[2];\r\n      const newDateformat = `${month}-${day}-${year}`;\r\n    return newDateformat;\r\n  }\r\n \r\n // will return date in format 06-Oct-1998\r\n  formatDateForInterviewPerforma(date: any) {\r\n    if (!(date instanceof Date)) return 'Invalid Date';\r\n    const months = [\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\"];\r\n    const year = date.getFullYear();\r\n    const month = months[date.getMonth()]; // Months are zero-based\r\n    const day = String(date.getDate()).padStart(2, '0');\r\n    const formattedDate = `${day}-${month}-${year}`; // ${hours}:${minutes}:${seconds}\r\n    return formattedDate;\r\n  }\r\n \r\n  /*************************** AUTH METHODS ****************************/\r\n  logOut() {\r\n    sessionStorage.clear();\r\n    this.router.navigate(['login'])\r\n  }\r\n \r\n  /******************* ALLOWED INPUTS ON KEY PRESS ********************/\r\n  allowOnlyDigits(event: any) {\r\n    const pattern = /[0-9\\-]/;\r\n    const inputChar = String.fromCharCode(event.charCode);\r\n    if (event.keyCode !== 8 && !pattern.test(inputChar)) {\r\n      event.preventDefault();\r\n    }\r\n  }\r\n  allowDigitsWithSpecialChar(event: any, specialChar: string) {\r\n    const pattern = new RegExp(`[0-9${specialChar}\\\\-]`);\r\n    const inputChar = String.fromCharCode(event.charCode);\r\n    if (event.keyCode !== 8 && !pattern.test(inputChar)) {\r\n      event.preventDefault();\r\n    }\r\n  }\r\n  allowOnlyAlphaNumeric(event: any) {\r\n    const pattern = new RegExp(`[0-9A-Za-z\\\\-]`);\r\n    const inputChar = String.fromCharCode(event.charCode);\r\n    if (event.keyCode !== 8 && !pattern.test(inputChar)) {\r\n      event.preventDefault();\r\n    }\r\n  }\r\n  allowAlphaNumericWithSpecialChar(event: any, specialChar: string) {\r\n    const pattern = new RegExp(`[0-9A-Za-z ${specialChar.replace(/[-\\/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&')}]`);\r\n    const inputChar = String.fromCharCode(event.charCode);\r\n    if (event.keyCode !== 8 && !pattern.test(inputChar)) {\r\n      event.preventDefault();\r\n    }\r\n  }\r\n\r\n  allowOnlyAlphabets(event: any) {\r\n    const pattern = new RegExp(`[A-Za-z\\\\s]`);\r\n    const inputChar = String.fromCharCode(event.charCode);\r\n    if (event.keyCode !== 8 && !pattern.test(inputChar)) {\r\n      event.preventDefault();\r\n    }\r\n  }\r\n \r\n  /* ---------------SORT ARRAY OBJECT VIA OBJECT PARAMETER--------------- */\r\n  sortArrayObject(objectToSort: any[], parameterName: string) {\r\n    objectToSort.sort((a: any, b: any) => {\r\n      let fa = a[parameterName].toLowerCase(),\r\n        fb = b[parameterName].toLowerCase();\r\n \r\n      if (fa < fb) return -1;\r\n      if (fa > fb) return 1;\r\n \r\n      return 0;\r\n    });\r\n    return objectToSort;\r\n  }\r\n \r\n  /* ---------------CONVERT A FILE TO BASE64 FORMAT--------------- */\r\n  convertToBase64(file: File): Promise<string> {\r\n    return new Promise<string>((resolve, reject) => {\r\n      const reader = new FileReader();\r\n      reader.readAsDataURL(file);\r\n \r\n      reader.onload = () => {\r\n        const base64String = reader.result as string;\r\n        const base64Data = base64String.substring(base64String.indexOf(',') + 1);\r\n        resolve(base64String);\r\n        // console.log(\"Base64 of document: \", base64Data)\r\n        // console.log(\"File: \", file);\r\n        // console.log(\"Base64 of document: \", base64String)\r\n      };\r\n \r\n      reader.onerror = (error) => {\r\n        reject(error);\r\n      };\r\n    });\r\n  }\r\n \r\n  // confirmationDialog(title: string, message: string, onConfirm: () => void) {\r\n  //   const dialogRef = this.dialog.open(ConfirmationDialogComponent, {\r\n  //     width: '300px',\r\n  //     data: {\r\n  //       title: title,\r\n  //       message: message,\r\n  //     },\r\n  //   });\r\n \r\n  //   dialogRef.afterClosed().subscribe((result: any) => {\r\n  //     if (result) {\r\n  //       onConfirm();\r\n  //     }\r\n  //   });\r\n \r\n  // }\r\n \r\n  // Generic filter function for lists\r\n  filterList(list: any[], key: string, value: any): any[] {\r\n    return list\r\n      ? list.filter(item =>\r\n        item[key] === value\r\n      )\r\n      : [];\r\n  }\r\n \r\n  isLeapYearCheck(year: number): boolean {\r\n    return (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);\r\n  }\r\n  // This will check date 365 days after current date\r\n  date365DaysAfter() {\r\n    const currentDate = new Date();\r\n    const currentYear = currentDate.getFullYear();\r\n    const date365DaysAfter = new Date(currentDate);\r\n    date365DaysAfter.setFullYear(currentYear + 1);\r\n    const isLeapYear = this.isLeapYearCheck(currentYear);\r\n    if (isLeapYear) date365DaysAfter.setDate(currentDate.getDate() - 1)\r\n    const formattedDate = date365DaysAfter.toISOString();\r\n    console.log(\"Date 365 days after current date, considering leap years:\", formattedDate);\r\n  }\r\n \r\n}\r\n \r\n// keyPress(event: any) {\r\n//   const pattern = /[0-9+.\\-]/;\r\n//   const inputChar = String.fromCharCode(event.charCode);\r\n//   if (event.keyCode !== 8 && !pattern.test(inputChar)) {\r\n//     event.preventDefault();\r\n//   }\r\n// }","import { HttpClient, HttpHeaders } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { Observable } from 'rxjs';\r\nimport { environment } from 'src/environments/environment';\r\nimport { QualificationDetailsModel } from '../modals/qualification.model';\r\nimport { CommonOutputModelArr } from '../modals/commonModel';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class UserService {\r\n   apiKey: any = window.btoa('kmS<A_Z4s6!P%%gi5[gd:eB]');\r\n    private createHeaders(): HttpHeaders {\r\n      let basicAuthHeaderString: any = sessionStorage.getItem('BasicKey');\r\n\r\n    return new HttpHeaders({\r\n        'Content-Type': 'application/json',\r\n        'Api-Key': this.apiKey,\r\n        'App-Name': 'iTAP',\r\n        'Authorization': basicAuthHeaderString\r\n    });\r\n  }\r\n\r\n  private createHeadersCandidate(): HttpHeaders {\r\n  return new HttpHeaders({\r\n      'Content-Type': 'application/json',\r\n      'Api-Key': this.apiKey,\r\n      'App-Name': 'iTAP'\r\n  });\r\n}\r\n\r\n  constructor(private http: HttpClient) { }\r\n\r\n  getLoggedInUsers(userDetails: any, userType: any): Observable<any> {\r\n    // Login?USER=1637&PWD=683320169627&userType=0\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/ItapLogin/Login?USER=${userDetails.managerRefNo}&PWD=${userDetails.aadhaarNumber}&userType=${userType}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  getMaster(phaseNo: any): Observable<any> {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/IP/LoadMasters?Phase=${phaseNo}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  getPostalCode(pincode: any): Observable<any> {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/IP/getPostalCode?PinCode=${pincode}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  getAadhar(aadharno: any, registrationNo: any) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/IP/getAadhar?RegNo=${registrationNo}&aadharNo=${aadharno}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  loadId(regno: any) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/IP/LoadID?regNo=${regno}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  updateId(req: any) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/IP/UpdateID`;\r\n    return this.http.post(url, req, {headers});\r\n  }\r\n\r\n  loadPersonalDetails(regno: any) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/IP/LoadPersonalDetail?regNo=${regno}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  savePersonalDetails(req: any) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/IP/SavePersonalDetail`;\r\n    return this.http.post(url, req, {headers});\r\n  }\r\n  updatePersonalDetails(req: any,phase:string) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/IP/updatePersonalDetail?Phase=${phase}`;\r\n    return this.http.post(url, req, {headers});\r\n  }\r\n\r\n  getLoggedInRegisterUser(existingUserDetails: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/ItapLogin/ExistingUSER?itapID=${existingUserDetails.registerNumber}&AadharNo=${existingUserDetails.aadharNo}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  // get qualification details\r\n  getQualificationDetails(regNo: number) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/IP/LoadQual?regNo=${regNo}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  // save qualification details\r\n  pushQualificationDetails(req: any) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/IP/UpdateQual`;\r\n    return this.http.post<CommonOutputModelArr>(url, req, {headers});\r\n  }\r\n\r\n  // get Family details\r\n  getFamilyDetails(regNo: number,Phase:string) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/IP/LoadFamily?regNo=${regNo}&Phase=${Phase}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  // save Family details\r\n  pushFamilyDetails(req: any) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/IP/UpdateFamily`;\r\n    return this.http.post(url, req, {headers});\r\n  }\r\n\r\n  // get Experience details\r\n  getExperienceDetails(regNo: number) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/IP/LoadExp?regNo=${regNo}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  // save Experience details\r\n  pushExperienceDetails(req: any, appUserName: any) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/IP/UpdateExp?APPUSERNAME=${appUserName}`;\r\n    return this.http.post(url, req, {headers});\r\n  }\r\n\r\n  // save Experience details\r\n  loadEMR(regNo: any) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/IP/LoadEMR?regNo=${regNo}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  updateEMR(req: any) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/IP/UpdateEMR`;\r\n    return this.http.post(url, req, {headers});\r\n  }\r\n\r\n  /* ------------------------ADMIN FILTER TRAINING------------------------ */\r\n  adminFilterTrnLoadMasters(staffCode: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/AdminFilterTrn/LoadMasters?PageName=AdminFilterTrn&StaffCode=${staffCode}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  adminFilterTrnLoadData(trn: string, div: string, tc: string, fromDate: any, toDate: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/AdminFilterTrn/LoadData?Trn=${trn}&Div=${div}&TC=${tc}&RFrom=${fromDate}&RTo=${toDate}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  getAdminFilterTrnViaAadhaar(aadhaarNo: string) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/AdminFilterTrn/LoadDataAadhaar?aadhaarNo=${aadhaarNo}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  getRPTInterviewPerformaTrn(regNos: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/rptInterviewPerformaTrn/GetData?tCodeList=${regNos}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  getRPTInterviewPerformaNewPer(regNos: any,key:any) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/rptInterviewPerformaTrn/GetDataLink?tCodeList=${regNos}&pCode=${key} `;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  getUserProfile(staffCode: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/UserProfile/GetProfile?staffcode=${staffCode}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  getUserRole(staffCode: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/RoleMasterITAP/LoadRecordSTAFF?STAFF_CODE=${staffCode}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  /* ------------------------ADMIN FILTER CONTROLS------------------------ */\r\n\r\n  approveRecords(data: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/AdminFilterTrn/ApproveRecords`;\r\n    return this.http.post(url, data, { headers });\r\n  }\r\n  updateTraining(data: any) {\r\n    const url = `${environment.apiOrigin}/AdminFilterTrn/UpdateTraining`;\r\n    const headers = this.createHeaders();\r\n    return this.http.post(url, data, { headers });\r\n  }\r\n  updateDivision(data: any) {\r\n    const url = `${environment.apiOrigin}/AdminFilterTrn/UpdateDivision`;\r\n    const headers = this.createHeaders();\r\n    return this.http.post(url, data, { headers });\r\n  }\r\n\r\n\r\n  /* ------------------------ADMIN ATTENDANCE MARKER------------------------ */\r\n  getAttendanceMarkerMasters() {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/PresentRegister/LoadMasters`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  getAttendanceMarkerTrn(level: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/PresentRegister/LoadTraining?Level=${level}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  getAttendanceMarkingData(level: any, staffCode: any, trnNo: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/PresentRegister/LoadRecord?StaffCode=${staffCode}&TrnNo=${trnNo}&level=${level}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  saveMarkedAttendance(data: any) {\r\n    const url = `${environment.apiOrigin}/PresentRegister/SaveRecord`;\r\n    const headers = this.createHeaders();\r\n    return this.http.post(url, data, { headers });\r\n  }\r\n\r\n  adminLogin(formData: any) {//20000004\r\n    const url = `${environment.apiOrigin}/user/login`;\r\n    let username = formData.get('userName').value;\r\n    let password = formData.get('password').value;\r\n    let basicAuthHeaderString = 'Basic ' + window.btoa(username + \":\" + password);\r\n    console.log('login123', username, password, basicAuthHeaderString);\r\n    sessionStorage.setItem('BasicKey', basicAuthHeaderString);\r\n    // let headers = new HttpHeaders(\r\n    //   { Authorization: basicAuthHeaderString }\r\n    // )\r\n    const headers = new HttpHeaders({\r\n      'Content-Type': 'application/json',\r\n      'Api-Key': this.apiKey,\r\n      'App-Name': 'iTAP',\r\n      'Authorization': basicAuthHeaderString\r\n    });\r\n    // const headers = this.createHeaders();\r\n    const body =\r\n    {\r\n      USERID: formData.get('userName').value,\r\n      PASSWD: formData.get('password').value\r\n    }\r\n    console.log(body);\r\n    return this.http.post(url, [body], { headers });\r\n  }\r\n\r\n  /* ******************************ORGANIZER EVALUATION APIS******************************* */\r\n  getOrgEvalMasters(staffCode: string) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/organizerEvaluation/LoadMasters?staff_code=${staffCode}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  getOrgEvalLoadTraining(level: string) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/organizerEvaluation/LoadTraining?Level=${level}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  getOrgEvalLoadCandidate(level: string, staffCode: string, trnPeriod: string) { // Test Data: Level=1&StaffCode=10034784&TrnPeriod=390\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/organizerEvaluation/LoadCandidate?Level=${level}&StaffCode=${staffCode}&TrnPeriod=${trnPeriod}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  getOrgEvalLoadEvaluation(regNo: string, trnNo: string) { // Test Data: RegNo=(Candidates loaded from above API)&TrnNo=390\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/organizerEvaluation/LoadEvaluation?RegNo=${regNo}&TrnNo=${trnNo}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  getOrgEvalRemoveEvaluation(tCode: string) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/organizerEvaluation/RemoveEvaluation?tCode=${tCode}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  getOrganizerEvaluation(trnCode: any, orgCode: any, divCode: any, level: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/rptOrganizerEvaluation/GetData?TrnCode=${trnCode}&OrganizerCode=${orgCode}&DivCode=${divCode}&Lvl=${level}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  getOrgEvalSaveEvaluation(reqBody: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/organizerEvaluation/SaveEvaluation`;\r\n    return this.http.post(url, reqBody, {headers});\r\n  }\r\n\r\n  /* ------------------------------INTERVIEW ASSIGNMENT APIS-------------------------------- */\r\n\r\n  getIntAssgnLoadCandidate(trnPeriod: any, division: any, group: any, action: any, round: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/InterviewAssignment/LoadCandidate?TrainingPeriod=${trnPeriod}&Division=${division}&Group=${group}&Action=${action}&round=${round}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  getIntAssgnLoadGrpDetails(trnNo: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/InterviewAssignment/LoadGroupDet?TrnNo=${trnNo}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  getIntAssgnCreateGroup(groupName: any, allowedCandidate: any, tCode: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/InterviewAssignment/CreateGroup?GroupName=${groupName}&AllowedCandidate=${allowedCandidate}&tCode=${tCode}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  getIntAssgnTransferCandidate(trainingPrd: any, staffCode: any, round: any, tCode: any, group: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/InterviewAssignment/TransferCandidate?TrainingPrd=${trainingPrd}&StaffCode=${staffCode}&Round=${round}&tCode=${tCode}&Group=${group}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  getIntAssgnRemoveCandidate(tCode: any, group: any, round: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/InterviewAssignment/RemoveCandidate?tCode=${tCode}&Group=${group}&Round=${round}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  getOrgMasterLoadMasters(staffCode: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/OrganizerMaster/LoadMasters?StaffCode=${staffCode}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  groupMaintenanceLoadGroups(round: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/GroupMaintainance/LoadGroups?Round=${round}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  //------------------------------------------GET DOCUMENTS-----------------------------------------\r\n\r\n  getDocumentList(M_CODE: string, userType: string) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/HRDocumentation/GetDocumentList?itapNo=${M_CODE}&USERTYPE=${userType}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  uploadDocuments(payload: any) {\r\n    const url = `${environment.apiOrigin}/HRDocumentation/UploadHRDocs`;\r\n    const formData = new FormData();\r\n    payload.file.forEach((file: any) => {\r\n      formData.append(`file`, file, file.name);\r\n    });\r\n    formData.append('listdata', JSON.stringify([payload.listdata]));\r\n    formData.append('removedFiles', JSON.stringify(payload.removedFiles));\r\n\r\n    const headers = new HttpHeaders()\r\n          .set('Accept', 'application/json')\r\n          .set('Api-Key', this.apiKey)\r\n          .set('App-Name', 'iTAP');\r\n\r\n    return this.http.post(url, formData, { headers: headers })\r\n  }\r\n\r\n  onFinalSave(payload: any) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/HRDocumentation/CandidateFinalSubmit`;\r\n    return this.http.post(url, payload, {headers});\r\n  }\r\n  onHRFinalSave(payload: any) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/HRDocumentation/HRFinalSubmit`;\r\n    return this.http.post(url, payload, {headers});\r\n  }\r\n  getFCList(M_CODE: any) {\r\n    const headers = this.createHeadersCandidate();\r\n    const url = `${environment.apiOrigin}/HRDocumentation/GeFCList?itapNo=${M_CODE}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  //------------------------------------------GET DOCUMENTS-----------------------------------------\r\n\r\n  getMastersJCFC(pageName: any, staffCode: any) { //PAGE_NAME: JoineeConFC\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/JoineeConfirmatonFC/LoadMasters?PageName=${pageName}&StaffCode=${staffCode}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  getRecordJCFC(candidateCode: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/JoineeConfirmatonFC/LoadRecord?candidateCode=${candidateCode}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  saveRecordsJCFC(staffCode: any, req: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/JoineeConfirmatonFC/SaveData?StaffCode=${staffCode}`;\r\n    return this.http.post(url, req, {headers});\r\n  }\r\n\r\n  saveRecordsJCEXP(staffCode: any, req: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/JoineeConExp/SaveData?StaffCode=${staffCode}`;\r\n    return this.http.post(url, req, {headers});\r\n  }\r\n\r\n  getJoineeListFC(staffCode: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/JoineeConfirmatonFC/LoadCandidate?StaffCode=${staffCode}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  getPostalCodeJCFC(pinCode: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/JoineeConfirmatonFC/getPostalCode?PinCode=${pinCode}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n  getManagerJCFC(staffCode: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/JoineeConfirmatonFC/LoadManager?StaffCode=${staffCode}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  //------------------------------------------FC DOCUMENTATION-----------------------------------------\r\n  getFCCandidateList(staffCode: any, trnDate: any, divCode: any, itapNo: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/FCDocumentation/GetCandidateList?FC_CODE=${staffCode}&Trn=${trnDate}&Div=${divCode}&ItapNo=${itapNo}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  //------------------------------------------EXP DOCUMENTATION-----------------------------------------\r\n  getExpCandidateList(staffCode: any, trnDate: any, divCode: any, itapNo: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/ExpenseDocumentation/GetExpenseCandidateList?FC_CODE=${staffCode}&Trn=${trnDate}&Div=${divCode}&ItapNo=${itapNo}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n  //------------------------------------------APPOINTMENT LETTER-----------------------------------------\r\n  getAppointmentLetterData(candidateCodeList: any) {\r\n    const headers = this.createHeaders();\r\n    const url = `${environment.apiOrigin}/rptAppointmentLetterV2/GetData/?tCodeList=${candidateCodeList}`;\r\n    return this.http.get(url, {headers});\r\n  }\r\n\r\n//Candidate Evaluation FC\r\ngetOrganizerEvaluationFC(trnCode: any, orgCode: any, divCode: any, level: any, canCode: any) {\r\n  const headers = this.createHeaders();\r\n  const url = `${environment.apiOrigin}/rptOrganizerEvaluation/GetDataFC?TrnCode=${trnCode}&OrganizerCode=${orgCode}&DivCode=${divCode}&Lvl=${level}&CandidateCode=${canCode}`;\r\n  return this.http.get(url, {headers});\r\n}\r\n\r\ndirectApplicant(div: string,fromDate: any, toDate: any)\r\n{\r\n  const headers = this.createHeaders();\r\n   const url = `${environment.apiOrigin}/ResumeService/GetUsersList?DIV_CODE=${div}&From=${fromDate}&To=${toDate}`;\r\n  return this.http.get(url,{headers});\r\n}\r\n\r\n\r\n//division-Assignment\r\nadminFilterDivisionLoadMasters(staffCode: any) {\r\n  const headers = this.createHeaders();\r\n  const url = `${environment.apiOrigin}/HrDivisionAssignment/LoadMasters?PageName=HrDivisionAssignment&StaffCode=${staffCode}`;\r\n  return this.http.get(url, {headers});\r\n}\r\nadminFilterDivisionLoadTableData(formData: any) {\r\n  const headers = this.createHeaders();\r\n  const url = `${environment.apiOrigin}/HrDivisionAssignment/getRecords?varDivision=${formData?.division}&varRole=${formData?.action}&varEmpName=${formData?.empCode}&varActive=`;\r\n  return this.http.get(url, {headers});\r\n}\r\n// adminFilterDivisionSaveUpdateTableData(formData: any) {\r\n//   const headers = this.createHeaders();\r\n//   const url = `${environment.apiOrigin}/HrDivisionAssignment/InsertRecords?varDivision=${formData?.division}&varRole=&varEmpName=${formData?.empCode}&varActive=${formData?.action}&updateID=${formData?.updateID}&StaffCode=${formData?.staffCode}`;\r\n//   return this.http.post(url, {headers});\r\n// }\r\nadminFilterDivisionSaveUpdateTableData(formData: any) {\r\n  const headers = this.createHeaders();\r\n  const url = `${environment.apiOrigin}/HrDivisionAssignment/InsertRecords?varDivision=${formData?.varDivision}&varRole=${formData?.varRole}&varEmpName=${formData?.varEmpName}&varActive=${formData?.varActive}&updateID=${formData?.updateID}&StaffCode=${formData?.staffCode}`;\r\n  return this.http.post(url,formData, {headers});\r\n}\r\nbankMasterGet() {\r\n  const headers = this.createHeaders();\r\n  const url = `${environment.apiOrigin}/BankMaster/LoadRecord`;\r\n  return this.http.get(url, {headers});\r\n}\r\nfuncForSaveBankMasterDetail(req : any,empCode:any) {\r\n  const headers = this.createHeaders();\r\n  req['CRTD_BY'] =empCode;\r\n  var _reqParam = new Array(req);\r\n  const url = `${environment.apiOrigin}/BankMaster/SaveBank`;\r\n  return this.http.post(url, _reqParam, {headers});\r\n}\r\nfuncForSaveIFSCMasterDetail(req : any,empCode:any) {\r\n  const headers = this.createHeaders();\r\n  req['CRTD_BY'] =empCode;\r\n  var _reqParam = new Array(req);\r\n  const url = `${environment.apiOrigin}/IFSCMaster/SaveBranch`;\r\n  return this.http.post(url, _reqParam, {headers});\r\n}\r\nfuncForGetIFSC(bankId : string): Observable<Object> {\r\n  const headers = this.createHeaders();\r\n  const url = `${environment.apiOrigin}/IFSCMaster/LoadRecord?BankID=${bankId}`;\r\n  return this.http.get(url, {headers});\r\n}\r\nloadCandidate(staffCode:string): Observable<Object>{\r\n  const headers = this.createHeadersCandidate();\r\n  const url = `${environment.apiOrigin}/joineeConfirmation/LoadCandidate?StaffCode=${staffCode}`;\r\n  return this.http.get(url, {headers});\r\n}\r\nloadRecord(candidateRecord:any): Observable<Object>{\r\n  const headers = this.createHeadersCandidate();\r\n  const url = `${environment.apiOrigin}/joineeConfirmation/loadRecord?candidateCode=${candidateRecord.candidateCode}&StaffCode=${candidateRecord.staffCode}`;\r\n  return this.http.get(url, {headers});\r\n}\r\nloadMasters(staffCode:string): Observable<Object>{\r\n  const headers = this.createHeadersCandidate();\r\n  const url = `${environment.apiOrigin}/joineeConfirmation/LoadMasters?PageName=JoineeConfirmationMgr&StaffCode=${staffCode}`;\r\n  return this.http.get(url, {headers});\r\n}\r\nloadPostalCode(pinCode:string): Observable<Object>{\r\n  const headers = this.createHeadersCandidate();\r\n  const url = `${environment.apiOrigin}/joineeConfirmation/getPostalCode?PinCode=${pinCode}`;\r\n  return this.http.get(url, {headers});\r\n}\r\n  \r\ncandidateSaveData(req:string,staffCode:String): Observable<Object>{\r\n  const headers = this.createHeadersCandidate();\r\n  var _reqParam = new Array(req);\r\n  const url = `${environment.apiOrigin}/joineeConfirmation/SaveData?StaffCode=${staffCode}`;\r\n  return this.http.post(url, _reqParam, {headers});\r\n}\r\nSaveFL(firstLine :string,T_CODE :string): Observable<Object>{\r\n  const headers = this.createHeadersCandidate();\r\n  const url = `${environment.apiOrigin}/joineeConfirmation/SaveFL?FirstLine=${firstLine}&T_CODE=${T_CODE}`;\r\n  return this.http.get(url, {headers});\r\n}\r\nsalaryMasterLoad(staffCode :any): Observable<Object>{\r\n  const headers = this.createHeaders();\r\n  const url = `${environment.apiOrigin}/SalaryMaster/LoadMasters?PageName=SalaryMaster&StaffCode=${staffCode}`;\r\n  return this.http.get(url, {headers});\r\n}\r\nsalaryMasterGetLoad(matData :any): Observable<Object>{\r\n  const headers = this.createHeaders();\r\n  const url = `${environment.apiOrigin}/SalaryMaster/GetSalary?DIV_CODE=${matData?.division}&DESIG_CODE=${matData?.designation}&STATE_CODE=${matData?.state}&HQ_CODE=${matData?.hq}`;\r\n  return this.http.get(url, {headers});\r\n}\r\nfunForUnlockRecord(itapNo :string,phase:string): Observable<Object>{\r\n  const headers = this.createHeaders();\r\n  const url = `${environment.apiOrigin}/ItapSupport/UnlockRecord?itapNo=${itapNo}&Option=${phase}`;\r\n  return this.http.get(url, {headers});\r\n}\r\nadminFilterTrnPreJoiningLoadMasters(staffCode: any) {\r\n  const headers = this.createHeaders();\r\n  const url = `${environment.apiOrigin}/PreJoining/LoadMasters?PageName=PreJoining&StaffCode=${staffCode}`;\r\n  return this.http.get(url, {headers});\r\n}\r\n\r\n \r\n}\r\n","import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { FileUploadComponent } from './file-upload/file-upload.component';\r\nimport { HrFileUploadComponent } from './hr-file-upload/hr-file-upload.component';\r\nimport { MatChipsModule } from '@angular/material/chips';\r\nimport { MatCheckboxModule } from '@angular/material/checkbox';\r\nimport { MatIconModule } from '@angular/material/icon';\r\nimport { MatButtonModule } from '@angular/material/button';\r\nimport { MatSelectModule } from '@angular/material/select';\r\nimport { MatRadioModule } from '@angular/material/radio';\r\nimport { MatAutocompleteModule } from '@angular/material/autocomplete';\r\nimport { Phase2RoutingModule } from '../phase2/phase2-routing.module';\r\nimport { MatTableModule } from '@angular/material/table';\r\nimport { MatExpansionModule } from '@angular/material/expansion';\r\nimport { MatProgressBarModule } from '@angular/material/progress-bar';\r\nimport { MatTooltipModule } from '@angular/material/tooltip';\r\nimport { UploadedFileListComponent } from './uploaded-file-list/uploaded-file-list.component';\r\nimport { DecimalFormatDirective } from '../directives/decimal-format.directive';\r\n\r\n\r\n@NgModule({\r\n  declarations: [\r\n    FileUploadComponent,\r\n    HrFileUploadComponent,\r\n    UploadedFileListComponent,\r\n    DecimalFormatDirective\r\n  ],\r\n  imports: [\r\n    CommonModule,\r\n    MatChipsModule,\r\n    MatCheckboxModule,\r\n    MatIconModule,\r\n    MatButtonModule,\r\n    MatSelectModule,\r\n    MatCheckboxModule,\r\n    MatRadioModule,\r\n    MatAutocompleteModule,\r\n    MatTableModule,\r\n    MatExpansionModule,\r\n    MatProgressBarModule,\r\n    MatChipsModule,\r\n    MatTooltipModule,\r\n  ],\r\n  exports: [\r\n    FileUploadComponent,\r\n    HrFileUploadComponent,\r\n    UploadedFileListComponent,\r\n    DecimalFormatDirective,\r\n  ]\r\n})\r\nexport class SharedModule { }\r\n","import { Observable } from '../Observable';\nimport { argsArgArrayOrObject } from '../util/argsArgArrayOrObject';\nimport { innerFrom } from './innerFrom';\nimport { popResultSelector } from '../util/args';\nimport { createOperatorSubscriber } from '../operators/OperatorSubscriber';\nimport { mapOneOrManyArgs } from '../util/mapOneOrManyArgs';\nimport { createObject } from '../util/createObject';\nexport function forkJoin(...args) {\n    const resultSelector = popResultSelector(args);\n    const { args: sources, keys } = argsArgArrayOrObject(args);\n    const result = new Observable((subscriber) => {\n        const { length } = sources;\n        if (!length) {\n            subscriber.complete();\n            return;\n        }\n        const values = new Array(length);\n        let remainingCompletions = length;\n        let remainingEmissions = length;\n        for (let sourceIndex = 0; sourceIndex < length; sourceIndex++) {\n            let hasValue = false;\n            innerFrom(sources[sourceIndex]).subscribe(createOperatorSubscriber(subscriber, (value) => {\n                if (!hasValue) {\n                    hasValue = true;\n                    remainingEmissions--;\n                }\n                values[sourceIndex] = value;\n            }, () => remainingCompletions--, undefined, () => {\n                if (!remainingCompletions || !hasValue) {\n                    if (!remainingEmissions) {\n                        subscriber.next(keys ? createObject(keys, values) : values);\n                    }\n                    subscriber.complete();\n                }\n            }));\n        }\n    });\n    return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;\n}\n","import { concat } from '../observable/concat';\nimport { take } from './take';\nimport { ignoreElements } from './ignoreElements';\nimport { mapTo } from './mapTo';\nimport { mergeMap } from './mergeMap';\nexport function delayWhen(delayDurationSelector, subscriptionDelay) {\n    if (subscriptionDelay) {\n        return (source) => concat(subscriptionDelay.pipe(take(1), ignoreElements()), source.pipe(delayWhen(delayDurationSelector)));\n    }\n    return mergeMap((value, index) => delayDurationSelector(value, index).pipe(take(1), mapTo(value)));\n}\n","import { operate } from '../util/lift';\nimport { createOperatorSubscriber } from './OperatorSubscriber';\nimport { noop } from '../util/noop';\nexport function ignoreElements() {\n    return operate((source, subscriber) => {\n        source.subscribe(createOperatorSubscriber(subscriber, noop));\n    });\n}\n","import { asyncScheduler } from '../scheduler/async';\nimport { delayWhen } from './delayWhen';\nimport { timer } from '../observable/timer';\nexport function delay(due, scheduler = asyncScheduler) {\n    const duration = timer(due, scheduler);\n    return delayWhen(() => duration);\n}\n","/**\n * @license Angular v14.3.0\n * (c) 2010-2022 Google LLC. https://angular.io/\n * License: MIT\n */\n\nimport * as i0 from '@angular/core';\nimport { Directive, InjectionToken, forwardRef, Optional, Inject, ɵisPromise, ɵisObservable, ɵRuntimeError, Self, EventEmitter, Input, Host, SkipSelf, ɵcoerceToBoolean, ChangeDetectorRef, Output, NgModule, Injectable, inject, Version } from '@angular/core';\nimport { ɵgetDOM } from '@angular/common';\nimport { from, forkJoin } from 'rxjs';\nimport { map } from 'rxjs/operators';\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 * Base class for all ControlValueAccessor classes defined in Forms package.\n * Contains common logic and utility functions.\n *\n * Note: this is an *internal-only* class and should not be extended or used directly in\n * applications code.\n */\nclass BaseControlValueAccessor {\n    constructor(_renderer, _elementRef) {\n        this._renderer = _renderer;\n        this._elementRef = _elementRef;\n        /**\n         * The registered callback function called when a change or input event occurs on the input\n         * element.\n         * @nodoc\n         */\n        this.onChange = (_) => { };\n        /**\n         * The registered callback function called when a blur event occurs on the input element.\n         * @nodoc\n         */\n        this.onTouched = () => { };\n    }\n    /**\n     * Helper method that sets a property on a target element using the current Renderer\n     * implementation.\n     * @nodoc\n     */\n    setProperty(key, value) {\n        this._renderer.setProperty(this._elementRef.nativeElement, key, value);\n    }\n    /**\n     * Registers a function called when the control is touched.\n     * @nodoc\n     */\n    registerOnTouched(fn) {\n        this.onTouched = fn;\n    }\n    /**\n     * Registers a function called when the control value changes.\n     * @nodoc\n     */\n    registerOnChange(fn) {\n        this.onChange = fn;\n    }\n    /**\n     * Sets the \"disabled\" property on the range input element.\n     * @nodoc\n     */\n    setDisabledState(isDisabled) {\n        this.setProperty('disabled', isDisabled);\n    }\n}\nBaseControlValueAccessor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: BaseControlValueAccessor, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });\nBaseControlValueAccessor.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: BaseControlValueAccessor, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: BaseControlValueAccessor, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }]; } });\n/**\n * Base class for all built-in ControlValueAccessor classes (except DefaultValueAccessor, which is\n * used in case no other CVAs can be found). We use this class to distinguish between default CVA,\n * built-in CVAs and custom CVAs, so that Forms logic can recognize built-in CVAs and treat custom\n * ones with higher priority (when both built-in and custom CVAs are present).\n *\n * Note: this is an *internal-only* class and should not be extended or used directly in\n * applications code.\n */\nclass BuiltInControlValueAccessor extends BaseControlValueAccessor {\n}\nBuiltInControlValueAccessor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: BuiltInControlValueAccessor, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nBuiltInControlValueAccessor.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: BuiltInControlValueAccessor, usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: BuiltInControlValueAccessor, decorators: [{\n            type: Directive\n        }] });\n/**\n * Used to provide a `ControlValueAccessor` for form controls.\n *\n * See `DefaultValueAccessor` for how to implement one.\n *\n * @publicApi\n */\nconst NG_VALUE_ACCESSOR = new InjectionToken('NgValueAccessor');\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 */\nconst CHECKBOX_VALUE_ACCESSOR = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => CheckboxControlValueAccessor),\n    multi: true,\n};\n/**\n * @description\n * A `ControlValueAccessor` for writing a value and listening to changes on a checkbox input\n * element.\n *\n * @usageNotes\n *\n * ### Using a checkbox with a reactive form.\n *\n * The following example shows how to use a checkbox with a reactive form.\n *\n * ```ts\n * const rememberLoginControl = new FormControl();\n * ```\n *\n * ```\n * <input type=\"checkbox\" [formControl]=\"rememberLoginControl\">\n * ```\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass CheckboxControlValueAccessor extends BuiltInControlValueAccessor {\n    /**\n     * Sets the \"checked\" property on the input element.\n     * @nodoc\n     */\n    writeValue(value) {\n        this.setProperty('checked', value);\n    }\n}\nCheckboxControlValueAccessor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: CheckboxControlValueAccessor, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nCheckboxControlValueAccessor.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: CheckboxControlValueAccessor, selector: \"input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]\", host: { listeners: { \"change\": \"onChange($event.target.checked)\", \"blur\": \"onTouched()\" } }, providers: [CHECKBOX_VALUE_ACCESSOR], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: CheckboxControlValueAccessor, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]',\n                    host: { '(change)': 'onChange($event.target.checked)', '(blur)': 'onTouched()' },\n                    providers: [CHECKBOX_VALUE_ACCESSOR]\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst DEFAULT_VALUE_ACCESSOR = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => DefaultValueAccessor),\n    multi: true\n};\n/**\n * We must check whether the agent is Android because composition events\n * behave differently between iOS and Android.\n */\nfunction _isAndroid() {\n    const userAgent = ɵgetDOM() ? ɵgetDOM().getUserAgent() : '';\n    return /android (\\d+)/.test(userAgent.toLowerCase());\n}\n/**\n * @description\n * Provide this token to control if form directives buffer IME input until\n * the \"compositionend\" event occurs.\n * @publicApi\n */\nconst COMPOSITION_BUFFER_MODE = new InjectionToken('CompositionEventMode');\n/**\n * The default `ControlValueAccessor` for writing a value and listening to changes on input\n * elements. The accessor is used by the `FormControlDirective`, `FormControlName`, and\n * `NgModel` directives.\n *\n * {@searchKeywords ngDefaultControl}\n *\n * @usageNotes\n *\n * ### Using the default value accessor\n *\n * The following example shows how to use an input element that activates the default value accessor\n * (in this case, a text field).\n *\n * ```ts\n * const firstNameControl = new FormControl();\n * ```\n *\n * ```\n * <input type=\"text\" [formControl]=\"firstNameControl\">\n * ```\n *\n * This value accessor is used by default for `<input type=\"text\">` and `<textarea>` elements, but\n * you could also use it for custom components that have similar behavior and do not require special\n * processing. In order to attach the default value accessor to a custom element, add the\n * `ngDefaultControl` attribute as shown below.\n *\n * ```\n * <custom-input-component ngDefaultControl [(ngModel)]=\"value\"></custom-input-component>\n * ```\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass DefaultValueAccessor extends BaseControlValueAccessor {\n    constructor(renderer, elementRef, _compositionMode) {\n        super(renderer, elementRef);\n        this._compositionMode = _compositionMode;\n        /** Whether the user is creating a composition string (IME events). */\n        this._composing = false;\n        if (this._compositionMode == null) {\n            this._compositionMode = !_isAndroid();\n        }\n    }\n    /**\n     * Sets the \"value\" property on the input element.\n     * @nodoc\n     */\n    writeValue(value) {\n        const normalizedValue = value == null ? '' : value;\n        this.setProperty('value', normalizedValue);\n    }\n    /** @internal */\n    _handleInput(value) {\n        if (!this._compositionMode || (this._compositionMode && !this._composing)) {\n            this.onChange(value);\n        }\n    }\n    /** @internal */\n    _compositionStart() {\n        this._composing = true;\n    }\n    /** @internal */\n    _compositionEnd(value) {\n        this._composing = false;\n        this._compositionMode && this.onChange(value);\n    }\n}\nDefaultValueAccessor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: DefaultValueAccessor, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: COMPOSITION_BUFFER_MODE, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nDefaultValueAccessor.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: DefaultValueAccessor, selector: \"input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]\", host: { listeners: { \"input\": \"$any(this)._handleInput($event.target.value)\", \"blur\": \"onTouched()\", \"compositionstart\": \"$any(this)._compositionStart()\", \"compositionend\": \"$any(this)._compositionEnd($event.target.value)\" } }, providers: [DEFAULT_VALUE_ACCESSOR], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: DefaultValueAccessor, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]',\n                    // TODO: vsavkin replace the above selector with the one below it once\n                    // https://github.com/angular/angular/issues/3011 is implemented\n                    // selector: '[ngModel],[formControl],[formControlName]',\n                    host: {\n                        '(input)': '$any(this)._handleInput($event.target.value)',\n                        '(blur)': 'onTouched()',\n                        '(compositionstart)': '$any(this)._compositionStart()',\n                        '(compositionend)': '$any(this)._compositionEnd($event.target.value)'\n                    },\n                    providers: [DEFAULT_VALUE_ACCESSOR]\n                }]\n        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [COMPOSITION_BUFFER_MODE]\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 */\nconst NG_DEV_MODE$1 = typeof ngDevMode === 'undefined' || !!ngDevMode;\nfunction isEmptyInputValue(value) {\n    /**\n     * Check if the object is a string or array before evaluating the length attribute.\n     * This avoids falsely rejecting objects that contain a custom length attribute.\n     * For example, the object {id: 1, length: 0, width: 0} should not be returned as empty.\n     */\n    return value == null ||\n        ((typeof value === 'string' || Array.isArray(value)) && value.length === 0);\n}\nfunction hasValidLength(value) {\n    // non-strict comparison is intentional, to check for both `null` and `undefined` values\n    return value != null && typeof value.length === 'number';\n}\n/**\n * @description\n * An `InjectionToken` for registering additional synchronous validators used with\n * `AbstractControl`s.\n *\n * @see `NG_ASYNC_VALIDATORS`\n *\n * @usageNotes\n *\n * ### Providing a custom validator\n *\n * The following example registers a custom validator directive. Adding the validator to the\n * existing collection of validators requires the `multi: true` option.\n *\n * ```typescript\n * @Directive({\n *   selector: '[customValidator]',\n *   providers: [{provide: NG_VALIDATORS, useExisting: CustomValidatorDirective, multi: true}]\n * })\n * class CustomValidatorDirective implements Validator {\n *   validate(control: AbstractControl): ValidationErrors | null {\n *     return { 'custom': true };\n *   }\n * }\n * ```\n *\n * @publicApi\n */\nconst NG_VALIDATORS = new InjectionToken('NgValidators');\n/**\n * @description\n * An `InjectionToken` for registering additional asynchronous validators used with\n * `AbstractControl`s.\n *\n * @see `NG_VALIDATORS`\n *\n * @usageNotes\n *\n * ### Provide a custom async validator directive\n *\n * The following example implements the `AsyncValidator` interface to create an\n * async validator directive with a custom error key.\n *\n * ```typescript\n * @Directive({\n *   selector: '[customAsyncValidator]',\n *   providers: [{provide: NG_ASYNC_VALIDATORS, useExisting: CustomAsyncValidatorDirective, multi:\n * true}]\n * })\n * class CustomAsyncValidatorDirective implements AsyncValidator {\n *   validate(control: AbstractControl): Promise<ValidationErrors|null> {\n *     return Promise.resolve({'custom': true});\n *   }\n * }\n * ```\n *\n * @publicApi\n */\nconst NG_ASYNC_VALIDATORS = new InjectionToken('NgAsyncValidators');\n/**\n * A regular expression that matches valid e-mail addresses.\n *\n * At a high level, this regexp matches e-mail addresses of the format `local-part@tld`, where:\n * - `local-part` consists of one or more of the allowed characters (alphanumeric and some\n *   punctuation symbols).\n * - `local-part` cannot begin or end with a period (`.`).\n * - `local-part` cannot be longer than 64 characters.\n * - `tld` consists of one or more `labels` separated by periods (`.`). For example `localhost` or\n *   `foo.com`.\n * - A `label` consists of one or more of the allowed characters (alphanumeric, dashes (`-`) and\n *   periods (`.`)).\n * - A `label` cannot begin or end with a dash (`-`) or a period (`.`).\n * - A `label` cannot be longer than 63 characters.\n * - The whole address cannot be longer than 254 characters.\n *\n * ## Implementation background\n *\n * This regexp was ported over from AngularJS (see there for git history):\n * https://github.com/angular/angular.js/blob/c133ef836/src/ng/directive/input.js#L27\n * It is based on the\n * [WHATWG version](https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address) with\n * some enhancements to incorporate more RFC rules (such as rules related to domain names and the\n * lengths of different parts of the address). The main differences from the WHATWG version are:\n *   - Disallow `local-part` to begin or end with a period (`.`).\n *   - Disallow `local-part` length to exceed 64 characters.\n *   - Disallow total address length to exceed 254 characters.\n *\n * See [this commit](https://github.com/angular/angular.js/commit/f3f5cf72e) for more details.\n */\nconst EMAIL_REGEXP = /^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;\n/**\n * @description\n * Provides a set of built-in validators that can be used by form controls.\n *\n * A validator is a function that processes a `FormControl` or collection of\n * controls and returns an error map or null. A null map means that validation has passed.\n *\n * @see [Form Validation](/guide/form-validation)\n *\n * @publicApi\n */\nclass Validators {\n    /**\n     * @description\n     * Validator that requires the control's value to be greater than or equal to the provided number.\n     *\n     * @usageNotes\n     *\n     * ### Validate against a minimum of 3\n     *\n     * ```typescript\n     * const control = new FormControl(2, Validators.min(3));\n     *\n     * console.log(control.errors); // {min: {min: 3, actual: 2}}\n     * ```\n     *\n     * @returns A validator function that returns an error map with the\n     * `min` property if the validation check fails, otherwise `null`.\n     *\n     * @see `updateValueAndValidity()`\n     *\n     */\n    static min(min) {\n        return minValidator(min);\n    }\n    /**\n     * @description\n     * Validator that requires the control's value to be less than or equal to the provided number.\n     *\n     * @usageNotes\n     *\n     * ### Validate against a maximum of 15\n     *\n     * ```typescript\n     * const control = new FormControl(16, Validators.max(15));\n     *\n     * console.log(control.errors); // {max: {max: 15, actual: 16}}\n     * ```\n     *\n     * @returns A validator function that returns an error map with the\n     * `max` property if the validation check fails, otherwise `null`.\n     *\n     * @see `updateValueAndValidity()`\n     *\n     */\n    static max(max) {\n        return maxValidator(max);\n    }\n    /**\n     * @description\n     * Validator that requires the control have a non-empty value.\n     *\n     * @usageNotes\n     *\n     * ### Validate that the field is non-empty\n     *\n     * ```typescript\n     * const control = new FormControl('', Validators.required);\n     *\n     * console.log(control.errors); // {required: true}\n     * ```\n     *\n     * @returns An error map with the `required` property\n     * if the validation check fails, otherwise `null`.\n     *\n     * @see `updateValueAndValidity()`\n     *\n     */\n    static required(control) {\n        return requiredValidator(control);\n    }\n    /**\n     * @description\n     * Validator that requires the control's value be true. This validator is commonly\n     * used for required checkboxes.\n     *\n     * @usageNotes\n     *\n     * ### Validate that the field value is true\n     *\n     * ```typescript\n     * const control = new FormControl('some value', Validators.requiredTrue);\n     *\n     * console.log(control.errors); // {required: true}\n     * ```\n     *\n     * @returns An error map that contains the `required` property\n     * set to `true` if the validation check fails, otherwise `null`.\n     *\n     * @see `updateValueAndValidity()`\n     *\n     */\n    static requiredTrue(control) {\n        return requiredTrueValidator(control);\n    }\n    /**\n     * @description\n     * Validator that requires the control's value pass an email validation test.\n     *\n     * Tests the value using a [regular\n     * expression](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions)\n     * pattern suitable for common use cases. The pattern is based on the definition of a valid email\n     * address in the [WHATWG HTML\n     * specification](https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address) with\n     * some enhancements to incorporate more RFC rules (such as rules related to domain names and the\n     * lengths of different parts of the address).\n     *\n     * The differences from the WHATWG version include:\n     * - Disallow `local-part` (the part before the `@` symbol) to begin or end with a period (`.`).\n     * - Disallow `local-part` to be longer than 64 characters.\n     * - Disallow the whole address to be longer than 254 characters.\n     *\n     * If this pattern does not satisfy your business needs, you can use `Validators.pattern()` to\n     * validate the value against a different pattern.\n     *\n     * @usageNotes\n     *\n     * ### Validate that the field matches a valid email pattern\n     *\n     * ```typescript\n     * const control = new FormControl('bad@', Validators.email);\n     *\n     * console.log(control.errors); // {email: true}\n     * ```\n     *\n     * @returns An error map with the `email` property\n     * if the validation check fails, otherwise `null`.\n     *\n     * @see `updateValueAndValidity()`\n     *\n     */\n    static email(control) {\n        return emailValidator(control);\n    }\n    /**\n     * @description\n     * Validator that requires the length of the control's value to be greater than or equal\n     * to the provided minimum length. This validator is also provided by default if you use the\n     * the HTML5 `minlength` attribute. Note that the `minLength` validator is intended to be used\n     * only for types that have a numeric `length` property, such as strings or arrays. The\n     * `minLength` validator logic is also not invoked for values when their `length` property is 0\n     * (for example in case of an empty string or an empty array), to support optional controls. You\n     * can use the standard `required` validator if empty values should not be considered valid.\n     *\n     * @usageNotes\n     *\n     * ### Validate that the field has a minimum of 3 characters\n     *\n     * ```typescript\n     * const control = new FormControl('ng', Validators.minLength(3));\n     *\n     * console.log(control.errors); // {minlength: {requiredLength: 3, actualLength: 2}}\n     * ```\n     *\n     * ```html\n     * <input minlength=\"5\">\n     * ```\n     *\n     * @returns A validator function that returns an error map with the\n     * `minlength` property if the validation check fails, otherwise `null`.\n     *\n     * @see `updateValueAndValidity()`\n     *\n     */\n    static minLength(minLength) {\n        return minLengthValidator(minLength);\n    }\n    /**\n     * @description\n     * Validator that requires the length of the control's value to be less than or equal\n     * to the provided maximum length. This validator is also provided by default if you use the\n     * the HTML5 `maxlength` attribute. Note that the `maxLength` validator is intended to be used\n     * only for types that have a numeric `length` property, such as strings or arrays.\n     *\n     * @usageNotes\n     *\n     * ### Validate that the field has maximum of 5 characters\n     *\n     * ```typescript\n     * const control = new FormControl('Angular', Validators.maxLength(5));\n     *\n     * console.log(control.errors); // {maxlength: {requiredLength: 5, actualLength: 7}}\n     * ```\n     *\n     * ```html\n     * <input maxlength=\"5\">\n     * ```\n     *\n     * @returns A validator function that returns an error map with the\n     * `maxlength` property if the validation check fails, otherwise `null`.\n     *\n     * @see `updateValueAndValidity()`\n     *\n     */\n    static maxLength(maxLength) {\n        return maxLengthValidator(maxLength);\n    }\n    /**\n     * @description\n     * Validator that requires the control's value to match a regex pattern. This validator is also\n     * provided by default if you use the HTML5 `pattern` attribute.\n     *\n     * @usageNotes\n     *\n     * ### Validate that the field only contains letters or spaces\n     *\n     * ```typescript\n     * const control = new FormControl('1', Validators.pattern('[a-zA-Z ]*'));\n     *\n     * console.log(control.errors); // {pattern: {requiredPattern: '^[a-zA-Z ]*$', actualValue: '1'}}\n     * ```\n     *\n     * ```html\n     * <input pattern=\"[a-zA-Z ]*\">\n     * ```\n     *\n     * ### Pattern matching with the global or sticky flag\n     *\n     * `RegExp` objects created with the `g` or `y` flags that are passed into `Validators.pattern`\n     * can produce different results on the same input when validations are run consecutively. This is\n     * due to how the behavior of `RegExp.prototype.test` is\n     * specified in [ECMA-262](https://tc39.es/ecma262/#sec-regexpbuiltinexec)\n     * (`RegExp` preserves the index of the last match when the global or sticky flag is used).\n     * Due to this behavior, it is recommended that when using\n     * `Validators.pattern` you **do not** pass in a `RegExp` object with either the global or sticky\n     * flag enabled.\n     *\n     * ```typescript\n     * // Not recommended (since the `g` flag is used)\n     * const controlOne = new FormControl('1', Validators.pattern(/foo/g));\n     *\n     * // Good\n     * const controlTwo = new FormControl('1', Validators.pattern(/foo/));\n     * ```\n     *\n     * @param pattern A regular expression to be used as is to test the values, or a string.\n     * If a string is passed, the `^` character is prepended and the `$` character is\n     * appended to the provided string (if not already present), and the resulting regular\n     * expression is used to test the values.\n     *\n     * @returns A validator function that returns an error map with the\n     * `pattern` property if the validation check fails, otherwise `null`.\n     *\n     * @see `updateValueAndValidity()`\n     *\n     */\n    static pattern(pattern) {\n        return patternValidator(pattern);\n    }\n    /**\n     * @description\n     * Validator that performs no operation.\n     *\n     * @see `updateValueAndValidity()`\n     *\n     */\n    static nullValidator(control) {\n        return nullValidator(control);\n    }\n    static compose(validators) {\n        return compose(validators);\n    }\n    /**\n     * @description\n     * Compose multiple async validators into a single function that returns the union\n     * of the individual error objects for the provided control.\n     *\n     * @returns A validator function that returns an error map with the\n     * merged error objects of the async validators if the validation check fails, otherwise `null`.\n     *\n     * @see `updateValueAndValidity()`\n     *\n     */\n    static composeAsync(validators) {\n        return composeAsync(validators);\n    }\n}\n/**\n * Validator that requires the control's value to be greater than or equal to the provided number.\n * See `Validators.min` for additional information.\n */\nfunction minValidator(min) {\n    return (control) => {\n        if (isEmptyInputValue(control.value) || isEmptyInputValue(min)) {\n            return null; // don't validate empty values to allow optional controls\n        }\n        const value = parseFloat(control.value);\n        // Controls with NaN values after parsing should be treated as not having a\n        // minimum, per the HTML forms spec: https://www.w3.org/TR/html5/forms.html#attr-input-min\n        return !isNaN(value) && value < min ? { 'min': { 'min': min, 'actual': control.value } } : null;\n    };\n}\n/**\n * Validator that requires the control's value to be less than or equal to the provided number.\n * See `Validators.max` for additional information.\n */\nfunction maxValidator(max) {\n    return (control) => {\n        if (isEmptyInputValue(control.value) || isEmptyInputValue(max)) {\n            return null; // don't validate empty values to allow optional controls\n        }\n        const value = parseFloat(control.value);\n        // Controls with NaN values after parsing should be treated as not having a\n        // maximum, per the HTML forms spec: https://www.w3.org/TR/html5/forms.html#attr-input-max\n        return !isNaN(value) && value > max ? { 'max': { 'max': max, 'actual': control.value } } : null;\n    };\n}\n/**\n * Validator that requires the control have a non-empty value.\n * See `Validators.required` for additional information.\n */\nfunction requiredValidator(control) {\n    return isEmptyInputValue(control.value) ? { 'required': true } : null;\n}\n/**\n * Validator that requires the control's value be true. This validator is commonly\n * used for required checkboxes.\n * See `Validators.requiredTrue` for additional information.\n */\nfunction requiredTrueValidator(control) {\n    return control.value === true ? null : { 'required': true };\n}\n/**\n * Validator that requires the control's value pass an email validation test.\n * See `Validators.email` for additional information.\n */\nfunction emailValidator(control) {\n    if (isEmptyInputValue(control.value)) {\n        return null; // don't validate empty values to allow optional controls\n    }\n    return EMAIL_REGEXP.test(control.value) ? null : { 'email': true };\n}\n/**\n * Validator that requires the length of the control's value to be greater than or equal\n * to the provided minimum length. See `Validators.minLength` for additional information.\n */\nfunction minLengthValidator(minLength) {\n    return (control) => {\n        if (isEmptyInputValue(control.value) || !hasValidLength(control.value)) {\n            // don't validate empty values to allow optional controls\n            // don't validate values without `length` property\n            return null;\n        }\n        return control.value.length < minLength ?\n            { 'minlength': { 'requiredLength': minLength, 'actualLength': control.value.length } } :\n            null;\n    };\n}\n/**\n * Validator that requires the length of the control's value to be less than or equal\n * to the provided maximum length. See `Validators.maxLength` for additional information.\n */\nfunction maxLengthValidator(maxLength) {\n    return (control) => {\n        return hasValidLength(control.value) && control.value.length > maxLength ?\n            { 'maxlength': { 'requiredLength': maxLength, 'actualLength': control.value.length } } :\n            null;\n    };\n}\n/**\n * Validator that requires the control's value to match a regex pattern.\n * See `Validators.pattern` for additional information.\n */\nfunction patternValidator(pattern) {\n    if (!pattern)\n        return nullValidator;\n    let regex;\n    let regexStr;\n    if (typeof pattern === 'string') {\n        regexStr = '';\n        if (pattern.charAt(0) !== '^')\n            regexStr += '^';\n        regexStr += pattern;\n        if (pattern.charAt(pattern.length - 1) !== '$')\n            regexStr += '$';\n        regex = new RegExp(regexStr);\n    }\n    else {\n        regexStr = pattern.toString();\n        regex = pattern;\n    }\n    return (control) => {\n        if (isEmptyInputValue(control.value)) {\n            return null; // don't validate empty values to allow optional controls\n        }\n        const value = control.value;\n        return regex.test(value) ? null :\n            { 'pattern': { 'requiredPattern': regexStr, 'actualValue': value } };\n    };\n}\n/**\n * Function that has `ValidatorFn` shape, but performs no operation.\n */\nfunction nullValidator(control) {\n    return null;\n}\nfunction isPresent(o) {\n    return o != null;\n}\nfunction toObservable(value) {\n    const obs = ɵisPromise(value) ? from(value) : value;\n    if (NG_DEV_MODE$1 && !(ɵisObservable(obs))) {\n        let errorMessage = `Expected async validator to return Promise or Observable.`;\n        // A synchronous validator will return object or null.\n        if (typeof value === 'object') {\n            errorMessage +=\n                ' Are you using a synchronous validator where an async validator is expected?';\n        }\n        throw new ɵRuntimeError(-1101 /* RuntimeErrorCode.WRONG_VALIDATOR_RETURN_TYPE */, errorMessage);\n    }\n    return obs;\n}\nfunction mergeErrors(arrayOfErrors) {\n    let res = {};\n    // Not using Array.reduce here due to a Chrome 80 bug\n    // https://bugs.chromium.org/p/chromium/issues/detail?id=1049982\n    arrayOfErrors.forEach((errors) => {\n        res = errors != null ? { ...res, ...errors } : res;\n    });\n    return Object.keys(res).length === 0 ? null : res;\n}\nfunction executeValidators(control, validators) {\n    return validators.map(validator => validator(control));\n}\nfunction isValidatorFn(validator) {\n    return !validator.validate;\n}\n/**\n * Given the list of validators that may contain both functions as well as classes, return the list\n * of validator functions (convert validator classes into validator functions). This is needed to\n * have consistent structure in validators list before composing them.\n *\n * @param validators The set of validators that may contain validators both in plain function form\n *     as well as represented as a validator class.\n */\nfunction normalizeValidators(validators) {\n    return validators.map(validator => {\n        return isValidatorFn(validator) ?\n            validator :\n            ((c) => validator.validate(c));\n    });\n}\n/**\n * Merges synchronous validators into a single validator function.\n * See `Validators.compose` for additional information.\n */\nfunction compose(validators) {\n    if (!validators)\n        return null;\n    const presentValidators = validators.filter(isPresent);\n    if (presentValidators.length == 0)\n        return null;\n    return function (control) {\n        return mergeErrors(executeValidators(control, presentValidators));\n    };\n}\n/**\n * Accepts a list of validators of different possible shapes (`Validator` and `ValidatorFn`),\n * normalizes the list (converts everything to `ValidatorFn`) and merges them into a single\n * validator function.\n */\nfunction composeValidators(validators) {\n    return validators != null ? compose(normalizeValidators(validators)) : null;\n}\n/**\n * Merges asynchronous validators into a single validator function.\n * See `Validators.composeAsync` for additional information.\n */\nfunction composeAsync(validators) {\n    if (!validators)\n        return null;\n    const presentValidators = validators.filter(isPresent);\n    if (presentValidators.length == 0)\n        return null;\n    return function (control) {\n        const observables = executeValidators(control, presentValidators).map(toObservable);\n        return forkJoin(observables).pipe(map(mergeErrors));\n    };\n}\n/**\n * Accepts a list of async validators of different possible shapes (`AsyncValidator` and\n * `AsyncValidatorFn`), normalizes the list (converts everything to `AsyncValidatorFn`) and merges\n * them into a single validator function.\n */\nfunction composeAsyncValidators(validators) {\n    return validators != null ? composeAsync(normalizeValidators(validators)) :\n        null;\n}\n/**\n * Merges raw control validators with a given directive validator and returns the combined list of\n * validators as an array.\n */\nfunction mergeValidators(controlValidators, dirValidator) {\n    if (controlValidators === null)\n        return [dirValidator];\n    return Array.isArray(controlValidators) ? [...controlValidators, dirValidator] :\n        [controlValidators, dirValidator];\n}\n/**\n * Retrieves the list of raw synchronous validators attached to a given control.\n */\nfunction getControlValidators(control) {\n    return control._rawValidators;\n}\n/**\n * Retrieves the list of raw asynchronous validators attached to a given control.\n */\nfunction getControlAsyncValidators(control) {\n    return control._rawAsyncValidators;\n}\n/**\n * Accepts a singleton validator, an array, or null, and returns an array type with the provided\n * validators.\n *\n * @param validators A validator, validators, or null.\n * @returns A validators array.\n */\nfunction makeValidatorsArray(validators) {\n    if (!validators)\n        return [];\n    return Array.isArray(validators) ? validators : [validators];\n}\n/**\n * Determines whether a validator or validators array has a given validator.\n *\n * @param validators The validator or validators to compare against.\n * @param validator The validator to check.\n * @returns Whether the validator is present.\n */\nfunction hasValidator(validators, validator) {\n    return Array.isArray(validators) ? validators.includes(validator) : validators === validator;\n}\n/**\n * Combines two arrays of validators into one. If duplicates are provided, only one will be added.\n *\n * @param validators The new validators.\n * @param currentValidators The base array of current validators.\n * @returns An array of validators.\n */\nfunction addValidators(validators, currentValidators) {\n    const current = makeValidatorsArray(currentValidators);\n    const validatorsToAdd = makeValidatorsArray(validators);\n    validatorsToAdd.forEach((v) => {\n        // Note: if there are duplicate entries in the new validators array,\n        // only the first one would be added to the current list of validators.\n        // Duplicate ones would be ignored since `hasValidator` would detect\n        // the presence of a validator function and we update the current list in place.\n        if (!hasValidator(current, v)) {\n            current.push(v);\n        }\n    });\n    return current;\n}\nfunction removeValidators(validators, currentValidators) {\n    return makeValidatorsArray(currentValidators).filter(v => !hasValidator(validators, v));\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 * @description\n * Base class for control directives.\n *\n * This class is only used internally in the `ReactiveFormsModule` and the `FormsModule`.\n *\n * @publicApi\n */\nclass AbstractControlDirective {\n    constructor() {\n        /**\n         * Set of synchronous validators as they were provided while calling `setValidators` function.\n         * @internal\n         */\n        this._rawValidators = [];\n        /**\n         * Set of asynchronous validators as they were provided while calling `setAsyncValidators`\n         * function.\n         * @internal\n         */\n        this._rawAsyncValidators = [];\n        /*\n         * The set of callbacks to be invoked when directive instance is being destroyed.\n         */\n        this._onDestroyCallbacks = [];\n    }\n    /**\n     * @description\n     * Reports the value of the control if it is present, otherwise null.\n     */\n    get value() {\n        return this.control ? this.control.value : null;\n    }\n    /**\n     * @description\n     * Reports whether the control is valid. A control is considered valid if no\n     * validation errors exist with the current value.\n     * If the control is not present, null is returned.\n     */\n    get valid() {\n        return this.control ? this.control.valid : null;\n    }\n    /**\n     * @description\n     * Reports whether the control is invalid, meaning that an error exists in the input value.\n     * If the control is not present, null is returned.\n     */\n    get invalid() {\n        return this.control ? this.control.invalid : null;\n    }\n    /**\n     * @description\n     * Reports whether a control is pending, meaning that that async validation is occurring and\n     * errors are not yet available for the input value. If the control is not present, null is\n     * returned.\n     */\n    get pending() {\n        return this.control ? this.control.pending : null;\n    }\n    /**\n     * @description\n     * Reports whether the control is disabled, meaning that the control is disabled\n     * in the UI and is exempt from validation checks and excluded from aggregate\n     * values of ancestor controls. If the control is not present, null is returned.\n     */\n    get disabled() {\n        return this.control ? this.control.disabled : null;\n    }\n    /**\n     * @description\n     * Reports whether the control is enabled, meaning that the control is included in ancestor\n     * calculations of validity or value. If the control is not present, null is returned.\n     */\n    get enabled() {\n        return this.control ? this.control.enabled : null;\n    }\n    /**\n     * @description\n     * Reports the control's validation errors. If the control is not present, null is returned.\n     */\n    get errors() {\n        return this.control ? this.control.errors : null;\n    }\n    /**\n     * @description\n     * Reports whether the control is pristine, meaning that the user has not yet changed\n     * the value in the UI. If the control is not present, null is returned.\n     */\n    get pristine() {\n        return this.control ? this.control.pristine : null;\n    }\n    /**\n     * @description\n     * Reports whether the control is dirty, meaning that the user has changed\n     * the value in the UI. If the control is not present, null is returned.\n     */\n    get dirty() {\n        return this.control ? this.control.dirty : null;\n    }\n    /**\n     * @description\n     * Reports whether the control is touched, meaning that the user has triggered\n     * a `blur` event on it. If the control is not present, null is returned.\n     */\n    get touched() {\n        return this.control ? this.control.touched : null;\n    }\n    /**\n     * @description\n     * Reports the validation status of the control. Possible values include:\n     * 'VALID', 'INVALID', 'DISABLED', and 'PENDING'.\n     * If the control is not present, null is returned.\n     */\n    get status() {\n        return this.control ? this.control.status : null;\n    }\n    /**\n     * @description\n     * Reports whether the control is untouched, meaning that the user has not yet triggered\n     * a `blur` event on it. If the control is not present, null is returned.\n     */\n    get untouched() {\n        return this.control ? this.control.untouched : null;\n    }\n    /**\n     * @description\n     * Returns a multicasting observable that emits a validation status whenever it is\n     * calculated for the control. If the control is not present, null is returned.\n     */\n    get statusChanges() {\n        return this.control ? this.control.statusChanges : null;\n    }\n    /**\n     * @description\n     * Returns a multicasting observable of value changes for the control that emits every time the\n     * value of the control changes in the UI or programmatically.\n     * If the control is not present, null is returned.\n     */\n    get valueChanges() {\n        return this.control ? this.control.valueChanges : null;\n    }\n    /**\n     * @description\n     * Returns an array that represents the path from the top-level form to this control.\n     * Each index is the string name of the control on that level.\n     */\n    get path() {\n        return null;\n    }\n    /**\n     * Sets synchronous validators for this directive.\n     * @internal\n     */\n    _setValidators(validators) {\n        this._rawValidators = validators || [];\n        this._composedValidatorFn = composeValidators(this._rawValidators);\n    }\n    /**\n     * Sets asynchronous validators for this directive.\n     * @internal\n     */\n    _setAsyncValidators(validators) {\n        this._rawAsyncValidators = validators || [];\n        this._composedAsyncValidatorFn = composeAsyncValidators(this._rawAsyncValidators);\n    }\n    /**\n     * @description\n     * Synchronous validator function composed of all the synchronous validators registered with this\n     * directive.\n     */\n    get validator() {\n        return this._composedValidatorFn || null;\n    }\n    /**\n     * @description\n     * Asynchronous validator function composed of all the asynchronous validators registered with\n     * this directive.\n     */\n    get asyncValidator() {\n        return this._composedAsyncValidatorFn || null;\n    }\n    /**\n     * Internal function to register callbacks that should be invoked\n     * when directive instance is being destroyed.\n     * @internal\n     */\n    _registerOnDestroy(fn) {\n        this._onDestroyCallbacks.push(fn);\n    }\n    /**\n     * Internal function to invoke all registered \"on destroy\" callbacks.\n     * Note: calling this function also clears the list of callbacks.\n     * @internal\n     */\n    _invokeOnDestroyCallbacks() {\n        this._onDestroyCallbacks.forEach(fn => fn());\n        this._onDestroyCallbacks = [];\n    }\n    /**\n     * @description\n     * Resets the control with the provided value if the control is present.\n     */\n    reset(value = undefined) {\n        if (this.control)\n            this.control.reset(value);\n    }\n    /**\n     * @description\n     * Reports whether the control with the given path has the error specified.\n     *\n     * @param errorCode The code of the error to check\n     * @param path A list of control names that designates how to move from the current control\n     * to the control that should be queried for errors.\n     *\n     * @usageNotes\n     * For example, for the following `FormGroup`:\n     *\n     * ```\n     * form = new FormGroup({\n     *   address: new FormGroup({ street: new FormControl() })\n     * });\n     * ```\n     *\n     * The path to the 'street' control from the root form would be 'address' -> 'street'.\n     *\n     * It can be provided to this method in one of two formats:\n     *\n     * 1. An array of string control names, e.g. `['address', 'street']`\n     * 1. A period-delimited list of control names in one string, e.g. `'address.street'`\n     *\n     * If no path is given, this method checks for the error on the current control.\n     *\n     * @returns whether the given error is present in the control at the given path.\n     *\n     * If the control is not present, false is returned.\n     */\n    hasError(errorCode, path) {\n        return this.control ? this.control.hasError(errorCode, path) : false;\n    }\n    /**\n     * @description\n     * Reports error data for the control with the given path.\n     *\n     * @param errorCode The code of the error to check\n     * @param path A list of control names that designates how to move from the current control\n     * to the control that should be queried for errors.\n     *\n     * @usageNotes\n     * For example, for the following `FormGroup`:\n     *\n     * ```\n     * form = new FormGroup({\n     *   address: new FormGroup({ street: new FormControl() })\n     * });\n     * ```\n     *\n     * The path to the 'street' control from the root form would be 'address' -> 'street'.\n     *\n     * It can be provided to this method in one of two formats:\n     *\n     * 1. An array of string control names, e.g. `['address', 'street']`\n     * 1. A period-delimited list of control names in one string, e.g. `'address.street'`\n     *\n     * @returns error data for that particular error. If the control or error is not present,\n     * null is returned.\n     */\n    getError(errorCode, path) {\n        return this.control ? this.control.getError(errorCode, path) : null;\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @description\n * A base class for directives that contain multiple registered instances of `NgControl`.\n * Only used by the forms module.\n *\n * @publicApi\n */\nclass ControlContainer extends AbstractControlDirective {\n    /**\n     * @description\n     * The top-level form directive for the control.\n     */\n    get formDirective() {\n        return null;\n    }\n    /**\n     * @description\n     * The path to this group.\n     */\n    get path() {\n        return null;\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @description\n * A base class that all `FormControl`-based directives extend. It binds a `FormControl`\n * object to a DOM element.\n *\n * @publicApi\n */\nclass NgControl extends AbstractControlDirective {\n    constructor() {\n        super(...arguments);\n        /**\n         * @description\n         * The parent form for the control.\n         *\n         * @internal\n         */\n        this._parent = null;\n        /**\n         * @description\n         * The name for the control\n         */\n        this.name = null;\n        /**\n         * @description\n         * The value accessor for the control\n         */\n        this.valueAccessor = null;\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// DO NOT REFACTOR!\n// Each status is represented by a separate function to make sure that\n// advanced Closure Compiler optimizations related to property renaming\n// can work correctly.\nclass AbstractControlStatus {\n    constructor(cd) {\n        this._cd = cd;\n    }\n    get isTouched() {\n        return !!this._cd?.control?.touched;\n    }\n    get isUntouched() {\n        return !!this._cd?.control?.untouched;\n    }\n    get isPristine() {\n        return !!this._cd?.control?.pristine;\n    }\n    get isDirty() {\n        return !!this._cd?.control?.dirty;\n    }\n    get isValid() {\n        return !!this._cd?.control?.valid;\n    }\n    get isInvalid() {\n        return !!this._cd?.control?.invalid;\n    }\n    get isPending() {\n        return !!this._cd?.control?.pending;\n    }\n    get isSubmitted() {\n        // We check for the `submitted` field from `NgForm` and `FormGroupDirective` classes, but\n        // we avoid instanceof checks to prevent non-tree-shakable references to those types.\n        return !!this._cd?.submitted;\n    }\n}\nconst ngControlStatusHost = {\n    '[class.ng-untouched]': 'isUntouched',\n    '[class.ng-touched]': 'isTouched',\n    '[class.ng-pristine]': 'isPristine',\n    '[class.ng-dirty]': 'isDirty',\n    '[class.ng-valid]': 'isValid',\n    '[class.ng-invalid]': 'isInvalid',\n    '[class.ng-pending]': 'isPending',\n};\nconst ngGroupStatusHost = {\n    ...ngControlStatusHost,\n    '[class.ng-submitted]': 'isSubmitted',\n};\n/**\n * @description\n * Directive automatically applied to Angular form controls that sets CSS classes\n * based on control status.\n *\n * @usageNotes\n *\n * ### CSS classes applied\n *\n * The following classes are applied as the properties become true:\n *\n * * ng-valid\n * * ng-invalid\n * * ng-pending\n * * ng-pristine\n * * ng-dirty\n * * ng-untouched\n * * ng-touched\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass NgControlStatus extends AbstractControlStatus {\n    constructor(cd) {\n        super(cd);\n    }\n}\nNgControlStatus.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NgControlStatus, deps: [{ token: NgControl, self: true }], target: i0.ɵɵFactoryTarget.Directive });\nNgControlStatus.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: NgControlStatus, selector: \"[formControlName],[ngModel],[formControl]\", host: { properties: { \"class.ng-untouched\": \"isUntouched\", \"class.ng-touched\": \"isTouched\", \"class.ng-pristine\": \"isPristine\", \"class.ng-dirty\": \"isDirty\", \"class.ng-valid\": \"isValid\", \"class.ng-invalid\": \"isInvalid\", \"class.ng-pending\": \"isPending\" } }, usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NgControlStatus, decorators: [{\n            type: Directive,\n            args: [{ selector: '[formControlName],[ngModel],[formControl]', host: ngControlStatusHost }]\n        }], ctorParameters: function () { return [{ type: NgControl, decorators: [{\n                    type: Self\n                }] }]; } });\n/**\n * @description\n * Directive automatically applied to Angular form groups that sets CSS classes\n * based on control status (valid/invalid/dirty/etc). On groups, this includes the additional\n * class ng-submitted.\n *\n * @see `NgControlStatus`\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass NgControlStatusGroup extends AbstractControlStatus {\n    constructor(cd) {\n        super(cd);\n    }\n}\nNgControlStatusGroup.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NgControlStatusGroup, deps: [{ token: ControlContainer, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });\nNgControlStatusGroup.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: NgControlStatusGroup, selector: \"[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]\", host: { properties: { \"class.ng-untouched\": \"isUntouched\", \"class.ng-touched\": \"isTouched\", \"class.ng-pristine\": \"isPristine\", \"class.ng-dirty\": \"isDirty\", \"class.ng-valid\": \"isValid\", \"class.ng-invalid\": \"isInvalid\", \"class.ng-pending\": \"isPending\", \"class.ng-submitted\": \"isSubmitted\" } }, usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NgControlStatusGroup, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]',\n                    host: ngGroupStatusHost\n                }]\n        }], ctorParameters: function () { return [{ type: ControlContainer, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\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 */\nconst formControlNameExample = `\n  <div [formGroup]=\"myGroup\">\n    <input formControlName=\"firstName\">\n  </div>\n\n  In your class:\n\n  this.myGroup = new FormGroup({\n      firstName: new FormControl()\n  });`;\nconst formGroupNameExample = `\n  <div [formGroup]=\"myGroup\">\n      <div formGroupName=\"person\">\n        <input formControlName=\"firstName\">\n      </div>\n  </div>\n\n  In your class:\n\n  this.myGroup = new FormGroup({\n      person: new FormGroup({ firstName: new FormControl() })\n  });`;\nconst formArrayNameExample = `\n  <div [formGroup]=\"myGroup\">\n    <div formArrayName=\"cities\">\n      <div *ngFor=\"let city of cityArray.controls; index as i\">\n        <input [formControlName]=\"i\">\n      </div>\n    </div>\n  </div>\n\n  In your class:\n\n  this.cityArray = new FormArray([new FormControl('SF')]);\n  this.myGroup = new FormGroup({\n    cities: this.cityArray\n  });`;\nconst ngModelGroupExample = `\n  <form>\n      <div ngModelGroup=\"person\">\n        <input [(ngModel)]=\"person.name\" name=\"firstName\">\n      </div>\n  </form>`;\nconst ngModelWithFormGroupExample = `\n  <div [formGroup]=\"myGroup\">\n      <input formControlName=\"firstName\">\n      <input [(ngModel)]=\"showMoreControls\" [ngModelOptions]=\"{standalone: true}\">\n  </div>\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 controlParentException() {\n    return new ɵRuntimeError(1050 /* RuntimeErrorCode.FORM_CONTROL_NAME_MISSING_PARENT */, `formControlName must be used with a parent formGroup directive.  You'll want to add a formGroup\n      directive and pass it an existing FormGroup instance (you can create one in your class).\n\n    Example:\n\n    ${formControlNameExample}`);\n}\nfunction ngModelGroupException() {\n    return new ɵRuntimeError(1051 /* RuntimeErrorCode.FORM_CONTROL_NAME_INSIDE_MODEL_GROUP */, `formControlName cannot be used with an ngModelGroup parent. It is only compatible with parents\n      that also have a \"form\" prefix: formGroupName, formArrayName, or formGroup.\n\n      Option 1:  Update the parent to be formGroupName (reactive form strategy)\n\n      ${formGroupNameExample}\n\n      Option 2: Use ngModel instead of formControlName (template-driven strategy)\n\n      ${ngModelGroupExample}`);\n}\nfunction missingFormException() {\n    return new ɵRuntimeError(1052 /* RuntimeErrorCode.FORM_GROUP_MISSING_INSTANCE */, `formGroup expects a FormGroup instance. Please pass one in.\n\n      Example:\n\n      ${formControlNameExample}`);\n}\nfunction groupParentException() {\n    return new ɵRuntimeError(1053 /* RuntimeErrorCode.FORM_GROUP_NAME_MISSING_PARENT */, `formGroupName must be used with a parent formGroup directive.  You'll want to add a formGroup\n    directive and pass it an existing FormGroup instance (you can create one in your class).\n\n    Example:\n\n    ${formGroupNameExample}`);\n}\nfunction arrayParentException() {\n    return new ɵRuntimeError(1054 /* RuntimeErrorCode.FORM_ARRAY_NAME_MISSING_PARENT */, `formArrayName must be used with a parent formGroup directive.  You'll want to add a formGroup\n      directive and pass it an existing FormGroup instance (you can create one in your class).\n\n      Example:\n\n      ${formArrayNameExample}`);\n}\nconst disabledAttrWarning = `\n  It looks like you're using the disabled attribute with a reactive form directive. If you set disabled to true\n  when you set up this control in your component class, the disabled attribute will actually be set in the DOM for\n  you. We recommend using this approach to avoid 'changed after checked' errors.\n\n  Example:\n  // Specify the \\`disabled\\` property at control creation time:\n  form = new FormGroup({\n    first: new FormControl({value: 'Nancy', disabled: true}, Validators.required),\n    last: new FormControl('Drew', Validators.required)\n  });\n\n  // Controls can also be enabled/disabled after creation:\n  form.get('first')?.enable();\n  form.get('last')?.disable();\n`;\nconst asyncValidatorsDroppedWithOptsWarning = `\n  It looks like you're constructing using a FormControl with both an options argument and an\n  async validators argument. Mixing these arguments will cause your async validators to be dropped.\n  You should either put all your validators in the options object, or in separate validators\n  arguments. For example:\n\n  // Using validators arguments\n  fc = new FormControl(42, Validators.required, myAsyncValidator);\n\n  // Using AbstractControlOptions\n  fc = new FormControl(42, {validators: Validators.required, asyncValidators: myAV});\n\n  // Do NOT mix them: async validators will be dropped!\n  fc = new FormControl(42, {validators: Validators.required}, /* Oops! */ myAsyncValidator);\n`;\nfunction ngModelWarning(directiveName) {\n    return `\n  It looks like you're using ngModel on the same form field as ${directiveName}.\n  Support for using the ngModel input property and ngModelChange event with\n  reactive form directives has been deprecated in Angular v6 and will be removed\n  in a future version of Angular.\n\n  For more information on this, see our API docs here:\n  https://angular.io/api/forms/${directiveName === 'formControl' ? 'FormControlDirective' : 'FormControlName'}#use-with-ngmodel\n  `;\n}\nfunction describeKey(isFormGroup, key) {\n    return isFormGroup ? `with name: '${key}'` : `at index: ${key}`;\n}\nfunction noControlsError(isFormGroup) {\n    return `\n    There are no form controls registered with this ${isFormGroup ? 'group' : 'array'} yet. If you're using ngModel,\n    you may want to check next tick (e.g. use setTimeout).\n  `;\n}\nfunction missingControlError(isFormGroup, key) {\n    return `Cannot find form control ${describeKey(isFormGroup, key)}`;\n}\nfunction missingControlValueError(isFormGroup, key) {\n    return `Must supply a value for form control ${describeKey(isFormGroup, key)}`;\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 */\nconst NG_DEV_MODE = typeof ngDevMode === 'undefined' || !!ngDevMode;\n/**\n * Reports that a control is valid, meaning that no errors exist in the input value.\n *\n * @see `status`\n */\nconst VALID = 'VALID';\n/**\n * Reports that a control is invalid, meaning that an error exists in the input value.\n *\n * @see `status`\n */\nconst INVALID = 'INVALID';\n/**\n * Reports that a control is pending, meaning that that async validation is occurring and\n * errors are not yet available for the input value.\n *\n * @see `markAsPending`\n * @see `status`\n */\nconst PENDING = 'PENDING';\n/**\n * Reports that a control is disabled, meaning that the control is exempt from ancestor\n * calculations of validity or value.\n *\n * @see `markAsDisabled`\n * @see `status`\n */\nconst DISABLED = 'DISABLED';\n/**\n * Gets validators from either an options object or given validators.\n */\nfunction pickValidators(validatorOrOpts) {\n    return (isOptionsObj(validatorOrOpts) ? validatorOrOpts.validators : validatorOrOpts) || null;\n}\n/**\n * Creates validator function by combining provided validators.\n */\nfunction coerceToValidator(validator) {\n    return Array.isArray(validator) ? composeValidators(validator) : validator || null;\n}\n/**\n * Gets async validators from either an options object or given validators.\n */\nfunction pickAsyncValidators(asyncValidator, validatorOrOpts) {\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n        if (isOptionsObj(validatorOrOpts) && asyncValidator) {\n            console.warn(asyncValidatorsDroppedWithOptsWarning);\n        }\n    }\n    return (isOptionsObj(validatorOrOpts) ? validatorOrOpts.asyncValidators : asyncValidator) || null;\n}\n/**\n * Creates async validator function by combining provided async validators.\n */\nfunction coerceToAsyncValidator(asyncValidator) {\n    return Array.isArray(asyncValidator) ? composeAsyncValidators(asyncValidator) :\n        asyncValidator || null;\n}\nfunction isOptionsObj(validatorOrOpts) {\n    return validatorOrOpts != null && !Array.isArray(validatorOrOpts) &&\n        typeof validatorOrOpts === 'object';\n}\nfunction assertControlPresent(parent, isGroup, key) {\n    const controls = parent.controls;\n    const collection = isGroup ? Object.keys(controls) : controls;\n    if (!collection.length) {\n        throw new ɵRuntimeError(1000 /* RuntimeErrorCode.NO_CONTROLS */, NG_DEV_MODE ? noControlsError(isGroup) : '');\n    }\n    if (!controls[key]) {\n        throw new ɵRuntimeError(1001 /* RuntimeErrorCode.MISSING_CONTROL */, NG_DEV_MODE ? missingControlError(isGroup, key) : '');\n    }\n}\nfunction assertAllValuesPresent(control, isGroup, value) {\n    control._forEachChild((_, key) => {\n        if (value[key] === undefined) {\n            throw new ɵRuntimeError(1002 /* RuntimeErrorCode.MISSING_CONTROL_VALUE */, NG_DEV_MODE ? missingControlValueError(isGroup, key) : '');\n        }\n    });\n}\n// clang-format on\n/**\n * This is the base class for `FormControl`, `FormGroup`, and `FormArray`.\n *\n * It provides some of the shared behavior that all controls and groups of controls have, like\n * running validators, calculating status, and resetting state. It also defines the properties\n * that are shared between all sub-classes, like `value`, `valid`, and `dirty`. It shouldn't be\n * instantiated directly.\n *\n * The first type parameter TValue represents the value type of the control (`control.value`).\n * The optional type parameter TRawValue  represents the raw value type (`control.getRawValue()`).\n *\n * @see [Forms Guide](/guide/forms)\n * @see [Reactive Forms Guide](/guide/reactive-forms)\n * @see [Dynamic Forms Guide](/guide/dynamic-form)\n *\n * @publicApi\n */\nclass AbstractControl {\n    /**\n     * Initialize the AbstractControl instance.\n     *\n     * @param validators The function or array of functions that is used to determine the validity of\n     *     this control synchronously.\n     * @param asyncValidators The function or array of functions that is used to determine validity of\n     *     this control asynchronously.\n     */\n    constructor(validators, asyncValidators) {\n        /** @internal */\n        this._pendingDirty = false;\n        /**\n         * Indicates that a control has its own pending asynchronous validation in progress.\n         *\n         * @internal\n         */\n        this._hasOwnPendingAsyncValidator = false;\n        /** @internal */\n        this._pendingTouched = false;\n        /** @internal */\n        this._onCollectionChange = () => { };\n        this._parent = null;\n        /**\n         * A control is `pristine` if the user has not yet changed\n         * the value in the UI.\n         *\n         * @returns True if the user has not yet changed the value in the UI; compare `dirty`.\n         * Programmatic changes to a control's value do not mark it dirty.\n         */\n        this.pristine = true;\n        /**\n         * True if the control is marked as `touched`.\n         *\n         * A control is marked `touched` once the user has triggered\n         * a `blur` event on it.\n         */\n        this.touched = false;\n        /** @internal */\n        this._onDisabledChange = [];\n        this._rawValidators = validators;\n        this._rawAsyncValidators = asyncValidators;\n        this._composedValidatorFn = coerceToValidator(this._rawValidators);\n        this._composedAsyncValidatorFn = coerceToAsyncValidator(this._rawAsyncValidators);\n    }\n    /**\n     * Returns the function that is used to determine the validity of this control synchronously.\n     * If multiple validators have been added, this will be a single composed function.\n     * See `Validators.compose()` for additional information.\n     */\n    get validator() {\n        return this._composedValidatorFn;\n    }\n    set validator(validatorFn) {\n        this._rawValidators = this._composedValidatorFn = validatorFn;\n    }\n    /**\n     * Returns the function that is used to determine the validity of this control asynchronously.\n     * If multiple validators have been added, this will be a single composed function.\n     * See `Validators.compose()` for additional information.\n     */\n    get asyncValidator() {\n        return this._composedAsyncValidatorFn;\n    }\n    set asyncValidator(asyncValidatorFn) {\n        this._rawAsyncValidators = this._composedAsyncValidatorFn = asyncValidatorFn;\n    }\n    /**\n     * The parent control.\n     */\n    get parent() {\n        return this._parent;\n    }\n    /**\n     * A control is `valid` when its `status` is `VALID`.\n     *\n     * @see {@link AbstractControl.status}\n     *\n     * @returns True if the control has passed all of its validation tests,\n     * false otherwise.\n     */\n    get valid() {\n        return this.status === VALID;\n    }\n    /**\n     * A control is `invalid` when its `status` is `INVALID`.\n     *\n     * @see {@link AbstractControl.status}\n     *\n     * @returns True if this control has failed one or more of its validation checks,\n     * false otherwise.\n     */\n    get invalid() {\n        return this.status === INVALID;\n    }\n    /**\n     * A control is `pending` when its `status` is `PENDING`.\n     *\n     * @see {@link AbstractControl.status}\n     *\n     * @returns True if this control is in the process of conducting a validation check,\n     * false otherwise.\n     */\n    get pending() {\n        return this.status == PENDING;\n    }\n    /**\n     * A control is `disabled` when its `status` is `DISABLED`.\n     *\n     * Disabled controls are exempt from validation checks and\n     * are not included in the aggregate value of their ancestor\n     * controls.\n     *\n     * @see {@link AbstractControl.status}\n     *\n     * @returns True if the control is disabled, false otherwise.\n     */\n    get disabled() {\n        return this.status === DISABLED;\n    }\n    /**\n     * A control is `enabled` as long as its `status` is not `DISABLED`.\n     *\n     * @returns True if the control has any status other than 'DISABLED',\n     * false if the status is 'DISABLED'.\n     *\n     * @see {@link AbstractControl.status}\n     *\n     */\n    get enabled() {\n        return this.status !== DISABLED;\n    }\n    /**\n     * A control is `dirty` if the user has changed the value\n     * in the UI.\n     *\n     * @returns True if the user has changed the value of this control in the UI; compare `pristine`.\n     * Programmatic changes to a control's value do not mark it dirty.\n     */\n    get dirty() {\n        return !this.pristine;\n    }\n    /**\n     * True if the control has not been marked as touched\n     *\n     * A control is `untouched` if the user has not yet triggered\n     * a `blur` event on it.\n     */\n    get untouched() {\n        return !this.touched;\n    }\n    /**\n     * Reports the update strategy of the `AbstractControl` (meaning\n     * the event on which the control updates itself).\n     * Possible values: `'change'` | `'blur'` | `'submit'`\n     * Default value: `'change'`\n     */\n    get updateOn() {\n        return this._updateOn ? this._updateOn : (this.parent ? this.parent.updateOn : 'change');\n    }\n    /**\n     * Sets the synchronous validators that are active on this control.  Calling\n     * this overwrites any existing synchronous validators.\n     *\n     * When you add or remove a validator at run time, you must call\n     * `updateValueAndValidity()` for the new validation to take effect.\n     *\n     * If you want to add a new validator without affecting existing ones, consider\n     * using `addValidators()` method instead.\n     */\n    setValidators(validators) {\n        this._rawValidators = validators;\n        this._composedValidatorFn = coerceToValidator(validators);\n    }\n    /**\n     * Sets the asynchronous validators that are active on this control. Calling this\n     * overwrites any existing asynchronous validators.\n     *\n     * When you add or remove a validator at run time, you must call\n     * `updateValueAndValidity()` for the new validation to take effect.\n     *\n     * If you want to add a new validator without affecting existing ones, consider\n     * using `addAsyncValidators()` method instead.\n     */\n    setAsyncValidators(validators) {\n        this._rawAsyncValidators = validators;\n        this._composedAsyncValidatorFn = coerceToAsyncValidator(validators);\n    }\n    /**\n     * Add a synchronous validator or validators to this control, without affecting other validators.\n     *\n     * When you add or remove a validator at run time, you must call\n     * `updateValueAndValidity()` for the new validation to take effect.\n     *\n     * Adding a validator that already exists will have no effect. If duplicate validator functions\n     * are present in the `validators` array, only the first instance would be added to a form\n     * control.\n     *\n     * @param validators The new validator function or functions to add to this control.\n     */\n    addValidators(validators) {\n        this.setValidators(addValidators(validators, this._rawValidators));\n    }\n    /**\n     * Add an asynchronous validator or validators to this control, without affecting other\n     * validators.\n     *\n     * When you add or remove a validator at run time, you must call\n     * `updateValueAndValidity()` for the new validation to take effect.\n     *\n     * Adding a validator that already exists will have no effect.\n     *\n     * @param validators The new asynchronous validator function or functions to add to this control.\n     */\n    addAsyncValidators(validators) {\n        this.setAsyncValidators(addValidators(validators, this._rawAsyncValidators));\n    }\n    /**\n     * Remove a synchronous validator from this control, without affecting other validators.\n     * Validators are compared by function reference; you must pass a reference to the exact same\n     * validator function as the one that was originally set. If a provided validator is not found,\n     * it is ignored.\n     *\n     * @usageNotes\n     *\n     * ### Reference to a ValidatorFn\n     *\n     * ```\n     * // Reference to the RequiredValidator\n     * const ctrl = new FormControl<string | null>('', Validators.required);\n     * ctrl.removeValidators(Validators.required);\n     *\n     * // Reference to anonymous function inside MinValidator\n     * const minValidator = Validators.min(3);\n     * const ctrl = new FormControl<string | null>('', minValidator);\n     * expect(ctrl.hasValidator(minValidator)).toEqual(true)\n     * expect(ctrl.hasValidator(Validators.min(3)).toEqual(false)\n     *\n     * ctrl.removeValidators(minValidator);\n     * ```\n     *\n     * When you add or remove a validator at run time, you must call\n     * `updateValueAndValidity()` for the new validation to take effect.\n     *\n     * @param validators The validator or validators to remove.\n     */\n    removeValidators(validators) {\n        this.setValidators(removeValidators(validators, this._rawValidators));\n    }\n    /**\n     * Remove an asynchronous validator from this control, without affecting other validators.\n     * Validators are compared by function reference; you must pass a reference to the exact same\n     * validator function as the one that was originally set. If a provided validator is not found, it\n     * is ignored.\n     *\n     * When you add or remove a validator at run time, you must call\n     * `updateValueAndValidity()` for the new validation to take effect.\n     *\n     * @param validators The asynchronous validator or validators to remove.\n     */\n    removeAsyncValidators(validators) {\n        this.setAsyncValidators(removeValidators(validators, this._rawAsyncValidators));\n    }\n    /**\n     * Check whether a synchronous validator function is present on this control. The provided\n     * validator must be a reference to the exact same function that was provided.\n     *\n     * @usageNotes\n     *\n     * ### Reference to a ValidatorFn\n     *\n     * ```\n     * // Reference to the RequiredValidator\n     * const ctrl = new FormControl<number | null>(0, Validators.required);\n     * expect(ctrl.hasValidator(Validators.required)).toEqual(true)\n     *\n     * // Reference to anonymous function inside MinValidator\n     * const minValidator = Validators.min(3);\n     * const ctrl = new FormControl<number | null>(0, minValidator);\n     * expect(ctrl.hasValidator(minValidator)).toEqual(true)\n     * expect(ctrl.hasValidator(Validators.min(3)).toEqual(false)\n     * ```\n     *\n     * @param validator The validator to check for presence. Compared by function reference.\n     * @returns Whether the provided validator was found on this control.\n     */\n    hasValidator(validator) {\n        return hasValidator(this._rawValidators, validator);\n    }\n    /**\n     * Check whether an asynchronous validator function is present on this control. The provided\n     * validator must be a reference to the exact same function that was provided.\n     *\n     * @param validator The asynchronous validator to check for presence. Compared by function\n     *     reference.\n     * @returns Whether the provided asynchronous validator was found on this control.\n     */\n    hasAsyncValidator(validator) {\n        return hasValidator(this._rawAsyncValidators, validator);\n    }\n    /**\n     * Empties out the synchronous validator list.\n     *\n     * When you add or remove a validator at run time, you must call\n     * `updateValueAndValidity()` for the new validation to take effect.\n     *\n     */\n    clearValidators() {\n        this.validator = null;\n    }\n    /**\n     * Empties out the async validator list.\n     *\n     * When you add or remove a validator at run time, you must call\n     * `updateValueAndValidity()` for the new validation to take effect.\n     *\n     */\n    clearAsyncValidators() {\n        this.asyncValidator = null;\n    }\n    /**\n     * Marks the control as `touched`. A control is touched by focus and\n     * blur events that do not change the value.\n     *\n     * @see `markAsUntouched()`\n     * @see `markAsDirty()`\n     * @see `markAsPristine()`\n     *\n     * @param opts Configuration options that determine how the control propagates changes\n     * and emits events after marking is applied.\n     * * `onlySelf`: When true, mark only this control. When false or not supplied,\n     * marks all direct ancestors. Default is false.\n     */\n    markAsTouched(opts = {}) {\n        this.touched = true;\n        if (this._parent && !opts.onlySelf) {\n            this._parent.markAsTouched(opts);\n        }\n    }\n    /**\n     * Marks the control and all its descendant controls as `touched`.\n     * @see `markAsTouched()`\n     */\n    markAllAsTouched() {\n        this.markAsTouched({ onlySelf: true });\n        this._forEachChild((control) => control.markAllAsTouched());\n    }\n    /**\n     * Marks the control as `untouched`.\n     *\n     * If the control has any children, also marks all children as `untouched`\n     * and recalculates the `touched` status of all parent controls.\n     *\n     * @see `markAsTouched()`\n     * @see `markAsDirty()`\n     * @see `markAsPristine()`\n     *\n     * @param opts Configuration options that determine how the control propagates changes\n     * and emits events after the marking is applied.\n     * * `onlySelf`: When true, mark only this control. When false or not supplied,\n     * marks all direct ancestors. Default is false.\n     */\n    markAsUntouched(opts = {}) {\n        this.touched = false;\n        this._pendingTouched = false;\n        this._forEachChild((control) => {\n            control.markAsUntouched({ onlySelf: true });\n        });\n        if (this._parent && !opts.onlySelf) {\n            this._parent._updateTouched(opts);\n        }\n    }\n    /**\n     * Marks the control as `dirty`. A control becomes dirty when\n     * the control's value is changed through the UI; compare `markAsTouched`.\n     *\n     * @see `markAsTouched()`\n     * @see `markAsUntouched()`\n     * @see `markAsPristine()`\n     *\n     * @param opts Configuration options that determine how the control propagates changes\n     * and emits events after marking is applied.\n     * * `onlySelf`: When true, mark only this control. When false or not supplied,\n     * marks all direct ancestors. Default is false.\n     */\n    markAsDirty(opts = {}) {\n        this.pristine = false;\n        if (this._parent && !opts.onlySelf) {\n            this._parent.markAsDirty(opts);\n        }\n    }\n    /**\n     * Marks the control as `pristine`.\n     *\n     * If the control has any children, marks all children as `pristine`,\n     * and recalculates the `pristine` status of all parent\n     * controls.\n     *\n     * @see `markAsTouched()`\n     * @see `markAsUntouched()`\n     * @see `markAsDirty()`\n     *\n     * @param opts Configuration options that determine how the control emits events after\n     * marking is applied.\n     * * `onlySelf`: When true, mark only this control. When false or not supplied,\n     * marks all direct ancestors. Default is false.\n     */\n    markAsPristine(opts = {}) {\n        this.pristine = true;\n        this._pendingDirty = false;\n        this._forEachChild((control) => {\n            control.markAsPristine({ onlySelf: true });\n        });\n        if (this._parent && !opts.onlySelf) {\n            this._parent._updatePristine(opts);\n        }\n    }\n    /**\n     * Marks the control as `pending`.\n     *\n     * A control is pending while the control performs async validation.\n     *\n     * @see {@link AbstractControl.status}\n     *\n     * @param opts Configuration options that determine how the control propagates changes and\n     * emits events after marking is applied.\n     * * `onlySelf`: When true, mark only this control. When false or not supplied,\n     * marks all direct ancestors. Default is false.\n     * * `emitEvent`: When true or not supplied (the default), the `statusChanges`\n     * observable emits an event with the latest status the control is marked pending.\n     * When false, no events are emitted.\n     *\n     */\n    markAsPending(opts = {}) {\n        this.status = PENDING;\n        if (opts.emitEvent !== false) {\n            this.statusChanges.emit(this.status);\n        }\n        if (this._parent && !opts.onlySelf) {\n            this._parent.markAsPending(opts);\n        }\n    }\n    /**\n     * Disables the control. This means the control is exempt from validation checks and\n     * excluded from the aggregate value of any parent. Its status is `DISABLED`.\n     *\n     * If the control has children, all children are also disabled.\n     *\n     * @see {@link AbstractControl.status}\n     *\n     * @param opts Configuration options that determine how the control propagates\n     * changes and emits events after the control is disabled.\n     * * `onlySelf`: When true, mark only this control. When false or not supplied,\n     * marks all direct ancestors. Default is false.\n     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n     * `valueChanges`\n     * observables emit events with the latest status and value when the control is disabled.\n     * When false, no events are emitted.\n     */\n    disable(opts = {}) {\n        // If parent has been marked artificially dirty we don't want to re-calculate the\n        // parent's dirtiness based on the children.\n        const skipPristineCheck = this._parentMarkedDirty(opts.onlySelf);\n        this.status = DISABLED;\n        this.errors = null;\n        this._forEachChild((control) => {\n            control.disable({ ...opts, onlySelf: true });\n        });\n        this._updateValue();\n        if (opts.emitEvent !== false) {\n            this.valueChanges.emit(this.value);\n            this.statusChanges.emit(this.status);\n        }\n        this._updateAncestors({ ...opts, skipPristineCheck });\n        this._onDisabledChange.forEach((changeFn) => changeFn(true));\n    }\n    /**\n     * Enables the control. This means the control is included in validation checks and\n     * the aggregate value of its parent. Its status recalculates based on its value and\n     * its validators.\n     *\n     * By default, if the control has children, all children are enabled.\n     *\n     * @see {@link AbstractControl.status}\n     *\n     * @param opts Configure options that control how the control propagates changes and\n     * emits events when marked as untouched\n     * * `onlySelf`: When true, mark only this control. When false or not supplied,\n     * marks all direct ancestors. Default is false.\n     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n     * `valueChanges`\n     * observables emit events with the latest status and value when the control is enabled.\n     * When false, no events are emitted.\n     */\n    enable(opts = {}) {\n        // If parent has been marked artificially dirty we don't want to re-calculate the\n        // parent's dirtiness based on the children.\n        const skipPristineCheck = this._parentMarkedDirty(opts.onlySelf);\n        this.status = VALID;\n        this._forEachChild((control) => {\n            control.enable({ ...opts, onlySelf: true });\n        });\n        this.updateValueAndValidity({ onlySelf: true, emitEvent: opts.emitEvent });\n        this._updateAncestors({ ...opts, skipPristineCheck });\n        this._onDisabledChange.forEach((changeFn) => changeFn(false));\n    }\n    _updateAncestors(opts) {\n        if (this._parent && !opts.onlySelf) {\n            this._parent.updateValueAndValidity(opts);\n            if (!opts.skipPristineCheck) {\n                this._parent._updatePristine();\n            }\n            this._parent._updateTouched();\n        }\n    }\n    /**\n     * Sets the parent of the control\n     *\n     * @param parent The new parent.\n     */\n    setParent(parent) {\n        this._parent = parent;\n    }\n    /**\n     * The raw value of this control. For most control implementations, the raw value will include\n     * disabled children.\n     */\n    getRawValue() {\n        return this.value;\n    }\n    /**\n     * Recalculates the value and validation status of the control.\n     *\n     * By default, it also updates the value and validity of its ancestors.\n     *\n     * @param opts Configuration options determine how the control propagates changes and emits events\n     * after updates and validity checks are applied.\n     * * `onlySelf`: When true, only update this control. When false or not supplied,\n     * update all direct ancestors. Default is false.\n     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n     * `valueChanges`\n     * observables emit events with the latest status and value when the control is updated.\n     * When false, no events are emitted.\n     */\n    updateValueAndValidity(opts = {}) {\n        this._setInitialStatus();\n        this._updateValue();\n        if (this.enabled) {\n            this._cancelExistingSubscription();\n            this.errors = this._runValidator();\n            this.status = this._calculateStatus();\n            if (this.status === VALID || this.status === PENDING) {\n                this._runAsyncValidator(opts.emitEvent);\n            }\n        }\n        if (opts.emitEvent !== false) {\n            this.valueChanges.emit(this.value);\n            this.statusChanges.emit(this.status);\n        }\n        if (this._parent && !opts.onlySelf) {\n            this._parent.updateValueAndValidity(opts);\n        }\n    }\n    /** @internal */\n    _updateTreeValidity(opts = { emitEvent: true }) {\n        this._forEachChild((ctrl) => ctrl._updateTreeValidity(opts));\n        this.updateValueAndValidity({ onlySelf: true, emitEvent: opts.emitEvent });\n    }\n    _setInitialStatus() {\n        this.status = this._allControlsDisabled() ? DISABLED : VALID;\n    }\n    _runValidator() {\n        return this.validator ? this.validator(this) : null;\n    }\n    _runAsyncValidator(emitEvent) {\n        if (this.asyncValidator) {\n            this.status = PENDING;\n            this._hasOwnPendingAsyncValidator = true;\n            const obs = toObservable(this.asyncValidator(this));\n            this._asyncValidationSubscription = obs.subscribe((errors) => {\n                this._hasOwnPendingAsyncValidator = false;\n                // This will trigger the recalculation of the validation status, which depends on\n                // the state of the asynchronous validation (whether it is in progress or not). So, it is\n                // necessary that we have updated the `_hasOwnPendingAsyncValidator` boolean flag first.\n                this.setErrors(errors, { emitEvent });\n            });\n        }\n    }\n    _cancelExistingSubscription() {\n        if (this._asyncValidationSubscription) {\n            this._asyncValidationSubscription.unsubscribe();\n            this._hasOwnPendingAsyncValidator = false;\n        }\n    }\n    /**\n     * Sets errors on a form control when running validations manually, rather than automatically.\n     *\n     * Calling `setErrors` also updates the validity of the parent control.\n     *\n     * @param opts Configuration options that determine how the control propagates\n     * changes and emits events after the control errors are set.\n     * * `emitEvent`: When true or not supplied (the default), the `statusChanges`\n     * observable emits an event after the errors are set.\n     *\n     * @usageNotes\n     *\n     * ### Manually set the errors for a control\n     *\n     * ```\n     * const login = new FormControl('someLogin');\n     * login.setErrors({\n     *   notUnique: true\n     * });\n     *\n     * expect(login.valid).toEqual(false);\n     * expect(login.errors).toEqual({ notUnique: true });\n     *\n     * login.setValue('someOtherLogin');\n     *\n     * expect(login.valid).toEqual(true);\n     * ```\n     */\n    setErrors(errors, opts = {}) {\n        this.errors = errors;\n        this._updateControlsErrors(opts.emitEvent !== false);\n    }\n    /**\n     * Retrieves a child control given the control's name or path.\n     *\n     * @param path A dot-delimited string or array of string/number values that define the path to the\n     * control. If a string is provided, passing it as a string literal will result in improved type\n     * information. Likewise, if an array is provided, passing it `as const` will cause improved type\n     * information to be available.\n     *\n     * @usageNotes\n     * ### Retrieve a nested control\n     *\n     * For example, to get a `name` control nested within a `person` sub-group:\n     *\n     * * `this.form.get('person.name');`\n     *\n     * -OR-\n     *\n     * * `this.form.get(['person', 'name'] as const);` // `as const` gives improved typings\n     *\n     * ### Retrieve a control in a FormArray\n     *\n     * When accessing an element inside a FormArray, you can use an element index.\n     * For example, to get a `price` control from the first element in an `items` array you can use:\n     *\n     * * `this.form.get('items.0.price');`\n     *\n     * -OR-\n     *\n     * * `this.form.get(['items', 0, 'price']);`\n     */\n    get(path) {\n        let currPath = path;\n        if (currPath == null)\n            return null;\n        if (!Array.isArray(currPath))\n            currPath = currPath.split('.');\n        if (currPath.length === 0)\n            return null;\n        return currPath.reduce((control, name) => control && control._find(name), this);\n    }\n    /**\n     * @description\n     * Reports error data for the control with the given path.\n     *\n     * @param errorCode The code of the error to check\n     * @param path A list of control names that designates how to move from the current control\n     * to the control that should be queried for errors.\n     *\n     * @usageNotes\n     * For example, for the following `FormGroup`:\n     *\n     * ```\n     * form = new FormGroup({\n     *   address: new FormGroup({ street: new FormControl() })\n     * });\n     * ```\n     *\n     * The path to the 'street' control from the root form would be 'address' -> 'street'.\n     *\n     * It can be provided to this method in one of two formats:\n     *\n     * 1. An array of string control names, e.g. `['address', 'street']`\n     * 1. A period-delimited list of control names in one string, e.g. `'address.street'`\n     *\n     * @returns error data for that particular error. If the control or error is not present,\n     * null is returned.\n     */\n    getError(errorCode, path) {\n        const control = path ? this.get(path) : this;\n        return control && control.errors ? control.errors[errorCode] : null;\n    }\n    /**\n     * @description\n     * Reports whether the control with the given path has the error specified.\n     *\n     * @param errorCode The code of the error to check\n     * @param path A list of control names that designates how to move from the current control\n     * to the control that should be queried for errors.\n     *\n     * @usageNotes\n     * For example, for the following `FormGroup`:\n     *\n     * ```\n     * form = new FormGroup({\n     *   address: new FormGroup({ street: new FormControl() })\n     * });\n     * ```\n     *\n     * The path to the 'street' control from the root form would be 'address' -> 'street'.\n     *\n     * It can be provided to this method in one of two formats:\n     *\n     * 1. An array of string control names, e.g. `['address', 'street']`\n     * 1. A period-delimited list of control names in one string, e.g. `'address.street'`\n     *\n     * If no path is given, this method checks for the error on the current control.\n     *\n     * @returns whether the given error is present in the control at the given path.\n     *\n     * If the control is not present, false is returned.\n     */\n    hasError(errorCode, path) {\n        return !!this.getError(errorCode, path);\n    }\n    /**\n     * Retrieves the top-level ancestor of this control.\n     */\n    get root() {\n        let x = this;\n        while (x._parent) {\n            x = x._parent;\n        }\n        return x;\n    }\n    /** @internal */\n    _updateControlsErrors(emitEvent) {\n        this.status = this._calculateStatus();\n        if (emitEvent) {\n            this.statusChanges.emit(this.status);\n        }\n        if (this._parent) {\n            this._parent._updateControlsErrors(emitEvent);\n        }\n    }\n    /** @internal */\n    _initObservables() {\n        this.valueChanges = new EventEmitter();\n        this.statusChanges = new EventEmitter();\n    }\n    _calculateStatus() {\n        if (this._allControlsDisabled())\n            return DISABLED;\n        if (this.errors)\n            return INVALID;\n        if (this._hasOwnPendingAsyncValidator || this._anyControlsHaveStatus(PENDING))\n            return PENDING;\n        if (this._anyControlsHaveStatus(INVALID))\n            return INVALID;\n        return VALID;\n    }\n    /** @internal */\n    _anyControlsHaveStatus(status) {\n        return this._anyControls((control) => control.status === status);\n    }\n    /** @internal */\n    _anyControlsDirty() {\n        return this._anyControls((control) => control.dirty);\n    }\n    /** @internal */\n    _anyControlsTouched() {\n        return this._anyControls((control) => control.touched);\n    }\n    /** @internal */\n    _updatePristine(opts = {}) {\n        this.pristine = !this._anyControlsDirty();\n        if (this._parent && !opts.onlySelf) {\n            this._parent._updatePristine(opts);\n        }\n    }\n    /** @internal */\n    _updateTouched(opts = {}) {\n        this.touched = this._anyControlsTouched();\n        if (this._parent && !opts.onlySelf) {\n            this._parent._updateTouched(opts);\n        }\n    }\n    /** @internal */\n    _registerOnCollectionChange(fn) {\n        this._onCollectionChange = fn;\n    }\n    /** @internal */\n    _setUpdateStrategy(opts) {\n        if (isOptionsObj(opts) && opts.updateOn != null) {\n            this._updateOn = opts.updateOn;\n        }\n    }\n    /**\n     * Check to see if parent has been marked artificially dirty.\n     *\n     * @internal\n     */\n    _parentMarkedDirty(onlySelf) {\n        const parentDirty = this._parent && this._parent.dirty;\n        return !onlySelf && !!parentDirty && !this._parent._anyControlsDirty();\n    }\n    /** @internal */\n    _find(name) {\n        return null;\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Tracks the value and validity state of a group of `FormControl` instances.\n *\n * A `FormGroup` aggregates the values of each child `FormControl` into one object,\n * with each control name as the key.  It calculates its status by reducing the status values\n * of its children. For example, if one of the controls in a group is invalid, the entire\n * group becomes invalid.\n *\n * `FormGroup` is one of the four fundamental building blocks used to define forms in Angular,\n * along with `FormControl`, `FormArray`, and `FormRecord`.\n *\n * When instantiating a `FormGroup`, pass in a collection of child controls as the first\n * argument. The key for each child registers the name for the control.\n *\n * `FormGroup` is intended for use cases where the keys are known ahead of time.\n * If you need to dynamically add and remove controls, use {@link FormRecord} instead.\n *\n * `FormGroup` accepts an optional type parameter `TControl`, which is an object type with inner\n * control types as values.\n *\n * @usageNotes\n *\n * ### Create a form group with 2 controls\n *\n * ```\n * const form = new FormGroup({\n *   first: new FormControl('Nancy', Validators.minLength(2)),\n *   last: new FormControl('Drew'),\n * });\n *\n * console.log(form.value);   // {first: 'Nancy', last; 'Drew'}\n * console.log(form.status);  // 'VALID'\n * ```\n *\n * ### The type argument, and optional controls\n *\n * `FormGroup` accepts one generic argument, which is an object containing its inner controls.\n * This type will usually be inferred automatically, but you can always specify it explicitly if you\n * wish.\n *\n * If you have controls that are optional (i.e. they can be removed, you can use the `?` in the\n * type):\n *\n * ```\n * const form = new FormGroup<{\n *   first: FormControl<string|null>,\n *   middle?: FormControl<string|null>, // Middle name is optional.\n *   last: FormControl<string|null>,\n * }>({\n *   first: new FormControl('Nancy'),\n *   last: new FormControl('Drew'),\n * });\n * ```\n *\n * ### Create a form group with a group-level validator\n *\n * You include group-level validators as the second arg, or group-level async\n * validators as the third arg. These come in handy when you want to perform validation\n * that considers the value of more than one child control.\n *\n * ```\n * const form = new FormGroup({\n *   password: new FormControl('', Validators.minLength(2)),\n *   passwordConfirm: new FormControl('', Validators.minLength(2)),\n * }, passwordMatchValidator);\n *\n *\n * function passwordMatchValidator(g: FormGroup) {\n *    return g.get('password').value === g.get('passwordConfirm').value\n *       ? null : {'mismatch': true};\n * }\n * ```\n *\n * Like `FormControl` instances, you choose to pass in\n * validators and async validators as part of an options object.\n *\n * ```\n * const form = new FormGroup({\n *   password: new FormControl('')\n *   passwordConfirm: new FormControl('')\n * }, { validators: passwordMatchValidator, asyncValidators: otherValidator });\n * ```\n *\n * ### Set the updateOn property for all controls in a form group\n *\n * The options object is used to set a default value for each child\n * control's `updateOn` property. If you set `updateOn` to `'blur'` at the\n * group level, all child controls default to 'blur', unless the child\n * has explicitly specified a different `updateOn` value.\n *\n * ```ts\n * const c = new FormGroup({\n *   one: new FormControl()\n * }, { updateOn: 'blur' });\n * ```\n *\n * ### Using a FormGroup with optional controls\n *\n * It is possible to have optional controls in a FormGroup. An optional control can be removed later\n * using `removeControl`, and can be omitted when calling `reset`. Optional controls must be\n * declared optional in the group's type.\n *\n * ```ts\n * const c = new FormGroup<{one?: FormControl<string>}>({\n *   one: new FormControl('')\n * });\n * ```\n *\n * Notice that `c.value.one` has type `string|null|undefined`. This is because calling `c.reset({})`\n * without providing the optional key `one` will cause it to become `null`.\n *\n * @publicApi\n */\nclass FormGroup extends AbstractControl {\n    /**\n     * Creates a new `FormGroup` instance.\n     *\n     * @param controls A collection of child controls. The key for each child is the name\n     * under which it is registered.\n     *\n     * @param validatorOrOpts A synchronous validator function, or an array of\n     * such functions, or an `AbstractControlOptions` object that contains validation functions\n     * and a validation trigger.\n     *\n     * @param asyncValidator A single async validator or array of async validator functions\n     *\n     */\n    constructor(controls, validatorOrOpts, asyncValidator) {\n        super(pickValidators(validatorOrOpts), pickAsyncValidators(asyncValidator, validatorOrOpts));\n        this.controls = controls;\n        this._initObservables();\n        this._setUpdateStrategy(validatorOrOpts);\n        this._setUpControls();\n        this.updateValueAndValidity({\n            onlySelf: true,\n            // If `asyncValidator` is present, it will trigger control status change from `PENDING` to\n            // `VALID` or `INVALID`. The status should be broadcasted via the `statusChanges` observable,\n            // so we set `emitEvent` to `true` to allow that during the control creation process.\n            emitEvent: !!this.asyncValidator\n        });\n    }\n    registerControl(name, control) {\n        if (this.controls[name])\n            return this.controls[name];\n        this.controls[name] = control;\n        control.setParent(this);\n        control._registerOnCollectionChange(this._onCollectionChange);\n        return control;\n    }\n    addControl(name, control, options = {}) {\n        this.registerControl(name, control);\n        this.updateValueAndValidity({ emitEvent: options.emitEvent });\n        this._onCollectionChange();\n    }\n    /**\n     * Remove a control from this group. In a strongly-typed group, required controls cannot be\n     * removed.\n     *\n     * This method also updates the value and validity of the control.\n     *\n     * @param name The control name to remove from the collection\n     * @param options Specifies whether this FormGroup instance should emit events after a\n     *     control is removed.\n     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n     * `valueChanges` observables emit events with the latest status and value when the control is\n     * removed. When false, no events are emitted.\n     */\n    removeControl(name, options = {}) {\n        if (this.controls[name])\n            this.controls[name]._registerOnCollectionChange(() => { });\n        delete (this.controls[name]);\n        this.updateValueAndValidity({ emitEvent: options.emitEvent });\n        this._onCollectionChange();\n    }\n    setControl(name, control, options = {}) {\n        if (this.controls[name])\n            this.controls[name]._registerOnCollectionChange(() => { });\n        delete (this.controls[name]);\n        if (control)\n            this.registerControl(name, control);\n        this.updateValueAndValidity({ emitEvent: options.emitEvent });\n        this._onCollectionChange();\n    }\n    contains(controlName) {\n        return this.controls.hasOwnProperty(controlName) && this.controls[controlName].enabled;\n    }\n    /**\n     * Sets the value of the `FormGroup`. It accepts an object that matches\n     * the structure of the group, with control names as keys.\n     *\n     * @usageNotes\n     * ### Set the complete value for the form group\n     *\n     * ```\n     * const form = new FormGroup({\n     *   first: new FormControl(),\n     *   last: new FormControl()\n     * });\n     *\n     * console.log(form.value);   // {first: null, last: null}\n     *\n     * form.setValue({first: 'Nancy', last: 'Drew'});\n     * console.log(form.value);   // {first: 'Nancy', last: 'Drew'}\n     * ```\n     *\n     * @throws When strict checks fail, such as setting the value of a control\n     * that doesn't exist or if you exclude a value of a control that does exist.\n     *\n     * @param value The new value for the control that matches the structure of the group.\n     * @param options Configuration options that determine how the control propagates changes\n     * and emits events after the value changes.\n     * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity\n     * updateValueAndValidity} method.\n     *\n     * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is\n     * false.\n     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n     * `valueChanges`\n     * observables emit events with the latest status and value when the control value is updated.\n     * When false, no events are emitted.\n     */\n    setValue(value, options = {}) {\n        assertAllValuesPresent(this, true, value);\n        Object.keys(value).forEach(name => {\n            assertControlPresent(this, true, name);\n            this.controls[name].setValue(value[name], { onlySelf: true, emitEvent: options.emitEvent });\n        });\n        this.updateValueAndValidity(options);\n    }\n    /**\n     * Patches the value of the `FormGroup`. It accepts an object with control\n     * names as keys, and does its best to match the values to the correct controls\n     * in the group.\n     *\n     * It accepts both super-sets and sub-sets of the group without throwing an error.\n     *\n     * @usageNotes\n     * ### Patch the value for a form group\n     *\n     * ```\n     * const form = new FormGroup({\n     *    first: new FormControl(),\n     *    last: new FormControl()\n     * });\n     * console.log(form.value);   // {first: null, last: null}\n     *\n     * form.patchValue({first: 'Nancy'});\n     * console.log(form.value);   // {first: 'Nancy', last: null}\n     * ```\n     *\n     * @param value The object that matches the structure of the group.\n     * @param options Configuration options that determine how the control propagates changes and\n     * emits events after the value is patched.\n     * * `onlySelf`: When true, each change only affects this control and not its parent. Default is\n     * true.\n     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n     * `valueChanges` observables emit events with the latest status and value when the control value\n     * is updated. When false, no events are emitted. The configuration options are passed to\n     * the {@link AbstractControl#updateValueAndValidity updateValueAndValidity} method.\n     */\n    patchValue(value, options = {}) {\n        // Even though the `value` argument type doesn't allow `null` and `undefined` values, the\n        // `patchValue` can be called recursively and inner data structures might have these values, so\n        // we just ignore such cases when a field containing FormGroup instance receives `null` or\n        // `undefined` as a value.\n        if (value == null /* both `null` and `undefined` */)\n            return;\n        Object.keys(value).forEach(name => {\n            // The compiler cannot see through the uninstantiated conditional type of `this.controls`, so\n            // `as any` is required.\n            const control = this.controls[name];\n            if (control) {\n                control.patchValue(\n                /* Guaranteed to be present, due to the outer forEach. */ value[name], { onlySelf: true, emitEvent: options.emitEvent });\n            }\n        });\n        this.updateValueAndValidity(options);\n    }\n    /**\n     * Resets the `FormGroup`, marks all descendants `pristine` and `untouched` and sets\n     * the value of all descendants to their default values, or null if no defaults were provided.\n     *\n     * You reset to a specific form state by passing in a map of states\n     * that matches the structure of your form, with control names as keys. The state\n     * is a standalone value or a form state object with both a value and a disabled\n     * status.\n     *\n     * @param value Resets the control with an initial value,\n     * or an object that defines the initial value and disabled state.\n     *\n     * @param options Configuration options that determine how the control propagates changes\n     * and emits events when the group is reset.\n     * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is\n     * false.\n     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n     * `valueChanges`\n     * observables emit events with the latest status and value when the control is reset.\n     * When false, no events are emitted.\n     * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity\n     * updateValueAndValidity} method.\n     *\n     * @usageNotes\n     *\n     * ### Reset the form group values\n     *\n     * ```ts\n     * const form = new FormGroup({\n     *   first: new FormControl('first name'),\n     *   last: new FormControl('last name')\n     * });\n     *\n     * console.log(form.value);  // {first: 'first name', last: 'last name'}\n     *\n     * form.reset({ first: 'name', last: 'last name' });\n     *\n     * console.log(form.value);  // {first: 'name', last: 'last name'}\n     * ```\n     *\n     * ### Reset the form group values and disabled status\n     *\n     * ```\n     * const form = new FormGroup({\n     *   first: new FormControl('first name'),\n     *   last: new FormControl('last name')\n     * });\n     *\n     * form.reset({\n     *   first: {value: 'name', disabled: true},\n     *   last: 'last'\n     * });\n     *\n     * console.log(form.value);  // {last: 'last'}\n     * console.log(form.get('first').status);  // 'DISABLED'\n     * ```\n     */\n    reset(value = {}, options = {}) {\n        this._forEachChild((control, name) => {\n            control.reset(value[name], { onlySelf: true, emitEvent: options.emitEvent });\n        });\n        this._updatePristine(options);\n        this._updateTouched(options);\n        this.updateValueAndValidity(options);\n    }\n    /**\n     * The aggregate value of the `FormGroup`, including any disabled controls.\n     *\n     * Retrieves all values regardless of disabled status.\n     */\n    getRawValue() {\n        return this._reduceChildren({}, (acc, control, name) => {\n            acc[name] = control.getRawValue();\n            return acc;\n        });\n    }\n    /** @internal */\n    _syncPendingControls() {\n        let subtreeUpdated = this._reduceChildren(false, (updated, child) => {\n            return child._syncPendingControls() ? true : updated;\n        });\n        if (subtreeUpdated)\n            this.updateValueAndValidity({ onlySelf: true });\n        return subtreeUpdated;\n    }\n    /** @internal */\n    _forEachChild(cb) {\n        Object.keys(this.controls).forEach(key => {\n            // The list of controls can change (for ex. controls might be removed) while the loop\n            // is running (as a result of invoking Forms API in `valueChanges` subscription), so we\n            // have to null check before invoking the callback.\n            const control = this.controls[key];\n            control && cb(control, key);\n        });\n    }\n    /** @internal */\n    _setUpControls() {\n        this._forEachChild((control) => {\n            control.setParent(this);\n            control._registerOnCollectionChange(this._onCollectionChange);\n        });\n    }\n    /** @internal */\n    _updateValue() {\n        this.value = this._reduceValue();\n    }\n    /** @internal */\n    _anyControls(condition) {\n        for (const [controlName, control] of Object.entries(this.controls)) {\n            if (this.contains(controlName) && condition(control)) {\n                return true;\n            }\n        }\n        return false;\n    }\n    /** @internal */\n    _reduceValue() {\n        let acc = {};\n        return this._reduceChildren(acc, (acc, control, name) => {\n            if (control.enabled || this.disabled) {\n                acc[name] = control.value;\n            }\n            return acc;\n        });\n    }\n    /** @internal */\n    _reduceChildren(initValue, fn) {\n        let res = initValue;\n        this._forEachChild((control, name) => {\n            res = fn(res, control, name);\n        });\n        return res;\n    }\n    /** @internal */\n    _allControlsDisabled() {\n        for (const controlName of Object.keys(this.controls)) {\n            if (this.controls[controlName].enabled) {\n                return false;\n            }\n        }\n        return Object.keys(this.controls).length > 0 || this.disabled;\n    }\n    /** @internal */\n    _find(name) {\n        return this.controls.hasOwnProperty(name) ?\n            this.controls[name] :\n            null;\n    }\n}\nconst UntypedFormGroup = FormGroup;\nconst isFormGroup = (control) => control instanceof FormGroup;\n/**\n * Tracks the value and validity state of a collection of `FormControl` instances, each of which has\n * the same value type.\n *\n * `FormRecord` is very similar to {@link FormGroup}, except it can be used with a dynamic keys,\n * with controls added and removed as needed.\n *\n * `FormRecord` accepts one generic argument, which describes the type of the controls it contains.\n *\n * @usageNotes\n *\n * ```\n * let numbers = new FormRecord({bill: new FormControl('415-123-456')});\n * numbers.addControl('bob', new FormControl('415-234-567'));\n * numbers.removeControl('bill');\n * ```\n *\n * @publicApi\n */\nclass FormRecord extends FormGroup {\n}\nconst isFormRecord = (control) => control instanceof FormRecord;\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 controlPath(name, parent) {\n    return [...parent.path, name];\n}\n/**\n * Links a Form control and a Form directive by setting up callbacks (such as `onChange`) on both\n * instances. This function is typically invoked when form directive is being initialized.\n *\n * @param control Form control instance that should be linked.\n * @param dir Directive that should be linked with a given control.\n */\nfunction setUpControl(control, dir) {\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n        if (!control)\n            _throwError(dir, 'Cannot find control with');\n        if (!dir.valueAccessor)\n            _throwError(dir, 'No value accessor for form control with');\n    }\n    setUpValidators(control, dir);\n    dir.valueAccessor.writeValue(control.value);\n    if (control.disabled) {\n        dir.valueAccessor.setDisabledState?.(true);\n    }\n    setUpViewChangePipeline(control, dir);\n    setUpModelChangePipeline(control, dir);\n    setUpBlurPipeline(control, dir);\n    setUpDisabledChangeHandler(control, dir);\n}\n/**\n * Reverts configuration performed by the `setUpControl` control function.\n * Effectively disconnects form control with a given form directive.\n * This function is typically invoked when corresponding form directive is being destroyed.\n *\n * @param control Form control which should be cleaned up.\n * @param dir Directive that should be disconnected from a given control.\n * @param validateControlPresenceOnChange Flag that indicates whether onChange handler should\n *     contain asserts to verify that it's not called once directive is destroyed. We need this flag\n *     to avoid potentially breaking changes caused by better control cleanup introduced in #39235.\n */\nfunction cleanUpControl(control, dir, validateControlPresenceOnChange = true) {\n    const noop = () => {\n        if (validateControlPresenceOnChange && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            _noControlError(dir);\n        }\n    };\n    // The `valueAccessor` field is typically defined on FromControl and FormControlName directive\n    // instances and there is a logic in `selectValueAccessor` function that throws if it's not the\n    // case. We still check the presence of `valueAccessor` before invoking its methods to make sure\n    // that cleanup works correctly if app code or tests are setup to ignore the error thrown from\n    // `selectValueAccessor`. See https://github.com/angular/angular/issues/40521.\n    if (dir.valueAccessor) {\n        dir.valueAccessor.registerOnChange(noop);\n        dir.valueAccessor.registerOnTouched(noop);\n    }\n    cleanUpValidators(control, dir);\n    if (control) {\n        dir._invokeOnDestroyCallbacks();\n        control._registerOnCollectionChange(() => { });\n    }\n}\nfunction registerOnValidatorChange(validators, onChange) {\n    validators.forEach((validator) => {\n        if (validator.registerOnValidatorChange)\n            validator.registerOnValidatorChange(onChange);\n    });\n}\n/**\n * Sets up disabled change handler function on a given form control if ControlValueAccessor\n * associated with a given directive instance supports the `setDisabledState` call.\n *\n * @param control Form control where disabled change handler should be setup.\n * @param dir Corresponding directive instance associated with this control.\n */\nfunction setUpDisabledChangeHandler(control, dir) {\n    if (dir.valueAccessor.setDisabledState) {\n        const onDisabledChange = (isDisabled) => {\n            dir.valueAccessor.setDisabledState(isDisabled);\n        };\n        control.registerOnDisabledChange(onDisabledChange);\n        // Register a callback function to cleanup disabled change handler\n        // from a control instance when a directive is destroyed.\n        dir._registerOnDestroy(() => {\n            control._unregisterOnDisabledChange(onDisabledChange);\n        });\n    }\n}\n/**\n * Sets up sync and async directive validators on provided form control.\n * This function merges validators from the directive into the validators of the control.\n *\n * @param control Form control where directive validators should be setup.\n * @param dir Directive instance that contains validators to be setup.\n */\nfunction setUpValidators(control, dir) {\n    const validators = getControlValidators(control);\n    if (dir.validator !== null) {\n        control.setValidators(mergeValidators(validators, dir.validator));\n    }\n    else if (typeof validators === 'function') {\n        // If sync validators are represented by a single validator function, we force the\n        // `Validators.compose` call to happen by executing the `setValidators` function with\n        // an array that contains that function. We need this to avoid possible discrepancies in\n        // validators behavior, so sync validators are always processed by the `Validators.compose`.\n        // Note: we should consider moving this logic inside the `setValidators` function itself, so we\n        // have consistent behavior on AbstractControl API level. The same applies to the async\n        // validators logic below.\n        control.setValidators([validators]);\n    }\n    const asyncValidators = getControlAsyncValidators(control);\n    if (dir.asyncValidator !== null) {\n        control.setAsyncValidators(mergeValidators(asyncValidators, dir.asyncValidator));\n    }\n    else if (typeof asyncValidators === 'function') {\n        control.setAsyncValidators([asyncValidators]);\n    }\n    // Re-run validation when validator binding changes, e.g. minlength=3 -> minlength=4\n    const onValidatorChange = () => control.updateValueAndValidity();\n    registerOnValidatorChange(dir._rawValidators, onValidatorChange);\n    registerOnValidatorChange(dir._rawAsyncValidators, onValidatorChange);\n}\n/**\n * Cleans up sync and async directive validators on provided form control.\n * This function reverts the setup performed by the `setUpValidators` function, i.e.\n * removes directive-specific validators from a given control instance.\n *\n * @param control Form control from where directive validators should be removed.\n * @param dir Directive instance that contains validators to be removed.\n * @returns true if a control was updated as a result of this action.\n */\nfunction cleanUpValidators(control, dir) {\n    let isControlUpdated = false;\n    if (control !== null) {\n        if (dir.validator !== null) {\n            const validators = getControlValidators(control);\n            if (Array.isArray(validators) && validators.length > 0) {\n                // Filter out directive validator function.\n                const updatedValidators = validators.filter((validator) => validator !== dir.validator);\n                if (updatedValidators.length !== validators.length) {\n                    isControlUpdated = true;\n                    control.setValidators(updatedValidators);\n                }\n            }\n        }\n        if (dir.asyncValidator !== null) {\n            const asyncValidators = getControlAsyncValidators(control);\n            if (Array.isArray(asyncValidators) && asyncValidators.length > 0) {\n                // Filter out directive async validator function.\n                const updatedAsyncValidators = asyncValidators.filter((asyncValidator) => asyncValidator !== dir.asyncValidator);\n                if (updatedAsyncValidators.length !== asyncValidators.length) {\n                    isControlUpdated = true;\n                    control.setAsyncValidators(updatedAsyncValidators);\n                }\n            }\n        }\n    }\n    // Clear onValidatorChange callbacks by providing a noop function.\n    const noop = () => { };\n    registerOnValidatorChange(dir._rawValidators, noop);\n    registerOnValidatorChange(dir._rawAsyncValidators, noop);\n    return isControlUpdated;\n}\nfunction setUpViewChangePipeline(control, dir) {\n    dir.valueAccessor.registerOnChange((newValue) => {\n        control._pendingValue = newValue;\n        control._pendingChange = true;\n        control._pendingDirty = true;\n        if (control.updateOn === 'change')\n            updateControl(control, dir);\n    });\n}\nfunction setUpBlurPipeline(control, dir) {\n    dir.valueAccessor.registerOnTouched(() => {\n        control._pendingTouched = true;\n        if (control.updateOn === 'blur' && control._pendingChange)\n            updateControl(control, dir);\n        if (control.updateOn !== 'submit')\n            control.markAsTouched();\n    });\n}\nfunction updateControl(control, dir) {\n    if (control._pendingDirty)\n        control.markAsDirty();\n    control.setValue(control._pendingValue, { emitModelToViewChange: false });\n    dir.viewToModelUpdate(control._pendingValue);\n    control._pendingChange = false;\n}\nfunction setUpModelChangePipeline(control, dir) {\n    const onChange = (newValue, emitModelEvent) => {\n        // control -> view\n        dir.valueAccessor.writeValue(newValue);\n        // control -> ngModel\n        if (emitModelEvent)\n            dir.viewToModelUpdate(newValue);\n    };\n    control.registerOnChange(onChange);\n    // Register a callback function to cleanup onChange handler\n    // from a control instance when a directive is destroyed.\n    dir._registerOnDestroy(() => {\n        control._unregisterOnChange(onChange);\n    });\n}\n/**\n * Links a FormGroup or FormArray instance and corresponding Form directive by setting up validators\n * present in the view.\n *\n * @param control FormGroup or FormArray instance that should be linked.\n * @param dir Directive that provides view validators.\n */\nfunction setUpFormContainer(control, dir) {\n    if (control == null && (typeof ngDevMode === 'undefined' || ngDevMode))\n        _throwError(dir, 'Cannot find control with');\n    setUpValidators(control, dir);\n}\n/**\n * Reverts the setup performed by the `setUpFormContainer` function.\n *\n * @param control FormGroup or FormArray instance that should be cleaned up.\n * @param dir Directive that provided view validators.\n * @returns true if a control was updated as a result of this action.\n */\nfunction cleanUpFormContainer(control, dir) {\n    return cleanUpValidators(control, dir);\n}\nfunction _noControlError(dir) {\n    return _throwError(dir, 'There is no FormControl instance attached to form control element with');\n}\nfunction _throwError(dir, message) {\n    const messageEnd = _describeControlLocation(dir);\n    throw new Error(`${message} ${messageEnd}`);\n}\nfunction _describeControlLocation(dir) {\n    const path = dir.path;\n    if (path && path.length > 1)\n        return `path: '${path.join(' -> ')}'`;\n    if (path?.[0])\n        return `name: '${path}'`;\n    return 'unspecified name attribute';\n}\nfunction _throwInvalidValueAccessorError(dir) {\n    const loc = _describeControlLocation(dir);\n    throw new ɵRuntimeError(1200 /* RuntimeErrorCode.NG_VALUE_ACCESSOR_NOT_PROVIDED */, `Value accessor was not provided as an array for form control with ${loc}. ` +\n        `Check that the \\`NG_VALUE_ACCESSOR\\` token is configured as a \\`multi: true\\` provider.`);\n}\nfunction isPropertyUpdated(changes, viewModel) {\n    if (!changes.hasOwnProperty('model'))\n        return false;\n    const change = changes['model'];\n    if (change.isFirstChange())\n        return true;\n    return !Object.is(viewModel, change.currentValue);\n}\nfunction isBuiltInAccessor(valueAccessor) {\n    // Check if a given value accessor is an instance of a class that directly extends\n    // `BuiltInControlValueAccessor` one.\n    return Object.getPrototypeOf(valueAccessor.constructor) === BuiltInControlValueAccessor;\n}\nfunction syncPendingControls(form, directives) {\n    form._syncPendingControls();\n    directives.forEach((dir) => {\n        const control = dir.control;\n        if (control.updateOn === 'submit' && control._pendingChange) {\n            dir.viewToModelUpdate(control._pendingValue);\n            control._pendingChange = false;\n        }\n    });\n}\n// TODO: vsavkin remove it once https://github.com/angular/angular/issues/3011 is implemented\nfunction selectValueAccessor(dir, valueAccessors) {\n    if (!valueAccessors)\n        return null;\n    if (!Array.isArray(valueAccessors) && (typeof ngDevMode === 'undefined' || ngDevMode))\n        _throwInvalidValueAccessorError(dir);\n    let defaultAccessor = undefined;\n    let builtinAccessor = undefined;\n    let customAccessor = undefined;\n    valueAccessors.forEach((v) => {\n        if (v.constructor === DefaultValueAccessor) {\n            defaultAccessor = v;\n        }\n        else if (isBuiltInAccessor(v)) {\n            if (builtinAccessor && (typeof ngDevMode === 'undefined' || ngDevMode))\n                _throwError(dir, 'More than one built-in value accessor matches form control with');\n            builtinAccessor = v;\n        }\n        else {\n            if (customAccessor && (typeof ngDevMode === 'undefined' || ngDevMode))\n                _throwError(dir, 'More than one custom value accessor matches form control with');\n            customAccessor = v;\n        }\n    });\n    if (customAccessor)\n        return customAccessor;\n    if (builtinAccessor)\n        return builtinAccessor;\n    if (defaultAccessor)\n        return defaultAccessor;\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n        _throwError(dir, 'No valid value accessor for form control with');\n    }\n    return null;\n}\nfunction removeListItem$1(list, el) {\n    const index = list.indexOf(el);\n    if (index > -1)\n        list.splice(index, 1);\n}\n// TODO(kara): remove after deprecation period\nfunction _ngModelWarning(name, type, instance, warningConfig) {\n    if (warningConfig === 'never')\n        return;\n    if (((warningConfig === null || warningConfig === 'once') && !type._ngModelWarningSentOnce) ||\n        (warningConfig === 'always' && !instance._ngModelWarningSent)) {\n        console.warn(ngModelWarning(name));\n        type._ngModelWarningSentOnce = true;\n        instance._ngModelWarningSent = true;\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst formDirectiveProvider$1 = {\n    provide: ControlContainer,\n    useExisting: forwardRef(() => NgForm)\n};\nconst resolvedPromise$1 = (() => Promise.resolve())();\n/**\n * @description\n * Creates a top-level `FormGroup` instance and binds it to a form\n * to track aggregate form value and validation status.\n *\n * As soon as you import the `FormsModule`, this directive becomes active by default on\n * all `<form>` tags.  You don't need to add a special selector.\n *\n * You optionally export the directive into a local template variable using `ngForm` as the key\n * (ex: `#myForm=\"ngForm\"`). This is optional, but useful.  Many properties from the underlying\n * `FormGroup` instance are duplicated on the directive itself, so a reference to it\n * gives you access to the aggregate value and validity status of the form, as well as\n * user interaction properties like `dirty` and `touched`.\n *\n * To register child controls with the form, use `NgModel` with a `name`\n * attribute. You may use `NgModelGroup` to create sub-groups within the form.\n *\n * If necessary, listen to the directive's `ngSubmit` event to be notified when the user has\n * triggered a form submission. The `ngSubmit` event emits the original form\n * submission event.\n *\n * In template driven forms, all `<form>` tags are automatically tagged as `NgForm`.\n * To import the `FormsModule` but skip its usage in some forms,\n * for example, to use native HTML5 validation, add the `ngNoForm` and the `<form>`\n * tags won't create an `NgForm` directive. In reactive forms, using `ngNoForm` is\n * unnecessary because the `<form>` tags are inert. In that case, you would\n * refrain from using the `formGroup` directive.\n *\n * @usageNotes\n *\n * ### Listening for form submission\n *\n * The following example shows how to capture the form values from the \"ngSubmit\" event.\n *\n * {@example forms/ts/simpleForm/simple_form_example.ts region='Component'}\n *\n * ### Setting the update options\n *\n * The following example shows you how to change the \"updateOn\" option from its default using\n * ngFormOptions.\n *\n * ```html\n * <form [ngFormOptions]=\"{updateOn: 'blur'}\">\n *    <input name=\"one\" ngModel>  <!-- this ngModel will update on blur -->\n * </form>\n * ```\n *\n * ### Native DOM validation UI\n *\n * In order to prevent the native DOM form validation UI from interfering with Angular's form\n * validation, Angular automatically adds the `novalidate` attribute on any `<form>` whenever\n * `FormModule` or `ReactiveFormModule` are imported into the application.\n * If you want to explicitly enable native DOM validation UI with Angular forms, you can add the\n * `ngNativeValidate` attribute to the `<form>` element:\n *\n * ```html\n * <form ngNativeValidate>\n *   ...\n * </form>\n * ```\n *\n * @ngModule FormsModule\n * @publicApi\n */\nclass NgForm extends ControlContainer {\n    constructor(validators, asyncValidators) {\n        super();\n        /**\n         * @description\n         * Returns whether the form submission has been triggered.\n         */\n        this.submitted = false;\n        this._directives = new Set();\n        /**\n         * @description\n         * Event emitter for the \"ngSubmit\" event\n         */\n        this.ngSubmit = new EventEmitter();\n        this.form =\n            new FormGroup({}, composeValidators(validators), composeAsyncValidators(asyncValidators));\n    }\n    /** @nodoc */\n    ngAfterViewInit() {\n        this._setUpdateStrategy();\n    }\n    /**\n     * @description\n     * The directive instance.\n     */\n    get formDirective() {\n        return this;\n    }\n    /**\n     * @description\n     * The internal `FormGroup` instance.\n     */\n    get control() {\n        return this.form;\n    }\n    /**\n     * @description\n     * Returns an array representing the path to this group. Because this directive\n     * always lives at the top level of a form, it is always an empty array.\n     */\n    get path() {\n        return [];\n    }\n    /**\n     * @description\n     * Returns a map of the controls in this group.\n     */\n    get controls() {\n        return this.form.controls;\n    }\n    /**\n     * @description\n     * Method that sets up the control directive in this group, re-calculates its value\n     * and validity, and adds the instance to the internal list of directives.\n     *\n     * @param dir The `NgModel` directive instance.\n     */\n    addControl(dir) {\n        resolvedPromise$1.then(() => {\n            const container = this._findContainer(dir.path);\n            dir.control =\n                container.registerControl(dir.name, dir.control);\n            setUpControl(dir.control, dir);\n            dir.control.updateValueAndValidity({ emitEvent: false });\n            this._directives.add(dir);\n        });\n    }\n    /**\n     * @description\n     * Retrieves the `FormControl` instance from the provided `NgModel` directive.\n     *\n     * @param dir The `NgModel` directive instance.\n     */\n    getControl(dir) {\n        return this.form.get(dir.path);\n    }\n    /**\n     * @description\n     * Removes the `NgModel` instance from the internal list of directives\n     *\n     * @param dir The `NgModel` directive instance.\n     */\n    removeControl(dir) {\n        resolvedPromise$1.then(() => {\n            const container = this._findContainer(dir.path);\n            if (container) {\n                container.removeControl(dir.name);\n            }\n            this._directives.delete(dir);\n        });\n    }\n    /**\n     * @description\n     * Adds a new `NgModelGroup` directive instance to the form.\n     *\n     * @param dir The `NgModelGroup` directive instance.\n     */\n    addFormGroup(dir) {\n        resolvedPromise$1.then(() => {\n            const container = this._findContainer(dir.path);\n            const group = new FormGroup({});\n            setUpFormContainer(group, dir);\n            container.registerControl(dir.name, group);\n            group.updateValueAndValidity({ emitEvent: false });\n        });\n    }\n    /**\n     * @description\n     * Removes the `NgModelGroup` directive instance from the form.\n     *\n     * @param dir The `NgModelGroup` directive instance.\n     */\n    removeFormGroup(dir) {\n        resolvedPromise$1.then(() => {\n            const container = this._findContainer(dir.path);\n            if (container) {\n                container.removeControl(dir.name);\n            }\n        });\n    }\n    /**\n     * @description\n     * Retrieves the `FormGroup` for a provided `NgModelGroup` directive instance\n     *\n     * @param dir The `NgModelGroup` directive instance.\n     */\n    getFormGroup(dir) {\n        return this.form.get(dir.path);\n    }\n    /**\n     * Sets the new value for the provided `NgControl` directive.\n     *\n     * @param dir The `NgControl` directive instance.\n     * @param value The new value for the directive's control.\n     */\n    updateModel(dir, value) {\n        resolvedPromise$1.then(() => {\n            const ctrl = this.form.get(dir.path);\n            ctrl.setValue(value);\n        });\n    }\n    /**\n     * @description\n     * Sets the value for this `FormGroup`.\n     *\n     * @param value The new value\n     */\n    setValue(value) {\n        this.control.setValue(value);\n    }\n    /**\n     * @description\n     * Method called when the \"submit\" event is triggered on the form.\n     * Triggers the `ngSubmit` emitter to emit the \"submit\" event as its payload.\n     *\n     * @param $event The \"submit\" event object\n     */\n    onSubmit($event) {\n        this.submitted = true;\n        syncPendingControls(this.form, this._directives);\n        this.ngSubmit.emit($event);\n        // Forms with `method=\"dialog\"` have some special behavior\n        // that won't reload the page and that shouldn't be prevented.\n        return $event?.target?.method === 'dialog';\n    }\n    /**\n     * @description\n     * Method called when the \"reset\" event is triggered on the form.\n     */\n    onReset() {\n        this.resetForm();\n    }\n    /**\n     * @description\n     * Resets the form to an initial value and resets its submitted status.\n     *\n     * @param value The new value for the form.\n     */\n    resetForm(value = undefined) {\n        this.form.reset(value);\n        this.submitted = false;\n    }\n    _setUpdateStrategy() {\n        if (this.options && this.options.updateOn != null) {\n            this.form._updateOn = this.options.updateOn;\n        }\n    }\n    _findContainer(path) {\n        path.pop();\n        return path.length ? this.form.get(path) : this.form;\n    }\n}\nNgForm.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NgForm, deps: [{ token: NG_VALIDATORS, optional: true, self: true }, { token: NG_ASYNC_VALIDATORS, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });\nNgForm.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: NgForm, selector: \"form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]\", inputs: { options: [\"ngFormOptions\", \"options\"] }, outputs: { ngSubmit: \"ngSubmit\" }, host: { listeners: { \"submit\": \"onSubmit($event)\", \"reset\": \"onReset()\" } }, providers: [formDirectiveProvider$1], exportAs: [\"ngForm\"], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NgForm, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]',\n                    providers: [formDirectiveProvider$1],\n                    host: { '(submit)': 'onSubmit($event)', '(reset)': 'onReset()' },\n                    outputs: ['ngSubmit'],\n                    exportAs: 'ngForm'\n                }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_VALIDATORS]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_ASYNC_VALIDATORS]\n                }] }]; }, propDecorators: { options: [{\n                type: Input,\n                args: ['ngFormOptions']\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 removeListItem(list, el) {\n    const index = list.indexOf(el);\n    if (index > -1)\n        list.splice(index, 1);\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 isFormControlState(formState) {\n    return typeof formState === 'object' && formState !== null &&\n        Object.keys(formState).length === 2 && 'value' in formState && 'disabled' in formState;\n}\nconst FormControl = (class FormControl extends AbstractControl {\n    constructor(\n    // formState and defaultValue will only be null if T is nullable\n    formState = null, validatorOrOpts, asyncValidator) {\n        super(pickValidators(validatorOrOpts), pickAsyncValidators(asyncValidator, validatorOrOpts));\n        /** @publicApi */\n        this.defaultValue = null;\n        /** @internal */\n        this._onChange = [];\n        /** @internal */\n        this._pendingChange = false;\n        this._applyFormState(formState);\n        this._setUpdateStrategy(validatorOrOpts);\n        this._initObservables();\n        this.updateValueAndValidity({\n            onlySelf: true,\n            // If `asyncValidator` is present, it will trigger control status change from `PENDING` to\n            // `VALID` or `INVALID`.\n            // The status should be broadcasted via the `statusChanges` observable, so we set\n            // `emitEvent` to `true` to allow that during the control creation process.\n            emitEvent: !!this.asyncValidator\n        });\n        if (isOptionsObj(validatorOrOpts) &&\n            (validatorOrOpts.nonNullable || validatorOrOpts.initialValueIsDefault)) {\n            if (isFormControlState(formState)) {\n                this.defaultValue = formState.value;\n            }\n            else {\n                this.defaultValue = formState;\n            }\n        }\n    }\n    setValue(value, options = {}) {\n        this.value = this._pendingValue = value;\n        if (this._onChange.length && options.emitModelToViewChange !== false) {\n            this._onChange.forEach((changeFn) => changeFn(this.value, options.emitViewToModelChange !== false));\n        }\n        this.updateValueAndValidity(options);\n    }\n    patchValue(value, options = {}) {\n        this.setValue(value, options);\n    }\n    reset(formState = this.defaultValue, options = {}) {\n        this._applyFormState(formState);\n        this.markAsPristine(options);\n        this.markAsUntouched(options);\n        this.setValue(this.value, options);\n        this._pendingChange = false;\n    }\n    /**  @internal */\n    _updateValue() { }\n    /**  @internal */\n    _anyControls(condition) {\n        return false;\n    }\n    /**  @internal */\n    _allControlsDisabled() {\n        return this.disabled;\n    }\n    registerOnChange(fn) {\n        this._onChange.push(fn);\n    }\n    /** @internal */\n    _unregisterOnChange(fn) {\n        removeListItem(this._onChange, fn);\n    }\n    registerOnDisabledChange(fn) {\n        this._onDisabledChange.push(fn);\n    }\n    /** @internal */\n    _unregisterOnDisabledChange(fn) {\n        removeListItem(this._onDisabledChange, fn);\n    }\n    /** @internal */\n    _forEachChild(cb) { }\n    /** @internal */\n    _syncPendingControls() {\n        if (this.updateOn === 'submit') {\n            if (this._pendingDirty)\n                this.markAsDirty();\n            if (this._pendingTouched)\n                this.markAsTouched();\n            if (this._pendingChange) {\n                this.setValue(this._pendingValue, { onlySelf: true, emitModelToViewChange: false });\n                return true;\n            }\n        }\n        return false;\n    }\n    _applyFormState(formState) {\n        if (isFormControlState(formState)) {\n            this.value = this._pendingValue = formState.value;\n            formState.disabled ? this.disable({ onlySelf: true, emitEvent: false }) :\n                this.enable({ onlySelf: true, emitEvent: false });\n        }\n        else {\n            this.value = this._pendingValue = formState;\n        }\n    }\n});\nconst UntypedFormControl = FormControl;\nconst isFormControl = (control) => control instanceof FormControl;\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 * @description\n * A base class for code shared between the `NgModelGroup` and `FormGroupName` directives.\n *\n * @publicApi\n */\nclass AbstractFormGroupDirective extends ControlContainer {\n    /** @nodoc */\n    ngOnInit() {\n        this._checkParentType();\n        // Register the group with its parent group.\n        this.formDirective.addFormGroup(this);\n    }\n    /** @nodoc */\n    ngOnDestroy() {\n        if (this.formDirective) {\n            // Remove the group from its parent group.\n            this.formDirective.removeFormGroup(this);\n        }\n    }\n    /**\n     * @description\n     * The `FormGroup` bound to this directive.\n     */\n    get control() {\n        return this.formDirective.getFormGroup(this);\n    }\n    /**\n     * @description\n     * The path to this group from the top-level directive.\n     */\n    get path() {\n        return controlPath(this.name == null ? this.name : this.name.toString(), this._parent);\n    }\n    /**\n     * @description\n     * The top-level directive for this group if present, otherwise null.\n     */\n    get formDirective() {\n        return this._parent ? this._parent.formDirective : null;\n    }\n    /** @internal */\n    _checkParentType() { }\n}\nAbstractFormGroupDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: AbstractFormGroupDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nAbstractFormGroupDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: AbstractFormGroupDirective, usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: AbstractFormGroupDirective, decorators: [{\n            type: Directive\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 modelParentException() {\n    return new ɵRuntimeError(1350 /* RuntimeErrorCode.NGMODEL_IN_FORM_GROUP */, `\n    ngModel cannot be used to register form controls with a parent formGroup directive.  Try using\n    formGroup's partner directive \"formControlName\" instead.  Example:\n\n    ${formControlNameExample}\n\n    Or, if you'd like to avoid registering this form control, indicate that it's standalone in ngModelOptions:\n\n    Example:\n\n    ${ngModelWithFormGroupExample}`);\n}\nfunction formGroupNameException() {\n    return new ɵRuntimeError(1351 /* RuntimeErrorCode.NGMODEL_IN_FORM_GROUP_NAME */, `\n    ngModel cannot be used to register form controls with a parent formGroupName or formArrayName directive.\n\n    Option 1: Use formControlName instead of ngModel (reactive strategy):\n\n    ${formGroupNameExample}\n\n    Option 2:  Update ngModel's parent be ngModelGroup (template-driven strategy):\n\n    ${ngModelGroupExample}`);\n}\nfunction missingNameException() {\n    return new ɵRuntimeError(1352 /* RuntimeErrorCode.NGMODEL_WITHOUT_NAME */, `If ngModel is used within a form tag, either the name attribute must be set or the form\n    control must be defined as 'standalone' in ngModelOptions.\n\n    Example 1: <input [(ngModel)]=\"person.firstName\" name=\"first\">\n    Example 2: <input [(ngModel)]=\"person.firstName\" [ngModelOptions]=\"{standalone: true}\">`);\n}\nfunction modelGroupParentException() {\n    return new ɵRuntimeError(1353 /* RuntimeErrorCode.NGMODELGROUP_IN_FORM_GROUP */, `\n    ngModelGroup cannot be used with a parent formGroup directive.\n\n    Option 1: Use formGroupName instead of ngModelGroup (reactive strategy):\n\n    ${formGroupNameExample}\n\n    Option 2:  Use a regular form tag instead of the formGroup directive (template-driven strategy):\n\n    ${ngModelGroupExample}`);\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 */\nconst modelGroupProvider = {\n    provide: ControlContainer,\n    useExisting: forwardRef(() => NgModelGroup)\n};\n/**\n * @description\n * Creates and binds a `FormGroup` instance to a DOM element.\n *\n * This directive can only be used as a child of `NgForm` (within `<form>` tags).\n *\n * Use this directive to validate a sub-group of your form separately from the\n * rest of your form, or if some values in your domain model make more sense\n * to consume together in a nested object.\n *\n * Provide a name for the sub-group and it will become the key\n * for the sub-group in the form's full value. If you need direct access, export the directive into\n * a local template variable using `ngModelGroup` (ex: `#myGroup=\"ngModelGroup\"`).\n *\n * @usageNotes\n *\n * ### Consuming controls in a grouping\n *\n * The following example shows you how to combine controls together in a sub-group\n * of the form.\n *\n * {@example forms/ts/ngModelGroup/ng_model_group_example.ts region='Component'}\n *\n * @ngModule FormsModule\n * @publicApi\n */\nclass NgModelGroup extends AbstractFormGroupDirective {\n    constructor(parent, validators, asyncValidators) {\n        super();\n        this._parent = parent;\n        this._setValidators(validators);\n        this._setAsyncValidators(asyncValidators);\n    }\n    /** @internal */\n    _checkParentType() {\n        if (!(this._parent instanceof NgModelGroup) && !(this._parent instanceof NgForm) &&\n            (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw modelGroupParentException();\n        }\n    }\n}\nNgModelGroup.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NgModelGroup, deps: [{ token: ControlContainer, host: true, skipSelf: true }, { token: NG_VALIDATORS, optional: true, self: true }, { token: NG_ASYNC_VALIDATORS, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });\nNgModelGroup.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: NgModelGroup, selector: \"[ngModelGroup]\", inputs: { name: [\"ngModelGroup\", \"name\"] }, providers: [modelGroupProvider], exportAs: [\"ngModelGroup\"], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NgModelGroup, decorators: [{\n            type: Directive,\n            args: [{ selector: '[ngModelGroup]', providers: [modelGroupProvider], exportAs: 'ngModelGroup' }]\n        }], ctorParameters: function () { return [{ type: ControlContainer, decorators: [{\n                    type: Host\n                }, {\n                    type: SkipSelf\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_VALIDATORS]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_ASYNC_VALIDATORS]\n                }] }]; }, propDecorators: { name: [{\n                type: Input,\n                args: ['ngModelGroup']\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 */\nconst formControlBinding$1 = {\n    provide: NgControl,\n    useExisting: forwardRef(() => NgModel)\n};\n/**\n * `ngModel` forces an additional change detection run when its inputs change:\n * E.g.:\n * ```\n * <div>{{myModel.valid}}</div>\n * <input [(ngModel)]=\"myValue\" #myModel=\"ngModel\">\n * ```\n * I.e. `ngModel` can export itself on the element and then be used in the template.\n * Normally, this would result in expressions before the `input` that use the exported directive\n * to have an old value as they have been\n * dirty checked before. As this is a very common case for `ngModel`, we added this second change\n * detection run.\n *\n * Notes:\n * - this is just one extra run no matter how many `ngModel`s have been changed.\n * - this is a general problem when using `exportAs` for directives!\n */\nconst resolvedPromise = (() => Promise.resolve())();\n/**\n * @description\n * Creates a `FormControl` instance from a domain model and binds it\n * to a form control element.\n *\n * The `FormControl` instance tracks the value, user interaction, and\n * validation status of the control and keeps the view synced with the model. If used\n * within a parent form, the directive also registers itself with the form as a child\n * control.\n *\n * This directive is used by itself or as part of a larger form. Use the\n * `ngModel` selector to activate it.\n *\n * It accepts a domain model as an optional `Input`. If you have a one-way binding\n * to `ngModel` with `[]` syntax, changing the domain model's value in the component\n * class sets the value in the view. If you have a two-way binding with `[()]` syntax\n * (also known as 'banana-in-a-box syntax'), the value in the UI always syncs back to\n * the domain model in your class.\n *\n * To inspect the properties of the associated `FormControl` (like the validity state),\n * export the directive into a local template variable using `ngModel` as the key (ex:\n * `#myVar=\"ngModel\"`). You can then access the control using the directive's `control` property.\n * However, the most commonly used properties (like `valid` and `dirty`) also exist on the control\n * for direct access. See a full list of properties directly available in\n * `AbstractControlDirective`.\n *\n * @see `RadioControlValueAccessor`\n * @see `SelectControlValueAccessor`\n *\n * @usageNotes\n *\n * ### Using ngModel on a standalone control\n *\n * The following examples show a simple standalone control using `ngModel`:\n *\n * {@example forms/ts/simpleNgModel/simple_ng_model_example.ts region='Component'}\n *\n * When using the `ngModel` within `<form>` tags, you'll also need to supply a `name` attribute\n * so that the control can be registered with the parent form under that name.\n *\n * In the context of a parent form, it's often unnecessary to include one-way or two-way binding,\n * as the parent form syncs the value for you. You access its properties by exporting it into a\n * local template variable using `ngForm` such as (`#f=\"ngForm\"`). Use the variable where\n * needed on form submission.\n *\n * If you do need to populate initial values into your form, using a one-way binding for\n * `ngModel` tends to be sufficient as long as you use the exported form's value rather\n * than the domain model's value on submit.\n *\n * ### Using ngModel within a form\n *\n * The following example shows controls using `ngModel` within a form:\n *\n * {@example forms/ts/simpleForm/simple_form_example.ts region='Component'}\n *\n * ### Using a standalone ngModel within a group\n *\n * The following example shows you how to use a standalone ngModel control\n * within a form. This controls the display of the form, but doesn't contain form data.\n *\n * ```html\n * <form>\n *   <input name=\"login\" ngModel placeholder=\"Login\">\n *   <input type=\"checkbox\" ngModel [ngModelOptions]=\"{standalone: true}\"> Show more options?\n * </form>\n * <!-- form value: {login: ''} -->\n * ```\n *\n * ### Setting the ngModel `name` attribute through options\n *\n * The following example shows you an alternate way to set the name attribute. Here,\n * an attribute identified as name is used within a custom form control component. To still be able\n * to specify the NgModel's name, you must specify it using the `ngModelOptions` input instead.\n *\n * ```html\n * <form>\n *   <my-custom-form-control name=\"Nancy\" ngModel [ngModelOptions]=\"{name: 'user'}\">\n *   </my-custom-form-control>\n * </form>\n * <!-- form value: {user: ''} -->\n * ```\n *\n * @ngModule FormsModule\n * @publicApi\n */\nclass NgModel extends NgControl {\n    constructor(parent, validators, asyncValidators, valueAccessors, _changeDetectorRef) {\n        super();\n        this._changeDetectorRef = _changeDetectorRef;\n        this.control = new FormControl();\n        /** @internal */\n        this._registered = false;\n        /**\n         * @description\n         * Event emitter for producing the `ngModelChange` event after\n         * the view model updates.\n         */\n        this.update = new EventEmitter();\n        this._parent = parent;\n        this._setValidators(validators);\n        this._setAsyncValidators(asyncValidators);\n        this.valueAccessor = selectValueAccessor(this, valueAccessors);\n    }\n    /** @nodoc */\n    ngOnChanges(changes) {\n        this._checkForErrors();\n        if (!this._registered || 'name' in changes) {\n            if (this._registered) {\n                this._checkName();\n                if (this.formDirective) {\n                    // We can't call `formDirective.removeControl(this)`, because the `name` has already been\n                    // changed. We also can't reset the name temporarily since the logic in `removeControl`\n                    // is inside a promise and it won't run immediately. We work around it by giving it an\n                    // object with the same shape instead.\n                    const oldName = changes['name'].previousValue;\n                    this.formDirective.removeControl({ name: oldName, path: this._getPath(oldName) });\n                }\n            }\n            this._setUpControl();\n        }\n        if ('isDisabled' in changes) {\n            this._updateDisabled(changes);\n        }\n        if (isPropertyUpdated(changes, this.viewModel)) {\n            this._updateValue(this.model);\n            this.viewModel = this.model;\n        }\n    }\n    /** @nodoc */\n    ngOnDestroy() {\n        this.formDirective && this.formDirective.removeControl(this);\n    }\n    /**\n     * @description\n     * Returns an array that represents the path from the top-level form to this control.\n     * Each index is the string name of the control on that level.\n     */\n    get path() {\n        return this._getPath(this.name);\n    }\n    /**\n     * @description\n     * The top-level directive for this control if present, otherwise null.\n     */\n    get formDirective() {\n        return this._parent ? this._parent.formDirective : null;\n    }\n    /**\n     * @description\n     * Sets the new value for the view model and emits an `ngModelChange` event.\n     *\n     * @param newValue The new value emitted by `ngModelChange`.\n     */\n    viewToModelUpdate(newValue) {\n        this.viewModel = newValue;\n        this.update.emit(newValue);\n    }\n    _setUpControl() {\n        this._setUpdateStrategy();\n        this._isStandalone() ? this._setUpStandalone() : this.formDirective.addControl(this);\n        this._registered = true;\n    }\n    _setUpdateStrategy() {\n        if (this.options && this.options.updateOn != null) {\n            this.control._updateOn = this.options.updateOn;\n        }\n    }\n    _isStandalone() {\n        return !this._parent || !!(this.options && this.options.standalone);\n    }\n    _setUpStandalone() {\n        setUpControl(this.control, this);\n        this.control.updateValueAndValidity({ emitEvent: false });\n    }\n    _checkForErrors() {\n        if (!this._isStandalone()) {\n            this._checkParentType();\n        }\n        this._checkName();\n    }\n    _checkParentType() {\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            if (!(this._parent instanceof NgModelGroup) &&\n                this._parent instanceof AbstractFormGroupDirective) {\n                throw formGroupNameException();\n            }\n            else if (!(this._parent instanceof NgModelGroup) && !(this._parent instanceof NgForm)) {\n                throw modelParentException();\n            }\n        }\n    }\n    _checkName() {\n        if (this.options && this.options.name)\n            this.name = this.options.name;\n        if (!this._isStandalone() && !this.name && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw missingNameException();\n        }\n    }\n    _updateValue(value) {\n        resolvedPromise.then(() => {\n            this.control.setValue(value, { emitViewToModelChange: false });\n            this._changeDetectorRef?.markForCheck();\n        });\n    }\n    _updateDisabled(changes) {\n        const disabledValue = changes['isDisabled'].currentValue;\n        // checking for 0 to avoid breaking change\n        const isDisabled = disabledValue !== 0 && ɵcoerceToBoolean(disabledValue);\n        resolvedPromise.then(() => {\n            if (isDisabled && !this.control.disabled) {\n                this.control.disable();\n            }\n            else if (!isDisabled && this.control.disabled) {\n                this.control.enable();\n            }\n            this._changeDetectorRef?.markForCheck();\n        });\n    }\n    _getPath(controlName) {\n        return this._parent ? controlPath(controlName, this._parent) : [controlName];\n    }\n}\nNgModel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NgModel, deps: [{ token: ControlContainer, host: true, optional: true }, { token: NG_VALIDATORS, optional: true, self: true }, { token: NG_ASYNC_VALIDATORS, optional: true, self: true }, { token: NG_VALUE_ACCESSOR, optional: true, self: true }, { token: ChangeDetectorRef, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nNgModel.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: NgModel, selector: \"[ngModel]:not([formControlName]):not([formControl])\", inputs: { name: \"name\", isDisabled: [\"disabled\", \"isDisabled\"], model: [\"ngModel\", \"model\"], options: [\"ngModelOptions\", \"options\"] }, outputs: { update: \"ngModelChange\" }, providers: [formControlBinding$1], exportAs: [\"ngModel\"], usesInheritance: true, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NgModel, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[ngModel]:not([formControlName]):not([formControl])',\n                    providers: [formControlBinding$1],\n                    exportAs: 'ngModel'\n                }]\n        }], ctorParameters: function () { return [{ type: ControlContainer, decorators: [{\n                    type: Optional\n                }, {\n                    type: Host\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_VALIDATORS]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_ASYNC_VALIDATORS]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_VALUE_ACCESSOR]\n                }] }, { type: i0.ChangeDetectorRef, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [ChangeDetectorRef]\n                }] }]; }, propDecorators: { name: [{\n                type: Input\n            }], isDisabled: [{\n                type: Input,\n                args: ['disabled']\n            }], model: [{\n                type: Input,\n                args: ['ngModel']\n            }], options: [{\n                type: Input,\n                args: ['ngModelOptions']\n            }], update: [{\n                type: Output,\n                args: ['ngModelChange']\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 * @description\n *\n * Adds `novalidate` attribute to all forms by default.\n *\n * `novalidate` is used to disable browser's native form validation.\n *\n * If you want to use native validation with Angular forms, just add `ngNativeValidate` attribute:\n *\n * ```\n * <form ngNativeValidate></form>\n * ```\n *\n * @publicApi\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n */\nclass ɵNgNoValidate {\n}\nɵNgNoValidate.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: ɵNgNoValidate, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nɵNgNoValidate.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: ɵNgNoValidate, selector: \"form:not([ngNoForm]):not([ngNativeValidate])\", host: { attributes: { \"novalidate\": \"\" } }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: ɵNgNoValidate, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'form:not([ngNoForm]):not([ngNativeValidate])',\n                    host: { 'novalidate': '' },\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst NUMBER_VALUE_ACCESSOR = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => NumberValueAccessor),\n    multi: true\n};\n/**\n * @description\n * The `ControlValueAccessor` for writing a number value and listening to number input changes.\n * The value accessor is used by the `FormControlDirective`, `FormControlName`, and `NgModel`\n * directives.\n *\n * @usageNotes\n *\n * ### Using a number input with a reactive form.\n *\n * The following example shows how to use a number input with a reactive form.\n *\n * ```ts\n * const totalCountControl = new FormControl();\n * ```\n *\n * ```\n * <input type=\"number\" [formControl]=\"totalCountControl\">\n * ```\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass NumberValueAccessor extends BuiltInControlValueAccessor {\n    /**\n     * Sets the \"value\" property on the input element.\n     * @nodoc\n     */\n    writeValue(value) {\n        // The value needs to be normalized for IE9, otherwise it is set to 'null' when null\n        const normalizedValue = value == null ? '' : value;\n        this.setProperty('value', normalizedValue);\n    }\n    /**\n     * Registers a function called when the control value changes.\n     * @nodoc\n     */\n    registerOnChange(fn) {\n        this.onChange = (value) => {\n            fn(value == '' ? null : parseFloat(value));\n        };\n    }\n}\nNumberValueAccessor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NumberValueAccessor, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nNumberValueAccessor.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: NumberValueAccessor, selector: \"input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]\", host: { listeners: { \"input\": \"onChange($event.target.value)\", \"blur\": \"onTouched()\" } }, providers: [NUMBER_VALUE_ACCESSOR], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NumberValueAccessor, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]',\n                    host: { '(input)': 'onChange($event.target.value)', '(blur)': 'onTouched()' },\n                    providers: [NUMBER_VALUE_ACCESSOR]\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst RADIO_VALUE_ACCESSOR = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => RadioControlValueAccessor),\n    multi: true\n};\nfunction throwNameError() {\n    throw new ɵRuntimeError(1202 /* RuntimeErrorCode.NAME_AND_FORM_CONTROL_NAME_MUST_MATCH */, `\n      If you define both a name and a formControlName attribute on your radio button, their values\n      must match. Ex: <input type=\"radio\" formControlName=\"food\" name=\"food\">\n    `);\n}\n/**\n * Internal-only NgModule that works as a host for the `RadioControlRegistry` tree-shakable\n * provider. Note: the `InternalFormsSharedModule` can not be used here directly, since it's\n * declared *after* the `RadioControlRegistry` class and the `providedIn` doesn't support\n * `forwardRef` logic.\n */\nclass RadioControlRegistryModule {\n}\nRadioControlRegistryModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: RadioControlRegistryModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nRadioControlRegistryModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"14.3.0\", ngImport: i0, type: RadioControlRegistryModule });\nRadioControlRegistryModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: RadioControlRegistryModule });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: RadioControlRegistryModule, decorators: [{\n            type: NgModule\n        }] });\n/**\n * @description\n * Class used by Angular to track radio buttons. For internal use only.\n */\nclass RadioControlRegistry {\n    constructor() {\n        this._accessors = [];\n    }\n    /**\n     * @description\n     * Adds a control to the internal registry. For internal use only.\n     */\n    add(control, accessor) {\n        this._accessors.push([control, accessor]);\n    }\n    /**\n     * @description\n     * Removes a control from the internal registry. For internal use only.\n     */\n    remove(accessor) {\n        for (let i = this._accessors.length - 1; i >= 0; --i) {\n            if (this._accessors[i][1] === accessor) {\n                this._accessors.splice(i, 1);\n                return;\n            }\n        }\n    }\n    /**\n     * @description\n     * Selects a radio button. For internal use only.\n     */\n    select(accessor) {\n        this._accessors.forEach((c) => {\n            if (this._isSameGroup(c, accessor) && c[1] !== accessor) {\n                c[1].fireUncheck(accessor.value);\n            }\n        });\n    }\n    _isSameGroup(controlPair, accessor) {\n        if (!controlPair[0].control)\n            return false;\n        return controlPair[0]._parent === accessor._control._parent &&\n            controlPair[1].name === accessor.name;\n    }\n}\nRadioControlRegistry.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: RadioControlRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable });\nRadioControlRegistry.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: RadioControlRegistry, providedIn: RadioControlRegistryModule });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: RadioControlRegistry, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: RadioControlRegistryModule }]\n        }] });\n/**\n * @description\n * The `ControlValueAccessor` for writing radio control values and listening to radio control\n * changes. The value accessor is used by the `FormControlDirective`, `FormControlName`, and\n * `NgModel` directives.\n *\n * @usageNotes\n *\n * ### Using radio buttons with reactive form directives\n *\n * The follow example shows how to use radio buttons in a reactive form. When using radio buttons in\n * a reactive form, radio buttons in the same group should have the same `formControlName`.\n * Providing a `name` attribute is optional.\n *\n * {@example forms/ts/reactiveRadioButtons/reactive_radio_button_example.ts region='Reactive'}\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass RadioControlValueAccessor extends BuiltInControlValueAccessor {\n    constructor(renderer, elementRef, _registry, _injector) {\n        super(renderer, elementRef);\n        this._registry = _registry;\n        this._injector = _injector;\n        /**\n         * The registered callback function called when a change event occurs on the input element.\n         * Note: we declare `onChange` here (also used as host listener) as a function with no arguments\n         * to override the `onChange` function (which expects 1 argument) in the parent\n         * `BaseControlValueAccessor` class.\n         * @nodoc\n         */\n        this.onChange = () => { };\n    }\n    /** @nodoc */\n    ngOnInit() {\n        this._control = this._injector.get(NgControl);\n        this._checkName();\n        this._registry.add(this._control, this);\n    }\n    /** @nodoc */\n    ngOnDestroy() {\n        this._registry.remove(this);\n    }\n    /**\n     * Sets the \"checked\" property value on the radio input element.\n     * @nodoc\n     */\n    writeValue(value) {\n        this._state = value === this.value;\n        this.setProperty('checked', this._state);\n    }\n    /**\n     * Registers a function called when the control value changes.\n     * @nodoc\n     */\n    registerOnChange(fn) {\n        this._fn = fn;\n        this.onChange = () => {\n            fn(this.value);\n            this._registry.select(this);\n        };\n    }\n    /**\n     * Sets the \"value\" on the radio input element and unchecks it.\n     *\n     * @param value\n     */\n    fireUncheck(value) {\n        this.writeValue(value);\n    }\n    _checkName() {\n        if (this.name && this.formControlName && this.name !== this.formControlName &&\n            (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throwNameError();\n        }\n        if (!this.name && this.formControlName)\n            this.name = this.formControlName;\n    }\n}\nRadioControlValueAccessor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: RadioControlValueAccessor, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: RadioControlRegistry }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive });\nRadioControlValueAccessor.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: RadioControlValueAccessor, selector: \"input[type=radio][formControlName],input[type=radio][formControl],input[type=radio][ngModel]\", inputs: { name: \"name\", formControlName: \"formControlName\", value: \"value\" }, host: { listeners: { \"change\": \"onChange()\", \"blur\": \"onTouched()\" } }, providers: [RADIO_VALUE_ACCESSOR], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: RadioControlValueAccessor, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'input[type=radio][formControlName],input[type=radio][formControl],input[type=radio][ngModel]',\n                    host: { '(change)': 'onChange()', '(blur)': 'onTouched()' },\n                    providers: [RADIO_VALUE_ACCESSOR]\n                }]\n        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: RadioControlRegistry }, { type: i0.Injector }]; }, propDecorators: { name: [{\n                type: Input\n            }], formControlName: [{\n                type: Input\n            }], value: [{\n                type: Input\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 */\nconst RANGE_VALUE_ACCESSOR = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => RangeValueAccessor),\n    multi: true\n};\n/**\n * @description\n * The `ControlValueAccessor` for writing a range value and listening to range input changes.\n * The value accessor is used by the `FormControlDirective`, `FormControlName`, and  `NgModel`\n * directives.\n *\n * @usageNotes\n *\n * ### Using a range input with a reactive form\n *\n * The following example shows how to use a range input with a reactive form.\n *\n * ```ts\n * const ageControl = new FormControl();\n * ```\n *\n * ```\n * <input type=\"range\" [formControl]=\"ageControl\">\n * ```\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass RangeValueAccessor extends BuiltInControlValueAccessor {\n    /**\n     * Sets the \"value\" property on the input element.\n     * @nodoc\n     */\n    writeValue(value) {\n        this.setProperty('value', parseFloat(value));\n    }\n    /**\n     * Registers a function called when the control value changes.\n     * @nodoc\n     */\n    registerOnChange(fn) {\n        this.onChange = (value) => {\n            fn(value == '' ? null : parseFloat(value));\n        };\n    }\n}\nRangeValueAccessor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: RangeValueAccessor, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nRangeValueAccessor.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: RangeValueAccessor, selector: \"input[type=range][formControlName],input[type=range][formControl],input[type=range][ngModel]\", host: { listeners: { \"change\": \"onChange($event.target.value)\", \"input\": \"onChange($event.target.value)\", \"blur\": \"onTouched()\" } }, providers: [RANGE_VALUE_ACCESSOR], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: RangeValueAccessor, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'input[type=range][formControlName],input[type=range][formControl],input[type=range][ngModel]',\n                    host: {\n                        '(change)': 'onChange($event.target.value)',\n                        '(input)': 'onChange($event.target.value)',\n                        '(blur)': 'onTouched()'\n                    },\n                    providers: [RANGE_VALUE_ACCESSOR]\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Token to provide to turn off the ngModel warning on formControl and formControlName.\n */\nconst NG_MODEL_WITH_FORM_CONTROL_WARNING = new InjectionToken('NgModelWithFormControlWarning');\nconst formControlBinding = {\n    provide: NgControl,\n    useExisting: forwardRef(() => FormControlDirective)\n};\n/**\n * @description\n * Synchronizes a standalone `FormControl` instance to a form control element.\n *\n * Note that support for using the `ngModel` input property and `ngModelChange` event with reactive\n * form directives was deprecated in Angular v6 and is scheduled for removal in\n * a future version of Angular.\n * For details, see [Deprecated features](guide/deprecations#ngmodel-with-reactive-forms).\n *\n * @see [Reactive Forms Guide](guide/reactive-forms)\n * @see `FormControl`\n * @see `AbstractControl`\n *\n * @usageNotes\n *\n * The following example shows how to register a standalone control and set its value.\n *\n * {@example forms/ts/simpleFormControl/simple_form_control_example.ts region='Component'}\n *\n * @ngModule ReactiveFormsModule\n * @publicApi\n */\nclass FormControlDirective extends NgControl {\n    constructor(validators, asyncValidators, valueAccessors, _ngModelWarningConfig) {\n        super();\n        this._ngModelWarningConfig = _ngModelWarningConfig;\n        /** @deprecated as of v6 */\n        this.update = new EventEmitter();\n        /**\n         * @description\n         * Instance property used to track whether an ngModel warning has been sent out for this\n         * particular `FormControlDirective` instance. Used to support warning config of \"always\".\n         *\n         * @internal\n         */\n        this._ngModelWarningSent = false;\n        this._setValidators(validators);\n        this._setAsyncValidators(asyncValidators);\n        this.valueAccessor = selectValueAccessor(this, valueAccessors);\n    }\n    /**\n     * @description\n     * Triggers a warning in dev mode that this input should not be used with reactive forms.\n     */\n    set isDisabled(isDisabled) {\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            console.warn(disabledAttrWarning);\n        }\n    }\n    /** @nodoc */\n    ngOnChanges(changes) {\n        if (this._isControlChanged(changes)) {\n            const previousForm = changes['form'].previousValue;\n            if (previousForm) {\n                cleanUpControl(previousForm, this, /* validateControlPresenceOnChange */ false);\n            }\n            setUpControl(this.form, this);\n            this.form.updateValueAndValidity({ emitEvent: false });\n        }\n        if (isPropertyUpdated(changes, this.viewModel)) {\n            if (typeof ngDevMode === 'undefined' || ngDevMode) {\n                _ngModelWarning('formControl', FormControlDirective, this, this._ngModelWarningConfig);\n            }\n            this.form.setValue(this.model);\n            this.viewModel = this.model;\n        }\n    }\n    /** @nodoc */\n    ngOnDestroy() {\n        if (this.form) {\n            cleanUpControl(this.form, this, /* validateControlPresenceOnChange */ false);\n        }\n    }\n    /**\n     * @description\n     * Returns an array that represents the path from the top-level form to this control.\n     * Each index is the string name of the control on that level.\n     */\n    get path() {\n        return [];\n    }\n    /**\n     * @description\n     * The `FormControl` bound to this directive.\n     */\n    get control() {\n        return this.form;\n    }\n    /**\n     * @description\n     * Sets the new value for the view model and emits an `ngModelChange` event.\n     *\n     * @param newValue The new value for the view model.\n     */\n    viewToModelUpdate(newValue) {\n        this.viewModel = newValue;\n        this.update.emit(newValue);\n    }\n    _isControlChanged(changes) {\n        return changes.hasOwnProperty('form');\n    }\n}\n/**\n * @description\n * Static property used to track whether any ngModel warnings have been sent across\n * all instances of FormControlDirective. Used to support warning config of \"once\".\n *\n * @internal\n */\nFormControlDirective._ngModelWarningSentOnce = false;\nFormControlDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: FormControlDirective, deps: [{ token: NG_VALIDATORS, optional: true, self: true }, { token: NG_ASYNC_VALIDATORS, optional: true, self: true }, { token: NG_VALUE_ACCESSOR, optional: true, self: true }, { token: NG_MODEL_WITH_FORM_CONTROL_WARNING, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nFormControlDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: FormControlDirective, selector: \"[formControl]\", inputs: { form: [\"formControl\", \"form\"], isDisabled: [\"disabled\", \"isDisabled\"], model: [\"ngModel\", \"model\"] }, outputs: { update: \"ngModelChange\" }, providers: [formControlBinding], exportAs: [\"ngForm\"], usesInheritance: true, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: FormControlDirective, decorators: [{\n            type: Directive,\n            args: [{ selector: '[formControl]', providers: [formControlBinding], exportAs: 'ngForm' }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_VALIDATORS]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_ASYNC_VALIDATORS]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_VALUE_ACCESSOR]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [NG_MODEL_WITH_FORM_CONTROL_WARNING]\n                }] }]; }, propDecorators: { form: [{\n                type: Input,\n                args: ['formControl']\n            }], isDisabled: [{\n                type: Input,\n                args: ['disabled']\n            }], model: [{\n                type: Input,\n                args: ['ngModel']\n            }], update: [{\n                type: Output,\n                args: ['ngModelChange']\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 */\nconst formDirectiveProvider = {\n    provide: ControlContainer,\n    useExisting: forwardRef(() => FormGroupDirective)\n};\n/**\n * @description\n *\n * Binds an existing `FormGroup` or `FormRecord` to a DOM element.\n *\n * This directive accepts an existing `FormGroup` instance. It will then use this\n * `FormGroup` instance to match any child `FormControl`, `FormGroup`/`FormRecord`,\n * and `FormArray` instances to child `FormControlName`, `FormGroupName`,\n * and `FormArrayName` directives.\n *\n * @see [Reactive Forms Guide](guide/reactive-forms)\n * @see `AbstractControl`\n *\n * @usageNotes\n * ### Register Form Group\n *\n * The following example registers a `FormGroup` with first name and last name controls,\n * and listens for the *ngSubmit* event when the button is clicked.\n *\n * {@example forms/ts/simpleFormGroup/simple_form_group_example.ts region='Component'}\n *\n * @ngModule ReactiveFormsModule\n * @publicApi\n */\nclass FormGroupDirective extends ControlContainer {\n    constructor(validators, asyncValidators) {\n        super();\n        /**\n         * @description\n         * Reports whether the form submission has been triggered.\n         */\n        this.submitted = false;\n        /**\n         * Callback that should be invoked when controls in FormGroup or FormArray collection change\n         * (added or removed). This callback triggers corresponding DOM updates.\n         */\n        this._onCollectionChange = () => this._updateDomValue();\n        /**\n         * @description\n         * Tracks the list of added `FormControlName` instances\n         */\n        this.directives = [];\n        /**\n         * @description\n         * Tracks the `FormGroup` bound to this directive.\n         */\n        this.form = null;\n        /**\n         * @description\n         * Emits an event when the form submission has been triggered.\n         */\n        this.ngSubmit = new EventEmitter();\n        this._setValidators(validators);\n        this._setAsyncValidators(asyncValidators);\n    }\n    /** @nodoc */\n    ngOnChanges(changes) {\n        this._checkFormPresent();\n        if (changes.hasOwnProperty('form')) {\n            this._updateValidators();\n            this._updateDomValue();\n            this._updateRegistrations();\n            this._oldForm = this.form;\n        }\n    }\n    /** @nodoc */\n    ngOnDestroy() {\n        if (this.form) {\n            cleanUpValidators(this.form, this);\n            // Currently the `onCollectionChange` callback is rewritten each time the\n            // `_registerOnCollectionChange` function is invoked. The implication is that cleanup should\n            // happen *only* when the `onCollectionChange` callback was set by this directive instance.\n            // Otherwise it might cause overriding a callback of some other directive instances. We should\n            // consider updating this logic later to make it similar to how `onChange` callbacks are\n            // handled, see https://github.com/angular/angular/issues/39732 for additional info.\n            if (this.form._onCollectionChange === this._onCollectionChange) {\n                this.form._registerOnCollectionChange(() => { });\n            }\n        }\n    }\n    /**\n     * @description\n     * Returns this directive's instance.\n     */\n    get formDirective() {\n        return this;\n    }\n    /**\n     * @description\n     * Returns the `FormGroup` bound to this directive.\n     */\n    get control() {\n        return this.form;\n    }\n    /**\n     * @description\n     * Returns an array representing the path to this group. Because this directive\n     * always lives at the top level of a form, it always an empty array.\n     */\n    get path() {\n        return [];\n    }\n    /**\n     * @description\n     * Method that sets up the control directive in this group, re-calculates its value\n     * and validity, and adds the instance to the internal list of directives.\n     *\n     * @param dir The `FormControlName` directive instance.\n     */\n    addControl(dir) {\n        const ctrl = this.form.get(dir.path);\n        setUpControl(ctrl, dir);\n        ctrl.updateValueAndValidity({ emitEvent: false });\n        this.directives.push(dir);\n        return ctrl;\n    }\n    /**\n     * @description\n     * Retrieves the `FormControl` instance from the provided `FormControlName` directive\n     *\n     * @param dir The `FormControlName` directive instance.\n     */\n    getControl(dir) {\n        return this.form.get(dir.path);\n    }\n    /**\n     * @description\n     * Removes the `FormControlName` instance from the internal list of directives\n     *\n     * @param dir The `FormControlName` directive instance.\n     */\n    removeControl(dir) {\n        cleanUpControl(dir.control || null, dir, /* validateControlPresenceOnChange */ false);\n        removeListItem$1(this.directives, dir);\n    }\n    /**\n     * Adds a new `FormGroupName` directive instance to the form.\n     *\n     * @param dir The `FormGroupName` directive instance.\n     */\n    addFormGroup(dir) {\n        this._setUpFormContainer(dir);\n    }\n    /**\n     * Performs the necessary cleanup when a `FormGroupName` directive instance is removed from the\n     * view.\n     *\n     * @param dir The `FormGroupName` directive instance.\n     */\n    removeFormGroup(dir) {\n        this._cleanUpFormContainer(dir);\n    }\n    /**\n     * @description\n     * Retrieves the `FormGroup` for a provided `FormGroupName` directive instance\n     *\n     * @param dir The `FormGroupName` directive instance.\n     */\n    getFormGroup(dir) {\n        return this.form.get(dir.path);\n    }\n    /**\n     * Performs the necessary setup when a `FormArrayName` directive instance is added to the view.\n     *\n     * @param dir The `FormArrayName` directive instance.\n     */\n    addFormArray(dir) {\n        this._setUpFormContainer(dir);\n    }\n    /**\n     * Performs the necessary cleanup when a `FormArrayName` directive instance is removed from the\n     * view.\n     *\n     * @param dir The `FormArrayName` directive instance.\n     */\n    removeFormArray(dir) {\n        this._cleanUpFormContainer(dir);\n    }\n    /**\n     * @description\n     * Retrieves the `FormArray` for a provided `FormArrayName` directive instance.\n     *\n     * @param dir The `FormArrayName` directive instance.\n     */\n    getFormArray(dir) {\n        return this.form.get(dir.path);\n    }\n    /**\n     * Sets the new value for the provided `FormControlName` directive.\n     *\n     * @param dir The `FormControlName` directive instance.\n     * @param value The new value for the directive's control.\n     */\n    updateModel(dir, value) {\n        const ctrl = this.form.get(dir.path);\n        ctrl.setValue(value);\n    }\n    /**\n     * @description\n     * Method called with the \"submit\" event is triggered on the form.\n     * Triggers the `ngSubmit` emitter to emit the \"submit\" event as its payload.\n     *\n     * @param $event The \"submit\" event object\n     */\n    onSubmit($event) {\n        this.submitted = true;\n        syncPendingControls(this.form, this.directives);\n        this.ngSubmit.emit($event);\n        // Forms with `method=\"dialog\"` have some special behavior that won't reload the page and that\n        // shouldn't be prevented. Note that we need to null check the `event` and the `target`, because\n        // some internal apps call this method directly with the wrong arguments.\n        return $event?.target?.method === 'dialog';\n    }\n    /**\n     * @description\n     * Method called when the \"reset\" event is triggered on the form.\n     */\n    onReset() {\n        this.resetForm();\n    }\n    /**\n     * @description\n     * Resets the form to an initial value and resets its submitted status.\n     *\n     * @param value The new value for the form.\n     */\n    resetForm(value = undefined) {\n        this.form.reset(value);\n        this.submitted = false;\n    }\n    /** @internal */\n    _updateDomValue() {\n        this.directives.forEach(dir => {\n            const oldCtrl = dir.control;\n            const newCtrl = this.form.get(dir.path);\n            if (oldCtrl !== newCtrl) {\n                // Note: the value of the `dir.control` may not be defined, for example when it's a first\n                // `FormControl` that is added to a `FormGroup` instance (via `addControl` call).\n                cleanUpControl(oldCtrl || null, dir);\n                // Check whether new control at the same location inside the corresponding `FormGroup` is an\n                // instance of `FormControl` and perform control setup only if that's the case.\n                // Note: we don't need to clear the list of directives (`this.directives`) here, it would be\n                // taken care of in the `removeControl` method invoked when corresponding `formControlName`\n                // directive instance is being removed (invoked from `FormControlName.ngOnDestroy`).\n                if (isFormControl(newCtrl)) {\n                    setUpControl(newCtrl, dir);\n                    dir.control = newCtrl;\n                }\n            }\n        });\n        this.form._updateTreeValidity({ emitEvent: false });\n    }\n    _setUpFormContainer(dir) {\n        const ctrl = this.form.get(dir.path);\n        setUpFormContainer(ctrl, dir);\n        // NOTE: this operation looks unnecessary in case no new validators were added in\n        // `setUpFormContainer` call. Consider updating this code to match the logic in\n        // `_cleanUpFormContainer` function.\n        ctrl.updateValueAndValidity({ emitEvent: false });\n    }\n    _cleanUpFormContainer(dir) {\n        if (this.form) {\n            const ctrl = this.form.get(dir.path);\n            if (ctrl) {\n                const isControlUpdated = cleanUpFormContainer(ctrl, dir);\n                if (isControlUpdated) {\n                    // Run validity check only in case a control was updated (i.e. view validators were\n                    // removed) as removing view validators might cause validity to change.\n                    ctrl.updateValueAndValidity({ emitEvent: false });\n                }\n            }\n        }\n    }\n    _updateRegistrations() {\n        this.form._registerOnCollectionChange(this._onCollectionChange);\n        if (this._oldForm) {\n            this._oldForm._registerOnCollectionChange(() => { });\n        }\n    }\n    _updateValidators() {\n        setUpValidators(this.form, this);\n        if (this._oldForm) {\n            cleanUpValidators(this._oldForm, this);\n        }\n    }\n    _checkFormPresent() {\n        if (!this.form && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw missingFormException();\n        }\n    }\n}\nFormGroupDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: FormGroupDirective, deps: [{ token: NG_VALIDATORS, optional: true, self: true }, { token: NG_ASYNC_VALIDATORS, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });\nFormGroupDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: FormGroupDirective, selector: \"[formGroup]\", inputs: { form: [\"formGroup\", \"form\"] }, outputs: { ngSubmit: \"ngSubmit\" }, host: { listeners: { \"submit\": \"onSubmit($event)\", \"reset\": \"onReset()\" } }, providers: [formDirectiveProvider], exportAs: [\"ngForm\"], usesInheritance: true, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: FormGroupDirective, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[formGroup]',\n                    providers: [formDirectiveProvider],\n                    host: { '(submit)': 'onSubmit($event)', '(reset)': 'onReset()' },\n                    exportAs: 'ngForm'\n                }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_VALIDATORS]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_ASYNC_VALIDATORS]\n                }] }]; }, propDecorators: { form: [{\n                type: Input,\n                args: ['formGroup']\n            }], ngSubmit: [{\n                type: Output\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 */\nconst formGroupNameProvider = {\n    provide: ControlContainer,\n    useExisting: forwardRef(() => FormGroupName)\n};\n/**\n * @description\n *\n * Syncs a nested `FormGroup` or `FormRecord` to a DOM element.\n *\n * This directive can only be used with a parent `FormGroupDirective`.\n *\n * It accepts the string name of the nested `FormGroup` or `FormRecord` to link, and\n * looks for a `FormGroup` or `FormRecord` registered with that name in the parent\n * `FormGroup` instance you passed into `FormGroupDirective`.\n *\n * Use nested form groups to validate a sub-group of a\n * form separately from the rest or to group the values of certain\n * controls into their own nested object.\n *\n * @see [Reactive Forms Guide](guide/reactive-forms)\n *\n * @usageNotes\n *\n * ### Access the group by name\n *\n * The following example uses the `AbstractControl.get` method to access the\n * associated `FormGroup`\n *\n * ```ts\n *   this.form.get('name');\n * ```\n *\n * ### Access individual controls in the group\n *\n * The following example uses the `AbstractControl.get` method to access\n * individual controls within the group using dot syntax.\n *\n * ```ts\n *   this.form.get('name.first');\n * ```\n *\n * ### Register a nested `FormGroup`.\n *\n * The following example registers a nested *name* `FormGroup` within an existing `FormGroup`,\n * and provides methods to retrieve the nested `FormGroup` and individual controls.\n *\n * {@example forms/ts/nestedFormGroup/nested_form_group_example.ts region='Component'}\n *\n * @ngModule ReactiveFormsModule\n * @publicApi\n */\nclass FormGroupName extends AbstractFormGroupDirective {\n    constructor(parent, validators, asyncValidators) {\n        super();\n        this._parent = parent;\n        this._setValidators(validators);\n        this._setAsyncValidators(asyncValidators);\n    }\n    /** @internal */\n    _checkParentType() {\n        if (_hasInvalidParent(this._parent) && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw groupParentException();\n        }\n    }\n}\nFormGroupName.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: FormGroupName, deps: [{ token: ControlContainer, host: true, optional: true, skipSelf: true }, { token: NG_VALIDATORS, optional: true, self: true }, { token: NG_ASYNC_VALIDATORS, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });\nFormGroupName.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: FormGroupName, selector: \"[formGroupName]\", inputs: { name: [\"formGroupName\", \"name\"] }, providers: [formGroupNameProvider], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: FormGroupName, decorators: [{\n            type: Directive,\n            args: [{ selector: '[formGroupName]', providers: [formGroupNameProvider] }]\n        }], ctorParameters: function () { return [{ type: ControlContainer, decorators: [{\n                    type: Optional\n                }, {\n                    type: Host\n                }, {\n                    type: SkipSelf\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_VALIDATORS]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_ASYNC_VALIDATORS]\n                }] }]; }, propDecorators: { name: [{\n                type: Input,\n                args: ['formGroupName']\n            }] } });\nconst formArrayNameProvider = {\n    provide: ControlContainer,\n    useExisting: forwardRef(() => FormArrayName)\n};\n/**\n * @description\n *\n * Syncs a nested `FormArray` to a DOM element.\n *\n * This directive is designed to be used with a parent `FormGroupDirective` (selector:\n * `[formGroup]`).\n *\n * It accepts the string name of the nested `FormArray` you want to link, and\n * will look for a `FormArray` registered with that name in the parent\n * `FormGroup` instance you passed into `FormGroupDirective`.\n *\n * @see [Reactive Forms Guide](guide/reactive-forms)\n * @see `AbstractControl`\n *\n * @usageNotes\n *\n * ### Example\n *\n * {@example forms/ts/nestedFormArray/nested_form_array_example.ts region='Component'}\n *\n * @ngModule ReactiveFormsModule\n * @publicApi\n */\nclass FormArrayName extends ControlContainer {\n    constructor(parent, validators, asyncValidators) {\n        super();\n        this._parent = parent;\n        this._setValidators(validators);\n        this._setAsyncValidators(asyncValidators);\n    }\n    /**\n     * A lifecycle method called when the directive's inputs are initialized. For internal use only.\n     * @throws If the directive does not have a valid parent.\n     * @nodoc\n     */\n    ngOnInit() {\n        this._checkParentType();\n        this.formDirective.addFormArray(this);\n    }\n    /**\n     * A lifecycle method called before the directive's instance is destroyed. For internal use only.\n     * @nodoc\n     */\n    ngOnDestroy() {\n        if (this.formDirective) {\n            this.formDirective.removeFormArray(this);\n        }\n    }\n    /**\n     * @description\n     * The `FormArray` bound to this directive.\n     */\n    get control() {\n        return this.formDirective.getFormArray(this);\n    }\n    /**\n     * @description\n     * The top-level directive for this group if present, otherwise null.\n     */\n    get formDirective() {\n        return this._parent ? this._parent.formDirective : null;\n    }\n    /**\n     * @description\n     * Returns an array that represents the path from the top-level form to this control.\n     * Each index is the string name of the control on that level.\n     */\n    get path() {\n        return controlPath(this.name == null ? this.name : this.name.toString(), this._parent);\n    }\n    _checkParentType() {\n        if (_hasInvalidParent(this._parent) && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw arrayParentException();\n        }\n    }\n}\nFormArrayName.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: FormArrayName, deps: [{ token: ControlContainer, host: true, optional: true, skipSelf: true }, { token: NG_VALIDATORS, optional: true, self: true }, { token: NG_ASYNC_VALIDATORS, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });\nFormArrayName.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: FormArrayName, selector: \"[formArrayName]\", inputs: { name: [\"formArrayName\", \"name\"] }, providers: [formArrayNameProvider], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: FormArrayName, decorators: [{\n            type: Directive,\n            args: [{ selector: '[formArrayName]', providers: [formArrayNameProvider] }]\n        }], ctorParameters: function () { return [{ type: ControlContainer, decorators: [{\n                    type: Optional\n                }, {\n                    type: Host\n                }, {\n                    type: SkipSelf\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_VALIDATORS]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_ASYNC_VALIDATORS]\n                }] }]; }, propDecorators: { name: [{\n                type: Input,\n                args: ['formArrayName']\n            }] } });\nfunction _hasInvalidParent(parent) {\n    return !(parent instanceof FormGroupName) && !(parent instanceof FormGroupDirective) &&\n        !(parent instanceof FormArrayName);\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 */\nconst controlNameBinding = {\n    provide: NgControl,\n    useExisting: forwardRef(() => FormControlName)\n};\n/**\n * @description\n * Syncs a `FormControl` in an existing `FormGroup` to a form control\n * element by name.\n *\n * @see [Reactive Forms Guide](guide/reactive-forms)\n * @see `FormControl`\n * @see `AbstractControl`\n *\n * @usageNotes\n *\n * ### Register `FormControl` within a group\n *\n * The following example shows how to register multiple form controls within a form group\n * and set their value.\n *\n * {@example forms/ts/simpleFormGroup/simple_form_group_example.ts region='Component'}\n *\n * To see `formControlName` examples with different form control types, see:\n *\n * * Radio buttons: `RadioControlValueAccessor`\n * * Selects: `SelectControlValueAccessor`\n *\n * ### Use with ngModel is deprecated\n *\n * Support for using the `ngModel` input property and `ngModelChange` event with reactive\n * form directives has been deprecated in Angular v6 and is scheduled for removal in\n * a future version of Angular.\n *\n * For details, see [Deprecated features](guide/deprecations#ngmodel-with-reactive-forms).\n *\n * @ngModule ReactiveFormsModule\n * @publicApi\n */\nclass FormControlName extends NgControl {\n    constructor(parent, validators, asyncValidators, valueAccessors, _ngModelWarningConfig) {\n        super();\n        this._ngModelWarningConfig = _ngModelWarningConfig;\n        this._added = false;\n        /** @deprecated as of v6 */\n        this.update = new EventEmitter();\n        /**\n         * @description\n         * Instance property used to track whether an ngModel warning has been sent out for this\n         * particular FormControlName instance. Used to support warning config of \"always\".\n         *\n         * @internal\n         */\n        this._ngModelWarningSent = false;\n        this._parent = parent;\n        this._setValidators(validators);\n        this._setAsyncValidators(asyncValidators);\n        this.valueAccessor = selectValueAccessor(this, valueAccessors);\n    }\n    /**\n     * @description\n     * Triggers a warning in dev mode that this input should not be used with reactive forms.\n     */\n    set isDisabled(isDisabled) {\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            console.warn(disabledAttrWarning);\n        }\n    }\n    /** @nodoc */\n    ngOnChanges(changes) {\n        if (!this._added)\n            this._setUpControl();\n        if (isPropertyUpdated(changes, this.viewModel)) {\n            if (typeof ngDevMode === 'undefined' || ngDevMode) {\n                _ngModelWarning('formControlName', FormControlName, this, this._ngModelWarningConfig);\n            }\n            this.viewModel = this.model;\n            this.formDirective.updateModel(this, this.model);\n        }\n    }\n    /** @nodoc */\n    ngOnDestroy() {\n        if (this.formDirective) {\n            this.formDirective.removeControl(this);\n        }\n    }\n    /**\n     * @description\n     * Sets the new value for the view model and emits an `ngModelChange` event.\n     *\n     * @param newValue The new value for the view model.\n     */\n    viewToModelUpdate(newValue) {\n        this.viewModel = newValue;\n        this.update.emit(newValue);\n    }\n    /**\n     * @description\n     * Returns an array that represents the path from the top-level form to this control.\n     * Each index is the string name of the control on that level.\n     */\n    get path() {\n        return controlPath(this.name == null ? this.name : this.name.toString(), this._parent);\n    }\n    /**\n     * @description\n     * The top-level directive for this group if present, otherwise null.\n     */\n    get formDirective() {\n        return this._parent ? this._parent.formDirective : null;\n    }\n    _checkParentType() {\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            if (!(this._parent instanceof FormGroupName) &&\n                this._parent instanceof AbstractFormGroupDirective) {\n                throw ngModelGroupException();\n            }\n            else if (!(this._parent instanceof FormGroupName) &&\n                !(this._parent instanceof FormGroupDirective) &&\n                !(this._parent instanceof FormArrayName)) {\n                throw controlParentException();\n            }\n        }\n    }\n    _setUpControl() {\n        this._checkParentType();\n        this.control = this.formDirective.addControl(this);\n        this._added = true;\n    }\n}\n/**\n * @description\n * Static property used to track whether any ngModel warnings have been sent across\n * all instances of FormControlName. Used to support warning config of \"once\".\n *\n * @internal\n */\nFormControlName._ngModelWarningSentOnce = false;\nFormControlName.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: FormControlName, deps: [{ token: ControlContainer, host: true, optional: true, skipSelf: true }, { token: NG_VALIDATORS, optional: true, self: true }, { token: NG_ASYNC_VALIDATORS, optional: true, self: true }, { token: NG_VALUE_ACCESSOR, optional: true, self: true }, { token: NG_MODEL_WITH_FORM_CONTROL_WARNING, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nFormControlName.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: FormControlName, selector: \"[formControlName]\", inputs: { name: [\"formControlName\", \"name\"], isDisabled: [\"disabled\", \"isDisabled\"], model: [\"ngModel\", \"model\"] }, outputs: { update: \"ngModelChange\" }, providers: [controlNameBinding], usesInheritance: true, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: FormControlName, decorators: [{\n            type: Directive,\n            args: [{ selector: '[formControlName]', providers: [controlNameBinding] }]\n        }], ctorParameters: function () { return [{ type: ControlContainer, decorators: [{\n                    type: Optional\n                }, {\n                    type: Host\n                }, {\n                    type: SkipSelf\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_VALIDATORS]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_ASYNC_VALIDATORS]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [NG_VALUE_ACCESSOR]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [NG_MODEL_WITH_FORM_CONTROL_WARNING]\n                }] }]; }, propDecorators: { name: [{\n                type: Input,\n                args: ['formControlName']\n            }], isDisabled: [{\n                type: Input,\n                args: ['disabled']\n            }], model: [{\n                type: Input,\n                args: ['ngModel']\n            }], update: [{\n                type: Output,\n                args: ['ngModelChange']\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 */\nconst SELECT_VALUE_ACCESSOR = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => SelectControlValueAccessor),\n    multi: true\n};\nfunction _buildValueString$1(id, value) {\n    if (id == null)\n        return `${value}`;\n    if (value && typeof value === 'object')\n        value = 'Object';\n    return `${id}: ${value}`.slice(0, 50);\n}\nfunction _extractId$1(valueString) {\n    return valueString.split(':')[0];\n}\n/**\n * @description\n * The `ControlValueAccessor` for writing select control values and listening to select control\n * changes. The value accessor is used by the `FormControlDirective`, `FormControlName`, and\n * `NgModel` directives.\n *\n * @usageNotes\n *\n * ### Using select controls in a reactive form\n *\n * The following examples show how to use a select control in a reactive form.\n *\n * {@example forms/ts/reactiveSelectControl/reactive_select_control_example.ts region='Component'}\n *\n * ### Using select controls in a template-driven form\n *\n * To use a select in a template-driven form, simply add an `ngModel` and a `name`\n * attribute to the main `<select>` tag.\n *\n * {@example forms/ts/selectControl/select_control_example.ts region='Component'}\n *\n * ### Customizing option selection\n *\n * Angular uses object identity to select option. It's possible for the identities of items\n * to change while the data does not. This can happen, for example, if the items are produced\n * from an RPC to the server, and that RPC is re-run. Even if the data hasn't changed, the\n * second response will produce objects with different identities.\n *\n * To customize the default option comparison algorithm, `<select>` supports `compareWith` input.\n * `compareWith` takes a **function** which has two arguments: `option1` and `option2`.\n * If `compareWith` is given, Angular selects option by the return value of the function.\n *\n * ```ts\n * const selectedCountriesControl = new FormControl();\n * ```\n *\n * ```\n * <select [compareWith]=\"compareFn\"  [formControl]=\"selectedCountriesControl\">\n *     <option *ngFor=\"let country of countries\" [ngValue]=\"country\">\n *         {{country.name}}\n *     </option>\n * </select>\n *\n * compareFn(c1: Country, c2: Country): boolean {\n *     return c1 && c2 ? c1.id === c2.id : c1 === c2;\n * }\n * ```\n *\n * **Note:** We listen to the 'change' event because 'input' events aren't fired\n * for selects in IE, see:\n * https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/input_event#browser_compatibility\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass SelectControlValueAccessor extends BuiltInControlValueAccessor {\n    constructor() {\n        super(...arguments);\n        /** @internal */\n        this._optionMap = new Map();\n        /** @internal */\n        this._idCounter = 0;\n        this._compareWith = Object.is;\n    }\n    /**\n     * @description\n     * Tracks the option comparison algorithm for tracking identities when\n     * checking for changes.\n     */\n    set compareWith(fn) {\n        if (typeof fn !== 'function' && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw new ɵRuntimeError(1201 /* RuntimeErrorCode.COMPAREWITH_NOT_A_FN */, `compareWith must be a function, but received ${JSON.stringify(fn)}`);\n        }\n        this._compareWith = fn;\n    }\n    /**\n     * Sets the \"value\" property on the select element.\n     * @nodoc\n     */\n    writeValue(value) {\n        this.value = value;\n        const id = this._getOptionId(value);\n        const valueString = _buildValueString$1(id, value);\n        this.setProperty('value', valueString);\n    }\n    /**\n     * Registers a function called when the control value changes.\n     * @nodoc\n     */\n    registerOnChange(fn) {\n        this.onChange = (valueString) => {\n            this.value = this._getOptionValue(valueString);\n            fn(this.value);\n        };\n    }\n    /** @internal */\n    _registerOption() {\n        return (this._idCounter++).toString();\n    }\n    /** @internal */\n    _getOptionId(value) {\n        for (const id of Array.from(this._optionMap.keys())) {\n            if (this._compareWith(this._optionMap.get(id), value))\n                return id;\n        }\n        return null;\n    }\n    /** @internal */\n    _getOptionValue(valueString) {\n        const id = _extractId$1(valueString);\n        return this._optionMap.has(id) ? this._optionMap.get(id) : valueString;\n    }\n}\nSelectControlValueAccessor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: SelectControlValueAccessor, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nSelectControlValueAccessor.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: SelectControlValueAccessor, selector: \"select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]\", inputs: { compareWith: \"compareWith\" }, host: { listeners: { \"change\": \"onChange($event.target.value)\", \"blur\": \"onTouched()\" } }, providers: [SELECT_VALUE_ACCESSOR], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: SelectControlValueAccessor, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]',\n                    host: { '(change)': 'onChange($event.target.value)', '(blur)': 'onTouched()' },\n                    providers: [SELECT_VALUE_ACCESSOR]\n                }]\n        }], propDecorators: { compareWith: [{\n                type: Input\n            }] } });\n/**\n * @description\n * Marks `<option>` as dynamic, so Angular can be notified when options change.\n *\n * @see `SelectControlValueAccessor`\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass NgSelectOption {\n    constructor(_element, _renderer, _select) {\n        this._element = _element;\n        this._renderer = _renderer;\n        this._select = _select;\n        if (this._select)\n            this.id = this._select._registerOption();\n    }\n    /**\n     * @description\n     * Tracks the value bound to the option element. Unlike the value binding,\n     * ngValue supports binding to objects.\n     */\n    set ngValue(value) {\n        if (this._select == null)\n            return;\n        this._select._optionMap.set(this.id, value);\n        this._setElementValue(_buildValueString$1(this.id, value));\n        this._select.writeValue(this._select.value);\n    }\n    /**\n     * @description\n     * Tracks simple string values bound to the option element.\n     * For objects, use the `ngValue` input binding.\n     */\n    set value(value) {\n        this._setElementValue(value);\n        if (this._select)\n            this._select.writeValue(this._select.value);\n    }\n    /** @internal */\n    _setElementValue(value) {\n        this._renderer.setProperty(this._element.nativeElement, 'value', value);\n    }\n    /** @nodoc */\n    ngOnDestroy() {\n        if (this._select) {\n            this._select._optionMap.delete(this.id);\n            this._select.writeValue(this._select.value);\n        }\n    }\n}\nNgSelectOption.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NgSelectOption, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: SelectControlValueAccessor, host: true, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nNgSelectOption.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: NgSelectOption, selector: \"option\", inputs: { ngValue: \"ngValue\", value: \"value\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NgSelectOption, decorators: [{\n            type: Directive,\n            args: [{ selector: 'option' }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: SelectControlValueAccessor, decorators: [{\n                    type: Optional\n                }, {\n                    type: Host\n                }] }]; }, propDecorators: { ngValue: [{\n                type: Input,\n                args: ['ngValue']\n            }], value: [{\n                type: Input,\n                args: ['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 */\nconst SELECT_MULTIPLE_VALUE_ACCESSOR = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => SelectMultipleControlValueAccessor),\n    multi: true\n};\nfunction _buildValueString(id, value) {\n    if (id == null)\n        return `${value}`;\n    if (typeof value === 'string')\n        value = `'${value}'`;\n    if (value && typeof value === 'object')\n        value = 'Object';\n    return `${id}: ${value}`.slice(0, 50);\n}\nfunction _extractId(valueString) {\n    return valueString.split(':')[0];\n}\n/** Mock interface for HTMLCollection */\nclass HTMLCollection {\n}\n/**\n * @description\n * The `ControlValueAccessor` for writing multi-select control values and listening to multi-select\n * control changes. The value accessor is used by the `FormControlDirective`, `FormControlName`, and\n * `NgModel` directives.\n *\n * @see `SelectControlValueAccessor`\n *\n * @usageNotes\n *\n * ### Using a multi-select control\n *\n * The follow example shows you how to use a multi-select control with a reactive form.\n *\n * ```ts\n * const countryControl = new FormControl();\n * ```\n *\n * ```\n * <select multiple name=\"countries\" [formControl]=\"countryControl\">\n *   <option *ngFor=\"let country of countries\" [ngValue]=\"country\">\n *     {{ country.name }}\n *   </option>\n * </select>\n * ```\n *\n * ### Customizing option selection\n *\n * To customize the default option comparison algorithm, `<select>` supports `compareWith` input.\n * See the `SelectControlValueAccessor` for usage.\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass SelectMultipleControlValueAccessor extends BuiltInControlValueAccessor {\n    constructor() {\n        super(...arguments);\n        /** @internal */\n        this._optionMap = new Map();\n        /** @internal */\n        this._idCounter = 0;\n        this._compareWith = Object.is;\n    }\n    /**\n     * @description\n     * Tracks the option comparison algorithm for tracking identities when\n     * checking for changes.\n     */\n    set compareWith(fn) {\n        if (typeof fn !== 'function' && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw new ɵRuntimeError(1201 /* RuntimeErrorCode.COMPAREWITH_NOT_A_FN */, `compareWith must be a function, but received ${JSON.stringify(fn)}`);\n        }\n        this._compareWith = fn;\n    }\n    /**\n     * Sets the \"value\" property on one or of more of the select's options.\n     * @nodoc\n     */\n    writeValue(value) {\n        this.value = value;\n        let optionSelectedStateSetter;\n        if (Array.isArray(value)) {\n            // convert values to ids\n            const ids = value.map((v) => this._getOptionId(v));\n            optionSelectedStateSetter = (opt, o) => {\n                opt._setSelected(ids.indexOf(o.toString()) > -1);\n            };\n        }\n        else {\n            optionSelectedStateSetter = (opt, o) => {\n                opt._setSelected(false);\n            };\n        }\n        this._optionMap.forEach(optionSelectedStateSetter);\n    }\n    /**\n     * Registers a function called when the control value changes\n     * and writes an array of the selected options.\n     * @nodoc\n     */\n    registerOnChange(fn) {\n        this.onChange = (element) => {\n            const selected = [];\n            const selectedOptions = element.selectedOptions;\n            if (selectedOptions !== undefined) {\n                const options = selectedOptions;\n                for (let i = 0; i < options.length; i++) {\n                    const opt = options[i];\n                    const val = this._getOptionValue(opt.value);\n                    selected.push(val);\n                }\n            }\n            // Degrade to use `options` when `selectedOptions` property is not available.\n            // Note: the `selectedOptions` is available in all supported browsers, but the Domino lib\n            // doesn't have it currently, see https://github.com/fgnass/domino/issues/177.\n            else {\n                const options = element.options;\n                for (let i = 0; i < options.length; i++) {\n                    const opt = options[i];\n                    if (opt.selected) {\n                        const val = this._getOptionValue(opt.value);\n                        selected.push(val);\n                    }\n                }\n            }\n            this.value = selected;\n            fn(selected);\n        };\n    }\n    /** @internal */\n    _registerOption(value) {\n        const id = (this._idCounter++).toString();\n        this._optionMap.set(id, value);\n        return id;\n    }\n    /** @internal */\n    _getOptionId(value) {\n        for (const id of Array.from(this._optionMap.keys())) {\n            if (this._compareWith(this._optionMap.get(id)._value, value))\n                return id;\n        }\n        return null;\n    }\n    /** @internal */\n    _getOptionValue(valueString) {\n        const id = _extractId(valueString);\n        return this._optionMap.has(id) ? this._optionMap.get(id)._value : valueString;\n    }\n}\nSelectMultipleControlValueAccessor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: SelectMultipleControlValueAccessor, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nSelectMultipleControlValueAccessor.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: SelectMultipleControlValueAccessor, selector: \"select[multiple][formControlName],select[multiple][formControl],select[multiple][ngModel]\", inputs: { compareWith: \"compareWith\" }, host: { listeners: { \"change\": \"onChange($event.target)\", \"blur\": \"onTouched()\" } }, providers: [SELECT_MULTIPLE_VALUE_ACCESSOR], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: SelectMultipleControlValueAccessor, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'select[multiple][formControlName],select[multiple][formControl],select[multiple][ngModel]',\n                    host: { '(change)': 'onChange($event.target)', '(blur)': 'onTouched()' },\n                    providers: [SELECT_MULTIPLE_VALUE_ACCESSOR]\n                }]\n        }], propDecorators: { compareWith: [{\n                type: Input\n            }] } });\n/**\n * @description\n * Marks `<option>` as dynamic, so Angular can be notified when options change.\n *\n * @see `SelectMultipleControlValueAccessor`\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass ɵNgSelectMultipleOption {\n    constructor(_element, _renderer, _select) {\n        this._element = _element;\n        this._renderer = _renderer;\n        this._select = _select;\n        if (this._select) {\n            this.id = this._select._registerOption(this);\n        }\n    }\n    /**\n     * @description\n     * Tracks the value bound to the option element. Unlike the value binding,\n     * ngValue supports binding to objects.\n     */\n    set ngValue(value) {\n        if (this._select == null)\n            return;\n        this._value = value;\n        this._setElementValue(_buildValueString(this.id, value));\n        this._select.writeValue(this._select.value);\n    }\n    /**\n     * @description\n     * Tracks simple string values bound to the option element.\n     * For objects, use the `ngValue` input binding.\n     */\n    set value(value) {\n        if (this._select) {\n            this._value = value;\n            this._setElementValue(_buildValueString(this.id, value));\n            this._select.writeValue(this._select.value);\n        }\n        else {\n            this._setElementValue(value);\n        }\n    }\n    /** @internal */\n    _setElementValue(value) {\n        this._renderer.setProperty(this._element.nativeElement, 'value', value);\n    }\n    /** @internal */\n    _setSelected(selected) {\n        this._renderer.setProperty(this._element.nativeElement, 'selected', selected);\n    }\n    /** @nodoc */\n    ngOnDestroy() {\n        if (this._select) {\n            this._select._optionMap.delete(this.id);\n            this._select.writeValue(this._select.value);\n        }\n    }\n}\nɵNgSelectMultipleOption.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: ɵNgSelectMultipleOption, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: SelectMultipleControlValueAccessor, host: true, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nɵNgSelectMultipleOption.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: ɵNgSelectMultipleOption, selector: \"option\", inputs: { ngValue: \"ngValue\", value: \"value\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: ɵNgSelectMultipleOption, decorators: [{\n            type: Directive,\n            args: [{ selector: 'option' }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: SelectMultipleControlValueAccessor, decorators: [{\n                    type: Optional\n                }, {\n                    type: Host\n                }] }]; }, propDecorators: { ngValue: [{\n                type: Input,\n                args: ['ngValue']\n            }], value: [{\n                type: Input,\n                args: ['value']\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Method that updates string to integer if not already a number\n *\n * @param value The value to convert to integer.\n * @returns value of parameter converted to number or integer.\n */\nfunction toInteger(value) {\n    return typeof value === 'number' ? value : parseInt(value, 10);\n}\n/**\n * Method that ensures that provided value is a float (and converts it to float if needed).\n *\n * @param value The value to convert to float.\n * @returns value of parameter converted to number or float.\n */\nfunction toFloat(value) {\n    return typeof value === 'number' ? value : parseFloat(value);\n}\n/**\n * A base class for Validator-based Directives. The class contains common logic shared across such\n * Directives.\n *\n * For internal use only, this class is not intended for use outside of the Forms package.\n */\nclass AbstractValidatorDirective {\n    constructor() {\n        this._validator = nullValidator;\n    }\n    /** @nodoc */\n    ngOnChanges(changes) {\n        if (this.inputName in changes) {\n            const input = this.normalizeInput(changes[this.inputName].currentValue);\n            this._enabled = this.enabled(input);\n            this._validator = this._enabled ? this.createValidator(input) : nullValidator;\n            if (this._onChange) {\n                this._onChange();\n            }\n        }\n    }\n    /** @nodoc */\n    validate(control) {\n        return this._validator(control);\n    }\n    /** @nodoc */\n    registerOnValidatorChange(fn) {\n        this._onChange = fn;\n    }\n    /**\n     * @description\n     * Determines whether this validator should be active or not based on an input.\n     * Base class implementation checks whether an input is defined (if the value is different from\n     * `null` and `undefined`). Validator classes that extend this base class can override this\n     * function with the logic specific to a particular validator directive.\n     */\n    enabled(input) {\n        return input != null /* both `null` and `undefined` */;\n    }\n}\nAbstractValidatorDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: AbstractValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nAbstractValidatorDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: AbstractValidatorDirective, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: AbstractValidatorDirective, decorators: [{\n            type: Directive\n        }] });\n/**\n * @description\n * Provider which adds `MaxValidator` to the `NG_VALIDATORS` multi-provider list.\n */\nconst MAX_VALIDATOR = {\n    provide: NG_VALIDATORS,\n    useExisting: forwardRef(() => MaxValidator),\n    multi: true\n};\n/**\n * A directive which installs the {@link MaxValidator} for any `formControlName`,\n * `formControl`, or control with `ngModel` that also has a `max` attribute.\n *\n * @see [Form Validation](guide/form-validation)\n *\n * @usageNotes\n *\n * ### Adding a max validator\n *\n * The following example shows how to add a max validator to an input attached to an\n * ngModel binding.\n *\n * ```html\n * <input type=\"number\" ngModel max=\"4\">\n * ```\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass MaxValidator extends AbstractValidatorDirective {\n    constructor() {\n        super(...arguments);\n        /** @internal */\n        this.inputName = 'max';\n        /** @internal */\n        this.normalizeInput = (input) => toFloat(input);\n        /** @internal */\n        this.createValidator = (max) => maxValidator(max);\n    }\n}\nMaxValidator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: MaxValidator, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMaxValidator.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: MaxValidator, selector: \"input[type=number][max][formControlName],input[type=number][max][formControl],input[type=number][max][ngModel]\", inputs: { max: \"max\" }, host: { properties: { \"attr.max\": \"_enabled ? max : null\" } }, providers: [MAX_VALIDATOR], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: MaxValidator, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'input[type=number][max][formControlName],input[type=number][max][formControl],input[type=number][max][ngModel]',\n                    providers: [MAX_VALIDATOR],\n                    host: { '[attr.max]': '_enabled ? max : null' }\n                }]\n        }], propDecorators: { max: [{\n                type: Input\n            }] } });\n/**\n * @description\n * Provider which adds `MinValidator` to the `NG_VALIDATORS` multi-provider list.\n */\nconst MIN_VALIDATOR = {\n    provide: NG_VALIDATORS,\n    useExisting: forwardRef(() => MinValidator),\n    multi: true\n};\n/**\n * A directive which installs the {@link MinValidator} for any `formControlName`,\n * `formControl`, or control with `ngModel` that also has a `min` attribute.\n *\n * @see [Form Validation](guide/form-validation)\n *\n * @usageNotes\n *\n * ### Adding a min validator\n *\n * The following example shows how to add a min validator to an input attached to an\n * ngModel binding.\n *\n * ```html\n * <input type=\"number\" ngModel min=\"4\">\n * ```\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass MinValidator extends AbstractValidatorDirective {\n    constructor() {\n        super(...arguments);\n        /** @internal */\n        this.inputName = 'min';\n        /** @internal */\n        this.normalizeInput = (input) => toFloat(input);\n        /** @internal */\n        this.createValidator = (min) => minValidator(min);\n    }\n}\nMinValidator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: MinValidator, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMinValidator.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: MinValidator, selector: \"input[type=number][min][formControlName],input[type=number][min][formControl],input[type=number][min][ngModel]\", inputs: { min: \"min\" }, host: { properties: { \"attr.min\": \"_enabled ? min : null\" } }, providers: [MIN_VALIDATOR], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: MinValidator, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'input[type=number][min][formControlName],input[type=number][min][formControl],input[type=number][min][ngModel]',\n                    providers: [MIN_VALIDATOR],\n                    host: { '[attr.min]': '_enabled ? min : null' }\n                }]\n        }], propDecorators: { min: [{\n                type: Input\n            }] } });\n/**\n * @description\n * Provider which adds `RequiredValidator` to the `NG_VALIDATORS` multi-provider list.\n */\nconst REQUIRED_VALIDATOR = {\n    provide: NG_VALIDATORS,\n    useExisting: forwardRef(() => RequiredValidator),\n    multi: true\n};\n/**\n * @description\n * Provider which adds `CheckboxRequiredValidator` to the `NG_VALIDATORS` multi-provider list.\n */\nconst CHECKBOX_REQUIRED_VALIDATOR = {\n    provide: NG_VALIDATORS,\n    useExisting: forwardRef(() => CheckboxRequiredValidator),\n    multi: true\n};\n/**\n * @description\n * A directive that adds the `required` validator to any controls marked with the\n * `required` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.\n *\n * @see [Form Validation](guide/form-validation)\n *\n * @usageNotes\n *\n * ### Adding a required validator using template-driven forms\n *\n * ```\n * <input name=\"fullName\" ngModel required>\n * ```\n *\n * @ngModule FormsModule\n * @ngModule ReactiveFormsModule\n * @publicApi\n */\nclass RequiredValidator extends AbstractValidatorDirective {\n    constructor() {\n        super(...arguments);\n        /** @internal */\n        this.inputName = 'required';\n        /** @internal */\n        this.normalizeInput = ɵcoerceToBoolean;\n        /** @internal */\n        this.createValidator = (input) => requiredValidator;\n    }\n    /** @nodoc */\n    enabled(input) {\n        return input;\n    }\n}\nRequiredValidator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: RequiredValidator, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nRequiredValidator.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: RequiredValidator, selector: \":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]\", inputs: { required: \"required\" }, host: { properties: { \"attr.required\": \"_enabled ? \\\"\\\" : null\" } }, providers: [REQUIRED_VALIDATOR], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: RequiredValidator, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: ':not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]',\n                    providers: [REQUIRED_VALIDATOR],\n                    host: { '[attr.required]': '_enabled ? \"\" : null' }\n                }]\n        }], propDecorators: { required: [{\n                type: Input\n            }] } });\n/**\n * A Directive that adds the `required` validator to checkbox controls marked with the\n * `required` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.\n *\n * @see [Form Validation](guide/form-validation)\n *\n * @usageNotes\n *\n * ### Adding a required checkbox validator using template-driven forms\n *\n * The following example shows how to add a checkbox required validator to an input attached to an\n * ngModel binding.\n *\n * ```\n * <input type=\"checkbox\" name=\"active\" ngModel required>\n * ```\n *\n * @publicApi\n * @ngModule FormsModule\n * @ngModule ReactiveFormsModule\n */\nclass CheckboxRequiredValidator extends RequiredValidator {\n    constructor() {\n        super(...arguments);\n        /** @internal */\n        this.createValidator = (input) => requiredTrueValidator;\n    }\n}\nCheckboxRequiredValidator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: CheckboxRequiredValidator, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nCheckboxRequiredValidator.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: CheckboxRequiredValidator, selector: \"input[type=checkbox][required][formControlName],input[type=checkbox][required][formControl],input[type=checkbox][required][ngModel]\", host: { properties: { \"attr.required\": \"_enabled ? \\\"\\\" : null\" } }, providers: [CHECKBOX_REQUIRED_VALIDATOR], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: CheckboxRequiredValidator, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'input[type=checkbox][required][formControlName],input[type=checkbox][required][formControl],input[type=checkbox][required][ngModel]',\n                    providers: [CHECKBOX_REQUIRED_VALIDATOR],\n                    host: { '[attr.required]': '_enabled ? \"\" : null' }\n                }]\n        }] });\n/**\n * @description\n * Provider which adds `EmailValidator` to the `NG_VALIDATORS` multi-provider list.\n */\nconst EMAIL_VALIDATOR = {\n    provide: NG_VALIDATORS,\n    useExisting: forwardRef(() => EmailValidator),\n    multi: true\n};\n/**\n * A directive that adds the `email` validator to controls marked with the\n * `email` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.\n *\n * The email validation is based on the WHATWG HTML specification with some enhancements to\n * incorporate more RFC rules. More information can be found on the [Validators.email\n * page](api/forms/Validators#email).\n *\n * @see [Form Validation](guide/form-validation)\n *\n * @usageNotes\n *\n * ### Adding an email validator\n *\n * The following example shows how to add an email validator to an input attached to an ngModel\n * binding.\n *\n * ```\n * <input type=\"email\" name=\"email\" ngModel email>\n * <input type=\"email\" name=\"email\" ngModel email=\"true\">\n * <input type=\"email\" name=\"email\" ngModel [email]=\"true\">\n * ```\n *\n * @publicApi\n * @ngModule FormsModule\n * @ngModule ReactiveFormsModule\n */\nclass EmailValidator extends AbstractValidatorDirective {\n    constructor() {\n        super(...arguments);\n        /** @internal */\n        this.inputName = 'email';\n        /** @internal */\n        this.normalizeInput = ɵcoerceToBoolean;\n        /** @internal */\n        this.createValidator = (input) => emailValidator;\n    }\n    /** @nodoc */\n    enabled(input) {\n        return input;\n    }\n}\nEmailValidator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: EmailValidator, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nEmailValidator.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: EmailValidator, selector: \"[email][formControlName],[email][formControl],[email][ngModel]\", inputs: { email: \"email\" }, providers: [EMAIL_VALIDATOR], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: EmailValidator, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[email][formControlName],[email][formControl],[email][ngModel]',\n                    providers: [EMAIL_VALIDATOR]\n                }]\n        }], propDecorators: { email: [{\n                type: Input\n            }] } });\n/**\n * @description\n * Provider which adds `MinLengthValidator` to the `NG_VALIDATORS` multi-provider list.\n */\nconst MIN_LENGTH_VALIDATOR = {\n    provide: NG_VALIDATORS,\n    useExisting: forwardRef(() => MinLengthValidator),\n    multi: true\n};\n/**\n * A directive that adds minimum length validation to controls marked with the\n * `minlength` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.\n *\n * @see [Form Validation](guide/form-validation)\n *\n * @usageNotes\n *\n * ### Adding a minimum length validator\n *\n * The following example shows how to add a minimum length validator to an input attached to an\n * ngModel binding.\n *\n * ```html\n * <input name=\"firstName\" ngModel minlength=\"4\">\n * ```\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass MinLengthValidator extends AbstractValidatorDirective {\n    constructor() {\n        super(...arguments);\n        /** @internal */\n        this.inputName = 'minlength';\n        /** @internal */\n        this.normalizeInput = (input) => toInteger(input);\n        /** @internal */\n        this.createValidator = (minlength) => minLengthValidator(minlength);\n    }\n}\nMinLengthValidator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: MinLengthValidator, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMinLengthValidator.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: MinLengthValidator, selector: \"[minlength][formControlName],[minlength][formControl],[minlength][ngModel]\", inputs: { minlength: \"minlength\" }, host: { properties: { \"attr.minlength\": \"_enabled ? minlength : null\" } }, providers: [MIN_LENGTH_VALIDATOR], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: MinLengthValidator, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[minlength][formControlName],[minlength][formControl],[minlength][ngModel]',\n                    providers: [MIN_LENGTH_VALIDATOR],\n                    host: { '[attr.minlength]': '_enabled ? minlength : null' }\n                }]\n        }], propDecorators: { minlength: [{\n                type: Input\n            }] } });\n/**\n * @description\n * Provider which adds `MaxLengthValidator` to the `NG_VALIDATORS` multi-provider list.\n */\nconst MAX_LENGTH_VALIDATOR = {\n    provide: NG_VALIDATORS,\n    useExisting: forwardRef(() => MaxLengthValidator),\n    multi: true\n};\n/**\n * A directive that adds max length validation to controls marked with the\n * `maxlength` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.\n *\n * @see [Form Validation](guide/form-validation)\n *\n * @usageNotes\n *\n * ### Adding a maximum length validator\n *\n * The following example shows how to add a maximum length validator to an input attached to an\n * ngModel binding.\n *\n * ```html\n * <input name=\"firstName\" ngModel maxlength=\"25\">\n * ```\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass MaxLengthValidator extends AbstractValidatorDirective {\n    constructor() {\n        super(...arguments);\n        /** @internal */\n        this.inputName = 'maxlength';\n        /** @internal */\n        this.normalizeInput = (input) => toInteger(input);\n        /** @internal */\n        this.createValidator = (maxlength) => maxLengthValidator(maxlength);\n    }\n}\nMaxLengthValidator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: MaxLengthValidator, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMaxLengthValidator.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: MaxLengthValidator, selector: \"[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]\", inputs: { maxlength: \"maxlength\" }, host: { properties: { \"attr.maxlength\": \"_enabled ? maxlength : null\" } }, providers: [MAX_LENGTH_VALIDATOR], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: MaxLengthValidator, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]',\n                    providers: [MAX_LENGTH_VALIDATOR],\n                    host: { '[attr.maxlength]': '_enabled ? maxlength : null' }\n                }]\n        }], propDecorators: { maxlength: [{\n                type: Input\n            }] } });\n/**\n * @description\n * Provider which adds `PatternValidator` to the `NG_VALIDATORS` multi-provider list.\n */\nconst PATTERN_VALIDATOR = {\n    provide: NG_VALIDATORS,\n    useExisting: forwardRef(() => PatternValidator),\n    multi: true\n};\n/**\n * @description\n * A directive that adds regex pattern validation to controls marked with the\n * `pattern` attribute. The regex must match the entire control value.\n * The directive is provided with the `NG_VALIDATORS` multi-provider list.\n *\n * @see [Form Validation](guide/form-validation)\n *\n * @usageNotes\n *\n * ### Adding a pattern validator\n *\n * The following example shows how to add a pattern validator to an input attached to an\n * ngModel binding.\n *\n * ```html\n * <input name=\"firstName\" ngModel pattern=\"[a-zA-Z ]*\">\n * ```\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass PatternValidator extends AbstractValidatorDirective {\n    constructor() {\n        super(...arguments);\n        /** @internal */\n        this.inputName = 'pattern';\n        /** @internal */\n        this.normalizeInput = (input) => input;\n        /** @internal */\n        this.createValidator = (input) => patternValidator(input);\n    }\n}\nPatternValidator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: PatternValidator, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nPatternValidator.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.3.0\", type: PatternValidator, selector: \"[pattern][formControlName],[pattern][formControl],[pattern][ngModel]\", inputs: { pattern: \"pattern\" }, host: { properties: { \"attr.pattern\": \"_enabled ? pattern : null\" } }, providers: [PATTERN_VALIDATOR], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: PatternValidator, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[pattern][formControlName],[pattern][formControl],[pattern][ngModel]',\n                    providers: [PATTERN_VALIDATOR],\n                    host: { '[attr.pattern]': '_enabled ? pattern : null' }\n                }]\n        }], propDecorators: { pattern: [{\n                type: Input\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 */\nconst SHARED_FORM_DIRECTIVES = [\n    ɵNgNoValidate,\n    NgSelectOption,\n    ɵNgSelectMultipleOption,\n    DefaultValueAccessor,\n    NumberValueAccessor,\n    RangeValueAccessor,\n    CheckboxControlValueAccessor,\n    SelectControlValueAccessor,\n    SelectMultipleControlValueAccessor,\n    RadioControlValueAccessor,\n    NgControlStatus,\n    NgControlStatusGroup,\n    RequiredValidator,\n    MinLengthValidator,\n    MaxLengthValidator,\n    PatternValidator,\n    CheckboxRequiredValidator,\n    EmailValidator,\n    MinValidator,\n    MaxValidator,\n];\nconst TEMPLATE_DRIVEN_DIRECTIVES = [NgModel, NgModelGroup, NgForm];\nconst REACTIVE_DRIVEN_DIRECTIVES = [FormControlDirective, FormGroupDirective, FormControlName, FormGroupName, FormArrayName];\n/**\n * Internal module used for sharing directives between FormsModule and ReactiveFormsModule\n */\nclass ɵInternalFormsSharedModule {\n}\nɵInternalFormsSharedModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: ɵInternalFormsSharedModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nɵInternalFormsSharedModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"14.3.0\", ngImport: i0, type: ɵInternalFormsSharedModule, declarations: [ɵNgNoValidate,\n        NgSelectOption,\n        ɵNgSelectMultipleOption,\n        DefaultValueAccessor,\n        NumberValueAccessor,\n        RangeValueAccessor,\n        CheckboxControlValueAccessor,\n        SelectControlValueAccessor,\n        SelectMultipleControlValueAccessor,\n        RadioControlValueAccessor,\n        NgControlStatus,\n        NgControlStatusGroup,\n        RequiredValidator,\n        MinLengthValidator,\n        MaxLengthValidator,\n        PatternValidator,\n        CheckboxRequiredValidator,\n        EmailValidator,\n        MinValidator,\n        MaxValidator], imports: [RadioControlRegistryModule], exports: [ɵNgNoValidate,\n        NgSelectOption,\n        ɵNgSelectMultipleOption,\n        DefaultValueAccessor,\n        NumberValueAccessor,\n        RangeValueAccessor,\n        CheckboxControlValueAccessor,\n        SelectControlValueAccessor,\n        SelectMultipleControlValueAccessor,\n        RadioControlValueAccessor,\n        NgControlStatus,\n        NgControlStatusGroup,\n        RequiredValidator,\n        MinLengthValidator,\n        MaxLengthValidator,\n        PatternValidator,\n        CheckboxRequiredValidator,\n        EmailValidator,\n        MinValidator,\n        MaxValidator] });\nɵInternalFormsSharedModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: ɵInternalFormsSharedModule, imports: [RadioControlRegistryModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: ɵInternalFormsSharedModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    declarations: SHARED_FORM_DIRECTIVES,\n                    imports: [RadioControlRegistryModule],\n                    exports: SHARED_FORM_DIRECTIVES,\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Exports the required providers and directives for template-driven forms,\n * making them available for import by NgModules that import this module.\n *\n * Providers associated with this module:\n * * `RadioControlRegistry`\n *\n * @see [Forms Overview](/guide/forms-overview)\n * @see [Template-driven Forms Guide](/guide/forms)\n *\n * @publicApi\n */\nclass FormsModule {\n}\nFormsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: FormsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nFormsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"14.3.0\", ngImport: i0, type: FormsModule, declarations: [NgModel, NgModelGroup, NgForm], exports: [ɵInternalFormsSharedModule, NgModel, NgModelGroup, NgForm] });\nFormsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: FormsModule, imports: [ɵInternalFormsSharedModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: FormsModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    declarations: TEMPLATE_DRIVEN_DIRECTIVES,\n                    exports: [ɵInternalFormsSharedModule, TEMPLATE_DRIVEN_DIRECTIVES]\n                }]\n        }] });\n/**\n * Exports the required infrastructure and directives for reactive forms,\n * making them available for import by NgModules that import this module.\n *\n * Providers associated with this module:\n * * `FormBuilder`\n * * `RadioControlRegistry`\n *\n * @see [Forms Overview](guide/forms-overview)\n * @see [Reactive Forms Guide](guide/reactive-forms)\n *\n * @publicApi\n */\nclass ReactiveFormsModule {\n    /**\n     * @description\n     * Provides options for configuring the reactive forms module.\n     *\n     * @param opts An object of configuration options\n     * * `warnOnNgModelWithFormControl` Configures when to emit a warning when an `ngModel`\n     * binding is used with reactive form directives.\n     */\n    static withConfig(opts) {\n        return {\n            ngModule: ReactiveFormsModule,\n            providers: [\n                { provide: NG_MODEL_WITH_FORM_CONTROL_WARNING, useValue: opts.warnOnNgModelWithFormControl }\n            ]\n        };\n    }\n}\nReactiveFormsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: ReactiveFormsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nReactiveFormsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"14.3.0\", ngImport: i0, type: ReactiveFormsModule, declarations: [FormControlDirective, FormGroupDirective, FormControlName, FormGroupName, FormArrayName], exports: [ɵInternalFormsSharedModule, FormControlDirective, FormGroupDirective, FormControlName, FormGroupName, FormArrayName] });\nReactiveFormsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: ReactiveFormsModule, imports: [ɵInternalFormsSharedModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: ReactiveFormsModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    declarations: [REACTIVE_DRIVEN_DIRECTIVES],\n                    exports: [ɵInternalFormsSharedModule, REACTIVE_DRIVEN_DIRECTIVES]\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Tracks the value and validity state of an array of `FormControl`,\n * `FormGroup` or `FormArray` instances.\n *\n * A `FormArray` aggregates the values of each child `FormControl` into an array.\n * It calculates its status by reducing the status values of its children. For example, if one of\n * the controls in a `FormArray` is invalid, the entire array becomes invalid.\n *\n * `FormArray` accepts one generic argument, which is the type of the controls inside.\n * If you need a heterogenous array, use {@link UntypedFormArray}.\n *\n * `FormArray` is one of the four fundamental building blocks used to define forms in Angular,\n * along with `FormControl`, `FormGroup`, and `FormRecord`.\n *\n * @usageNotes\n *\n * ### Create an array of form controls\n *\n * ```\n * const arr = new FormArray([\n *   new FormControl('Nancy', Validators.minLength(2)),\n *   new FormControl('Drew'),\n * ]);\n *\n * console.log(arr.value);   // ['Nancy', 'Drew']\n * console.log(arr.status);  // 'VALID'\n * ```\n *\n * ### Create a form array with array-level validators\n *\n * You include array-level validators and async validators. These come in handy\n * when you want to perform validation that considers the value of more than one child\n * control.\n *\n * The two types of validators are passed in separately as the second and third arg\n * respectively, or together as part of an options object.\n *\n * ```\n * const arr = new FormArray([\n *   new FormControl('Nancy'),\n *   new FormControl('Drew')\n * ], {validators: myValidator, asyncValidators: myAsyncValidator});\n * ```\n *\n * ### Set the updateOn property for all controls in a form array\n *\n * The options object is used to set a default value for each child\n * control's `updateOn` property. If you set `updateOn` to `'blur'` at the\n * array level, all child controls default to 'blur', unless the child\n * has explicitly specified a different `updateOn` value.\n *\n * ```ts\n * const arr = new FormArray([\n *    new FormControl()\n * ], {updateOn: 'blur'});\n * ```\n *\n * ### Adding or removing controls from a form array\n *\n * To change the controls in the array, use the `push`, `insert`, `removeAt` or `clear` methods\n * in `FormArray` itself. These methods ensure the controls are properly tracked in the\n * form's hierarchy. Do not modify the array of `AbstractControl`s used to instantiate\n * the `FormArray` directly, as that result in strange and unexpected behavior such\n * as broken change detection.\n *\n * @publicApi\n */\nclass FormArray extends AbstractControl {\n    /**\n     * Creates a new `FormArray` instance.\n     *\n     * @param controls An array of child controls. Each child control is given an index\n     * where it is registered.\n     *\n     * @param validatorOrOpts A synchronous validator function, or an array of\n     * such functions, or an `AbstractControlOptions` object that contains validation functions\n     * and a validation trigger.\n     *\n     * @param asyncValidator A single async validator or array of async validator functions\n     *\n     */\n    constructor(controls, validatorOrOpts, asyncValidator) {\n        super(pickValidators(validatorOrOpts), pickAsyncValidators(asyncValidator, validatorOrOpts));\n        this.controls = controls;\n        this._initObservables();\n        this._setUpdateStrategy(validatorOrOpts);\n        this._setUpControls();\n        this.updateValueAndValidity({\n            onlySelf: true,\n            // If `asyncValidator` is present, it will trigger control status change from `PENDING` to\n            // `VALID` or `INVALID`.\n            // The status should be broadcasted via the `statusChanges` observable, so we set `emitEvent`\n            // to `true` to allow that during the control creation process.\n            emitEvent: !!this.asyncValidator\n        });\n    }\n    /**\n     * Get the `AbstractControl` at the given `index` in the array.\n     *\n     * @param index Index in the array to retrieve the control. If `index` is negative, it will wrap\n     *     around from the back, and if index is greatly negative (less than `-length`), the result is\n     * undefined. This behavior is the same as `Array.at(index)`.\n     */\n    at(index) {\n        return this.controls[this._adjustIndex(index)];\n    }\n    /**\n     * Insert a new `AbstractControl` at the end of the array.\n     *\n     * @param control Form control to be inserted\n     * @param options Specifies whether this FormArray instance should emit events after a new\n     *     control is added.\n     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n     * `valueChanges` observables emit events with the latest status and value when the control is\n     * inserted. When false, no events are emitted.\n     */\n    push(control, options = {}) {\n        this.controls.push(control);\n        this._registerControl(control);\n        this.updateValueAndValidity({ emitEvent: options.emitEvent });\n        this._onCollectionChange();\n    }\n    /**\n     * Insert a new `AbstractControl` at the given `index` in the array.\n     *\n     * @param index Index in the array to insert the control. If `index` is negative, wraps around\n     *     from the back. If `index` is greatly negative (less than `-length`), prepends to the array.\n     * This behavior is the same as `Array.splice(index, 0, control)`.\n     * @param control Form control to be inserted\n     * @param options Specifies whether this FormArray instance should emit events after a new\n     *     control is inserted.\n     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n     * `valueChanges` observables emit events with the latest status and value when the control is\n     * inserted. When false, no events are emitted.\n     */\n    insert(index, control, options = {}) {\n        this.controls.splice(index, 0, control);\n        this._registerControl(control);\n        this.updateValueAndValidity({ emitEvent: options.emitEvent });\n    }\n    /**\n     * Remove the control at the given `index` in the array.\n     *\n     * @param index Index in the array to remove the control.  If `index` is negative, wraps around\n     *     from the back. If `index` is greatly negative (less than `-length`), removes the first\n     *     element. This behavior is the same as `Array.splice(index, 1)`.\n     * @param options Specifies whether this FormArray instance should emit events after a\n     *     control is removed.\n     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n     * `valueChanges` observables emit events with the latest status and value when the control is\n     * removed. When false, no events are emitted.\n     */\n    removeAt(index, options = {}) {\n        // Adjust the index, then clamp it at no less than 0 to prevent undesired underflows.\n        let adjustedIndex = this._adjustIndex(index);\n        if (adjustedIndex < 0)\n            adjustedIndex = 0;\n        if (this.controls[adjustedIndex])\n            this.controls[adjustedIndex]._registerOnCollectionChange(() => { });\n        this.controls.splice(adjustedIndex, 1);\n        this.updateValueAndValidity({ emitEvent: options.emitEvent });\n    }\n    /**\n     * Replace an existing control.\n     *\n     * @param index Index in the array to replace the control. If `index` is negative, wraps around\n     *     from the back. If `index` is greatly negative (less than `-length`), replaces the first\n     *     element. This behavior is the same as `Array.splice(index, 1, control)`.\n     * @param control The `AbstractControl` control to replace the existing control\n     * @param options Specifies whether this FormArray instance should emit events after an\n     *     existing control is replaced with a new one.\n     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n     * `valueChanges` observables emit events with the latest status and value when the control is\n     * replaced with a new one. When false, no events are emitted.\n     */\n    setControl(index, control, options = {}) {\n        // Adjust the index, then clamp it at no less than 0 to prevent undesired underflows.\n        let adjustedIndex = this._adjustIndex(index);\n        if (adjustedIndex < 0)\n            adjustedIndex = 0;\n        if (this.controls[adjustedIndex])\n            this.controls[adjustedIndex]._registerOnCollectionChange(() => { });\n        this.controls.splice(adjustedIndex, 1);\n        if (control) {\n            this.controls.splice(adjustedIndex, 0, control);\n            this._registerControl(control);\n        }\n        this.updateValueAndValidity({ emitEvent: options.emitEvent });\n        this._onCollectionChange();\n    }\n    /**\n     * Length of the control array.\n     */\n    get length() {\n        return this.controls.length;\n    }\n    /**\n     * Sets the value of the `FormArray`. It accepts an array that matches\n     * the structure of the control.\n     *\n     * This method performs strict checks, and throws an error if you try\n     * to set the value of a control that doesn't exist or if you exclude the\n     * value of a control.\n     *\n     * @usageNotes\n     * ### Set the values for the controls in the form array\n     *\n     * ```\n     * const arr = new FormArray([\n     *   new FormControl(),\n     *   new FormControl()\n     * ]);\n     * console.log(arr.value);   // [null, null]\n     *\n     * arr.setValue(['Nancy', 'Drew']);\n     * console.log(arr.value);   // ['Nancy', 'Drew']\n     * ```\n     *\n     * @param value Array of values for the controls\n     * @param options Configure options that determine how the control propagates changes and\n     * emits events after the value changes\n     *\n     * * `onlySelf`: When true, each change only affects this control, and not its parent. Default\n     * is false.\n     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n     * `valueChanges`\n     * observables emit events with the latest status and value when the control value is updated.\n     * When false, no events are emitted.\n     * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity\n     * updateValueAndValidity} method.\n     */\n    setValue(value, options = {}) {\n        assertAllValuesPresent(this, false, value);\n        value.forEach((newValue, index) => {\n            assertControlPresent(this, false, index);\n            this.at(index).setValue(newValue, { onlySelf: true, emitEvent: options.emitEvent });\n        });\n        this.updateValueAndValidity(options);\n    }\n    /**\n     * Patches the value of the `FormArray`. It accepts an array that matches the\n     * structure of the control, and does its best to match the values to the correct\n     * controls in the group.\n     *\n     * It accepts both super-sets and sub-sets of the array without throwing an error.\n     *\n     * @usageNotes\n     * ### Patch the values for controls in a form array\n     *\n     * ```\n     * const arr = new FormArray([\n     *    new FormControl(),\n     *    new FormControl()\n     * ]);\n     * console.log(arr.value);   // [null, null]\n     *\n     * arr.patchValue(['Nancy']);\n     * console.log(arr.value);   // ['Nancy', null]\n     * ```\n     *\n     * @param value Array of latest values for the controls\n     * @param options Configure options that determine how the control propagates changes and\n     * emits events after the value changes\n     *\n     * * `onlySelf`: When true, each change only affects this control, and not its parent. Default\n     * is false.\n     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n     * `valueChanges` observables emit events with the latest status and value when the control\n     * value is updated. When false, no events are emitted. The configuration options are passed to\n     * the {@link AbstractControl#updateValueAndValidity updateValueAndValidity} method.\n     */\n    patchValue(value, options = {}) {\n        // Even though the `value` argument type doesn't allow `null` and `undefined` values, the\n        // `patchValue` can be called recursively and inner data structures might have these values,\n        // so we just ignore such cases when a field containing FormArray instance receives `null` or\n        // `undefined` as a value.\n        if (value == null /* both `null` and `undefined` */)\n            return;\n        value.forEach((newValue, index) => {\n            if (this.at(index)) {\n                this.at(index).patchValue(newValue, { onlySelf: true, emitEvent: options.emitEvent });\n            }\n        });\n        this.updateValueAndValidity(options);\n    }\n    /**\n     * Resets the `FormArray` and all descendants are marked `pristine` and `untouched`, and the\n     * value of all descendants to null or null maps.\n     *\n     * You reset to a specific form state by passing in an array of states\n     * that matches the structure of the control. The state is a standalone value\n     * or a form state object with both a value and a disabled status.\n     *\n     * @usageNotes\n     * ### Reset the values in a form array\n     *\n     * ```ts\n     * const arr = new FormArray([\n     *    new FormControl(),\n     *    new FormControl()\n     * ]);\n     * arr.reset(['name', 'last name']);\n     *\n     * console.log(arr.value);  // ['name', 'last name']\n     * ```\n     *\n     * ### Reset the values in a form array and the disabled status for the first control\n     *\n     * ```\n     * arr.reset([\n     *   {value: 'name', disabled: true},\n     *   'last'\n     * ]);\n     *\n     * console.log(arr.value);  // ['last']\n     * console.log(arr.at(0).status);  // 'DISABLED'\n     * ```\n     *\n     * @param value Array of values for the controls\n     * @param options Configure options that determine how the control propagates changes and\n     * emits events after the value changes\n     *\n     * * `onlySelf`: When true, each change only affects this control, and not its parent. Default\n     * is false.\n     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n     * `valueChanges`\n     * observables emit events with the latest status and value when the control is reset.\n     * When false, no events are emitted.\n     * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity\n     * updateValueAndValidity} method.\n     */\n    reset(value = [], options = {}) {\n        this._forEachChild((control, index) => {\n            control.reset(value[index], { onlySelf: true, emitEvent: options.emitEvent });\n        });\n        this._updatePristine(options);\n        this._updateTouched(options);\n        this.updateValueAndValidity(options);\n    }\n    /**\n     * The aggregate value of the array, including any disabled controls.\n     *\n     * Reports all values regardless of disabled status.\n     */\n    getRawValue() {\n        return this.controls.map((control) => control.getRawValue());\n    }\n    /**\n     * Remove all controls in the `FormArray`.\n     *\n     * @param options Specifies whether this FormArray instance should emit events after all\n     *     controls are removed.\n     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n     * `valueChanges` observables emit events with the latest status and value when all controls\n     * in this FormArray instance are removed. When false, no events are emitted.\n     *\n     * @usageNotes\n     * ### Remove all elements from a FormArray\n     *\n     * ```ts\n     * const arr = new FormArray([\n     *    new FormControl(),\n     *    new FormControl()\n     * ]);\n     * console.log(arr.length);  // 2\n     *\n     * arr.clear();\n     * console.log(arr.length);  // 0\n     * ```\n     *\n     * It's a simpler and more efficient alternative to removing all elements one by one:\n     *\n     * ```ts\n     * const arr = new FormArray([\n     *    new FormControl(),\n     *    new FormControl()\n     * ]);\n     *\n     * while (arr.length) {\n     *    arr.removeAt(0);\n     * }\n     * ```\n     */\n    clear(options = {}) {\n        if (this.controls.length < 1)\n            return;\n        this._forEachChild((control) => control._registerOnCollectionChange(() => { }));\n        this.controls.splice(0);\n        this.updateValueAndValidity({ emitEvent: options.emitEvent });\n    }\n    /**\n     * Adjusts a negative index by summing it with the length of the array. For very negative\n     * indices, the result may remain negative.\n     * @internal\n     */\n    _adjustIndex(index) {\n        return index < 0 ? index + this.length : index;\n    }\n    /** @internal */\n    _syncPendingControls() {\n        let subtreeUpdated = this.controls.reduce((updated, child) => {\n            return child._syncPendingControls() ? true : updated;\n        }, false);\n        if (subtreeUpdated)\n            this.updateValueAndValidity({ onlySelf: true });\n        return subtreeUpdated;\n    }\n    /** @internal */\n    _forEachChild(cb) {\n        this.controls.forEach((control, index) => {\n            cb(control, index);\n        });\n    }\n    /** @internal */\n    _updateValue() {\n        this.value =\n            this.controls.filter((control) => control.enabled || this.disabled)\n                .map((control) => control.value);\n    }\n    /** @internal */\n    _anyControls(condition) {\n        return this.controls.some((control) => control.enabled && condition(control));\n    }\n    /** @internal */\n    _setUpControls() {\n        this._forEachChild((control) => this._registerControl(control));\n    }\n    /** @internal */\n    _allControlsDisabled() {\n        for (const control of this.controls) {\n            if (control.enabled)\n                return false;\n        }\n        return this.controls.length > 0 || this.disabled;\n    }\n    _registerControl(control) {\n        control.setParent(this);\n        control._registerOnCollectionChange(this._onCollectionChange);\n    }\n    /** @internal */\n    _find(name) {\n        return this.at(name) ?? null;\n    }\n}\nconst UntypedFormArray = FormArray;\nconst isFormArray = (control) => control instanceof FormArray;\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 isAbstractControlOptions(options) {\n    return !!options &&\n        (options.asyncValidators !== undefined ||\n            options.validators !== undefined ||\n            options.updateOn !== undefined);\n}\n// clang-format on\n/**\n * @description\n * Creates an `AbstractControl` from a user-specified configuration.\n *\n * The `FormBuilder` provides syntactic sugar that shortens creating instances of a\n * `FormControl`, `FormGroup`, or `FormArray`. It reduces the amount of boilerplate needed to\n * build complex forms.\n *\n * @see [Reactive Forms Guide](guide/reactive-forms)\n *\n * @publicApi\n */\nclass FormBuilder {\n    constructor() {\n        this.useNonNullable = false;\n    }\n    /**\n     * @description\n     * Returns a FormBuilder in which automatically constructed @see FormControl} elements\n     * have `{nonNullable: true}` and are non-nullable.\n     *\n     * **Constructing non-nullable controls**\n     *\n     * When constructing a control, it will be non-nullable, and will reset to its initial value.\n     *\n     * ```ts\n     * let nnfb = new FormBuilder().nonNullable;\n     * let name = nnfb.control('Alex'); // FormControl<string>\n     * name.reset();\n     * console.log(name); // 'Alex'\n     * ```\n     *\n     * **Constructing non-nullable groups or arrays**\n     *\n     * When constructing a group or array, all automatically created inner controls will be\n     * non-nullable, and will reset to their initial values.\n     *\n     * ```ts\n     * let nnfb = new FormBuilder().nonNullable;\n     * let name = nnfb.group({who: 'Alex'}); // FormGroup<{who: FormControl<string>}>\n     * name.reset();\n     * console.log(name); // {who: 'Alex'}\n     * ```\n     * **Constructing *nullable* fields on groups or arrays**\n     *\n     * It is still possible to have a nullable field. In particular, any `FormControl` which is\n     * *already* constructed will not be altered. For example:\n     *\n     * ```ts\n     * let nnfb = new FormBuilder().nonNullable;\n     * // FormGroup<{who: FormControl<string|null>}>\n     * let name = nnfb.group({who: new FormControl('Alex')});\n     * name.reset(); console.log(name); // {who: null}\n     * ```\n     *\n     * Because the inner control is constructed explicitly by the caller, the builder has\n     * no control over how it is created, and cannot exclude the `null`.\n     */\n    get nonNullable() {\n        const nnfb = new FormBuilder();\n        nnfb.useNonNullable = true;\n        return nnfb;\n    }\n    group(controls, options = null) {\n        const reducedControls = this._reduceControls(controls);\n        let newOptions = {};\n        if (isAbstractControlOptions(options)) {\n            // `options` are `AbstractControlOptions`\n            newOptions = options;\n        }\n        else if (options !== null) {\n            // `options` are legacy form group options\n            newOptions.validators = options.validator;\n            newOptions.asyncValidators = options.asyncValidator;\n        }\n        return new FormGroup(reducedControls, newOptions);\n    }\n    /**\n     * @description\n     * Constructs a new `FormRecord` instance. Accepts a single generic argument, which is an object\n     * containing all the keys and corresponding inner control types.\n     *\n     * @param controls A collection of child controls. The key for each child is the name\n     * under which it is registered.\n     *\n     * @param options Configuration options object for the `FormRecord`. The object should have the\n     * `AbstractControlOptions` type and might contain the following fields:\n     * * `validators`: A synchronous validator function, or an array of validator functions.\n     * * `asyncValidators`: A single async validator or array of async validator functions.\n     * * `updateOn`: The event upon which the control should be updated (options: 'change' | 'blur'\n     * | submit').\n     */\n    record(controls, options = null) {\n        const reducedControls = this._reduceControls(controls);\n        // Cast to `any` because the inferred types are not as specific as Element.\n        return new FormRecord(reducedControls, options);\n    }\n    /**\n     * @description\n     * Constructs a new `FormControl` with the given state, validators and options. Sets\n     * `{nonNullable: true}` in the options to get a non-nullable control. Otherwise, the\n     * control will be nullable. Accepts a single generic argument, which is the type  of the\n     * control's value.\n     *\n     * @param formState Initializes the control with an initial state value, or\n     * with an object that contains both a value and a disabled status.\n     *\n     * @param validatorOrOpts A synchronous validator function, or an array of\n     * such functions, or a `FormControlOptions` object that contains\n     * validation functions and a validation trigger.\n     *\n     * @param asyncValidator A single async validator or array of async validator\n     * functions.\n     *\n     * @usageNotes\n     *\n     * ### Initialize a control as disabled\n     *\n     * The following example returns a control with an initial value in a disabled state.\n     *\n     * <code-example path=\"forms/ts/formBuilder/form_builder_example.ts\" region=\"disabled-control\">\n     * </code-example>\n     */\n    control(formState, validatorOrOpts, asyncValidator) {\n        let newOptions = {};\n        if (!this.useNonNullable) {\n            return new FormControl(formState, validatorOrOpts, asyncValidator);\n        }\n        if (isAbstractControlOptions(validatorOrOpts)) {\n            // If the second argument is options, then they are copied.\n            newOptions = validatorOrOpts;\n        }\n        else {\n            // If the other arguments are validators, they are copied into an options object.\n            newOptions.validators = validatorOrOpts;\n            newOptions.asyncValidators = asyncValidator;\n        }\n        return new FormControl(formState, { ...newOptions, nonNullable: true });\n    }\n    /**\n     * Constructs a new `FormArray` from the given array of configurations,\n     * validators and options. Accepts a single generic argument, which is the type of each control\n     * inside the array.\n     *\n     * @param controls An array of child controls or control configs. Each child control is given an\n     *     index when it is registered.\n     *\n     * @param validatorOrOpts A synchronous validator function, or an array of such functions, or an\n     *     `AbstractControlOptions` object that contains\n     * validation functions and a validation trigger.\n     *\n     * @param asyncValidator A single async validator or array of async validator functions.\n     */\n    array(controls, validatorOrOpts, asyncValidator) {\n        const createdControls = controls.map(c => this._createControl(c));\n        // Cast to `any` because the inferred types are not as specific as Element.\n        return new FormArray(createdControls, validatorOrOpts, asyncValidator);\n    }\n    /** @internal */\n    _reduceControls(controls) {\n        const createdControls = {};\n        Object.keys(controls).forEach(controlName => {\n            createdControls[controlName] = this._createControl(controls[controlName]);\n        });\n        return createdControls;\n    }\n    /** @internal */\n    _createControl(controls) {\n        if (controls instanceof FormControl) {\n            return controls;\n        }\n        else if (controls instanceof AbstractControl) { // A control; just return it\n            return controls;\n        }\n        else if (Array.isArray(controls)) { // ControlConfig Tuple\n            const value = controls[0];\n            const validator = controls.length > 1 ? controls[1] : null;\n            const asyncValidator = controls.length > 2 ? controls[2] : null;\n            return this.control(value, validator, asyncValidator);\n        }\n        else { // T or FormControlState<T>\n            return this.control(controls);\n        }\n    }\n}\nFormBuilder.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: FormBuilder, deps: [], target: i0.ɵɵFactoryTarget.Injectable });\nFormBuilder.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: FormBuilder, providedIn: ReactiveFormsModule });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: FormBuilder, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: ReactiveFormsModule }]\n        }] });\n/**\n * @description\n * `NonNullableFormBuilder` is similar to {@link FormBuilder}, but automatically constructed\n * {@link FormControl} elements have `{nonNullable: true}` and are non-nullable.\n *\n * @publicApi\n */\nclass NonNullableFormBuilder {\n}\nNonNullableFormBuilder.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NonNullableFormBuilder, deps: [], target: i0.ɵɵFactoryTarget.Injectable });\nNonNullableFormBuilder.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NonNullableFormBuilder, providedIn: ReactiveFormsModule, useFactory: () => inject(FormBuilder).nonNullable });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: NonNullableFormBuilder, decorators: [{\n            type: Injectable,\n            args: [{\n                    providedIn: ReactiveFormsModule,\n                    useFactory: () => inject(FormBuilder).nonNullable,\n                }]\n        }] });\n/**\n * UntypedFormBuilder is the same as @see FormBuilder, but it provides untyped controls.\n */\nclass UntypedFormBuilder extends FormBuilder {\n    group(controlsConfig, options = null) {\n        return super.group(controlsConfig, options);\n    }\n    /**\n     * Like `FormBuilder#control`, except the resulting control is untyped.\n     */\n    control(formState, validatorOrOpts, asyncValidator) {\n        return super.control(formState, validatorOrOpts, asyncValidator);\n    }\n    /**\n     * Like `FormBuilder#array`, except the resulting array is untyped.\n     */\n    array(controlsConfig, validatorOrOpts, asyncValidator) {\n        return super.array(controlsConfig, validatorOrOpts, asyncValidator);\n    }\n}\nUntypedFormBuilder.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: UntypedFormBuilder, deps: null, target: i0.ɵɵFactoryTarget.Injectable });\nUntypedFormBuilder.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: UntypedFormBuilder, providedIn: ReactiveFormsModule });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.3.0\", ngImport: i0, type: UntypedFormBuilder, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: ReactiveFormsModule }]\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 * @publicApi\n */\nconst VERSION = new Version('14.3.0');\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// This file only reexports content of the `src` folder. Keep it that way.\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { AbstractControl, AbstractControlDirective, AbstractFormGroupDirective, COMPOSITION_BUFFER_MODE, CheckboxControlValueAccessor, CheckboxRequiredValidator, ControlContainer, DefaultValueAccessor, EmailValidator, FormArray, FormArrayName, FormBuilder, FormControl, FormControlDirective, FormControlName, FormGroup, FormGroupDirective, FormGroupName, FormRecord, FormsModule, MaxLengthValidator, MaxValidator, MinLengthValidator, MinValidator, NG_ASYNC_VALIDATORS, NG_VALIDATORS, NG_VALUE_ACCESSOR, NgControl, NgControlStatus, NgControlStatusGroup, NgForm, NgModel, NgModelGroup, NgSelectOption, NonNullableFormBuilder, NumberValueAccessor, PatternValidator, RadioControlValueAccessor, RangeValueAccessor, ReactiveFormsModule, RequiredValidator, SelectControlValueAccessor, SelectMultipleControlValueAccessor, UntypedFormArray, UntypedFormBuilder, UntypedFormControl, UntypedFormGroup, VERSION, Validators, ɵInternalFormsSharedModule, ɵNgNoValidate, ɵNgSelectMultipleOption };\n","import { ActiveDescendantKeyManager } from '@angular/cdk/a11y';\nimport { coerceBooleanProperty, coerceStringArray } from '@angular/cdk/coercion';\nimport * as i1 from '@angular/cdk/platform';\nimport { _getEventTarget } from '@angular/cdk/platform';\nimport * as i0 from '@angular/core';\nimport { InjectionToken, EventEmitter, TemplateRef, Directive, Inject, ViewChild, Input, Output, Component, ViewEncapsulation, ChangeDetectionStrategy, ContentChildren, forwardRef, Optional, Host, NgModule } from '@angular/core';\nimport { mixinDisableRipple, MAT_OPTION_PARENT_COMPONENT, MAT_OPTGROUP, MatOption, MatOptionSelectionChange, _countGroupLabelsBeforeOption, _getOptionScrollPosition, MatOptionModule, MatCommonModule } from '@angular/material/core';\nimport { Subscription, Subject, defer, merge, of, fromEvent } from 'rxjs';\nimport * as i2 from '@angular/common';\nimport { DOCUMENT, CommonModule } from '@angular/common';\nimport * as i1$1 from '@angular/cdk/overlay';\nimport { Overlay, OverlayConfig, OverlayModule } from '@angular/cdk/overlay';\nimport * as i3 from '@angular/cdk/scrolling';\nimport { CdkScrollableModule } from '@angular/cdk/scrolling';\nimport * as i2$1 from '@angular/cdk/bidi';\nimport { hasModifierKey, ESCAPE, ENTER, UP_ARROW, DOWN_ARROW, TAB } from '@angular/cdk/keycodes';\nimport { TemplatePortal } from '@angular/cdk/portal';\nimport { NG_VALUE_ACCESSOR } from '@angular/forms';\nimport * as i4 from '@angular/material/form-field';\nimport { MAT_FORM_FIELD } from '@angular/material/form-field';\nimport { startWith, switchMap, take, filter, map, tap, delay } from 'rxjs/operators';\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 * Autocomplete IDs need to be unique across components, so this counter exists outside of\n * the component definition.\n */\nlet _uniqueAutocompleteIdCounter = 0;\n/** Event object that is emitted when an autocomplete option is selected. */\nclass MatAutocompleteSelectedEvent {\n    constructor(\n    /** Reference to the autocomplete panel that emitted the event. */\n    source, \n    /** Option that was selected. */\n    option) {\n        this.source = source;\n        this.option = option;\n    }\n}\n// Boilerplate for applying mixins to MatAutocomplete.\n/** @docs-private */\nconst _MatAutocompleteMixinBase = mixinDisableRipple(class {\n});\n/** Injection token to be used to override the default options for `mat-autocomplete`. */\nconst MAT_AUTOCOMPLETE_DEFAULT_OPTIONS = new InjectionToken('mat-autocomplete-default-options', {\n    providedIn: 'root',\n    factory: MAT_AUTOCOMPLETE_DEFAULT_OPTIONS_FACTORY,\n});\n/** @docs-private */\nfunction MAT_AUTOCOMPLETE_DEFAULT_OPTIONS_FACTORY() {\n    return { autoActiveFirstOption: false };\n}\n/** Base class with all of the `MatAutocomplete` functionality. */\nclass _MatAutocompleteBase extends _MatAutocompleteMixinBase {\n    constructor(_changeDetectorRef, _elementRef, defaults, platform) {\n        super();\n        this._changeDetectorRef = _changeDetectorRef;\n        this._elementRef = _elementRef;\n        this._activeOptionChanges = Subscription.EMPTY;\n        /** Whether the autocomplete panel should be visible, depending on option length. */\n        this.showPanel = false;\n        this._isOpen = false;\n        /** Function that maps an option's control value to its display value in the trigger. */\n        this.displayWith = null;\n        /** Event that is emitted whenever an option from the list is selected. */\n        this.optionSelected = new EventEmitter();\n        /** Event that is emitted when the autocomplete panel is opened. */\n        this.opened = new EventEmitter();\n        /** Event that is emitted when the autocomplete panel is closed. */\n        this.closed = new EventEmitter();\n        /** Emits whenever an option is activated. */\n        this.optionActivated = new EventEmitter();\n        this._classList = {};\n        /** Unique ID to be used by autocomplete trigger's \"aria-owns\" property. */\n        this.id = `mat-autocomplete-${_uniqueAutocompleteIdCounter++}`;\n        // TODO(crisbeto): the problem that the `inertGroups` option resolves is only present on\n        // Safari using VoiceOver. We should occasionally check back to see whether the bug\n        // wasn't resolved in VoiceOver, and if it has, we can remove this and the `inertGroups`\n        // option altogether.\n        this.inertGroups = platform?.SAFARI || false;\n        this._autoActiveFirstOption = !!defaults.autoActiveFirstOption;\n    }\n    /** Whether the autocomplete panel is open. */\n    get isOpen() {\n        return this._isOpen && this.showPanel;\n    }\n    /**\n     * Whether the first option should be highlighted when the autocomplete panel is opened.\n     * Can be configured globally through the `MAT_AUTOCOMPLETE_DEFAULT_OPTIONS` token.\n     */\n    get autoActiveFirstOption() {\n        return this._autoActiveFirstOption;\n    }\n    set autoActiveFirstOption(value) {\n        this._autoActiveFirstOption = coerceBooleanProperty(value);\n    }\n    /**\n     * Takes classes set on the host mat-autocomplete element and applies them to the panel\n     * inside the overlay container to allow for easy styling.\n     */\n    set classList(value) {\n        if (value && value.length) {\n            this._classList = coerceStringArray(value).reduce((classList, className) => {\n                classList[className] = true;\n                return classList;\n            }, {});\n        }\n        else {\n            this._classList = {};\n        }\n        this._setVisibilityClasses(this._classList);\n        this._elementRef.nativeElement.className = '';\n    }\n    ngAfterContentInit() {\n        this._keyManager = new ActiveDescendantKeyManager(this.options).withWrap();\n        this._activeOptionChanges = this._keyManager.change.subscribe(index => {\n            if (this.isOpen) {\n                this.optionActivated.emit({ source: this, option: this.options.toArray()[index] || null });\n            }\n        });\n        // Set the initial visibility state.\n        this._setVisibility();\n    }\n    ngOnDestroy() {\n        this._activeOptionChanges.unsubscribe();\n    }\n    /**\n     * Sets the panel scrollTop. This allows us to manually scroll to display options\n     * above or below the fold, as they are not actually being focused when active.\n     */\n    _setScrollTop(scrollTop) {\n        if (this.panel) {\n            this.panel.nativeElement.scrollTop = scrollTop;\n        }\n    }\n    /** Returns the panel's scrollTop. */\n    _getScrollTop() {\n        return this.panel ? this.panel.nativeElement.scrollTop : 0;\n    }\n    /** Panel should hide itself when the option list is empty. */\n    _setVisibility() {\n        this.showPanel = !!this.options.length;\n        this._setVisibilityClasses(this._classList);\n        this._changeDetectorRef.markForCheck();\n    }\n    /** Emits the `select` event. */\n    _emitSelectEvent(option) {\n        const event = new MatAutocompleteSelectedEvent(this, option);\n        this.optionSelected.emit(event);\n    }\n    /** Gets the aria-labelledby for the autocomplete panel. */\n    _getPanelAriaLabelledby(labelId) {\n        if (this.ariaLabel) {\n            return null;\n        }\n        const labelExpression = labelId ? labelId + ' ' : '';\n        return this.ariaLabelledby ? labelExpression + this.ariaLabelledby : labelId;\n    }\n    /** Sets the autocomplete visibility classes on a classlist based on the panel is visible. */\n    _setVisibilityClasses(classList) {\n        classList[this._visibleClass] = this.showPanel;\n        classList[this._hiddenClass] = !this.showPanel;\n    }\n}\n_MatAutocompleteBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatAutocompleteBase, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: MAT_AUTOCOMPLETE_DEFAULT_OPTIONS }, { token: i1.Platform }], target: i0.ɵɵFactoryTarget.Directive });\n_MatAutocompleteBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: _MatAutocompleteBase, inputs: { ariaLabel: [\"aria-label\", \"ariaLabel\"], ariaLabelledby: [\"aria-labelledby\", \"ariaLabelledby\"], displayWith: \"displayWith\", autoActiveFirstOption: \"autoActiveFirstOption\", panelWidth: \"panelWidth\", classList: [\"class\", \"classList\"] }, outputs: { optionSelected: \"optionSelected\", opened: \"opened\", closed: \"closed\", optionActivated: \"optionActivated\" }, viewQueries: [{ propertyName: \"template\", first: true, predicate: TemplateRef, descendants: true, static: true }, { propertyName: \"panel\", first: true, predicate: [\"panel\"], descendants: true }], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatAutocompleteBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_AUTOCOMPLETE_DEFAULT_OPTIONS]\n                }] }, { type: i1.Platform }]; }, propDecorators: { template: [{\n                type: ViewChild,\n                args: [TemplateRef, { static: true }]\n            }], panel: [{\n                type: ViewChild,\n                args: ['panel']\n            }], ariaLabel: [{\n                type: Input,\n                args: ['aria-label']\n            }], ariaLabelledby: [{\n                type: Input,\n                args: ['aria-labelledby']\n            }], displayWith: [{\n                type: Input\n            }], autoActiveFirstOption: [{\n                type: Input\n            }], panelWidth: [{\n                type: Input\n            }], optionSelected: [{\n                type: Output\n            }], opened: [{\n                type: Output\n            }], closed: [{\n                type: Output\n            }], optionActivated: [{\n                type: Output\n            }], classList: [{\n                type: Input,\n                args: ['class']\n            }] } });\nclass MatAutocomplete extends _MatAutocompleteBase {\n    constructor() {\n        super(...arguments);\n        this._visibleClass = 'mat-autocomplete-visible';\n        this._hiddenClass = 'mat-autocomplete-hidden';\n    }\n}\nMatAutocomplete.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatAutocomplete, deps: null, target: i0.ɵɵFactoryTarget.Component });\nMatAutocomplete.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatAutocomplete, selector: \"mat-autocomplete\", inputs: { disableRipple: \"disableRipple\" }, host: { classAttribute: \"mat-autocomplete\" }, providers: [{ provide: MAT_OPTION_PARENT_COMPONENT, useExisting: MatAutocomplete }], queries: [{ propertyName: \"optionGroups\", predicate: MAT_OPTGROUP, descendants: true }, { propertyName: \"options\", predicate: MatOption, descendants: true }], exportAs: [\"matAutocomplete\"], usesInheritance: true, ngImport: i0, template: \"<ng-template let-formFieldId=\\\"id\\\">\\n  <div class=\\\"mat-autocomplete-panel\\\"\\n       role=\\\"listbox\\\"\\n       [id]=\\\"id\\\"\\n       [attr.aria-label]=\\\"ariaLabel || null\\\"\\n       [attr.aria-labelledby]=\\\"_getPanelAriaLabelledby(formFieldId)\\\"\\n       [ngClass]=\\\"_classList\\\"\\n       #panel>\\n    <ng-content></ng-content>\\n  </div>\\n</ng-template>\\n\", styles: [\".mat-autocomplete-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;visibility:hidden;max-width:none;max-height:256px;position:relative;width:100%;border-bottom-left-radius:4px;border-bottom-right-radius:4px}.mat-autocomplete-panel.mat-autocomplete-visible{visibility:visible}.mat-autocomplete-panel.mat-autocomplete-hidden{visibility:hidden}.mat-autocomplete-panel-above .mat-autocomplete-panel{border-radius:0;border-top-left-radius:4px;border-top-right-radius:4px}.mat-autocomplete-panel .mat-divider-horizontal{margin-top:-1px}.cdk-high-contrast-active .mat-autocomplete-panel{outline:solid 1px}mat-autocomplete{display:none}\\n\"], directives: [{ type: i2.NgClass, selector: \"[ngClass]\", inputs: [\"class\", \"ngClass\"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatAutocomplete, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-autocomplete', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, exportAs: 'matAutocomplete', inputs: ['disableRipple'], host: {\n                        'class': 'mat-autocomplete',\n                    }, providers: [{ provide: MAT_OPTION_PARENT_COMPONENT, useExisting: MatAutocomplete }], template: \"<ng-template let-formFieldId=\\\"id\\\">\\n  <div class=\\\"mat-autocomplete-panel\\\"\\n       role=\\\"listbox\\\"\\n       [id]=\\\"id\\\"\\n       [attr.aria-label]=\\\"ariaLabel || null\\\"\\n       [attr.aria-labelledby]=\\\"_getPanelAriaLabelledby(formFieldId)\\\"\\n       [ngClass]=\\\"_classList\\\"\\n       #panel>\\n    <ng-content></ng-content>\\n  </div>\\n</ng-template>\\n\", styles: [\".mat-autocomplete-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;visibility:hidden;max-width:none;max-height:256px;position:relative;width:100%;border-bottom-left-radius:4px;border-bottom-right-radius:4px}.mat-autocomplete-panel.mat-autocomplete-visible{visibility:visible}.mat-autocomplete-panel.mat-autocomplete-hidden{visibility:hidden}.mat-autocomplete-panel-above .mat-autocomplete-panel{border-radius:0;border-top-left-radius:4px;border-top-right-radius:4px}.mat-autocomplete-panel .mat-divider-horizontal{margin-top:-1px}.cdk-high-contrast-active .mat-autocomplete-panel{outline:solid 1px}mat-autocomplete{display:none}\\n\"] }]\n        }], propDecorators: { optionGroups: [{\n                type: ContentChildren,\n                args: [MAT_OPTGROUP, { descendants: true }]\n            }], options: [{\n                type: ContentChildren,\n                args: [MatOption, { descendants: true }]\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/** Base class containing all of the functionality for `MatAutocompleteOrigin`. */\nclass _MatAutocompleteOriginBase {\n    constructor(\n    /** Reference to the element on which the directive is applied. */\n    elementRef) {\n        this.elementRef = elementRef;\n    }\n}\n_MatAutocompleteOriginBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatAutocompleteOriginBase, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });\n_MatAutocompleteOriginBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: _MatAutocompleteOriginBase, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatAutocompleteOriginBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; } });\n/**\n * Directive applied to an element to make it usable\n * as a connection point for an autocomplete panel.\n */\nclass MatAutocompleteOrigin extends _MatAutocompleteOriginBase {\n}\nMatAutocompleteOrigin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatAutocompleteOrigin, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatAutocompleteOrigin.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatAutocompleteOrigin, selector: \"[matAutocompleteOrigin]\", exportAs: [\"matAutocompleteOrigin\"], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatAutocompleteOrigin, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matAutocompleteOrigin]',\n                    exportAs: 'matAutocompleteOrigin',\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Injection token that determines the scroll handling while the autocomplete panel is open. */\nconst MAT_AUTOCOMPLETE_SCROLL_STRATEGY = new InjectionToken('mat-autocomplete-scroll-strategy');\n/** @docs-private */\nfunction MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY(overlay) {\n    return () => overlay.scrollStrategies.reposition();\n}\n/** @docs-private */\nconst MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER = {\n    provide: MAT_AUTOCOMPLETE_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY,\n};\n/**\n * Provider that allows the autocomplete to register as a ControlValueAccessor.\n * @docs-private\n */\nconst MAT_AUTOCOMPLETE_VALUE_ACCESSOR = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => MatAutocompleteTrigger),\n    multi: true,\n};\n/**\n * Creates an error to be thrown when attempting to use an autocomplete trigger without a panel.\n * @docs-private\n */\nfunction getMatAutocompleteMissingPanelError() {\n    return Error('Attempting to open an undefined instance of `mat-autocomplete`. ' +\n        'Make sure that the id passed to the `matAutocomplete` is correct and that ' +\n        \"you're attempting to open it after the ngAfterContentInit hook.\");\n}\n/** Base class with all of the `MatAutocompleteTrigger` functionality. */\nclass _MatAutocompleteTriggerBase {\n    constructor(_element, _overlay, _viewContainerRef, _zone, _changeDetectorRef, scrollStrategy, _dir, _formField, _document, _viewportRuler, _defaults) {\n        this._element = _element;\n        this._overlay = _overlay;\n        this._viewContainerRef = _viewContainerRef;\n        this._zone = _zone;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._dir = _dir;\n        this._formField = _formField;\n        this._document = _document;\n        this._viewportRuler = _viewportRuler;\n        this._defaults = _defaults;\n        this._componentDestroyed = false;\n        this._autocompleteDisabled = false;\n        /** Whether or not the label state is being overridden. */\n        this._manuallyFloatingLabel = false;\n        /** Subscription to viewport size changes. */\n        this._viewportSubscription = Subscription.EMPTY;\n        /**\n         * Whether the autocomplete can open the next time it is focused. Used to prevent a focused,\n         * closed autocomplete from being reopened if the user switches to another browser tab and then\n         * comes back.\n         */\n        this._canOpenOnNextFocus = true;\n        /** Stream of keyboard events that can close the panel. */\n        this._closeKeyEventStream = new Subject();\n        /**\n         * Event handler for when the window is blurred. Needs to be an\n         * arrow function in order to preserve the context.\n         */\n        this._windowBlurHandler = () => {\n            // If the user blurred the window while the autocomplete is focused, it means that it'll be\n            // refocused when they come back. In this case we want to skip the first focus event, if the\n            // pane was closed, in order to avoid reopening it unintentionally.\n            this._canOpenOnNextFocus =\n                this._document.activeElement !== this._element.nativeElement || this.panelOpen;\n        };\n        /** `View -> model callback called when value changes` */\n        this._onChange = () => { };\n        /** `View -> model callback called when autocomplete has been touched` */\n        this._onTouched = () => { };\n        /**\n         * Position of the autocomplete panel relative to the trigger element. A position of `auto`\n         * will render the panel underneath the trigger if there is enough space for it to fit in\n         * the viewport, otherwise the panel will be shown above it. If the position is set to\n         * `above` or `below`, the panel will always be shown above or below the trigger. no matter\n         * whether it fits completely in the viewport.\n         */\n        this.position = 'auto';\n        /**\n         * `autocomplete` attribute to be set on the input element.\n         * @docs-private\n         */\n        this.autocompleteAttribute = 'off';\n        this._overlayAttached = false;\n        /** Stream of changes to the selection state of the autocomplete options. */\n        this.optionSelections = defer(() => {\n            const options = this.autocomplete ? this.autocomplete.options : null;\n            if (options) {\n                return options.changes.pipe(startWith(options), switchMap(() => merge(...options.map(option => option.onSelectionChange))));\n            }\n            // If there are any subscribers before `ngAfterViewInit`, the `autocomplete` will be undefined.\n            // Return a stream that we'll replace with the real one once everything is in place.\n            return this._zone.onStable.pipe(take(1), switchMap(() => this.optionSelections));\n        });\n        this._scrollStrategy = scrollStrategy;\n    }\n    /**\n     * Whether the autocomplete is disabled. When disabled, the element will\n     * act as a regular input and the user won't be able to open the panel.\n     */\n    get autocompleteDisabled() {\n        return this._autocompleteDisabled;\n    }\n    set autocompleteDisabled(value) {\n        this._autocompleteDisabled = coerceBooleanProperty(value);\n    }\n    ngAfterViewInit() {\n        const window = this._getWindow();\n        if (typeof window !== 'undefined') {\n            this._zone.runOutsideAngular(() => window.addEventListener('blur', this._windowBlurHandler));\n        }\n    }\n    ngOnChanges(changes) {\n        if (changes['position'] && this._positionStrategy) {\n            this._setStrategyPositions(this._positionStrategy);\n            if (this.panelOpen) {\n                this._overlayRef.updatePosition();\n            }\n        }\n    }\n    ngOnDestroy() {\n        const window = this._getWindow();\n        if (typeof window !== 'undefined') {\n            window.removeEventListener('blur', this._windowBlurHandler);\n        }\n        this._viewportSubscription.unsubscribe();\n        this._componentDestroyed = true;\n        this._destroyPanel();\n        this._closeKeyEventStream.complete();\n    }\n    /** Whether or not the autocomplete panel is open. */\n    get panelOpen() {\n        return this._overlayAttached && this.autocomplete.showPanel;\n    }\n    /** Opens the autocomplete suggestion panel. */\n    openPanel() {\n        this._attachOverlay();\n        this._floatLabel();\n    }\n    /** Closes the autocomplete suggestion panel. */\n    closePanel() {\n        this._resetLabel();\n        if (!this._overlayAttached) {\n            return;\n        }\n        if (this.panelOpen) {\n            // Only emit if the panel was visible.\n            // The `NgZone.onStable` always emits outside of the Angular zone,\n            // so all the subscriptions from `_subscribeToClosingActions()` are also outside of the Angular zone.\n            // We should manually run in Angular zone to update UI after panel closing.\n            this._zone.run(() => {\n                this.autocomplete.closed.emit();\n            });\n        }\n        this.autocomplete._isOpen = this._overlayAttached = false;\n        if (this._overlayRef && this._overlayRef.hasAttached()) {\n            this._overlayRef.detach();\n            this._closingActionsSubscription.unsubscribe();\n        }\n        // Note that in some cases this can end up being called after the component is destroyed.\n        // Add a check to ensure that we don't try to run change detection on a destroyed view.\n        if (!this._componentDestroyed) {\n            // We need to trigger change detection manually, because\n            // `fromEvent` doesn't seem to do it at the proper time.\n            // This ensures that the label is reset when the\n            // user clicks outside.\n            this._changeDetectorRef.detectChanges();\n        }\n    }\n    /**\n     * Updates the position of the autocomplete suggestion panel to ensure that it fits all options\n     * within the viewport.\n     */\n    updatePosition() {\n        if (this._overlayAttached) {\n            this._overlayRef.updatePosition();\n        }\n    }\n    /**\n     * A stream of actions that should close the autocomplete panel, including\n     * when an option is selected, on blur, and when TAB is pressed.\n     */\n    get panelClosingActions() {\n        return merge(this.optionSelections, this.autocomplete._keyManager.tabOut.pipe(filter(() => this._overlayAttached)), this._closeKeyEventStream, this._getOutsideClickStream(), this._overlayRef\n            ? this._overlayRef.detachments().pipe(filter(() => this._overlayAttached))\n            : of()).pipe(\n        // Normalize the output so we return a consistent type.\n        map(event => (event instanceof MatOptionSelectionChange ? event : null)));\n    }\n    /** The currently active option, coerced to MatOption type. */\n    get activeOption() {\n        if (this.autocomplete && this.autocomplete._keyManager) {\n            return this.autocomplete._keyManager.activeItem;\n        }\n        return null;\n    }\n    /** Stream of clicks outside of the autocomplete panel. */\n    _getOutsideClickStream() {\n        return merge(fromEvent(this._document, 'click'), fromEvent(this._document, 'auxclick'), fromEvent(this._document, 'touchend')).pipe(filter(event => {\n            // If we're in the Shadow DOM, the event target will be the shadow root, so we have to\n            // fall back to check the first element in the path of the click event.\n            const clickTarget = _getEventTarget(event);\n            const formField = this._formField ? this._formField._elementRef.nativeElement : null;\n            const customOrigin = this.connectedTo ? this.connectedTo.elementRef.nativeElement : null;\n            return (this._overlayAttached &&\n                clickTarget !== this._element.nativeElement &&\n                // Normally focus moves inside `mousedown` so this condition will almost always be\n                // true. Its main purpose is to handle the case where the input is focused from an\n                // outside click which propagates up to the `body` listener within the same sequence\n                // and causes the panel to close immediately (see #3106).\n                this._document.activeElement !== this._element.nativeElement &&\n                (!formField || !formField.contains(clickTarget)) &&\n                (!customOrigin || !customOrigin.contains(clickTarget)) &&\n                !!this._overlayRef &&\n                !this._overlayRef.overlayElement.contains(clickTarget));\n        }));\n    }\n    // Implemented as part of ControlValueAccessor.\n    writeValue(value) {\n        Promise.resolve().then(() => this._setTriggerValue(value));\n    }\n    // Implemented as part of ControlValueAccessor.\n    registerOnChange(fn) {\n        this._onChange = fn;\n    }\n    // Implemented as part of ControlValueAccessor.\n    registerOnTouched(fn) {\n        this._onTouched = fn;\n    }\n    // Implemented as part of ControlValueAccessor.\n    setDisabledState(isDisabled) {\n        this._element.nativeElement.disabled = isDisabled;\n    }\n    _handleKeydown(event) {\n        const keyCode = event.keyCode;\n        const hasModifier = hasModifierKey(event);\n        // Prevent the default action on all escape key presses. This is here primarily to bring IE\n        // in line with other browsers. By default, pressing escape on IE will cause it to revert\n        // the input value to the one that it had on focus, however it won't dispatch any events\n        // which means that the model value will be out of sync with the view.\n        if (keyCode === ESCAPE && !hasModifier) {\n            event.preventDefault();\n        }\n        if (this.activeOption && keyCode === ENTER && this.panelOpen && !hasModifier) {\n            this.activeOption._selectViaInteraction();\n            this._resetActiveItem();\n            event.preventDefault();\n        }\n        else if (this.autocomplete) {\n            const prevActiveItem = this.autocomplete._keyManager.activeItem;\n            const isArrowKey = keyCode === UP_ARROW || keyCode === DOWN_ARROW;\n            if (keyCode === TAB || (isArrowKey && !hasModifier && this.panelOpen)) {\n                this.autocomplete._keyManager.onKeydown(event);\n            }\n            else if (isArrowKey && this._canOpen()) {\n                this.openPanel();\n            }\n            if (isArrowKey || this.autocomplete._keyManager.activeItem !== prevActiveItem) {\n                this._scrollToOption(this.autocomplete._keyManager.activeItemIndex || 0);\n            }\n        }\n    }\n    _handleInput(event) {\n        let target = event.target;\n        let value = target.value;\n        // Based on `NumberValueAccessor` from forms.\n        if (target.type === 'number') {\n            value = value == '' ? null : parseFloat(value);\n        }\n        // If the input has a placeholder, IE will fire the `input` event on page load,\n        // focus and blur, in addition to when the user actually changed the value. To\n        // filter out all of the extra events, we save the value on focus and between\n        // `input` events, and we check whether it changed.\n        // See: https://connect.microsoft.com/IE/feedback/details/885747/\n        if (this._previousValue !== value) {\n            this._previousValue = value;\n            this._onChange(value);\n            if (this._canOpen() && this._document.activeElement === event.target) {\n                this.openPanel();\n            }\n        }\n    }\n    _handleFocus() {\n        if (!this._canOpenOnNextFocus) {\n            this._canOpenOnNextFocus = true;\n        }\n        else if (this._canOpen()) {\n            this._previousValue = this._element.nativeElement.value;\n            this._attachOverlay();\n            this._floatLabel(true);\n        }\n    }\n    _handleClick() {\n        if (this._canOpen() && !this.panelOpen) {\n            this.openPanel();\n        }\n    }\n    /**\n     * In \"auto\" mode, the label will animate down as soon as focus is lost.\n     * This causes the value to jump when selecting an option with the mouse.\n     * This method manually floats the label until the panel can be closed.\n     * @param shouldAnimate Whether the label should be animated when it is floated.\n     */\n    _floatLabel(shouldAnimate = false) {\n        if (this._formField && this._formField.floatLabel === 'auto') {\n            if (shouldAnimate) {\n                this._formField._animateAndLockLabel();\n            }\n            else {\n                this._formField.floatLabel = 'always';\n            }\n            this._manuallyFloatingLabel = true;\n        }\n    }\n    /** If the label has been manually elevated, return it to its normal state. */\n    _resetLabel() {\n        if (this._manuallyFloatingLabel) {\n            this._formField.floatLabel = 'auto';\n            this._manuallyFloatingLabel = false;\n        }\n    }\n    /**\n     * This method listens to a stream of panel closing actions and resets the\n     * stream every time the option list changes.\n     */\n    _subscribeToClosingActions() {\n        const firstStable = this._zone.onStable.pipe(take(1));\n        const optionChanges = this.autocomplete.options.changes.pipe(tap(() => this._positionStrategy.reapplyLastPosition()), \n        // Defer emitting to the stream until the next tick, because changing\n        // bindings in here will cause \"changed after checked\" errors.\n        delay(0));\n        // When the zone is stable initially, and when the option list changes...\n        return (merge(firstStable, optionChanges)\n            .pipe(\n        // create a new stream of panelClosingActions, replacing any previous streams\n        // that were created, and flatten it so our stream only emits closing events...\n        switchMap(() => {\n            // The `NgZone.onStable` always emits outside of the Angular zone, thus we have to re-enter\n            // the Angular zone. This will lead to change detection being called outside of the Angular\n            // zone and the `autocomplete.opened` will also emit outside of the Angular.\n            this._zone.run(() => {\n                const wasOpen = this.panelOpen;\n                this._resetActiveItem();\n                this.autocomplete._setVisibility();\n                this._changeDetectorRef.detectChanges();\n                if (this.panelOpen) {\n                    this._overlayRef.updatePosition();\n                    // If the `panelOpen` state changed, we need to make sure to emit the `opened`\n                    // event, because we may not have emitted it when the panel was attached. This\n                    // can happen if the users opens the panel and there are no options, but the\n                    // options come in slightly later or as a result of the value changing.\n                    if (wasOpen !== this.panelOpen) {\n                        this.autocomplete.opened.emit();\n                    }\n                }\n            });\n            return this.panelClosingActions;\n        }), \n        // when the first closing event occurs...\n        take(1))\n            // set the value, close the panel, and complete.\n            .subscribe(event => this._setValueAndClose(event)));\n    }\n    /** Destroys the autocomplete suggestion panel. */\n    _destroyPanel() {\n        if (this._overlayRef) {\n            this.closePanel();\n            this._overlayRef.dispose();\n            this._overlayRef = null;\n        }\n    }\n    _setTriggerValue(value) {\n        const toDisplay = this.autocomplete && this.autocomplete.displayWith\n            ? this.autocomplete.displayWith(value)\n            : value;\n        // Simply falling back to an empty string if the display value is falsy does not work properly.\n        // The display value can also be the number zero and shouldn't fall back to an empty string.\n        const inputValue = toDisplay != null ? toDisplay : '';\n        // If it's used within a `MatFormField`, we should set it through the property so it can go\n        // through change detection.\n        if (this._formField) {\n            this._formField._control.value = inputValue;\n        }\n        else {\n            this._element.nativeElement.value = inputValue;\n        }\n        this._previousValue = inputValue;\n    }\n    /**\n     * This method closes the panel, and if a value is specified, also sets the associated\n     * control to that value. It will also mark the control as dirty if this interaction\n     * stemmed from the user.\n     */\n    _setValueAndClose(event) {\n        const source = event && event.source;\n        if (source) {\n            this._clearPreviousSelectedOption(source);\n            this._setTriggerValue(source.value);\n            this._onChange(source.value);\n            this.autocomplete._emitSelectEvent(source);\n            this._element.nativeElement.focus();\n        }\n        this.closePanel();\n    }\n    /**\n     * Clear any previous selected option and emit a selection change event for this option\n     */\n    _clearPreviousSelectedOption(skip) {\n        this.autocomplete.options.forEach(option => {\n            if (option !== skip && option.selected) {\n                option.deselect();\n            }\n        });\n    }\n    _attachOverlay() {\n        if (!this.autocomplete && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getMatAutocompleteMissingPanelError();\n        }\n        let overlayRef = this._overlayRef;\n        if (!overlayRef) {\n            this._portal = new TemplatePortal(this.autocomplete.template, this._viewContainerRef, {\n                id: this._formField?.getLabelId(),\n            });\n            overlayRef = this._overlay.create(this._getOverlayConfig());\n            this._overlayRef = overlayRef;\n            // Use the `keydownEvents` in order to take advantage of\n            // the overlay event targeting provided by the CDK overlay.\n            overlayRef.keydownEvents().subscribe(event => {\n                // Close when pressing ESCAPE or ALT + UP_ARROW, based on the a11y guidelines.\n                // See: https://www.w3.org/TR/wai-aria-practices-1.1/#textbox-keyboard-interaction\n                if ((event.keyCode === ESCAPE && !hasModifierKey(event)) ||\n                    (event.keyCode === UP_ARROW && hasModifierKey(event, 'altKey'))) {\n                    this._closeKeyEventStream.next();\n                    this._resetActiveItem();\n                    // We need to stop propagation, otherwise the event will eventually\n                    // reach the input itself and cause the overlay to be reopened.\n                    event.stopPropagation();\n                    event.preventDefault();\n                }\n            });\n            this._viewportSubscription = this._viewportRuler.change().subscribe(() => {\n                if (this.panelOpen && overlayRef) {\n                    overlayRef.updateSize({ width: this._getPanelWidth() });\n                }\n            });\n        }\n        else {\n            // Update the trigger, panel width and direction, in case anything has changed.\n            this._positionStrategy.setOrigin(this._getConnectedElement());\n            overlayRef.updateSize({ width: this._getPanelWidth() });\n        }\n        if (overlayRef && !overlayRef.hasAttached()) {\n            overlayRef.attach(this._portal);\n            this._closingActionsSubscription = this._subscribeToClosingActions();\n        }\n        const wasOpen = this.panelOpen;\n        this.autocomplete._setVisibility();\n        this.autocomplete._isOpen = this._overlayAttached = true;\n        // We need to do an extra `panelOpen` check in here, because the\n        // autocomplete won't be shown if there are no options.\n        if (this.panelOpen && wasOpen !== this.panelOpen) {\n            this.autocomplete.opened.emit();\n        }\n    }\n    _getOverlayConfig() {\n        return new OverlayConfig({\n            positionStrategy: this._getOverlayPosition(),\n            scrollStrategy: this._scrollStrategy(),\n            width: this._getPanelWidth(),\n            direction: this._dir,\n            panelClass: this._defaults?.overlayPanelClass,\n        });\n    }\n    _getOverlayPosition() {\n        const strategy = this._overlay\n            .position()\n            .flexibleConnectedTo(this._getConnectedElement())\n            .withFlexibleDimensions(false)\n            .withPush(false);\n        this._setStrategyPositions(strategy);\n        this._positionStrategy = strategy;\n        return strategy;\n    }\n    /** Sets the positions on a position strategy based on the directive's input state. */\n    _setStrategyPositions(positionStrategy) {\n        // Note that we provide horizontal fallback positions, even though by default the dropdown\n        // width matches the input, because consumers can override the width. See #18854.\n        const belowPositions = [\n            { originX: 'start', originY: 'bottom', overlayX: 'start', overlayY: 'top' },\n            { originX: 'end', originY: 'bottom', overlayX: 'end', overlayY: 'top' },\n        ];\n        // The overlay edge connected to the trigger should have squared corners, while\n        // the opposite end has rounded corners. We apply a CSS class to swap the\n        // border-radius based on the overlay position.\n        const panelClass = this._aboveClass;\n        const abovePositions = [\n            { originX: 'start', originY: 'top', overlayX: 'start', overlayY: 'bottom', panelClass },\n            { originX: 'end', originY: 'top', overlayX: 'end', overlayY: 'bottom', panelClass },\n        ];\n        let positions;\n        if (this.position === 'above') {\n            positions = abovePositions;\n        }\n        else if (this.position === 'below') {\n            positions = belowPositions;\n        }\n        else {\n            positions = [...belowPositions, ...abovePositions];\n        }\n        positionStrategy.withPositions(positions);\n    }\n    _getConnectedElement() {\n        if (this.connectedTo) {\n            return this.connectedTo.elementRef;\n        }\n        return this._formField ? this._formField.getConnectedOverlayOrigin() : this._element;\n    }\n    _getPanelWidth() {\n        return this.autocomplete.panelWidth || this._getHostWidth();\n    }\n    /** Returns the width of the input element, so the panel width can match it. */\n    _getHostWidth() {\n        return this._getConnectedElement().nativeElement.getBoundingClientRect().width;\n    }\n    /**\n     * Resets the active item to -1 so arrow events will activate the\n     * correct options, or to 0 if the consumer opted into it.\n     */\n    _resetActiveItem() {\n        const autocomplete = this.autocomplete;\n        if (autocomplete.autoActiveFirstOption) {\n            // Note that we go through `setFirstItemActive`, rather than `setActiveItem(0)`, because\n            // the former will find the next enabled option, if the first one is disabled.\n            autocomplete._keyManager.setFirstItemActive();\n        }\n        else {\n            autocomplete._keyManager.setActiveItem(-1);\n        }\n    }\n    /** Determines whether the panel can be opened. */\n    _canOpen() {\n        const element = this._element.nativeElement;\n        return !element.readOnly && !element.disabled && !this._autocompleteDisabled;\n    }\n    /** Use defaultView of injected document if available or fallback to global window reference */\n    _getWindow() {\n        return this._document?.defaultView || window;\n    }\n    /** Scrolls to a particular option in the list. */\n    _scrollToOption(index) {\n        // Given that we are not actually focusing active options, we must manually adjust scroll\n        // to reveal options below the fold. First, we find the offset of the option from the top\n        // of the panel. If that offset is below the fold, the new scrollTop will be the offset -\n        // the panel height + the option height, so the active option will be just visible at the\n        // bottom of the panel. If that offset is above the top of the visible panel, the new scrollTop\n        // will become the offset. If that offset is visible within the panel already, the scrollTop is\n        // not adjusted.\n        const autocomplete = this.autocomplete;\n        const labelCount = _countGroupLabelsBeforeOption(index, autocomplete.options, autocomplete.optionGroups);\n        if (index === 0 && labelCount === 1) {\n            // If we've got one group label before the option and we're at the top option,\n            // scroll the list to the top. This is better UX than scrolling the list to the\n            // top of the option, because it allows the user to read the top group's label.\n            autocomplete._setScrollTop(0);\n        }\n        else if (autocomplete.panel) {\n            const option = autocomplete.options.toArray()[index];\n            if (option) {\n                const element = option._getHostElement();\n                const newScrollPosition = _getOptionScrollPosition(element.offsetTop, element.offsetHeight, autocomplete._getScrollTop(), autocomplete.panel.nativeElement.offsetHeight);\n                autocomplete._setScrollTop(newScrollPosition);\n            }\n        }\n    }\n}\n_MatAutocompleteTriggerBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatAutocompleteTriggerBase, deps: [{ token: i0.ElementRef }, { token: i1$1.Overlay }, { token: i0.ViewContainerRef }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }, { token: MAT_AUTOCOMPLETE_SCROLL_STRATEGY }, { token: i2$1.Directionality, optional: true }, { token: MAT_FORM_FIELD, host: true, optional: true }, { token: DOCUMENT, optional: true }, { token: i3.ViewportRuler }, { token: MAT_AUTOCOMPLETE_DEFAULT_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\n_MatAutocompleteTriggerBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: _MatAutocompleteTriggerBase, inputs: { autocomplete: [\"matAutocomplete\", \"autocomplete\"], position: [\"matAutocompletePosition\", \"position\"], connectedTo: [\"matAutocompleteConnectedTo\", \"connectedTo\"], autocompleteAttribute: [\"autocomplete\", \"autocompleteAttribute\"], autocompleteDisabled: [\"matAutocompleteDisabled\", \"autocompleteDisabled\"] }, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatAutocompleteTriggerBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1$1.Overlay }, { type: i0.ViewContainerRef }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_AUTOCOMPLETE_SCROLL_STRATEGY]\n                }] }, { type: i2$1.Directionality, decorators: [{\n                    type: Optional\n                }] }, { type: i4.MatFormField, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_FORM_FIELD]\n                }, {\n                    type: Host\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: i3.ViewportRuler }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_AUTOCOMPLETE_DEFAULT_OPTIONS]\n                }] }]; }, propDecorators: { autocomplete: [{\n                type: Input,\n                args: ['matAutocomplete']\n            }], position: [{\n                type: Input,\n                args: ['matAutocompletePosition']\n            }], connectedTo: [{\n                type: Input,\n                args: ['matAutocompleteConnectedTo']\n            }], autocompleteAttribute: [{\n                type: Input,\n                args: ['autocomplete']\n            }], autocompleteDisabled: [{\n                type: Input,\n                args: ['matAutocompleteDisabled']\n            }] } });\nclass MatAutocompleteTrigger extends _MatAutocompleteTriggerBase {\n    constructor() {\n        super(...arguments);\n        this._aboveClass = 'mat-autocomplete-panel-above';\n    }\n}\nMatAutocompleteTrigger.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatAutocompleteTrigger, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatAutocompleteTrigger.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatAutocompleteTrigger, selector: \"input[matAutocomplete], textarea[matAutocomplete]\", host: { listeners: { \"focusin\": \"_handleFocus()\", \"blur\": \"_onTouched()\", \"input\": \"_handleInput($event)\", \"keydown\": \"_handleKeydown($event)\", \"click\": \"_handleClick()\" }, properties: { \"attr.autocomplete\": \"autocompleteAttribute\", \"attr.role\": \"autocompleteDisabled ? null : \\\"combobox\\\"\", \"attr.aria-autocomplete\": \"autocompleteDisabled ? null : \\\"list\\\"\", \"attr.aria-activedescendant\": \"(panelOpen && activeOption) ? activeOption.id : null\", \"attr.aria-expanded\": \"autocompleteDisabled ? null : panelOpen.toString()\", \"attr.aria-owns\": \"(autocompleteDisabled || !panelOpen) ? null : autocomplete?.id\", \"attr.aria-haspopup\": \"autocompleteDisabled ? null : \\\"listbox\\\"\" }, classAttribute: \"mat-autocomplete-trigger\" }, providers: [MAT_AUTOCOMPLETE_VALUE_ACCESSOR], exportAs: [\"matAutocompleteTrigger\"], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatAutocompleteTrigger, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: `input[matAutocomplete], textarea[matAutocomplete]`,\n                    host: {\n                        'class': 'mat-autocomplete-trigger',\n                        '[attr.autocomplete]': 'autocompleteAttribute',\n                        '[attr.role]': 'autocompleteDisabled ? null : \"combobox\"',\n                        '[attr.aria-autocomplete]': 'autocompleteDisabled ? null : \"list\"',\n                        '[attr.aria-activedescendant]': '(panelOpen && activeOption) ? activeOption.id : null',\n                        '[attr.aria-expanded]': 'autocompleteDisabled ? null : panelOpen.toString()',\n                        '[attr.aria-owns]': '(autocompleteDisabled || !panelOpen) ? null : autocomplete?.id',\n                        '[attr.aria-haspopup]': 'autocompleteDisabled ? null : \"listbox\"',\n                        // Note: we use `focusin`, as opposed to `focus`, in order to open the panel\n                        // a little earlier. This avoids issues where IE delays the focusing of the input.\n                        '(focusin)': '_handleFocus()',\n                        '(blur)': '_onTouched()',\n                        '(input)': '_handleInput($event)',\n                        '(keydown)': '_handleKeydown($event)',\n                        '(click)': '_handleClick()',\n                    },\n                    exportAs: 'matAutocompleteTrigger',\n                    providers: [MAT_AUTOCOMPLETE_VALUE_ACCESSOR],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatAutocompleteModule {\n}\nMatAutocompleteModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatAutocompleteModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatAutocompleteModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatAutocompleteModule, declarations: [MatAutocomplete, MatAutocompleteTrigger, MatAutocompleteOrigin], imports: [OverlayModule, MatOptionModule, MatCommonModule, CommonModule], exports: [MatAutocomplete,\n        MatAutocompleteTrigger,\n        MatAutocompleteOrigin,\n        CdkScrollableModule,\n        MatOptionModule,\n        MatCommonModule] });\nMatAutocompleteModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatAutocompleteModule, providers: [MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER], imports: [[OverlayModule, MatOptionModule, MatCommonModule, CommonModule], CdkScrollableModule,\n        MatOptionModule,\n        MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatAutocompleteModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [OverlayModule, MatOptionModule, MatCommonModule, CommonModule],\n                    exports: [\n                        MatAutocomplete,\n                        MatAutocompleteTrigger,\n                        MatAutocompleteOrigin,\n                        CdkScrollableModule,\n                        MatOptionModule,\n                        MatCommonModule,\n                    ],\n                    declarations: [MatAutocomplete, MatAutocompleteTrigger, MatAutocompleteOrigin],\n                    providers: [MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_AUTOCOMPLETE_DEFAULT_OPTIONS, MAT_AUTOCOMPLETE_DEFAULT_OPTIONS_FACTORY, MAT_AUTOCOMPLETE_SCROLL_STRATEGY, MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY, MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER, MAT_AUTOCOMPLETE_VALUE_ACCESSOR, MatAutocomplete, MatAutocompleteModule, MatAutocompleteOrigin, MatAutocompleteSelectedEvent, MatAutocompleteTrigger, _MatAutocompleteBase, _MatAutocompleteOriginBase, _MatAutocompleteTriggerBase, getMatAutocompleteMissingPanelError };\n","import * as i1 from '@angular/cdk/a11y';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport * as i0 from '@angular/core';\nimport { InjectionToken, forwardRef, EventEmitter, Component, ViewEncapsulation, ChangeDetectionStrategy, Attribute, Optional, Inject, Input, Output, ViewChild, Directive, NgModule } from '@angular/core';\nimport { NG_VALUE_ACCESSOR, NG_VALIDATORS, CheckboxRequiredValidator } from '@angular/forms';\nimport * as i2 from '@angular/material/core';\nimport { mixinTabIndex, mixinColor, mixinDisableRipple, mixinDisabled, MatRipple, MatRippleModule, MatCommonModule } from '@angular/material/core';\nimport { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';\nimport * as i3 from '@angular/cdk/observers';\nimport { ObserversModule } from '@angular/cdk/observers';\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Injection token to be used to override the default options for `mat-checkbox`. */\nconst MAT_CHECKBOX_DEFAULT_OPTIONS = new InjectionToken('mat-checkbox-default-options', {\n    providedIn: 'root',\n    factory: MAT_CHECKBOX_DEFAULT_OPTIONS_FACTORY,\n});\n/** @docs-private */\nfunction MAT_CHECKBOX_DEFAULT_OPTIONS_FACTORY() {\n    return {\n        color: 'accent',\n        clickAction: 'check-indeterminate',\n    };\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// Increasing integer for generating unique ids for checkbox components.\nlet nextUniqueId = 0;\n// Default checkbox configuration.\nconst defaults = MAT_CHECKBOX_DEFAULT_OPTIONS_FACTORY();\n/**\n * Provider Expression that allows mat-checkbox to register as a ControlValueAccessor.\n * This allows it to support [(ngModel)].\n * @docs-private\n */\nconst MAT_CHECKBOX_CONTROL_VALUE_ACCESSOR = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => MatCheckbox),\n    multi: true,\n};\n/** Change event object emitted by MatCheckbox. */\nclass MatCheckboxChange {\n}\n// Boilerplate for applying mixins to MatCheckbox.\n/** @docs-private */\nconst _MatCheckboxBase = mixinTabIndex(mixinColor(mixinDisableRipple(mixinDisabled(class {\n    constructor(_elementRef) {\n        this._elementRef = _elementRef;\n    }\n}))));\n/**\n * A material design checkbox component. Supports all of the functionality of an HTML5 checkbox,\n * and exposes a similar API. A MatCheckbox can be either checked, unchecked, indeterminate, or\n * disabled. Note that all additional accessibility attributes are taken care of by the component,\n * so there is no need to provide them yourself. However, if you want to omit a label and still\n * have the checkbox be accessible, you may supply an [aria-label] input.\n * See: https://material.io/design/components/selection-controls.html\n */\nclass MatCheckbox extends _MatCheckboxBase {\n    constructor(elementRef, _changeDetectorRef, _focusMonitor, _ngZone, tabIndex, _animationMode, _options) {\n        super(elementRef);\n        this._changeDetectorRef = _changeDetectorRef;\n        this._focusMonitor = _focusMonitor;\n        this._ngZone = _ngZone;\n        this._animationMode = _animationMode;\n        this._options = _options;\n        /**\n         * Attached to the aria-label attribute of the host element. In most cases, aria-labelledby will\n         * take precedence so this may be omitted.\n         */\n        this.ariaLabel = '';\n        /**\n         * Users can specify the `aria-labelledby` attribute which will be forwarded to the input element\n         */\n        this.ariaLabelledby = null;\n        this._uniqueId = `mat-checkbox-${++nextUniqueId}`;\n        /** A unique id for the checkbox input. If none is supplied, it will be auto-generated. */\n        this.id = this._uniqueId;\n        /** Whether the label should appear after or before the checkbox. Defaults to 'after' */\n        this.labelPosition = 'after';\n        /** Name value will be applied to the input element if present */\n        this.name = null;\n        /** Event emitted when the checkbox's `checked` value changes. */\n        this.change = new EventEmitter();\n        /** Event emitted when the checkbox's `indeterminate` value changes. */\n        this.indeterminateChange = new EventEmitter();\n        /**\n         * Called when the checkbox is blurred. Needed to properly implement ControlValueAccessor.\n         * @docs-private\n         */\n        this._onTouched = () => { };\n        this._currentAnimationClass = '';\n        this._currentCheckState = 0 /* Init */;\n        this._controlValueAccessorChangeFn = () => { };\n        this._checked = false;\n        this._disabled = false;\n        this._indeterminate = false;\n        this._options = this._options || defaults;\n        this.color = this.defaultColor = this._options.color || defaults.color;\n        this.tabIndex = parseInt(tabIndex) || 0;\n    }\n    /** Returns the unique id for the visual hidden input. */\n    get inputId() {\n        return `${this.id || this._uniqueId}-input`;\n    }\n    /** Whether the checkbox is required. */\n    get required() {\n        return this._required;\n    }\n    set required(value) {\n        this._required = coerceBooleanProperty(value);\n    }\n    ngAfterViewInit() {\n        this._focusMonitor.monitor(this._elementRef, true).subscribe(focusOrigin => {\n            if (!focusOrigin) {\n                // When a focused element becomes disabled, the browser *immediately* fires a blur event.\n                // Angular does not expect events to be raised during change detection, so any state change\n                // (such as a form control's 'ng-touched') will cause a changed-after-checked error.\n                // See https://github.com/angular/angular/issues/17793. To work around this, we defer\n                // telling the form control it has been touched until the next tick.\n                Promise.resolve().then(() => {\n                    this._onTouched();\n                    this._changeDetectorRef.markForCheck();\n                });\n            }\n        });\n        this._syncIndeterminate(this._indeterminate);\n    }\n    // TODO: Delete next major revision.\n    ngAfterViewChecked() { }\n    ngOnDestroy() {\n        this._focusMonitor.stopMonitoring(this._elementRef);\n    }\n    /**\n     * Whether the checkbox is checked.\n     */\n    get checked() {\n        return this._checked;\n    }\n    set checked(value) {\n        const checked = coerceBooleanProperty(value);\n        if (checked != this.checked) {\n            this._checked = checked;\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n    /**\n     * Whether the checkbox is disabled. This fully overrides the implementation provided by\n     * mixinDisabled, but the mixin is still required because mixinTabIndex requires it.\n     */\n    get disabled() {\n        return this._disabled;\n    }\n    set disabled(value) {\n        const newValue = coerceBooleanProperty(value);\n        if (newValue !== this.disabled) {\n            this._disabled = newValue;\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n    /**\n     * Whether the checkbox is indeterminate. This is also known as \"mixed\" mode and can be used to\n     * represent a checkbox with three states, e.g. a checkbox that represents a nested list of\n     * checkable items. Note that whenever checkbox is manually clicked, indeterminate is immediately\n     * set to false.\n     */\n    get indeterminate() {\n        return this._indeterminate;\n    }\n    set indeterminate(value) {\n        const changed = value != this._indeterminate;\n        this._indeterminate = coerceBooleanProperty(value);\n        if (changed) {\n            if (this._indeterminate) {\n                this._transitionCheckState(3 /* Indeterminate */);\n            }\n            else {\n                this._transitionCheckState(this.checked ? 1 /* Checked */ : 2 /* Unchecked */);\n            }\n            this.indeterminateChange.emit(this._indeterminate);\n        }\n        this._syncIndeterminate(this._indeterminate);\n    }\n    _isRippleDisabled() {\n        return this.disableRipple || this.disabled;\n    }\n    /** Method being called whenever the label text changes. */\n    _onLabelTextChange() {\n        // Since the event of the `cdkObserveContent` directive runs outside of the zone, the checkbox\n        // component will be only marked for check, but no actual change detection runs automatically.\n        // Instead of going back into the zone in order to trigger a change detection which causes\n        // *all* components to be checked (if explicitly marked or not using OnPush), we only trigger\n        // an explicit change detection for the checkbox view and its children.\n        this._changeDetectorRef.detectChanges();\n    }\n    // Implemented as part of ControlValueAccessor.\n    writeValue(value) {\n        this.checked = !!value;\n    }\n    // Implemented as part of ControlValueAccessor.\n    registerOnChange(fn) {\n        this._controlValueAccessorChangeFn = fn;\n    }\n    // Implemented as part of ControlValueAccessor.\n    registerOnTouched(fn) {\n        this._onTouched = fn;\n    }\n    // Implemented as part of ControlValueAccessor.\n    setDisabledState(isDisabled) {\n        this.disabled = isDisabled;\n    }\n    _getAriaChecked() {\n        if (this.checked) {\n            return 'true';\n        }\n        return this.indeterminate ? 'mixed' : 'false';\n    }\n    _transitionCheckState(newState) {\n        let oldState = this._currentCheckState;\n        let element = this._elementRef.nativeElement;\n        if (oldState === newState) {\n            return;\n        }\n        if (this._currentAnimationClass.length > 0) {\n            element.classList.remove(this._currentAnimationClass);\n        }\n        this._currentAnimationClass = this._getAnimationClassForCheckStateTransition(oldState, newState);\n        this._currentCheckState = newState;\n        if (this._currentAnimationClass.length > 0) {\n            element.classList.add(this._currentAnimationClass);\n            // Remove the animation class to avoid animation when the checkbox is moved between containers\n            const animationClass = this._currentAnimationClass;\n            this._ngZone.runOutsideAngular(() => {\n                setTimeout(() => {\n                    element.classList.remove(animationClass);\n                }, 1000);\n            });\n        }\n    }\n    _emitChangeEvent() {\n        const event = new MatCheckboxChange();\n        event.source = this;\n        event.checked = this.checked;\n        this._controlValueAccessorChangeFn(this.checked);\n        this.change.emit(event);\n        // Assigning the value again here is redundant, but we have to do it in case it was\n        // changed inside the `change` listener which will cause the input to be out of sync.\n        if (this._inputElement) {\n            this._inputElement.nativeElement.checked = this.checked;\n        }\n    }\n    /** Toggles the `checked` state of the checkbox. */\n    toggle() {\n        this.checked = !this.checked;\n        this._controlValueAccessorChangeFn(this.checked);\n    }\n    /**\n     * Event handler for checkbox input element.\n     * Toggles checked state if element is not disabled.\n     * Do not toggle on (change) event since IE doesn't fire change event when\n     *   indeterminate checkbox is clicked.\n     * @param event\n     */\n    _onInputClick(event) {\n        const clickAction = this._options?.clickAction;\n        // We have to stop propagation for click events on the visual hidden input element.\n        // By default, when a user clicks on a label element, a generated click event will be\n        // dispatched on the associated input element. Since we are using a label element as our\n        // root container, the click event on the `checkbox` will be executed twice.\n        // The real click event will bubble up, and the generated click event also tries to bubble up.\n        // This will lead to multiple click events.\n        // Preventing bubbling for the second event will solve that issue.\n        event.stopPropagation();\n        // If resetIndeterminate is false, and the current state is indeterminate, do nothing on click\n        if (!this.disabled && clickAction !== 'noop') {\n            // When user manually click on the checkbox, `indeterminate` is set to false.\n            if (this.indeterminate && clickAction !== 'check') {\n                Promise.resolve().then(() => {\n                    this._indeterminate = false;\n                    this.indeterminateChange.emit(this._indeterminate);\n                });\n            }\n            this._checked = !this._checked;\n            this._transitionCheckState(this._checked ? 1 /* Checked */ : 2 /* Unchecked */);\n            // Emit our custom change event if the native input emitted one.\n            // It is important to only emit it, if the native input triggered one, because\n            // we don't want to trigger a change event, when the `checked` variable changes for example.\n            this._emitChangeEvent();\n        }\n        else if (!this.disabled && clickAction === 'noop') {\n            // Reset native input when clicked with noop. The native checkbox becomes checked after\n            // click, reset it to be align with `checked` value of `mat-checkbox`.\n            this._inputElement.nativeElement.checked = this.checked;\n            this._inputElement.nativeElement.indeterminate = this.indeterminate;\n        }\n    }\n    /** Focuses the checkbox. */\n    focus(origin, options) {\n        if (origin) {\n            this._focusMonitor.focusVia(this._inputElement, origin, options);\n        }\n        else {\n            this._inputElement.nativeElement.focus(options);\n        }\n    }\n    _onInteractionEvent(event) {\n        // We always have to stop propagation on the change event.\n        // Otherwise the change event, from the input element, will bubble up and\n        // emit its event object to the `change` output.\n        event.stopPropagation();\n    }\n    _getAnimationClassForCheckStateTransition(oldState, newState) {\n        // Don't transition if animations are disabled.\n        if (this._animationMode === 'NoopAnimations') {\n            return '';\n        }\n        let animSuffix = '';\n        switch (oldState) {\n            case 0 /* Init */:\n                // Handle edge case where user interacts with checkbox that does not have [(ngModel)] or\n                // [checked] bound to it.\n                if (newState === 1 /* Checked */) {\n                    animSuffix = 'unchecked-checked';\n                }\n                else if (newState == 3 /* Indeterminate */) {\n                    animSuffix = 'unchecked-indeterminate';\n                }\n                else {\n                    return '';\n                }\n                break;\n            case 2 /* Unchecked */:\n                animSuffix =\n                    newState === 1 /* Checked */\n                        ? 'unchecked-checked'\n                        : 'unchecked-indeterminate';\n                break;\n            case 1 /* Checked */:\n                animSuffix =\n                    newState === 2 /* Unchecked */\n                        ? 'checked-unchecked'\n                        : 'checked-indeterminate';\n                break;\n            case 3 /* Indeterminate */:\n                animSuffix =\n                    newState === 1 /* Checked */\n                        ? 'indeterminate-checked'\n                        : 'indeterminate-unchecked';\n                break;\n        }\n        return `mat-checkbox-anim-${animSuffix}`;\n    }\n    /**\n     * Syncs the indeterminate value with the checkbox DOM node.\n     *\n     * We sync `indeterminate` directly on the DOM node, because in Ivy the check for whether a\n     * property is supported on an element boils down to `if (propName in element)`. Domino's\n     * HTMLInputElement doesn't have an `indeterminate` property so Ivy will warn during\n     * server-side rendering.\n     */\n    _syncIndeterminate(value) {\n        const nativeCheckbox = this._inputElement;\n        if (nativeCheckbox) {\n            nativeCheckbox.nativeElement.indeterminate = value;\n        }\n    }\n}\nMatCheckbox.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCheckbox, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i1.FocusMonitor }, { token: i0.NgZone }, { token: 'tabindex', attribute: true }, { token: ANIMATION_MODULE_TYPE, optional: true }, { token: MAT_CHECKBOX_DEFAULT_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Component });\nMatCheckbox.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatCheckbox, selector: \"mat-checkbox\", inputs: { disableRipple: \"disableRipple\", color: \"color\", tabIndex: \"tabIndex\", ariaLabel: [\"aria-label\", \"ariaLabel\"], ariaLabelledby: [\"aria-labelledby\", \"ariaLabelledby\"], ariaDescribedby: [\"aria-describedby\", \"ariaDescribedby\"], id: \"id\", required: \"required\", labelPosition: \"labelPosition\", name: \"name\", value: \"value\", checked: \"checked\", disabled: \"disabled\", indeterminate: \"indeterminate\" }, outputs: { change: \"change\", indeterminateChange: \"indeterminateChange\" }, host: { properties: { \"id\": \"id\", \"attr.tabindex\": \"null\", \"attr.aria-label\": \"null\", \"attr.aria-labelledby\": \"null\", \"class.mat-checkbox-indeterminate\": \"indeterminate\", \"class.mat-checkbox-checked\": \"checked\", \"class.mat-checkbox-disabled\": \"disabled\", \"class.mat-checkbox-label-before\": \"labelPosition == \\\"before\\\"\", \"class._mat-animation-noopable\": \"_animationMode === 'NoopAnimations'\" }, classAttribute: \"mat-checkbox\" }, providers: [MAT_CHECKBOX_CONTROL_VALUE_ACCESSOR], viewQueries: [{ propertyName: \"_inputElement\", first: true, predicate: [\"input\"], descendants: true }, { propertyName: \"ripple\", first: true, predicate: MatRipple, descendants: true }], exportAs: [\"matCheckbox\"], usesInheritance: true, ngImport: i0, template: \"<label [attr.for]=\\\"inputId\\\" class=\\\"mat-checkbox-layout\\\" #label>\\n  <span class=\\\"mat-checkbox-inner-container\\\"\\n       [class.mat-checkbox-inner-container-no-side-margin]=\\\"!checkboxLabel.textContent || !checkboxLabel.textContent.trim()\\\">\\n    <input #input\\n           class=\\\"mat-checkbox-input cdk-visually-hidden\\\" type=\\\"checkbox\\\"\\n           [id]=\\\"inputId\\\"\\n           [required]=\\\"required\\\"\\n           [checked]=\\\"checked\\\"\\n           [attr.value]=\\\"value\\\"\\n           [disabled]=\\\"disabled\\\"\\n           [attr.name]=\\\"name\\\"\\n           [tabIndex]=\\\"tabIndex\\\"\\n           [attr.aria-label]=\\\"ariaLabel || null\\\"\\n           [attr.aria-labelledby]=\\\"ariaLabelledby\\\"\\n           [attr.aria-checked]=\\\"_getAriaChecked()\\\"\\n           [attr.aria-describedby]=\\\"ariaDescribedby\\\"\\n           (change)=\\\"_onInteractionEvent($event)\\\"\\n           (click)=\\\"_onInputClick($event)\\\">\\n    <span matRipple class=\\\"mat-checkbox-ripple mat-focus-indicator\\\"\\n         [matRippleTrigger]=\\\"label\\\"\\n         [matRippleDisabled]=\\\"_isRippleDisabled()\\\"\\n         [matRippleRadius]=\\\"20\\\"\\n         [matRippleCentered]=\\\"true\\\"\\n         [matRippleAnimation]=\\\"{enterDuration: _animationMode === 'NoopAnimations' ? 0 : 150}\\\">\\n      <span class=\\\"mat-ripple-element mat-checkbox-persistent-ripple\\\"></span>\\n    </span>\\n    <span class=\\\"mat-checkbox-frame\\\"></span>\\n    <span class=\\\"mat-checkbox-background\\\">\\n      <svg version=\\\"1.1\\\"\\n           focusable=\\\"false\\\"\\n           class=\\\"mat-checkbox-checkmark\\\"\\n           viewBox=\\\"0 0 24 24\\\"\\n           aria-hidden=\\\"true\\\">\\n        <path class=\\\"mat-checkbox-checkmark-path\\\"\\n              fill=\\\"none\\\"\\n              stroke=\\\"white\\\"\\n              d=\\\"M4.1,12.7 9,17.6 20.3,6.3\\\"/>\\n      </svg>\\n      <!-- Element for rendering the indeterminate state checkbox. -->\\n      <span class=\\\"mat-checkbox-mixedmark\\\"></span>\\n    </span>\\n  </span>\\n  <span class=\\\"mat-checkbox-label\\\" #checkboxLabel (cdkObserveContent)=\\\"_onLabelTextChange()\\\">\\n    <!-- Add an invisible span so JAWS can read the label -->\\n    <span style=\\\"display:none\\\">&nbsp;</span>\\n    <ng-content></ng-content>\\n  </span>\\n</label>\\n\", styles: [\"@keyframes mat-checkbox-fade-in-background{0%{opacity:0}50%{opacity:1}}@keyframes mat-checkbox-fade-out-background{0%,50%{opacity:1}100%{opacity:0}}@keyframes mat-checkbox-unchecked-checked-checkmark-path{0%,50%{stroke-dashoffset:22.910259}50%{animation-timing-function:cubic-bezier(0, 0, 0.2, 0.1)}100%{stroke-dashoffset:0}}@keyframes mat-checkbox-unchecked-indeterminate-mixedmark{0%,68.2%{transform:scaleX(0)}68.2%{animation-timing-function:cubic-bezier(0, 0, 0, 1)}100%{transform:scaleX(1)}}@keyframes mat-checkbox-checked-unchecked-checkmark-path{from{animation-timing-function:cubic-bezier(0.4, 0, 1, 1);stroke-dashoffset:0}to{stroke-dashoffset:-22.910259}}@keyframes mat-checkbox-checked-indeterminate-checkmark{from{animation-timing-function:cubic-bezier(0, 0, 0.2, 0.1);opacity:1;transform:rotate(0deg)}to{opacity:0;transform:rotate(45deg)}}@keyframes mat-checkbox-indeterminate-checked-checkmark{from{animation-timing-function:cubic-bezier(0.14, 0, 0, 1);opacity:0;transform:rotate(45deg)}to{opacity:1;transform:rotate(360deg)}}@keyframes mat-checkbox-checked-indeterminate-mixedmark{from{animation-timing-function:cubic-bezier(0, 0, 0.2, 0.1);opacity:0;transform:rotate(-45deg)}to{opacity:1;transform:rotate(0deg)}}@keyframes mat-checkbox-indeterminate-checked-mixedmark{from{animation-timing-function:cubic-bezier(0.14, 0, 0, 1);opacity:1;transform:rotate(0deg)}to{opacity:0;transform:rotate(315deg)}}@keyframes mat-checkbox-indeterminate-unchecked-mixedmark{0%{animation-timing-function:linear;opacity:1;transform:scaleX(1)}32.8%,100%{opacity:0;transform:scaleX(0)}}.mat-checkbox-background,.mat-checkbox-frame{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:2px;box-sizing:border-box;pointer-events:none}.mat-checkbox{display:inline-block;transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);cursor:pointer;-webkit-tap-highlight-color:transparent}._mat-animation-noopable.mat-checkbox{transition:none;animation:none}.mat-checkbox .mat-ripple-element:not(.mat-checkbox-persistent-ripple){opacity:.16}.mat-checkbox .mat-checkbox-ripple{position:absolute;left:calc(50% - 20px);top:calc(50% - 20px);height:40px;width:40px;z-index:1;pointer-events:none}.cdk-high-contrast-active .mat-checkbox.cdk-keyboard-focused .mat-checkbox-ripple{outline:solid 3px}.mat-checkbox-layout{-webkit-user-select:none;user-select:none;cursor:inherit;align-items:baseline;vertical-align:middle;display:inline-flex;white-space:nowrap}.mat-checkbox-label{-webkit-user-select:auto;user-select:auto}.mat-checkbox-inner-container{display:inline-block;height:16px;line-height:0;margin:auto;margin-right:8px;order:0;position:relative;vertical-align:middle;white-space:nowrap;width:16px;flex-shrink:0}[dir=rtl] .mat-checkbox-inner-container{margin-left:8px;margin-right:auto}.mat-checkbox-inner-container-no-side-margin{margin-left:0;margin-right:0}.mat-checkbox-frame{background-color:transparent;transition:border-color 90ms cubic-bezier(0, 0, 0.2, 0.1);border-width:2px;border-style:solid}._mat-animation-noopable .mat-checkbox-frame{transition:none}.mat-checkbox-background{align-items:center;display:inline-flex;justify-content:center;transition:background-color 90ms cubic-bezier(0, 0, 0.2, 0.1),opacity 90ms cubic-bezier(0, 0, 0.2, 0.1);-webkit-print-color-adjust:exact;color-adjust:exact}._mat-animation-noopable .mat-checkbox-background{transition:none}.cdk-high-contrast-active .mat-checkbox .mat-checkbox-background{background:none}.mat-checkbox-persistent-ripple{display:block;width:100%;height:100%;transform:none}.mat-checkbox-inner-container:hover .mat-checkbox-persistent-ripple{opacity:.04}.mat-checkbox.cdk-keyboard-focused .mat-checkbox-persistent-ripple{opacity:.12}.mat-checkbox-persistent-ripple,.mat-checkbox.mat-checkbox-disabled .mat-checkbox-inner-container:hover .mat-checkbox-persistent-ripple{opacity:0}@media(hover: none){.mat-checkbox-inner-container:hover .mat-checkbox-persistent-ripple{display:none}}.mat-checkbox-checkmark{top:0;left:0;right:0;bottom:0;position:absolute;width:100%}.mat-checkbox-checkmark-path{stroke-dashoffset:22.910259;stroke-dasharray:22.910259;stroke-width:2.1333333333px}.cdk-high-contrast-black-on-white .mat-checkbox-checkmark-path{stroke:#000 !important}.mat-checkbox-mixedmark{width:calc(100% - 6px);height:2px;opacity:0;transform:scaleX(0) rotate(0deg);border-radius:2px}.cdk-high-contrast-active .mat-checkbox-mixedmark{height:0;border-top:solid 2px;margin-top:2px}.mat-checkbox-label-before .mat-checkbox-inner-container{order:1;margin-left:8px;margin-right:auto}[dir=rtl] .mat-checkbox-label-before .mat-checkbox-inner-container{margin-left:auto;margin-right:8px}.mat-checkbox-checked .mat-checkbox-checkmark{opacity:1}.mat-checkbox-checked .mat-checkbox-checkmark-path{stroke-dashoffset:0}.mat-checkbox-checked .mat-checkbox-mixedmark{transform:scaleX(1) rotate(-45deg)}.mat-checkbox-indeterminate .mat-checkbox-checkmark{opacity:0;transform:rotate(45deg)}.mat-checkbox-indeterminate .mat-checkbox-checkmark-path{stroke-dashoffset:0}.mat-checkbox-indeterminate .mat-checkbox-mixedmark{opacity:1;transform:scaleX(1) rotate(0deg)}.mat-checkbox-unchecked .mat-checkbox-background{background-color:transparent}.mat-checkbox-disabled{cursor:default}.cdk-high-contrast-active .mat-checkbox-disabled{opacity:.5}.mat-checkbox-anim-unchecked-checked .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-in-background}.mat-checkbox-anim-unchecked-checked .mat-checkbox-checkmark-path{animation:180ms linear 0ms mat-checkbox-unchecked-checked-checkmark-path}.mat-checkbox-anim-unchecked-indeterminate .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-in-background}.mat-checkbox-anim-unchecked-indeterminate .mat-checkbox-mixedmark{animation:90ms linear 0ms mat-checkbox-unchecked-indeterminate-mixedmark}.mat-checkbox-anim-checked-unchecked .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-out-background}.mat-checkbox-anim-checked-unchecked .mat-checkbox-checkmark-path{animation:90ms linear 0ms mat-checkbox-checked-unchecked-checkmark-path}.mat-checkbox-anim-checked-indeterminate .mat-checkbox-checkmark{animation:90ms linear 0ms mat-checkbox-checked-indeterminate-checkmark}.mat-checkbox-anim-checked-indeterminate .mat-checkbox-mixedmark{animation:90ms linear 0ms mat-checkbox-checked-indeterminate-mixedmark}.mat-checkbox-anim-indeterminate-checked .mat-checkbox-checkmark{animation:500ms linear 0ms mat-checkbox-indeterminate-checked-checkmark}.mat-checkbox-anim-indeterminate-checked .mat-checkbox-mixedmark{animation:500ms linear 0ms mat-checkbox-indeterminate-checked-mixedmark}.mat-checkbox-anim-indeterminate-unchecked .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-out-background}.mat-checkbox-anim-indeterminate-unchecked .mat-checkbox-mixedmark{animation:300ms linear 0ms mat-checkbox-indeterminate-unchecked-mixedmark}.mat-checkbox-input{bottom:0;left:50%}\\n\"], directives: [{ type: i2.MatRipple, selector: \"[mat-ripple], [matRipple]\", inputs: [\"matRippleColor\", \"matRippleUnbounded\", \"matRippleCentered\", \"matRippleRadius\", \"matRippleAnimation\", \"matRippleDisabled\", \"matRippleTrigger\"], exportAs: [\"matRipple\"] }, { type: i3.CdkObserveContent, selector: \"[cdkObserveContent]\", inputs: [\"cdkObserveContentDisabled\", \"debounce\"], outputs: [\"cdkObserveContent\"], exportAs: [\"cdkObserveContent\"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCheckbox, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-checkbox', exportAs: 'matCheckbox', host: {\n                        'class': 'mat-checkbox',\n                        '[id]': 'id',\n                        '[attr.tabindex]': 'null',\n                        '[attr.aria-label]': 'null',\n                        '[attr.aria-labelledby]': 'null',\n                        '[class.mat-checkbox-indeterminate]': 'indeterminate',\n                        '[class.mat-checkbox-checked]': 'checked',\n                        '[class.mat-checkbox-disabled]': 'disabled',\n                        '[class.mat-checkbox-label-before]': 'labelPosition == \"before\"',\n                        '[class._mat-animation-noopable]': `_animationMode === 'NoopAnimations'`,\n                    }, providers: [MAT_CHECKBOX_CONTROL_VALUE_ACCESSOR], inputs: ['disableRipple', 'color', 'tabIndex'], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: \"<label [attr.for]=\\\"inputId\\\" class=\\\"mat-checkbox-layout\\\" #label>\\n  <span class=\\\"mat-checkbox-inner-container\\\"\\n       [class.mat-checkbox-inner-container-no-side-margin]=\\\"!checkboxLabel.textContent || !checkboxLabel.textContent.trim()\\\">\\n    <input #input\\n           class=\\\"mat-checkbox-input cdk-visually-hidden\\\" type=\\\"checkbox\\\"\\n           [id]=\\\"inputId\\\"\\n           [required]=\\\"required\\\"\\n           [checked]=\\\"checked\\\"\\n           [attr.value]=\\\"value\\\"\\n           [disabled]=\\\"disabled\\\"\\n           [attr.name]=\\\"name\\\"\\n           [tabIndex]=\\\"tabIndex\\\"\\n           [attr.aria-label]=\\\"ariaLabel || null\\\"\\n           [attr.aria-labelledby]=\\\"ariaLabelledby\\\"\\n           [attr.aria-checked]=\\\"_getAriaChecked()\\\"\\n           [attr.aria-describedby]=\\\"ariaDescribedby\\\"\\n           (change)=\\\"_onInteractionEvent($event)\\\"\\n           (click)=\\\"_onInputClick($event)\\\">\\n    <span matRipple class=\\\"mat-checkbox-ripple mat-focus-indicator\\\"\\n         [matRippleTrigger]=\\\"label\\\"\\n         [matRippleDisabled]=\\\"_isRippleDisabled()\\\"\\n         [matRippleRadius]=\\\"20\\\"\\n         [matRippleCentered]=\\\"true\\\"\\n         [matRippleAnimation]=\\\"{enterDuration: _animationMode === 'NoopAnimations' ? 0 : 150}\\\">\\n      <span class=\\\"mat-ripple-element mat-checkbox-persistent-ripple\\\"></span>\\n    </span>\\n    <span class=\\\"mat-checkbox-frame\\\"></span>\\n    <span class=\\\"mat-checkbox-background\\\">\\n      <svg version=\\\"1.1\\\"\\n           focusable=\\\"false\\\"\\n           class=\\\"mat-checkbox-checkmark\\\"\\n           viewBox=\\\"0 0 24 24\\\"\\n           aria-hidden=\\\"true\\\">\\n        <path class=\\\"mat-checkbox-checkmark-path\\\"\\n              fill=\\\"none\\\"\\n              stroke=\\\"white\\\"\\n              d=\\\"M4.1,12.7 9,17.6 20.3,6.3\\\"/>\\n      </svg>\\n      <!-- Element for rendering the indeterminate state checkbox. -->\\n      <span class=\\\"mat-checkbox-mixedmark\\\"></span>\\n    </span>\\n  </span>\\n  <span class=\\\"mat-checkbox-label\\\" #checkboxLabel (cdkObserveContent)=\\\"_onLabelTextChange()\\\">\\n    <!-- Add an invisible span so JAWS can read the label -->\\n    <span style=\\\"display:none\\\">&nbsp;</span>\\n    <ng-content></ng-content>\\n  </span>\\n</label>\\n\", styles: [\"@keyframes mat-checkbox-fade-in-background{0%{opacity:0}50%{opacity:1}}@keyframes mat-checkbox-fade-out-background{0%,50%{opacity:1}100%{opacity:0}}@keyframes mat-checkbox-unchecked-checked-checkmark-path{0%,50%{stroke-dashoffset:22.910259}50%{animation-timing-function:cubic-bezier(0, 0, 0.2, 0.1)}100%{stroke-dashoffset:0}}@keyframes mat-checkbox-unchecked-indeterminate-mixedmark{0%,68.2%{transform:scaleX(0)}68.2%{animation-timing-function:cubic-bezier(0, 0, 0, 1)}100%{transform:scaleX(1)}}@keyframes mat-checkbox-checked-unchecked-checkmark-path{from{animation-timing-function:cubic-bezier(0.4, 0, 1, 1);stroke-dashoffset:0}to{stroke-dashoffset:-22.910259}}@keyframes mat-checkbox-checked-indeterminate-checkmark{from{animation-timing-function:cubic-bezier(0, 0, 0.2, 0.1);opacity:1;transform:rotate(0deg)}to{opacity:0;transform:rotate(45deg)}}@keyframes mat-checkbox-indeterminate-checked-checkmark{from{animation-timing-function:cubic-bezier(0.14, 0, 0, 1);opacity:0;transform:rotate(45deg)}to{opacity:1;transform:rotate(360deg)}}@keyframes mat-checkbox-checked-indeterminate-mixedmark{from{animation-timing-function:cubic-bezier(0, 0, 0.2, 0.1);opacity:0;transform:rotate(-45deg)}to{opacity:1;transform:rotate(0deg)}}@keyframes mat-checkbox-indeterminate-checked-mixedmark{from{animation-timing-function:cubic-bezier(0.14, 0, 0, 1);opacity:1;transform:rotate(0deg)}to{opacity:0;transform:rotate(315deg)}}@keyframes mat-checkbox-indeterminate-unchecked-mixedmark{0%{animation-timing-function:linear;opacity:1;transform:scaleX(1)}32.8%,100%{opacity:0;transform:scaleX(0)}}.mat-checkbox-background,.mat-checkbox-frame{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:2px;box-sizing:border-box;pointer-events:none}.mat-checkbox{display:inline-block;transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);cursor:pointer;-webkit-tap-highlight-color:transparent}._mat-animation-noopable.mat-checkbox{transition:none;animation:none}.mat-checkbox .mat-ripple-element:not(.mat-checkbox-persistent-ripple){opacity:.16}.mat-checkbox .mat-checkbox-ripple{position:absolute;left:calc(50% - 20px);top:calc(50% - 20px);height:40px;width:40px;z-index:1;pointer-events:none}.cdk-high-contrast-active .mat-checkbox.cdk-keyboard-focused .mat-checkbox-ripple{outline:solid 3px}.mat-checkbox-layout{-webkit-user-select:none;user-select:none;cursor:inherit;align-items:baseline;vertical-align:middle;display:inline-flex;white-space:nowrap}.mat-checkbox-label{-webkit-user-select:auto;user-select:auto}.mat-checkbox-inner-container{display:inline-block;height:16px;line-height:0;margin:auto;margin-right:8px;order:0;position:relative;vertical-align:middle;white-space:nowrap;width:16px;flex-shrink:0}[dir=rtl] .mat-checkbox-inner-container{margin-left:8px;margin-right:auto}.mat-checkbox-inner-container-no-side-margin{margin-left:0;margin-right:0}.mat-checkbox-frame{background-color:transparent;transition:border-color 90ms cubic-bezier(0, 0, 0.2, 0.1);border-width:2px;border-style:solid}._mat-animation-noopable .mat-checkbox-frame{transition:none}.mat-checkbox-background{align-items:center;display:inline-flex;justify-content:center;transition:background-color 90ms cubic-bezier(0, 0, 0.2, 0.1),opacity 90ms cubic-bezier(0, 0, 0.2, 0.1);-webkit-print-color-adjust:exact;color-adjust:exact}._mat-animation-noopable .mat-checkbox-background{transition:none}.cdk-high-contrast-active .mat-checkbox .mat-checkbox-background{background:none}.mat-checkbox-persistent-ripple{display:block;width:100%;height:100%;transform:none}.mat-checkbox-inner-container:hover .mat-checkbox-persistent-ripple{opacity:.04}.mat-checkbox.cdk-keyboard-focused .mat-checkbox-persistent-ripple{opacity:.12}.mat-checkbox-persistent-ripple,.mat-checkbox.mat-checkbox-disabled .mat-checkbox-inner-container:hover .mat-checkbox-persistent-ripple{opacity:0}@media(hover: none){.mat-checkbox-inner-container:hover .mat-checkbox-persistent-ripple{display:none}}.mat-checkbox-checkmark{top:0;left:0;right:0;bottom:0;position:absolute;width:100%}.mat-checkbox-checkmark-path{stroke-dashoffset:22.910259;stroke-dasharray:22.910259;stroke-width:2.1333333333px}.cdk-high-contrast-black-on-white .mat-checkbox-checkmark-path{stroke:#000 !important}.mat-checkbox-mixedmark{width:calc(100% - 6px);height:2px;opacity:0;transform:scaleX(0) rotate(0deg);border-radius:2px}.cdk-high-contrast-active .mat-checkbox-mixedmark{height:0;border-top:solid 2px;margin-top:2px}.mat-checkbox-label-before .mat-checkbox-inner-container{order:1;margin-left:8px;margin-right:auto}[dir=rtl] .mat-checkbox-label-before .mat-checkbox-inner-container{margin-left:auto;margin-right:8px}.mat-checkbox-checked .mat-checkbox-checkmark{opacity:1}.mat-checkbox-checked .mat-checkbox-checkmark-path{stroke-dashoffset:0}.mat-checkbox-checked .mat-checkbox-mixedmark{transform:scaleX(1) rotate(-45deg)}.mat-checkbox-indeterminate .mat-checkbox-checkmark{opacity:0;transform:rotate(45deg)}.mat-checkbox-indeterminate .mat-checkbox-checkmark-path{stroke-dashoffset:0}.mat-checkbox-indeterminate .mat-checkbox-mixedmark{opacity:1;transform:scaleX(1) rotate(0deg)}.mat-checkbox-unchecked .mat-checkbox-background{background-color:transparent}.mat-checkbox-disabled{cursor:default}.cdk-high-contrast-active .mat-checkbox-disabled{opacity:.5}.mat-checkbox-anim-unchecked-checked .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-in-background}.mat-checkbox-anim-unchecked-checked .mat-checkbox-checkmark-path{animation:180ms linear 0ms mat-checkbox-unchecked-checked-checkmark-path}.mat-checkbox-anim-unchecked-indeterminate .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-in-background}.mat-checkbox-anim-unchecked-indeterminate .mat-checkbox-mixedmark{animation:90ms linear 0ms mat-checkbox-unchecked-indeterminate-mixedmark}.mat-checkbox-anim-checked-unchecked .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-out-background}.mat-checkbox-anim-checked-unchecked .mat-checkbox-checkmark-path{animation:90ms linear 0ms mat-checkbox-checked-unchecked-checkmark-path}.mat-checkbox-anim-checked-indeterminate .mat-checkbox-checkmark{animation:90ms linear 0ms mat-checkbox-checked-indeterminate-checkmark}.mat-checkbox-anim-checked-indeterminate .mat-checkbox-mixedmark{animation:90ms linear 0ms mat-checkbox-checked-indeterminate-mixedmark}.mat-checkbox-anim-indeterminate-checked .mat-checkbox-checkmark{animation:500ms linear 0ms mat-checkbox-indeterminate-checked-checkmark}.mat-checkbox-anim-indeterminate-checked .mat-checkbox-mixedmark{animation:500ms linear 0ms mat-checkbox-indeterminate-checked-mixedmark}.mat-checkbox-anim-indeterminate-unchecked .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-out-background}.mat-checkbox-anim-indeterminate-unchecked .mat-checkbox-mixedmark{animation:300ms linear 0ms mat-checkbox-indeterminate-unchecked-mixedmark}.mat-checkbox-input{bottom:0;left:50%}\\n\"] }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i1.FocusMonitor }, { type: i0.NgZone }, { type: undefined, decorators: [{\n                    type: Attribute,\n                    args: ['tabindex']\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [ANIMATION_MODULE_TYPE]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_CHECKBOX_DEFAULT_OPTIONS]\n                }] }]; }, propDecorators: { ariaLabel: [{\n                type: Input,\n                args: ['aria-label']\n            }], ariaLabelledby: [{\n                type: Input,\n                args: ['aria-labelledby']\n            }], ariaDescribedby: [{\n                type: Input,\n                args: ['aria-describedby']\n            }], id: [{\n                type: Input\n            }], required: [{\n                type: Input\n            }], labelPosition: [{\n                type: Input\n            }], name: [{\n                type: Input\n            }], change: [{\n                type: Output\n            }], indeterminateChange: [{\n                type: Output\n            }], value: [{\n                type: Input\n            }], _inputElement: [{\n                type: ViewChild,\n                args: ['input']\n            }], ripple: [{\n                type: ViewChild,\n                args: [MatRipple]\n            }], checked: [{\n                type: Input\n            }], disabled: [{\n                type: Input\n            }], indeterminate: [{\n                type: Input\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 */\nconst MAT_CHECKBOX_REQUIRED_VALIDATOR = {\n    provide: NG_VALIDATORS,\n    useExisting: forwardRef(() => MatCheckboxRequiredValidator),\n    multi: true,\n};\n/**\n * Validator for Material checkbox's required attribute in template-driven checkbox.\n * Current CheckboxRequiredValidator only work with `input type=checkbox` and does not\n * work with `mat-checkbox`.\n */\nclass MatCheckboxRequiredValidator extends CheckboxRequiredValidator {\n}\nMatCheckboxRequiredValidator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCheckboxRequiredValidator, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatCheckboxRequiredValidator.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatCheckboxRequiredValidator, selector: \"mat-checkbox[required][formControlName],\\n             mat-checkbox[required][formControl], mat-checkbox[required][ngModel]\", providers: [MAT_CHECKBOX_REQUIRED_VALIDATOR], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCheckboxRequiredValidator, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: `mat-checkbox[required][formControlName],\n             mat-checkbox[required][formControl], mat-checkbox[required][ngModel]`,\n                    providers: [MAT_CHECKBOX_REQUIRED_VALIDATOR],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** This module is used by both original and MDC-based checkbox implementations. */\nclass _MatCheckboxRequiredValidatorModule {\n}\n_MatCheckboxRequiredValidatorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatCheckboxRequiredValidatorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\n_MatCheckboxRequiredValidatorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatCheckboxRequiredValidatorModule, declarations: [MatCheckboxRequiredValidator], exports: [MatCheckboxRequiredValidator] });\n_MatCheckboxRequiredValidatorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatCheckboxRequiredValidatorModule });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatCheckboxRequiredValidatorModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    exports: [MatCheckboxRequiredValidator],\n                    declarations: [MatCheckboxRequiredValidator],\n                }]\n        }] });\nclass MatCheckboxModule {\n}\nMatCheckboxModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCheckboxModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatCheckboxModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCheckboxModule, declarations: [MatCheckbox], imports: [MatRippleModule, MatCommonModule, ObserversModule, _MatCheckboxRequiredValidatorModule], exports: [MatCheckbox, MatCommonModule, _MatCheckboxRequiredValidatorModule] });\nMatCheckboxModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCheckboxModule, imports: [[MatRippleModule, MatCommonModule, ObserversModule, _MatCheckboxRequiredValidatorModule], MatCommonModule, _MatCheckboxRequiredValidatorModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCheckboxModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [MatRippleModule, MatCommonModule, ObserversModule, _MatCheckboxRequiredValidatorModule],\n                    exports: [MatCheckbox, MatCommonModule, _MatCheckboxRequiredValidatorModule],\n                    declarations: [MatCheckbox],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_CHECKBOX_CONTROL_VALUE_ACCESSOR, MAT_CHECKBOX_DEFAULT_OPTIONS, MAT_CHECKBOX_DEFAULT_OPTIONS_FACTORY, MAT_CHECKBOX_REQUIRED_VALIDATOR, MatCheckbox, MatCheckboxChange, MatCheckboxModule, MatCheckboxRequiredValidator, _MatCheckboxRequiredValidatorModule };\n","import { SPACE, BACKSPACE, DELETE, TAB, hasModifierKey, ENTER } from '@angular/cdk/keycodes';\nimport * as i0 from '@angular/core';\nimport { InjectionToken, Directive, EventEmitter, Optional, Inject, Attribute, ContentChild, Input, Output, Component, ViewEncapsulation, ChangeDetectionStrategy, Self, ContentChildren, NgModule } from '@angular/core';\nimport * as i3 from '@angular/material/core';\nimport { mixinTabIndex, mixinColor, mixinDisableRipple, RippleRenderer, MAT_RIPPLE_GLOBAL_OPTIONS, mixinErrorState, MatCommonModule, ErrorStateMatcher } from '@angular/material/core';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport * as i1 from '@angular/cdk/platform';\nimport { DOCUMENT } from '@angular/common';\nimport { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';\nimport { Subject, merge } from 'rxjs';\nimport { take, takeUntil, startWith } from 'rxjs/operators';\nimport { FocusKeyManager } from '@angular/cdk/a11y';\nimport * as i1$1 from '@angular/cdk/bidi';\nimport { SelectionModel } from '@angular/cdk/collections';\nimport * as i2 from '@angular/forms';\nimport { Validators } from '@angular/forms';\nimport { MatFormFieldControl } from '@angular/material/form-field';\n\n/** Event object emitted by MatChip when selected or deselected. */\nclass MatChipSelectionChange {\n    constructor(\n    /** Reference to the chip that emitted the event. */\n    source, \n    /** Whether the chip that emitted the event is selected. */\n    selected, \n    /** Whether the selection change was a result of a user interaction. */\n    isUserInput = false) {\n        this.source = source;\n        this.selected = selected;\n        this.isUserInput = isUserInput;\n    }\n}\n/**\n * Injection token that can be used to reference instances of `MatChipRemove`. It serves as\n * alternative token to the actual `MatChipRemove` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */\nconst MAT_CHIP_REMOVE = new InjectionToken('MatChipRemove');\n/**\n * Injection token that can be used to reference instances of `MatChipAvatar`. It serves as\n * alternative token to the actual `MatChipAvatar` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */\nconst MAT_CHIP_AVATAR = new InjectionToken('MatChipAvatar');\n/**\n * Injection token that can be used to reference instances of `MatChipTrailingIcon`. It serves as\n * alternative token to the actual `MatChipTrailingIcon` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */\nconst MAT_CHIP_TRAILING_ICON = new InjectionToken('MatChipTrailingIcon');\n// Boilerplate for applying mixins to MatChip.\n/** @docs-private */\nclass MatChipBase {\n    constructor(_elementRef) {\n        this._elementRef = _elementRef;\n    }\n}\nconst _MatChipMixinBase = mixinTabIndex(mixinColor(mixinDisableRipple(MatChipBase), 'primary'), -1);\n/**\n * Dummy directive to add CSS class to chip avatar.\n * @docs-private\n */\nclass MatChipAvatar {\n}\nMatChipAvatar.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatChipAvatar, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatChipAvatar.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatChipAvatar, selector: \"mat-chip-avatar, [matChipAvatar]\", host: { classAttribute: \"mat-chip-avatar\" }, providers: [{ provide: MAT_CHIP_AVATAR, useExisting: MatChipAvatar }], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatChipAvatar, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-chip-avatar, [matChipAvatar]',\n                    host: { 'class': 'mat-chip-avatar' },\n                    providers: [{ provide: MAT_CHIP_AVATAR, useExisting: MatChipAvatar }],\n                }]\n        }] });\n/**\n * Dummy directive to add CSS class to chip trailing icon.\n * @docs-private\n */\nclass MatChipTrailingIcon {\n}\nMatChipTrailingIcon.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatChipTrailingIcon, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatChipTrailingIcon.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatChipTrailingIcon, selector: \"mat-chip-trailing-icon, [matChipTrailingIcon]\", host: { classAttribute: \"mat-chip-trailing-icon\" }, providers: [{ provide: MAT_CHIP_TRAILING_ICON, useExisting: MatChipTrailingIcon }], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatChipTrailingIcon, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-chip-trailing-icon, [matChipTrailingIcon]',\n                    host: { 'class': 'mat-chip-trailing-icon' },\n                    providers: [{ provide: MAT_CHIP_TRAILING_ICON, useExisting: MatChipTrailingIcon }],\n                }]\n        }] });\n/** Material Design styled chip directive. Used inside the MatChipList component. */\nclass MatChip extends _MatChipMixinBase {\n    constructor(elementRef, _ngZone, platform, globalRippleOptions, _changeDetectorRef, _document, animationMode, tabIndex) {\n        super(elementRef);\n        this._ngZone = _ngZone;\n        this._changeDetectorRef = _changeDetectorRef;\n        /** Whether the chip has focus. */\n        this._hasFocus = false;\n        /** Whether the chip list is selectable */\n        this.chipListSelectable = true;\n        /** Whether the chip list is in multi-selection mode. */\n        this._chipListMultiple = false;\n        /** Whether the chip list as a whole is disabled. */\n        this._chipListDisabled = false;\n        this._selected = false;\n        this._selectable = true;\n        this._disabled = false;\n        this._removable = true;\n        /** Emits when the chip is focused. */\n        this._onFocus = new Subject();\n        /** Emits when the chip is blured. */\n        this._onBlur = new Subject();\n        /** Emitted when the chip is selected or deselected. */\n        this.selectionChange = new EventEmitter();\n        /** Emitted when the chip is destroyed. */\n        this.destroyed = new EventEmitter();\n        /** Emitted when a chip is to be removed. */\n        this.removed = new EventEmitter();\n        this._addHostClassName();\n        // Dynamically create the ripple target, append it within the chip, and use it as the\n        // chip's ripple target. Adding the class '.mat-chip-ripple' ensures that it will have\n        // the proper styles.\n        this._chipRippleTarget = _document.createElement('div');\n        this._chipRippleTarget.classList.add('mat-chip-ripple');\n        this._elementRef.nativeElement.appendChild(this._chipRippleTarget);\n        this._chipRipple = new RippleRenderer(this, _ngZone, this._chipRippleTarget, platform);\n        this._chipRipple.setupTriggerEvents(elementRef);\n        this.rippleConfig = globalRippleOptions || {};\n        this._animationsDisabled = animationMode === 'NoopAnimations';\n        this.tabIndex = tabIndex != null ? parseInt(tabIndex) || -1 : -1;\n    }\n    /**\n     * Whether ripples are disabled on interaction\n     * @docs-private\n     */\n    get rippleDisabled() {\n        return (this.disabled ||\n            this.disableRipple ||\n            this._animationsDisabled ||\n            !!this.rippleConfig.disabled);\n    }\n    /** Whether the chip is selected. */\n    get selected() {\n        return this._selected;\n    }\n    set selected(value) {\n        const coercedValue = coerceBooleanProperty(value);\n        if (coercedValue !== this._selected) {\n            this._selected = coercedValue;\n            this._dispatchSelectionChange();\n        }\n    }\n    /** The value of the chip. Defaults to the content inside `<mat-chip>` tags. */\n    get value() {\n        return this._value !== undefined ? this._value : this._elementRef.nativeElement.textContent;\n    }\n    set value(value) {\n        this._value = value;\n    }\n    /**\n     * Whether or not the chip is selectable. When a chip is not selectable,\n     * changes to its selected state are always ignored. By default a chip is\n     * selectable, and it becomes non-selectable if its parent chip list is\n     * not selectable.\n     */\n    get selectable() {\n        return this._selectable && this.chipListSelectable;\n    }\n    set selectable(value) {\n        this._selectable = coerceBooleanProperty(value);\n    }\n    /** Whether the chip is disabled. */\n    get disabled() {\n        return this._chipListDisabled || this._disabled;\n    }\n    set disabled(value) {\n        this._disabled = coerceBooleanProperty(value);\n    }\n    /**\n     * Determines whether or not the chip displays the remove styling and emits (removed) events.\n     */\n    get removable() {\n        return this._removable;\n    }\n    set removable(value) {\n        this._removable = coerceBooleanProperty(value);\n    }\n    /** The ARIA selected applied to the chip. */\n    get ariaSelected() {\n        // Remove the `aria-selected` when the chip is deselected in single-selection mode, because\n        // it adds noise to NVDA users where \"not selected\" will be read out for each chip.\n        return this.selectable && (this._chipListMultiple || this.selected)\n            ? this.selected.toString()\n            : null;\n    }\n    _addHostClassName() {\n        const basicChipAttrName = 'mat-basic-chip';\n        const element = this._elementRef.nativeElement;\n        if (element.hasAttribute(basicChipAttrName) ||\n            element.tagName.toLowerCase() === basicChipAttrName) {\n            element.classList.add(basicChipAttrName);\n            return;\n        }\n        else {\n            element.classList.add('mat-standard-chip');\n        }\n    }\n    ngOnDestroy() {\n        this.destroyed.emit({ chip: this });\n        this._chipRipple._removeTriggerEvents();\n    }\n    /** Selects the chip. */\n    select() {\n        if (!this._selected) {\n            this._selected = true;\n            this._dispatchSelectionChange();\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n    /** Deselects the chip. */\n    deselect() {\n        if (this._selected) {\n            this._selected = false;\n            this._dispatchSelectionChange();\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n    /** Select this chip and emit selected event */\n    selectViaInteraction() {\n        if (!this._selected) {\n            this._selected = true;\n            this._dispatchSelectionChange(true);\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n    /** Toggles the current selected state of this chip. */\n    toggleSelected(isUserInput = false) {\n        this._selected = !this.selected;\n        this._dispatchSelectionChange(isUserInput);\n        this._changeDetectorRef.markForCheck();\n        return this.selected;\n    }\n    /** Allows for programmatic focusing of the chip. */\n    focus() {\n        if (!this._hasFocus) {\n            this._elementRef.nativeElement.focus();\n            this._onFocus.next({ chip: this });\n        }\n        this._hasFocus = true;\n    }\n    /**\n     * Allows for programmatic removal of the chip. Called by the MatChipList when the DELETE or\n     * BACKSPACE keys are pressed.\n     *\n     * Informs any listeners of the removal request. Does not remove the chip from the DOM.\n     */\n    remove() {\n        if (this.removable) {\n            this.removed.emit({ chip: this });\n        }\n    }\n    /** Handles click events on the chip. */\n    _handleClick(event) {\n        if (this.disabled) {\n            event.preventDefault();\n        }\n    }\n    /** Handle custom key presses. */\n    _handleKeydown(event) {\n        if (this.disabled) {\n            return;\n        }\n        switch (event.keyCode) {\n            case DELETE:\n            case BACKSPACE:\n                // If we are removable, remove the focused chip\n                this.remove();\n                // Always prevent so page navigation does not occur\n                event.preventDefault();\n                break;\n            case SPACE:\n                // If we are selectable, toggle the focused chip\n                if (this.selectable) {\n                    this.toggleSelected(true);\n                }\n                // Always prevent space from scrolling the page since the list has focus\n                event.preventDefault();\n                break;\n        }\n    }\n    _blur() {\n        // When animations are enabled, Angular may end up removing the chip from the DOM a little\n        // earlier than usual, causing it to be blurred and throwing off the logic in the chip list\n        // that moves focus not the next item. To work around the issue, we defer marking the chip\n        // as not focused until the next time the zone stabilizes.\n        this._ngZone.onStable.pipe(take(1)).subscribe(() => {\n            this._ngZone.run(() => {\n                this._hasFocus = false;\n                this._onBlur.next({ chip: this });\n            });\n        });\n    }\n    _dispatchSelectionChange(isUserInput = false) {\n        this.selectionChange.emit({\n            source: this,\n            isUserInput,\n            selected: this._selected,\n        });\n    }\n}\nMatChip.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatChip, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: i1.Platform }, { token: MAT_RIPPLE_GLOBAL_OPTIONS, optional: true }, { token: i0.ChangeDetectorRef }, { token: DOCUMENT }, { token: ANIMATION_MODULE_TYPE, optional: true }, { token: 'tabindex', attribute: true }], target: i0.ɵɵFactoryTarget.Directive });\nMatChip.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatChip, selector: \"mat-basic-chip, [mat-basic-chip], mat-chip, [mat-chip]\", inputs: { color: \"color\", disableRipple: \"disableRipple\", tabIndex: \"tabIndex\", selected: \"selected\", value: \"value\", selectable: \"selectable\", disabled: \"disabled\", removable: \"removable\" }, outputs: { selectionChange: \"selectionChange\", destroyed: \"destroyed\", removed: \"removed\" }, host: { attributes: { \"role\": \"option\" }, listeners: { \"click\": \"_handleClick($event)\", \"keydown\": \"_handleKeydown($event)\", \"focus\": \"focus()\", \"blur\": \"_blur()\" }, properties: { \"attr.tabindex\": \"disabled ? null : tabIndex\", \"class.mat-chip-selected\": \"selected\", \"class.mat-chip-with-avatar\": \"avatar\", \"class.mat-chip-with-trailing-icon\": \"trailingIcon || removeIcon\", \"class.mat-chip-disabled\": \"disabled\", \"class._mat-animation-noopable\": \"_animationsDisabled\", \"attr.disabled\": \"disabled || null\", \"attr.aria-disabled\": \"disabled.toString()\", \"attr.aria-selected\": \"ariaSelected\" }, classAttribute: \"mat-chip mat-focus-indicator\" }, queries: [{ propertyName: \"avatar\", first: true, predicate: MAT_CHIP_AVATAR, descendants: true }, { propertyName: \"trailingIcon\", first: true, predicate: MAT_CHIP_TRAILING_ICON, descendants: true }, { propertyName: \"removeIcon\", first: true, predicate: MAT_CHIP_REMOVE, descendants: true }], exportAs: [\"matChip\"], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatChip, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: `mat-basic-chip, [mat-basic-chip], mat-chip, [mat-chip]`,\n                    inputs: ['color', 'disableRipple', 'tabIndex'],\n                    exportAs: 'matChip',\n                    host: {\n                        'class': 'mat-chip mat-focus-indicator',\n                        '[attr.tabindex]': 'disabled ? null : tabIndex',\n                        'role': 'option',\n                        '[class.mat-chip-selected]': 'selected',\n                        '[class.mat-chip-with-avatar]': 'avatar',\n                        '[class.mat-chip-with-trailing-icon]': 'trailingIcon || removeIcon',\n                        '[class.mat-chip-disabled]': 'disabled',\n                        '[class._mat-animation-noopable]': '_animationsDisabled',\n                        '[attr.disabled]': 'disabled || null',\n                        '[attr.aria-disabled]': 'disabled.toString()',\n                        '[attr.aria-selected]': 'ariaSelected',\n                        '(click)': '_handleClick($event)',\n                        '(keydown)': '_handleKeydown($event)',\n                        '(focus)': 'focus()',\n                        '(blur)': '_blur()',\n                    },\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: i1.Platform }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_RIPPLE_GLOBAL_OPTIONS]\n                }] }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [ANIMATION_MODULE_TYPE]\n                }] }, { type: undefined, decorators: [{\n                    type: Attribute,\n                    args: ['tabindex']\n                }] }]; }, propDecorators: { avatar: [{\n                type: ContentChild,\n                args: [MAT_CHIP_AVATAR]\n            }], trailingIcon: [{\n                type: ContentChild,\n                args: [MAT_CHIP_TRAILING_ICON]\n            }], removeIcon: [{\n                type: ContentChild,\n                args: [MAT_CHIP_REMOVE]\n            }], selected: [{\n                type: Input\n            }], value: [{\n                type: Input\n            }], selectable: [{\n                type: Input\n            }], disabled: [{\n                type: Input\n            }], removable: [{\n                type: Input\n            }], selectionChange: [{\n                type: Output\n            }], destroyed: [{\n                type: Output\n            }], removed: [{\n                type: Output\n            }] } });\n/**\n * Applies proper (click) support and adds styling for use with the Material Design \"cancel\" icon\n * available at https://material.io/icons/#ic_cancel.\n *\n * Example:\n *\n *     `<mat-chip>\n *       <mat-icon matChipRemove>cancel</mat-icon>\n *     </mat-chip>`\n *\n * You *may* use a custom icon, but you may need to override the `mat-chip-remove` positioning\n * styles to properly center the icon within the chip.\n */\nclass MatChipRemove {\n    constructor(_parentChip, elementRef) {\n        this._parentChip = _parentChip;\n        if (elementRef.nativeElement.nodeName === 'BUTTON') {\n            elementRef.nativeElement.setAttribute('type', 'button');\n        }\n    }\n    /** Calls the parent chip's public `remove()` method if applicable. */\n    _handleClick(event) {\n        const parentChip = this._parentChip;\n        if (parentChip.removable && !parentChip.disabled) {\n            parentChip.remove();\n        }\n        // We need to stop event propagation because otherwise the event will bubble up to the\n        // form field and cause the `onContainerClick` method to be invoked. This method would then\n        // reset the focused chip that has been focused after chip removal. Usually the parent\n        // the parent click listener of the `MatChip` would prevent propagation, but it can happen\n        // that the chip is being removed before the event bubbles up.\n        event.stopPropagation();\n        event.preventDefault();\n    }\n}\nMatChipRemove.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatChipRemove, deps: [{ token: MatChip }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });\nMatChipRemove.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatChipRemove, selector: \"[matChipRemove]\", host: { listeners: { \"click\": \"_handleClick($event)\" }, classAttribute: \"mat-chip-remove mat-chip-trailing-icon\" }, providers: [{ provide: MAT_CHIP_REMOVE, useExisting: MatChipRemove }], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatChipRemove, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matChipRemove]',\n                    host: {\n                        'class': 'mat-chip-remove mat-chip-trailing-icon',\n                        '(click)': '_handleClick($event)',\n                    },\n                    providers: [{ provide: MAT_CHIP_REMOVE, useExisting: MatChipRemove }],\n                }]\n        }], ctorParameters: function () { return [{ type: MatChip }, { type: i0.ElementRef }]; } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Injection token to be used to override the default options for the chips module. */\nconst MAT_CHIPS_DEFAULT_OPTIONS = new InjectionToken('mat-chips-default-options');\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// Boilerplate for applying mixins to MatChipList.\n/** @docs-private */\nconst _MatChipListBase = mixinErrorState(class {\n    constructor(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, \n    /** @docs-private */\n    ngControl) {\n        this._defaultErrorStateMatcher = _defaultErrorStateMatcher;\n        this._parentForm = _parentForm;\n        this._parentFormGroup = _parentFormGroup;\n        this.ngControl = ngControl;\n    }\n});\n// Increasing integer for generating unique ids for chip-list components.\nlet nextUniqueId$1 = 0;\n/** Change event object that is emitted when the chip list value has changed. */\nclass MatChipListChange {\n    constructor(\n    /** Chip list that emitted the event. */\n    source, \n    /** Value of the chip list when the event was emitted. */\n    value) {\n        this.source = source;\n        this.value = value;\n    }\n}\n/**\n * A material design chips component (named ChipList for its similarity to the List component).\n */\nclass MatChipList extends _MatChipListBase {\n    constructor(_elementRef, _changeDetectorRef, _dir, _parentForm, _parentFormGroup, _defaultErrorStateMatcher, ngControl) {\n        super(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl);\n        this._elementRef = _elementRef;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._dir = _dir;\n        /**\n         * Implemented as part of MatFormFieldControl.\n         * @docs-private\n         */\n        this.controlType = 'mat-chip-list';\n        /**\n         * When a chip is destroyed, we store the index of the destroyed chip until the chips\n         * query list notifies about the update. This is necessary because we cannot determine an\n         * appropriate chip that should receive focus until the array of chips updated completely.\n         */\n        this._lastDestroyedChipIndex = null;\n        /** Subject that emits when the component has been destroyed. */\n        this._destroyed = new Subject();\n        /** Uid of the chip list */\n        this._uid = `mat-chip-list-${nextUniqueId$1++}`;\n        /** Tab index for the chip list. */\n        this._tabIndex = 0;\n        /**\n         * User defined tab index.\n         * When it is not null, use user defined tab index. Otherwise use _tabIndex\n         */\n        this._userTabIndex = null;\n        /** Function when touched */\n        this._onTouched = () => { };\n        /** Function when changed */\n        this._onChange = () => { };\n        this._multiple = false;\n        this._compareWith = (o1, o2) => o1 === o2;\n        this._disabled = false;\n        /** Orientation of the chip list. */\n        this.ariaOrientation = 'horizontal';\n        this._selectable = true;\n        /** Event emitted when the selected chip list value has been changed by the user. */\n        this.change = new EventEmitter();\n        /**\n         * Event that emits whenever the raw value of the chip-list changes. This is here primarily\n         * to facilitate the two-way binding for the `value` input.\n         * @docs-private\n         */\n        this.valueChange = new EventEmitter();\n        if (this.ngControl) {\n            this.ngControl.valueAccessor = this;\n        }\n    }\n    /** The array of selected chips inside chip list. */\n    get selected() {\n        return this.multiple ? this._selectionModel?.selected || [] : this._selectionModel?.selected[0];\n    }\n    /** The ARIA role applied to the chip list. */\n    get role() {\n        return this.empty ? null : 'listbox';\n    }\n    /** Whether the user should be allowed to select multiple chips. */\n    get multiple() {\n        return this._multiple;\n    }\n    set multiple(value) {\n        this._multiple = coerceBooleanProperty(value);\n        this._syncChipsState();\n    }\n    /**\n     * A function to compare the option values with the selected values. The first argument\n     * is a value from an option. The second is a value from the selection. A boolean\n     * should be returned.\n     */\n    get compareWith() {\n        return this._compareWith;\n    }\n    set compareWith(fn) {\n        this._compareWith = fn;\n        if (this._selectionModel) {\n            // A different comparator means the selection could change.\n            this._initializeSelection();\n        }\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get value() {\n        return this._value;\n    }\n    set value(value) {\n        this.writeValue(value);\n        this._value = value;\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get id() {\n        return this._chipInput ? this._chipInput.id : this._uid;\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get required() {\n        return this._required ?? this.ngControl?.control?.hasValidator(Validators.required) ?? false;\n    }\n    set required(value) {\n        this._required = coerceBooleanProperty(value);\n        this.stateChanges.next();\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get placeholder() {\n        return this._chipInput ? this._chipInput.placeholder : this._placeholder;\n    }\n    set placeholder(value) {\n        this._placeholder = value;\n        this.stateChanges.next();\n    }\n    /** Whether any chips or the matChipInput inside of this chip-list has focus. */\n    get focused() {\n        return (this._chipInput && this._chipInput.focused) || this._hasFocusedChip();\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get empty() {\n        return (!this._chipInput || this._chipInput.empty) && (!this.chips || this.chips.length === 0);\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get shouldLabelFloat() {\n        return !this.empty || this.focused;\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get disabled() {\n        return this.ngControl ? !!this.ngControl.disabled : this._disabled;\n    }\n    set disabled(value) {\n        this._disabled = coerceBooleanProperty(value);\n        this._syncChipsState();\n    }\n    /**\n     * Whether or not this chip list is selectable. When a chip list is not selectable,\n     * the selected states for all the chips inside the chip list are always ignored.\n     */\n    get selectable() {\n        return this._selectable;\n    }\n    set selectable(value) {\n        this._selectable = coerceBooleanProperty(value);\n        if (this.chips) {\n            this.chips.forEach(chip => (chip.chipListSelectable = this._selectable));\n        }\n    }\n    set tabIndex(value) {\n        this._userTabIndex = value;\n        this._tabIndex = value;\n    }\n    /** Combined stream of all of the child chips' selection change events. */\n    get chipSelectionChanges() {\n        return merge(...this.chips.map(chip => chip.selectionChange));\n    }\n    /** Combined stream of all of the child chips' focus change events. */\n    get chipFocusChanges() {\n        return merge(...this.chips.map(chip => chip._onFocus));\n    }\n    /** Combined stream of all of the child chips' blur change events. */\n    get chipBlurChanges() {\n        return merge(...this.chips.map(chip => chip._onBlur));\n    }\n    /** Combined stream of all of the child chips' remove change events. */\n    get chipRemoveChanges() {\n        return merge(...this.chips.map(chip => chip.destroyed));\n    }\n    ngAfterContentInit() {\n        this._keyManager = new FocusKeyManager(this.chips)\n            .withWrap()\n            .withVerticalOrientation()\n            .withHomeAndEnd()\n            .withHorizontalOrientation(this._dir ? this._dir.value : 'ltr');\n        if (this._dir) {\n            this._dir.change\n                .pipe(takeUntil(this._destroyed))\n                .subscribe(dir => this._keyManager.withHorizontalOrientation(dir));\n        }\n        this._keyManager.tabOut.pipe(takeUntil(this._destroyed)).subscribe(() => {\n            this._allowFocusEscape();\n        });\n        // When the list changes, re-subscribe\n        this.chips.changes.pipe(startWith(null), takeUntil(this._destroyed)).subscribe(() => {\n            if (this.disabled) {\n                // Since this happens after the content has been\n                // checked, we need to defer it to the next tick.\n                Promise.resolve().then(() => {\n                    this._syncChipsState();\n                });\n            }\n            this._resetChips();\n            // Reset chips selected/deselected status\n            this._initializeSelection();\n            // Check to see if we need to update our tab index\n            this._updateTabIndex();\n            // Check to see if we have a destroyed chip and need to refocus\n            this._updateFocusForDestroyedChips();\n            this.stateChanges.next();\n        });\n    }\n    ngOnInit() {\n        this._selectionModel = new SelectionModel(this.multiple, undefined, false);\n        this.stateChanges.next();\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            if (this.ngControl.disabled !== this._disabled) {\n                this.disabled = !!this.ngControl.disabled;\n            }\n        }\n    }\n    ngOnDestroy() {\n        this._destroyed.next();\n        this._destroyed.complete();\n        this.stateChanges.complete();\n        this._dropSubscriptions();\n    }\n    /** Associates an HTML input element with this chip list. */\n    registerInput(inputElement) {\n        this._chipInput = inputElement;\n        // We use this attribute to match the chip list to its input in test harnesses.\n        // Set the attribute directly here to avoid \"changed after checked\" errors.\n        this._elementRef.nativeElement.setAttribute('data-mat-chip-input', inputElement.id);\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    setDescribedByIds(ids) {\n        this._ariaDescribedby = ids.join(' ');\n    }\n    // Implemented as part of ControlValueAccessor.\n    writeValue(value) {\n        if (this.chips) {\n            this._setSelectionByValue(value, false);\n        }\n    }\n    // Implemented as part of ControlValueAccessor.\n    registerOnChange(fn) {\n        this._onChange = fn;\n    }\n    // Implemented as part of ControlValueAccessor.\n    registerOnTouched(fn) {\n        this._onTouched = fn;\n    }\n    // Implemented as part of ControlValueAccessor.\n    setDisabledState(isDisabled) {\n        this.disabled = isDisabled;\n        this.stateChanges.next();\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    onContainerClick(event) {\n        if (!this._originatesFromChip(event)) {\n            this.focus();\n        }\n    }\n    /**\n     * Focuses the first non-disabled chip in this chip list, or the associated input when there\n     * are no eligible chips.\n     */\n    focus(options) {\n        if (this.disabled) {\n            return;\n        }\n        // TODO: ARIA says this should focus the first `selected` chip if any are selected.\n        // Focus on first element if there's no chipInput inside chip-list\n        if (this._chipInput && this._chipInput.focused) {\n            // do nothing\n        }\n        else if (this.chips.length > 0) {\n            this._keyManager.setFirstItemActive();\n            this.stateChanges.next();\n        }\n        else {\n            this._focusInput(options);\n            this.stateChanges.next();\n        }\n    }\n    /** Attempt to focus an input if we have one. */\n    _focusInput(options) {\n        if (this._chipInput) {\n            this._chipInput.focus(options);\n        }\n    }\n    /**\n     * Pass events to the keyboard manager. Available here for tests.\n     */\n    _keydown(event) {\n        const target = event.target;\n        if (target && target.classList.contains('mat-chip')) {\n            this._keyManager.onKeydown(event);\n            this.stateChanges.next();\n        }\n    }\n    /**\n     * Check the tab index as you should not be allowed to focus an empty list.\n     */\n    _updateTabIndex() {\n        // If we have 0 chips, we should not allow keyboard focus\n        this._tabIndex = this._userTabIndex || (this.chips.length === 0 ? -1 : 0);\n    }\n    /**\n     * If the amount of chips changed, we need to update the\n     * key manager state and focus the next closest chip.\n     */\n    _updateFocusForDestroyedChips() {\n        // Move focus to the closest chip. If no other chips remain, focus the chip-list itself.\n        if (this._lastDestroyedChipIndex != null) {\n            if (this.chips.length) {\n                const newChipIndex = Math.min(this._lastDestroyedChipIndex, this.chips.length - 1);\n                this._keyManager.setActiveItem(newChipIndex);\n            }\n            else {\n                this.focus();\n            }\n        }\n        this._lastDestroyedChipIndex = null;\n    }\n    /**\n     * Utility to ensure all indexes are valid.\n     *\n     * @param index The index to be checked.\n     * @returns True if the index is valid for our list of chips.\n     */\n    _isValidIndex(index) {\n        return index >= 0 && index < this.chips.length;\n    }\n    _setSelectionByValue(value, isUserInput = true) {\n        this._clearSelection();\n        this.chips.forEach(chip => chip.deselect());\n        if (Array.isArray(value)) {\n            value.forEach(currentValue => this._selectValue(currentValue, isUserInput));\n            this._sortValues();\n        }\n        else {\n            const correspondingChip = this._selectValue(value, isUserInput);\n            // Shift focus to the active item. Note that we shouldn't do this in multiple\n            // mode, because we don't know what chip the user interacted with last.\n            if (correspondingChip) {\n                if (isUserInput) {\n                    this._keyManager.setActiveItem(correspondingChip);\n                }\n            }\n        }\n    }\n    /**\n     * Finds and selects the chip based on its value.\n     * @returns Chip that has the corresponding value.\n     */\n    _selectValue(value, isUserInput = true) {\n        const correspondingChip = this.chips.find(chip => {\n            return chip.value != null && this._compareWith(chip.value, value);\n        });\n        if (correspondingChip) {\n            isUserInput ? correspondingChip.selectViaInteraction() : correspondingChip.select();\n            this._selectionModel.select(correspondingChip);\n        }\n        return correspondingChip;\n    }\n    _initializeSelection() {\n        // Defer setting the value in order to avoid the \"Expression\n        // has changed after it was checked\" errors from Angular.\n        Promise.resolve().then(() => {\n            if (this.ngControl || this._value) {\n                this._setSelectionByValue(this.ngControl ? this.ngControl.value : this._value, false);\n                this.stateChanges.next();\n            }\n        });\n    }\n    /**\n     * Deselects every chip in the list.\n     * @param skip Chip that should not be deselected.\n     */\n    _clearSelection(skip) {\n        this._selectionModel.clear();\n        this.chips.forEach(chip => {\n            if (chip !== skip) {\n                chip.deselect();\n            }\n        });\n        this.stateChanges.next();\n    }\n    /**\n     * Sorts the model values, ensuring that they keep the same\n     * order that they have in the panel.\n     */\n    _sortValues() {\n        if (this._multiple) {\n            this._selectionModel.clear();\n            this.chips.forEach(chip => {\n                if (chip.selected) {\n                    this._selectionModel.select(chip);\n                }\n            });\n            this.stateChanges.next();\n        }\n    }\n    /** Emits change event to set the model value. */\n    _propagateChanges(fallbackValue) {\n        let valueToEmit = null;\n        if (Array.isArray(this.selected)) {\n            valueToEmit = this.selected.map(chip => chip.value);\n        }\n        else {\n            valueToEmit = this.selected ? this.selected.value : fallbackValue;\n        }\n        this._value = valueToEmit;\n        this.change.emit(new MatChipListChange(this, valueToEmit));\n        this.valueChange.emit(valueToEmit);\n        this._onChange(valueToEmit);\n        this._changeDetectorRef.markForCheck();\n    }\n    /** When blurred, mark the field as touched when focus moved outside the chip list. */\n    _blur() {\n        if (!this._hasFocusedChip()) {\n            this._keyManager.setActiveItem(-1);\n        }\n        if (!this.disabled) {\n            if (this._chipInput) {\n                // If there's a chip input, we should check whether the focus moved to chip input.\n                // If the focus is not moved to chip input, mark the field as touched. If the focus moved\n                // to chip input, do nothing.\n                // Timeout is needed to wait for the focus() event trigger on chip input.\n                setTimeout(() => {\n                    if (!this.focused) {\n                        this._markAsTouched();\n                    }\n                });\n            }\n            else {\n                // If there's no chip input, then mark the field as touched.\n                this._markAsTouched();\n            }\n        }\n    }\n    /** Mark the field as touched */\n    _markAsTouched() {\n        this._onTouched();\n        this._changeDetectorRef.markForCheck();\n        this.stateChanges.next();\n    }\n    /**\n     * Removes the `tabindex` from the chip list and resets it back afterwards, allowing the\n     * user to tab out of it. This prevents the list from capturing focus and redirecting\n     * it back to the first chip, creating a focus trap, if it user tries to tab away.\n     */\n    _allowFocusEscape() {\n        if (this._tabIndex !== -1) {\n            this._tabIndex = -1;\n            setTimeout(() => {\n                this._tabIndex = this._userTabIndex || 0;\n                this._changeDetectorRef.markForCheck();\n            });\n        }\n    }\n    _resetChips() {\n        this._dropSubscriptions();\n        this._listenToChipsFocus();\n        this._listenToChipsSelection();\n        this._listenToChipsRemoved();\n    }\n    _dropSubscriptions() {\n        if (this._chipFocusSubscription) {\n            this._chipFocusSubscription.unsubscribe();\n            this._chipFocusSubscription = null;\n        }\n        if (this._chipBlurSubscription) {\n            this._chipBlurSubscription.unsubscribe();\n            this._chipBlurSubscription = null;\n        }\n        if (this._chipSelectionSubscription) {\n            this._chipSelectionSubscription.unsubscribe();\n            this._chipSelectionSubscription = null;\n        }\n        if (this._chipRemoveSubscription) {\n            this._chipRemoveSubscription.unsubscribe();\n            this._chipRemoveSubscription = null;\n        }\n    }\n    /** Listens to user-generated selection events on each chip. */\n    _listenToChipsSelection() {\n        this._chipSelectionSubscription = this.chipSelectionChanges.subscribe(event => {\n            event.source.selected\n                ? this._selectionModel.select(event.source)\n                : this._selectionModel.deselect(event.source);\n            // For single selection chip list, make sure the deselected value is unselected.\n            if (!this.multiple) {\n                this.chips.forEach(chip => {\n                    if (!this._selectionModel.isSelected(chip) && chip.selected) {\n                        chip.deselect();\n                    }\n                });\n            }\n            if (event.isUserInput) {\n                this._propagateChanges();\n            }\n        });\n    }\n    /** Listens to user-generated selection events on each chip. */\n    _listenToChipsFocus() {\n        this._chipFocusSubscription = this.chipFocusChanges.subscribe(event => {\n            let chipIndex = this.chips.toArray().indexOf(event.chip);\n            if (this._isValidIndex(chipIndex)) {\n                this._keyManager.updateActiveItem(chipIndex);\n            }\n            this.stateChanges.next();\n        });\n        this._chipBlurSubscription = this.chipBlurChanges.subscribe(() => {\n            this._blur();\n            this.stateChanges.next();\n        });\n    }\n    _listenToChipsRemoved() {\n        this._chipRemoveSubscription = this.chipRemoveChanges.subscribe(event => {\n            const chip = event.chip;\n            const chipIndex = this.chips.toArray().indexOf(event.chip);\n            // In case the chip that will be removed is currently focused, we temporarily store\n            // the index in order to be able to determine an appropriate sibling chip that will\n            // receive focus.\n            if (this._isValidIndex(chipIndex) && chip._hasFocus) {\n                this._lastDestroyedChipIndex = chipIndex;\n            }\n        });\n    }\n    /** Checks whether an event comes from inside a chip element. */\n    _originatesFromChip(event) {\n        let currentElement = event.target;\n        while (currentElement && currentElement !== this._elementRef.nativeElement) {\n            if (currentElement.classList.contains('mat-chip')) {\n                return true;\n            }\n            currentElement = currentElement.parentElement;\n        }\n        return false;\n    }\n    /** Checks whether any of the chips is focused. */\n    _hasFocusedChip() {\n        return this.chips && this.chips.some(chip => chip._hasFocus);\n    }\n    /** Syncs the list's state with the individual chips. */\n    _syncChipsState() {\n        if (this.chips) {\n            this.chips.forEach(chip => {\n                chip._chipListDisabled = this._disabled;\n                chip._chipListMultiple = this.multiple;\n            });\n        }\n    }\n}\nMatChipList.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatChipList, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i1$1.Directionality, optional: true }, { token: i2.NgForm, optional: true }, { token: i2.FormGroupDirective, optional: true }, { token: i3.ErrorStateMatcher }, { token: i2.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component });\nMatChipList.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatChipList, selector: \"mat-chip-list\", inputs: { errorStateMatcher: \"errorStateMatcher\", multiple: \"multiple\", compareWith: \"compareWith\", value: \"value\", required: \"required\", placeholder: \"placeholder\", disabled: \"disabled\", ariaOrientation: [\"aria-orientation\", \"ariaOrientation\"], selectable: \"selectable\", tabIndex: \"tabIndex\" }, outputs: { change: \"change\", valueChange: \"valueChange\" }, host: { listeners: { \"focus\": \"focus()\", \"blur\": \"_blur()\", \"keydown\": \"_keydown($event)\" }, properties: { \"attr.tabindex\": \"disabled ? null : _tabIndex\", \"attr.aria-describedby\": \"_ariaDescribedby || null\", \"attr.aria-required\": \"role ? required : null\", \"attr.aria-disabled\": \"disabled.toString()\", \"attr.aria-invalid\": \"errorState\", \"attr.aria-multiselectable\": \"multiple\", \"attr.role\": \"role\", \"class.mat-chip-list-disabled\": \"disabled\", \"class.mat-chip-list-invalid\": \"errorState\", \"class.mat-chip-list-required\": \"required\", \"attr.aria-orientation\": \"ariaOrientation\", \"id\": \"_uid\" }, classAttribute: \"mat-chip-list\" }, providers: [{ provide: MatFormFieldControl, useExisting: MatChipList }], queries: [{ propertyName: \"chips\", predicate: MatChip, descendants: true }], exportAs: [\"matChipList\"], usesInheritance: true, ngImport: i0, template: `<div class=\"mat-chip-list-wrapper\"><ng-content></ng-content></div>`, isInline: true, styles: [\".mat-chip{position:relative;box-sizing:border-box;-webkit-tap-highlight-color:transparent;border:none;-webkit-appearance:none;-moz-appearance:none}.mat-standard-chip{transition:box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);display:inline-flex;padding:7px 12px;border-radius:16px;align-items:center;cursor:default;min-height:32px;height:1px}._mat-animation-noopable.mat-standard-chip{transition:none;animation:none}.mat-standard-chip .mat-chip-remove{border:none;-webkit-appearance:none;-moz-appearance:none;padding:0;background:none}.mat-standard-chip .mat-chip-remove.mat-icon,.mat-standard-chip .mat-chip-remove .mat-icon{width:18px;height:18px;font-size:18px}.mat-standard-chip::after{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:inherit;opacity:0;content:\\\"\\\";pointer-events:none;transition:opacity 200ms cubic-bezier(0.35, 0, 0.25, 1)}.mat-standard-chip:hover::after{opacity:.12}.mat-standard-chip:focus{outline:none}.mat-standard-chip:focus::after{opacity:.16}.cdk-high-contrast-active .mat-standard-chip{outline:solid 1px}.cdk-high-contrast-active .mat-standard-chip:focus{outline:dotted 2px}.cdk-high-contrast-active .mat-standard-chip.mat-chip-selected{outline-width:3px}.mat-standard-chip.mat-chip-disabled::after{opacity:0}.mat-standard-chip.mat-chip-disabled .mat-chip-remove,.mat-standard-chip.mat-chip-disabled .mat-chip-trailing-icon{cursor:default}.mat-standard-chip.mat-chip-with-trailing-icon.mat-chip-with-avatar,.mat-standard-chip.mat-chip-with-avatar{padding-top:0;padding-bottom:0}.mat-standard-chip.mat-chip-with-trailing-icon.mat-chip-with-avatar{padding-right:8px;padding-left:0}[dir=rtl] .mat-standard-chip.mat-chip-with-trailing-icon.mat-chip-with-avatar{padding-left:8px;padding-right:0}.mat-standard-chip.mat-chip-with-trailing-icon{padding-top:7px;padding-bottom:7px;padding-right:8px;padding-left:12px}[dir=rtl] .mat-standard-chip.mat-chip-with-trailing-icon{padding-left:8px;padding-right:12px}.mat-standard-chip.mat-chip-with-avatar{padding-left:0;padding-right:12px}[dir=rtl] .mat-standard-chip.mat-chip-with-avatar{padding-right:0;padding-left:12px}.mat-standard-chip .mat-chip-avatar{width:24px;height:24px;margin-right:8px;margin-left:4px}[dir=rtl] .mat-standard-chip .mat-chip-avatar{margin-left:8px;margin-right:4px}.mat-standard-chip .mat-chip-remove,.mat-standard-chip .mat-chip-trailing-icon{width:18px;height:18px;cursor:pointer}.mat-standard-chip .mat-chip-remove,.mat-standard-chip .mat-chip-trailing-icon{margin-left:8px;margin-right:0}[dir=rtl] .mat-standard-chip .mat-chip-remove,[dir=rtl] .mat-standard-chip .mat-chip-trailing-icon{margin-right:8px;margin-left:0}.mat-chip-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit;overflow:hidden;transform:translateZ(0)}.mat-chip-list-wrapper{display:flex;flex-direction:row;flex-wrap:wrap;align-items:center;margin:-4px}.mat-chip-list-wrapper input.mat-input-element,.mat-chip-list-wrapper .mat-standard-chip{margin:4px}.mat-chip-list-stacked .mat-chip-list-wrapper{flex-direction:column;align-items:flex-start}.mat-chip-list-stacked .mat-chip-list-wrapper .mat-standard-chip{width:100%}.mat-chip-avatar{border-radius:50%;justify-content:center;align-items:center;display:flex;overflow:hidden;object-fit:cover}input.mat-chip-input{width:150px;margin:4px;flex:1 0 150px}\\n\"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatChipList, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-chip-list', template: `<div class=\"mat-chip-list-wrapper\"><ng-content></ng-content></div>`, exportAs: 'matChipList', host: {\n                        '[attr.tabindex]': 'disabled ? null : _tabIndex',\n                        '[attr.aria-describedby]': '_ariaDescribedby || null',\n                        '[attr.aria-required]': 'role ? required : null',\n                        '[attr.aria-disabled]': 'disabled.toString()',\n                        '[attr.aria-invalid]': 'errorState',\n                        '[attr.aria-multiselectable]': 'multiple',\n                        '[attr.role]': 'role',\n                        '[class.mat-chip-list-disabled]': 'disabled',\n                        '[class.mat-chip-list-invalid]': 'errorState',\n                        '[class.mat-chip-list-required]': 'required',\n                        '[attr.aria-orientation]': 'ariaOrientation',\n                        'class': 'mat-chip-list',\n                        '(focus)': 'focus()',\n                        '(blur)': '_blur()',\n                        '(keydown)': '_keydown($event)',\n                        '[id]': '_uid',\n                    }, providers: [{ provide: MatFormFieldControl, useExisting: MatChipList }], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, styles: [\".mat-chip{position:relative;box-sizing:border-box;-webkit-tap-highlight-color:transparent;border:none;-webkit-appearance:none;-moz-appearance:none}.mat-standard-chip{transition:box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);display:inline-flex;padding:7px 12px;border-radius:16px;align-items:center;cursor:default;min-height:32px;height:1px}._mat-animation-noopable.mat-standard-chip{transition:none;animation:none}.mat-standard-chip .mat-chip-remove{border:none;-webkit-appearance:none;-moz-appearance:none;padding:0;background:none}.mat-standard-chip .mat-chip-remove.mat-icon,.mat-standard-chip .mat-chip-remove .mat-icon{width:18px;height:18px;font-size:18px}.mat-standard-chip::after{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:inherit;opacity:0;content:\\\"\\\";pointer-events:none;transition:opacity 200ms cubic-bezier(0.35, 0, 0.25, 1)}.mat-standard-chip:hover::after{opacity:.12}.mat-standard-chip:focus{outline:none}.mat-standard-chip:focus::after{opacity:.16}.cdk-high-contrast-active .mat-standard-chip{outline:solid 1px}.cdk-high-contrast-active .mat-standard-chip:focus{outline:dotted 2px}.cdk-high-contrast-active .mat-standard-chip.mat-chip-selected{outline-width:3px}.mat-standard-chip.mat-chip-disabled::after{opacity:0}.mat-standard-chip.mat-chip-disabled .mat-chip-remove,.mat-standard-chip.mat-chip-disabled .mat-chip-trailing-icon{cursor:default}.mat-standard-chip.mat-chip-with-trailing-icon.mat-chip-with-avatar,.mat-standard-chip.mat-chip-with-avatar{padding-top:0;padding-bottom:0}.mat-standard-chip.mat-chip-with-trailing-icon.mat-chip-with-avatar{padding-right:8px;padding-left:0}[dir=rtl] .mat-standard-chip.mat-chip-with-trailing-icon.mat-chip-with-avatar{padding-left:8px;padding-right:0}.mat-standard-chip.mat-chip-with-trailing-icon{padding-top:7px;padding-bottom:7px;padding-right:8px;padding-left:12px}[dir=rtl] .mat-standard-chip.mat-chip-with-trailing-icon{padding-left:8px;padding-right:12px}.mat-standard-chip.mat-chip-with-avatar{padding-left:0;padding-right:12px}[dir=rtl] .mat-standard-chip.mat-chip-with-avatar{padding-right:0;padding-left:12px}.mat-standard-chip .mat-chip-avatar{width:24px;height:24px;margin-right:8px;margin-left:4px}[dir=rtl] .mat-standard-chip .mat-chip-avatar{margin-left:8px;margin-right:4px}.mat-standard-chip .mat-chip-remove,.mat-standard-chip .mat-chip-trailing-icon{width:18px;height:18px;cursor:pointer}.mat-standard-chip .mat-chip-remove,.mat-standard-chip .mat-chip-trailing-icon{margin-left:8px;margin-right:0}[dir=rtl] .mat-standard-chip .mat-chip-remove,[dir=rtl] .mat-standard-chip .mat-chip-trailing-icon{margin-right:8px;margin-left:0}.mat-chip-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit;overflow:hidden;transform:translateZ(0)}.mat-chip-list-wrapper{display:flex;flex-direction:row;flex-wrap:wrap;align-items:center;margin:-4px}.mat-chip-list-wrapper input.mat-input-element,.mat-chip-list-wrapper .mat-standard-chip{margin:4px}.mat-chip-list-stacked .mat-chip-list-wrapper{flex-direction:column;align-items:flex-start}.mat-chip-list-stacked .mat-chip-list-wrapper .mat-standard-chip{width:100%}.mat-chip-avatar{border-radius:50%;justify-content:center;align-items:center;display:flex;overflow:hidden;object-fit:cover}input.mat-chip-input{width:150px;margin:4px;flex:1 0 150px}\\n\"] }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i1$1.Directionality, decorators: [{\n                    type: Optional\n                }] }, { type: i2.NgForm, decorators: [{\n                    type: Optional\n                }] }, { type: i2.FormGroupDirective, decorators: [{\n                    type: Optional\n                }] }, { type: i3.ErrorStateMatcher }, { type: i2.NgControl, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }] }]; }, propDecorators: { errorStateMatcher: [{\n                type: Input\n            }], multiple: [{\n                type: Input\n            }], compareWith: [{\n                type: Input\n            }], value: [{\n                type: Input\n            }], required: [{\n                type: Input\n            }], placeholder: [{\n                type: Input\n            }], disabled: [{\n                type: Input\n            }], ariaOrientation: [{\n                type: Input,\n                args: ['aria-orientation']\n            }], selectable: [{\n                type: Input\n            }], tabIndex: [{\n                type: Input\n            }], change: [{\n                type: Output\n            }], valueChange: [{\n                type: Output\n            }], chips: [{\n                type: ContentChildren,\n                args: [MatChip, {\n                        // We need to use `descendants: true`, because Ivy will no longer match\n                        // indirect descendants if it's left as false.\n                        descendants: true,\n                    }]\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// Increasing integer for generating unique ids.\nlet nextUniqueId = 0;\n/**\n * Directive that adds chip-specific behaviors to an input element inside `<mat-form-field>`.\n * May be placed inside or outside of an `<mat-chip-list>`.\n */\nclass MatChipInput {\n    constructor(_elementRef, _defaultOptions) {\n        this._elementRef = _elementRef;\n        this._defaultOptions = _defaultOptions;\n        /** Whether the control is focused. */\n        this.focused = false;\n        this._addOnBlur = false;\n        /**\n         * The list of key codes that will trigger a chipEnd event.\n         *\n         * Defaults to `[ENTER]`.\n         */\n        this.separatorKeyCodes = this._defaultOptions.separatorKeyCodes;\n        /** Emitted when a chip is to be added. */\n        this.chipEnd = new EventEmitter();\n        /** The input's placeholder text. */\n        this.placeholder = '';\n        /** Unique id for the input. */\n        this.id = `mat-chip-list-input-${nextUniqueId++}`;\n        this._disabled = false;\n        this.inputElement = this._elementRef.nativeElement;\n    }\n    /** Register input for chip list */\n    set chipList(value) {\n        if (value) {\n            this._chipList = value;\n            this._chipList.registerInput(this);\n        }\n    }\n    /**\n     * Whether or not the chipEnd event will be emitted when the input is blurred.\n     */\n    get addOnBlur() {\n        return this._addOnBlur;\n    }\n    set addOnBlur(value) {\n        this._addOnBlur = coerceBooleanProperty(value);\n    }\n    /** Whether the input is disabled. */\n    get disabled() {\n        return this._disabled || (this._chipList && this._chipList.disabled);\n    }\n    set disabled(value) {\n        this._disabled = coerceBooleanProperty(value);\n    }\n    /** Whether the input is empty. */\n    get empty() {\n        return !this.inputElement.value;\n    }\n    ngOnChanges() {\n        this._chipList.stateChanges.next();\n    }\n    ngOnDestroy() {\n        this.chipEnd.complete();\n    }\n    ngAfterContentInit() {\n        this._focusLastChipOnBackspace = this.empty;\n    }\n    /** Utility method to make host definition/tests more clear. */\n    _keydown(event) {\n        if (event) {\n            // Allow the user's focus to escape when they're tabbing forward. Note that we don't\n            // want to do this when going backwards, because focus should go back to the first chip.\n            if (event.keyCode === TAB && !hasModifierKey(event, 'shiftKey')) {\n                this._chipList._allowFocusEscape();\n            }\n            // To prevent the user from accidentally deleting chips when pressing BACKSPACE continuously,\n            // We focus the last chip on backspace only after the user has released the backspace button,\n            // and the input is empty (see behaviour in _keyup)\n            if (event.keyCode === BACKSPACE && this._focusLastChipOnBackspace) {\n                this._chipList._keyManager.setLastItemActive();\n                event.preventDefault();\n                return;\n            }\n            else {\n                this._focusLastChipOnBackspace = false;\n            }\n        }\n        this._emitChipEnd(event);\n    }\n    /**\n     * Pass events to the keyboard manager. Available here for tests.\n     */\n    _keyup(event) {\n        // Allow user to move focus to chips next time he presses backspace\n        if (!this._focusLastChipOnBackspace && event.keyCode === BACKSPACE && this.empty) {\n            this._focusLastChipOnBackspace = true;\n            event.preventDefault();\n        }\n    }\n    /** Checks to see if the blur should emit the (chipEnd) event. */\n    _blur() {\n        if (this.addOnBlur) {\n            this._emitChipEnd();\n        }\n        this.focused = false;\n        // Blur the chip list if it is not focused\n        if (!this._chipList.focused) {\n            this._chipList._blur();\n        }\n        this._chipList.stateChanges.next();\n    }\n    _focus() {\n        this.focused = true;\n        this._focusLastChipOnBackspace = this.empty;\n        this._chipList.stateChanges.next();\n    }\n    /** Checks to see if the (chipEnd) event needs to be emitted. */\n    _emitChipEnd(event) {\n        if (!this.inputElement.value && !!event) {\n            this._chipList._keydown(event);\n        }\n        if (!event || this._isSeparatorKey(event)) {\n            this.chipEnd.emit({\n                input: this.inputElement,\n                value: this.inputElement.value,\n                chipInput: this,\n            });\n            event?.preventDefault();\n        }\n    }\n    _onInput() {\n        // Let chip list know whenever the value changes.\n        this._chipList.stateChanges.next();\n    }\n    /** Focuses the input. */\n    focus(options) {\n        this.inputElement.focus(options);\n    }\n    /** Clears the input */\n    clear() {\n        this.inputElement.value = '';\n        this._focusLastChipOnBackspace = true;\n    }\n    /** Checks whether a keycode is one of the configured separators. */\n    _isSeparatorKey(event) {\n        return !hasModifierKey(event) && new Set(this.separatorKeyCodes).has(event.keyCode);\n    }\n}\nMatChipInput.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatChipInput, deps: [{ token: i0.ElementRef }, { token: MAT_CHIPS_DEFAULT_OPTIONS }], target: i0.ɵɵFactoryTarget.Directive });\nMatChipInput.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatChipInput, selector: \"input[matChipInputFor]\", inputs: { chipList: [\"matChipInputFor\", \"chipList\"], addOnBlur: [\"matChipInputAddOnBlur\", \"addOnBlur\"], separatorKeyCodes: [\"matChipInputSeparatorKeyCodes\", \"separatorKeyCodes\"], placeholder: \"placeholder\", id: \"id\", disabled: \"disabled\" }, outputs: { chipEnd: \"matChipInputTokenEnd\" }, host: { listeners: { \"keydown\": \"_keydown($event)\", \"keyup\": \"_keyup($event)\", \"blur\": \"_blur()\", \"focus\": \"_focus()\", \"input\": \"_onInput()\" }, properties: { \"id\": \"id\", \"attr.disabled\": \"disabled || null\", \"attr.placeholder\": \"placeholder || null\", \"attr.aria-invalid\": \"_chipList && _chipList.ngControl ? _chipList.ngControl.invalid : null\", \"attr.aria-required\": \"_chipList && _chipList.required || null\" }, classAttribute: \"mat-chip-input mat-input-element\" }, exportAs: [\"matChipInput\", \"matChipInputFor\"], usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatChipInput, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'input[matChipInputFor]',\n                    exportAs: 'matChipInput, matChipInputFor',\n                    host: {\n                        'class': 'mat-chip-input mat-input-element',\n                        '(keydown)': '_keydown($event)',\n                        '(keyup)': '_keyup($event)',\n                        '(blur)': '_blur()',\n                        '(focus)': '_focus()',\n                        '(input)': '_onInput()',\n                        '[id]': 'id',\n                        '[attr.disabled]': 'disabled || null',\n                        '[attr.placeholder]': 'placeholder || null',\n                        '[attr.aria-invalid]': '_chipList && _chipList.ngControl ? _chipList.ngControl.invalid : null',\n                        '[attr.aria-required]': '_chipList && _chipList.required || null',\n                    },\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_CHIPS_DEFAULT_OPTIONS]\n                }] }]; }, propDecorators: { chipList: [{\n                type: Input,\n                args: ['matChipInputFor']\n            }], addOnBlur: [{\n                type: Input,\n                args: ['matChipInputAddOnBlur']\n            }], separatorKeyCodes: [{\n                type: Input,\n                args: ['matChipInputSeparatorKeyCodes']\n            }], chipEnd: [{\n                type: Output,\n                args: ['matChipInputTokenEnd']\n            }], placeholder: [{\n                type: Input\n            }], id: [{\n                type: Input\n            }], disabled: [{\n                type: Input\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 */\nconst CHIP_DECLARATIONS = [\n    MatChipList,\n    MatChip,\n    MatChipInput,\n    MatChipRemove,\n    MatChipAvatar,\n    MatChipTrailingIcon,\n];\nclass MatChipsModule {\n}\nMatChipsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatChipsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatChipsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatChipsModule, declarations: [MatChipList,\n        MatChip,\n        MatChipInput,\n        MatChipRemove,\n        MatChipAvatar,\n        MatChipTrailingIcon], imports: [MatCommonModule], exports: [MatChipList,\n        MatChip,\n        MatChipInput,\n        MatChipRemove,\n        MatChipAvatar,\n        MatChipTrailingIcon] });\nMatChipsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatChipsModule, providers: [\n        ErrorStateMatcher,\n        {\n            provide: MAT_CHIPS_DEFAULT_OPTIONS,\n            useValue: {\n                separatorKeyCodes: [ENTER],\n            },\n        },\n    ], imports: [[MatCommonModule]] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatChipsModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [MatCommonModule],\n                    exports: CHIP_DECLARATIONS,\n                    declarations: CHIP_DECLARATIONS,\n                    providers: [\n                        ErrorStateMatcher,\n                        {\n                            provide: MAT_CHIPS_DEFAULT_OPTIONS,\n                            useValue: {\n                                separatorKeyCodes: [ENTER],\n                            },\n                        },\n                    ],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_CHIPS_DEFAULT_OPTIONS, MAT_CHIP_AVATAR, MAT_CHIP_REMOVE, MAT_CHIP_TRAILING_ICON, MatChip, MatChipAvatar, MatChipInput, MatChipList, MatChipListChange, MatChipRemove, MatChipSelectionChange, MatChipTrailingIcon, MatChipsModule };\n","import * as i8 from '@angular/cdk/a11y';\nimport { A11yModule } from '@angular/cdk/a11y';\nimport * as i9 from '@angular/cdk/overlay';\nimport { Overlay, FlexibleConnectedPositionStrategy, OverlayConfig, OverlayModule } from '@angular/cdk/overlay';\nimport * as i7 from '@angular/cdk/portal';\nimport { ComponentPortal, TemplatePortal, PortalModule } from '@angular/cdk/portal';\nimport * as i1 from '@angular/common';\nimport { CommonModule } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { Injectable, EventEmitter, Component, ViewEncapsulation, ChangeDetectionStrategy, Input, Output, Optional, SkipSelf, InjectionToken, Inject, ViewChild, forwardRef, Directive, Attribute, ContentChild, InjectFlags, Self, TemplateRef, NgModule } from '@angular/core';\nimport * as i3 from '@angular/material/button';\nimport { MatButtonModule } from '@angular/material/button';\nimport { CdkScrollableModule } from '@angular/cdk/scrolling';\nimport * as i1$1 from '@angular/material/core';\nimport { DateAdapter, MAT_DATE_FORMATS, mixinColor, mixinErrorState, MatCommonModule } from '@angular/material/core';\nimport { Subject, Subscription, merge, of } from 'rxjs';\nimport { ESCAPE, hasModifierKey, SPACE, ENTER, PAGE_DOWN, PAGE_UP, END, HOME, DOWN_ARROW, UP_ARROW, RIGHT_ARROW, LEFT_ARROW, BACKSPACE } from '@angular/cdk/keycodes';\nimport * as i2 from '@angular/cdk/bidi';\nimport { take, startWith, filter } from 'rxjs/operators';\nimport { coerceBooleanProperty, coerceStringArray } from '@angular/cdk/coercion';\nimport { _getFocusedElementPierceShadowDom } from '@angular/cdk/platform';\nimport { trigger, transition, animate, keyframes, style, state } from '@angular/animations';\nimport * as i2$2 from '@angular/forms';\nimport { NG_VALUE_ACCESSOR, NG_VALIDATORS, Validators, NgControl } from '@angular/forms';\nimport * as i2$1 from '@angular/material/form-field';\nimport { MAT_FORM_FIELD, MatFormFieldControl } from '@angular/material/form-field';\nimport { MAT_INPUT_VALUE_ACCESSOR } from '@angular/material/input';\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/** @docs-private */\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 * @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/** Datepicker data that requires internationalization. */\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        /** A label for the calendar popup (used by screen readers). */\n        this.calendarLabel = 'Calendar';\n        /** A label for the button used to open the calendar popup (used by screen readers). */\n        this.openCalendarLabel = 'Open calendar';\n        /** Label for the button used to close the calendar popup. */\n        this.closeCalendarLabel = 'Close calendar';\n        /** A label for the previous month button (used by screen readers). */\n        this.prevMonthLabel = 'Previous month';\n        /** A label for the next month button (used by screen readers). */\n        this.nextMonthLabel = 'Next month';\n        /** A label for the previous year button (used by screen readers). */\n        this.prevYearLabel = 'Previous year';\n        /** A label for the next year button (used by screen readers). */\n        this.nextYearLabel = 'Next year';\n        /** A label for the previous multi-year button (used by screen readers). */\n        this.prevMultiYearLabel = 'Previous 24 years';\n        /** A label for the next multi-year button (used by screen readers). */\n        this.nextMultiYearLabel = 'Next 24 years';\n        /** A label for the 'switch to month view' button (used by screen readers). */\n        this.switchToMonthViewLabel = 'Choose date';\n        /** A label for the 'switch to year view' button (used by screen readers). */\n        this.switchToMultiYearViewLabel = 'Choose month and year';\n    }\n    /** Formats a range of years. */\n    formatYearRange(start, end) {\n        return `${start} \\u2013 ${end}`;\n    }\n}\nMatDatepickerIntl.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerIntl, deps: [], target: i0.ɵɵFactoryTarget.Injectable });\nMatDatepickerIntl.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerIntl, providedIn: 'root' });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerIntl, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\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 * An internal class that represents the data corresponding to a single calendar cell.\n * @docs-private\n */\nclass MatCalendarCell {\n    constructor(value, displayValue, ariaLabel, enabled, cssClasses = {}, compareValue = value, rawValue) {\n        this.value = value;\n        this.displayValue = displayValue;\n        this.ariaLabel = ariaLabel;\n        this.enabled = enabled;\n        this.cssClasses = cssClasses;\n        this.compareValue = compareValue;\n        this.rawValue = rawValue;\n    }\n}\n/**\n * An internal component used to display calendar data in a table.\n * @docs-private\n */\nclass MatCalendarBody {\n    constructor(_elementRef, _ngZone) {\n        this._elementRef = _elementRef;\n        this._ngZone = _ngZone;\n        /** The number of columns in the table. */\n        this.numCols = 7;\n        /** The cell number of the active cell in the table. */\n        this.activeCell = 0;\n        /** Whether a range is being selected. */\n        this.isRange = false;\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        /** Start of the preview range. */\n        this.previewStart = null;\n        /** End of the preview range. */\n        this.previewEnd = null;\n        /** Emits when a new value is selected. */\n        this.selectedValueChange = new EventEmitter();\n        /** Emits when the preview has changed as a result of a user action. */\n        this.previewChange = new EventEmitter();\n        /**\n         * Event handler for when the user enters an element\n         * inside the calendar body (e.g. by hovering in or focus).\n         */\n        this._enterHandler = (event) => {\n            if (this._skipNextFocus && event.type === 'focus') {\n                this._skipNextFocus = false;\n                return;\n            }\n            // We only need to hit the zone when we're selecting a range.\n            if (event.target && this.isRange) {\n                const cell = this._getCellFromElement(event.target);\n                if (cell) {\n                    this._ngZone.run(() => this.previewChange.emit({ value: cell.enabled ? cell : null, event }));\n                }\n            }\n        };\n        /**\n         * Event handler for when the user's pointer leaves an element\n         * inside the calendar body (e.g. by hovering out or blurring).\n         */\n        this._leaveHandler = (event) => {\n            // We only need to hit the zone when we're selecting a range.\n            if (this.previewEnd !== null && this.isRange) {\n                // Only reset the preview end value when leaving cells. This looks better, because\n                // we have a gap between the cells and the rows and we don't want to remove the\n                // range just for it to show up again when the user moves a few pixels to the side.\n                if (event.target && this._getCellFromElement(event.target)) {\n                    this._ngZone.run(() => this.previewChange.emit({ value: null, event }));\n                }\n            }\n        };\n        _ngZone.runOutsideAngular(() => {\n            const element = _elementRef.nativeElement;\n            element.addEventListener('mouseenter', this._enterHandler, true);\n            element.addEventListener('focus', this._enterHandler, true);\n            element.addEventListener('mouseleave', this._leaveHandler, true);\n            element.addEventListener('blur', this._leaveHandler, true);\n        });\n    }\n    /** Called when a cell is clicked. */\n    _cellClicked(cell, event) {\n        if (cell.enabled) {\n            this.selectedValueChange.emit({ value: cell.value, event });\n        }\n    }\n    /** Returns whether a cell should be marked as selected. */\n    _isSelected(value) {\n        return this.startValue === value || this.endValue === value;\n    }\n    ngOnChanges(changes) {\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    ngOnDestroy() {\n        const element = this._elementRef.nativeElement;\n        element.removeEventListener('mouseenter', this._enterHandler, true);\n        element.removeEventListener('focus', this._enterHandler, true);\n        element.removeEventListener('mouseleave', this._leaveHandler, true);\n        element.removeEventListener('blur', this._leaveHandler, true);\n    }\n    /** Returns whether a cell is active. */\n    _isActiveCell(rowIndex, colIndex) {\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     *\n     * Adding a 0ms setTimeout seems to fix Voiceover losing focus when pressing PageUp/PageDown\n     * (issue #24330).\n     *\n     * Determined a 0ms by gradually increasing duration from 0 and testing two use cases with screen\n     * reader enabled:\n     *\n     * 1. Pressing PageUp/PageDown repeatedly with pausing between each key press.\n     * 2. Pressing and holding the PageDown key with repeated keys enabled.\n     *\n     * Test 1 worked roughly 95-99% of the time with 0ms and got a little bit better as the duration\n     * increased. Test 2 got slightly better until the duration was long enough to interfere with\n     * repeated keys. If the repeated key speed was faster than the timeout duration, then pressing\n     * and holding pagedown caused the entire page to scroll.\n     *\n     * Since repeated key speed can verify across machines, determined that any duration could\n     * potentially interfere with repeated keys. 0ms would be best because it almost entirely\n     * eliminates the focus being lost in Voiceover (#24330) without causing unintended side effects.\n     * Adding delay also complicates writing tests.\n     */\n    _focusActiveCell(movePreview = true) {\n        this._ngZone.runOutsideAngular(() => {\n            this._ngZone.onStable.pipe(take(1)).subscribe(() => {\n                setTimeout(() => {\n                    const activeCell = this._elementRef.nativeElement.querySelector('.mat-calendar-body-active');\n                    if (activeCell) {\n                        if (!movePreview) {\n                            this._skipNextFocus = true;\n                        }\n                        activeCell.focus();\n                    }\n                });\n            });\n        });\n    }\n    /** Gets whether a value is the start of the main range. */\n    _isRangeStart(value) {\n        return isStart(value, this.startValue, this.endValue);\n    }\n    /** Gets whether a value is the end of the main range. */\n    _isRangeEnd(value) {\n        return isEnd(value, this.startValue, this.endValue);\n    }\n    /** Gets whether a value is within the currently-selected range. */\n    _isInRange(value) {\n        return isInRange(value, this.startValue, this.endValue, this.isRange);\n    }\n    /** Gets whether a value is the start of the comparison range. */\n    _isComparisonStart(value) {\n        return isStart(value, this.comparisonStart, this.comparisonEnd);\n    }\n    /** Whether the cell is a start bridge cell between the main and comparison ranges. */\n    _isComparisonBridgeStart(value, rowIndex, colIndex) {\n        if (!this._isComparisonStart(value) || this._isRangeStart(value) || !this._isInRange(value)) {\n            return false;\n        }\n        let previousCell = this.rows[rowIndex][colIndex - 1];\n        if (!previousCell) {\n            const previousRow = this.rows[rowIndex - 1];\n            previousCell = previousRow && previousRow[previousRow.length - 1];\n        }\n        return previousCell && !this._isRangeEnd(previousCell.compareValue);\n    }\n    /** Whether the cell is an end bridge cell between the main and comparison ranges. */\n    _isComparisonBridgeEnd(value, rowIndex, colIndex) {\n        if (!this._isComparisonEnd(value) || this._isRangeEnd(value) || !this._isInRange(value)) {\n            return false;\n        }\n        let nextCell = this.rows[rowIndex][colIndex + 1];\n        if (!nextCell) {\n            const nextRow = this.rows[rowIndex + 1];\n            nextCell = nextRow && nextRow[0];\n        }\n        return nextCell && !this._isRangeStart(nextCell.compareValue);\n    }\n    /** Gets whether a value is the end of the comparison range. */\n    _isComparisonEnd(value) {\n        return isEnd(value, this.comparisonStart, this.comparisonEnd);\n    }\n    /** Gets whether a value is within the current comparison range. */\n    _isInComparisonRange(value) {\n        return isInRange(value, this.comparisonStart, this.comparisonEnd, this.isRange);\n    }\n    /**\n     * Gets whether a value is the same as the start and end of the comparison range.\n     * For context, the functions that we use to determine whether something is the start/end of\n     * a range don't allow for the start and end to be on the same day, because we'd have to use\n     * much more specific CSS selectors to style them correctly in all scenarios. This is fine for\n     * the regular range, because when it happens, the selected styles take over and still show where\n     * the range would've been, however we don't have these selected styles for a comparison range.\n     * This function is used to apply a class that serves the same purpose as the one for selected\n     * dates, but it only applies in the context of a comparison range.\n     */\n    _isComparisonIdentical(value) {\n        // Note that we don't need to null check the start/end\n        // here, because the `value` will always be defined.\n        return this.comparisonStart === this.comparisonEnd && value === this.comparisonStart;\n    }\n    /** Gets whether a value is the start of the preview range. */\n    _isPreviewStart(value) {\n        return isStart(value, this.previewStart, this.previewEnd);\n    }\n    /** Gets whether a value is the end of the preview range. */\n    _isPreviewEnd(value) {\n        return isEnd(value, this.previewStart, this.previewEnd);\n    }\n    /** Gets whether a value is inside the preview range. */\n    _isInPreview(value) {\n        return isInRange(value, this.previewStart, this.previewEnd, this.isRange);\n    }\n    /** Finds the MatCalendarCell that corresponds to a DOM node. */\n    _getCellFromElement(element) {\n        let cell;\n        if (isTableCell(element)) {\n            cell = element;\n        }\n        else if (isTableCell(element.parentNode)) {\n            cell = element.parentNode;\n        }\n        if (cell) {\n            const row = cell.getAttribute('data-mat-row');\n            const col = cell.getAttribute('data-mat-col');\n            if (row && col) {\n                return this.rows[parseInt(row)][parseInt(col)];\n            }\n        }\n        return null;\n    }\n}\nMatCalendarBody.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCalendarBody, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });\nMatCalendarBody.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatCalendarBody, selector: \"[mat-calendar-body]\", inputs: { label: \"label\", rows: \"rows\", todayValue: \"todayValue\", startValue: \"startValue\", endValue: \"endValue\", labelMinRequiredCells: \"labelMinRequiredCells\", numCols: \"numCols\", activeCell: \"activeCell\", isRange: \"isRange\", cellAspectRatio: \"cellAspectRatio\", comparisonStart: \"comparisonStart\", comparisonEnd: \"comparisonEnd\", previewStart: \"previewStart\", previewEnd: \"previewEnd\" }, outputs: { selectedValueChange: \"selectedValueChange\", previewChange: \"previewChange\" }, host: { classAttribute: \"mat-calendar-body\" }, exportAs: [\"matCalendarBody\"], usesOnChanges: true, ngImport: i0, 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    This cell is purely decorative, but we can't put `aria-hidden` or `role=\\\"presentation\\\"` on it,\\n    because it throws off the week days for the rest of the row on NVDA. The aspect ratio of the\\n    table cells is maintained by setting the top and bottom padding as a percentage of the width\\n    (a variant of the trick described here: https://www.w3schools.com/howto/howto_css_aspect_ratio.asp).\\n  -->\\n  <td *ngIf=\\\"rowIndex === 0 && _firstRowOffset\\\"\\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  <!--\\n    Each gridcell in the calendar contains a button, which signals to assistive technology that the\\n    cell is interactable, as well as the selection state via `aria-pressed`. See #23476 for\\n    background.\\n  -->\\n  <td\\n    *ngFor=\\\"let item of row; let colIndex = index\\\"\\n    role=\\\"gridcell\\\"\\n    class=\\\"mat-calendar-body-cell-container\\\"\\n    [style.width]=\\\"_cellWidth\\\"\\n    [style.paddingTop]=\\\"_cellPadding\\\"\\n    [style.paddingBottom]=\\\"_cellPadding\\\"\\n    [attr.data-mat-row]=\\\"rowIndex\\\"\\n    [attr.data-mat-col]=\\\"colIndex\\\"\\n  >\\n    <button\\n        type=\\\"button\\\"\\n        class=\\\"mat-calendar-body-cell\\\"\\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        [class.mat-calendar-body-range-start]=\\\"_isRangeStart(item.compareValue)\\\"\\n        [class.mat-calendar-body-range-end]=\\\"_isRangeEnd(item.compareValue)\\\"\\n        [class.mat-calendar-body-in-range]=\\\"_isInRange(item.compareValue)\\\"\\n        [class.mat-calendar-body-comparison-bridge-start]=\\\"_isComparisonBridgeStart(item.compareValue, rowIndex, colIndex)\\\"\\n        [class.mat-calendar-body-comparison-bridge-end]=\\\"_isComparisonBridgeEnd(item.compareValue, rowIndex, colIndex)\\\"\\n        [class.mat-calendar-body-comparison-start]=\\\"_isComparisonStart(item.compareValue)\\\"\\n        [class.mat-calendar-body-comparison-end]=\\\"_isComparisonEnd(item.compareValue)\\\"\\n        [class.mat-calendar-body-in-comparison-range]=\\\"_isInComparisonRange(item.compareValue)\\\"\\n        [class.mat-calendar-body-preview-start]=\\\"_isPreviewStart(item.compareValue)\\\"\\n        [class.mat-calendar-body-preview-end]=\\\"_isPreviewEnd(item.compareValue)\\\"\\n        [class.mat-calendar-body-in-preview]=\\\"_isInPreview(item.compareValue)\\\"\\n        [attr.aria-label]=\\\"item.ariaLabel\\\"\\n        [attr.aria-disabled]=\\\"!item.enabled || null\\\"\\n        [attr.aria-pressed]=\\\"_isSelected(item.compareValue)\\\"\\n        [attr.aria-current]=\\\"todayValue === item.compareValue ? 'date' : null\\\"\\n        (click)=\\\"_cellClicked(item, $event)\\\">\\n        <div class=\\\"mat-calendar-body-cell-content mat-focus-indicator\\\"\\n          [class.mat-calendar-body-selected]=\\\"_isSelected(item.compareValue)\\\"\\n          [class.mat-calendar-body-comparison-identical]=\\\"_isComparisonIdentical(item.compareValue)\\\"\\n          [class.mat-calendar-body-today]=\\\"todayValue === item.compareValue\\\">\\n          {{item.displayValue}}\\n        </div>\\n        <div class=\\\"mat-calendar-body-cell-preview\\\" aria-hidden=\\\"true\\\"></div>\\n    </button>\\n  </td>\\n</tr>\\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-container{position:relative;height:0;line-height:0}.mat-calendar-body-cell{-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;position:absolute;top:0;left:0;width:100%;height:100%;background:none;text-align:center;outline:none;font-family:inherit;margin:0}.mat-calendar-body-cell::-moz-focus-inner{border:0}.mat-calendar-body-cell::before,.mat-calendar-body-cell::after,.mat-calendar-body-cell-preview{content:\\\"\\\";position:absolute;top:5%;left:0;z-index:0;box-sizing:border-box;height:90%;width:100%}.mat-calendar-body-range-start:not(.mat-calendar-body-in-comparison-range)::before,.mat-calendar-body-range-start::after,.mat-calendar-body-comparison-start:not(.mat-calendar-body-comparison-bridge-start)::before,.mat-calendar-body-comparison-start::after,.mat-calendar-body-preview-start .mat-calendar-body-cell-preview{left:5%;width:95%;border-top-left-radius:999px;border-bottom-left-radius:999px}[dir=rtl] .mat-calendar-body-range-start:not(.mat-calendar-body-in-comparison-range)::before,[dir=rtl] .mat-calendar-body-range-start::after,[dir=rtl] .mat-calendar-body-comparison-start:not(.mat-calendar-body-comparison-bridge-start)::before,[dir=rtl] .mat-calendar-body-comparison-start::after,[dir=rtl] .mat-calendar-body-preview-start .mat-calendar-body-cell-preview{left:0;border-radius:0;border-top-right-radius:999px;border-bottom-right-radius:999px}.mat-calendar-body-range-end:not(.mat-calendar-body-in-comparison-range)::before,.mat-calendar-body-range-end::after,.mat-calendar-body-comparison-end:not(.mat-calendar-body-comparison-bridge-end)::before,.mat-calendar-body-comparison-end::after,.mat-calendar-body-preview-end .mat-calendar-body-cell-preview{width:95%;border-top-right-radius:999px;border-bottom-right-radius:999px}[dir=rtl] .mat-calendar-body-range-end:not(.mat-calendar-body-in-comparison-range)::before,[dir=rtl] .mat-calendar-body-range-end::after,[dir=rtl] .mat-calendar-body-comparison-end:not(.mat-calendar-body-comparison-bridge-end)::before,[dir=rtl] .mat-calendar-body-comparison-end::after,[dir=rtl] .mat-calendar-body-preview-end .mat-calendar-body-cell-preview{left:5%;border-radius:0;border-top-left-radius:999px;border-bottom-left-radius:999px}[dir=rtl] .mat-calendar-body-comparison-bridge-start.mat-calendar-body-range-end::after,[dir=rtl] .mat-calendar-body-comparison-bridge-end.mat-calendar-body-range-start::after{width:95%;border-top-right-radius:999px;border-bottom-right-radius:999px}.mat-calendar-body-comparison-start.mat-calendar-body-range-end::after,[dir=rtl] .mat-calendar-body-comparison-start.mat-calendar-body-range-end::after,.mat-calendar-body-comparison-end.mat-calendar-body-range-start::after,[dir=rtl] .mat-calendar-body-comparison-end.mat-calendar-body-range-start::after{width:90%}.mat-calendar-body-in-preview .mat-calendar-body-cell-preview{border-top:dashed 1px;border-bottom:dashed 1px}.mat-calendar-body-preview-start .mat-calendar-body-cell-preview{border-left:dashed 1px}[dir=rtl] .mat-calendar-body-preview-start .mat-calendar-body-cell-preview{border-left:0;border-right:dashed 1px}.mat-calendar-body-preview-end .mat-calendar-body-cell-preview{border-right:dashed 1px}[dir=rtl] .mat-calendar-body-preview-end .mat-calendar-body-cell-preview{border-right:0;border-left:dashed 1px}.mat-calendar-body-disabled{cursor:default}.cdk-high-contrast-active .mat-calendar-body-disabled{opacity:.5}.mat-calendar-body-cell-content{top:5%;left:5%;z-index:1;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}.mat-calendar-body-cell-content.mat-focus-indicator{position:absolute}.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-cell:not(.mat-calendar-body-in-range) .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,.cdk-high-contrast-active .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content{outline:dotted 2px}.cdk-high-contrast-active .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content.mat-calendar-body-selected,.cdk-high-contrast-active .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content.mat-calendar-body-selected{outline:solid 3px}.cdk-high-contrast-active .mat-calendar-body-cell::before,.cdk-high-contrast-active .mat-calendar-body-cell::after,.cdk-high-contrast-active .mat-calendar-body-selected{background:none}.cdk-high-contrast-active .mat-calendar-body-in-range::before,.cdk-high-contrast-active .mat-calendar-body-comparison-bridge-start::before,.cdk-high-contrast-active .mat-calendar-body-comparison-bridge-end::before{border-top:solid 1px;border-bottom:solid 1px}.cdk-high-contrast-active .mat-calendar-body-range-start::before{border-left:solid 1px}[dir=rtl] .cdk-high-contrast-active .mat-calendar-body-range-start::before{border-left:0;border-right:solid 1px}.cdk-high-contrast-active .mat-calendar-body-range-end::before{border-right:solid 1px}[dir=rtl] .cdk-high-contrast-active .mat-calendar-body-range-end::before{border-right:0;border-left:solid 1px}.cdk-high-contrast-active .mat-calendar-body-in-comparison-range::before{border-top:dashed 1px;border-bottom:dashed 1px}.cdk-high-contrast-active .mat-calendar-body-comparison-start::before{border-left:dashed 1px}[dir=rtl] .cdk-high-contrast-active .mat-calendar-body-comparison-start::before{border-left:0;border-right:dashed 1px}.cdk-high-contrast-active .mat-calendar-body-comparison-end::before{border-right:dashed 1px}[dir=rtl] .cdk-high-contrast-active .mat-calendar-body-comparison-end::before{border-right:0;border-left:dashed 1px}[dir=rtl] .mat-calendar-body-label{text-align:right}\\n\"], directives: [{ type: i1.NgIf, selector: \"[ngIf]\", inputs: [\"ngIf\", \"ngIfThen\", \"ngIfElse\"] }, { type: i1.NgForOf, selector: \"[ngFor][ngForOf]\", inputs: [\"ngForOf\", \"ngForTrackBy\", \"ngForTemplate\"] }, { type: i1.NgClass, selector: \"[ngClass]\", inputs: [\"class\", \"ngClass\"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCalendarBody, decorators: [{\n            type: Component,\n            args: [{ selector: '[mat-calendar-body]', host: {\n                        'class': 'mat-calendar-body',\n                    }, exportAs: 'matCalendarBody', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, 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    This cell is purely decorative, but we can't put `aria-hidden` or `role=\\\"presentation\\\"` on it,\\n    because it throws off the week days for the rest of the row on NVDA. The aspect ratio of the\\n    table cells is maintained by setting the top and bottom padding as a percentage of the width\\n    (a variant of the trick described here: https://www.w3schools.com/howto/howto_css_aspect_ratio.asp).\\n  -->\\n  <td *ngIf=\\\"rowIndex === 0 && _firstRowOffset\\\"\\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  <!--\\n    Each gridcell in the calendar contains a button, which signals to assistive technology that the\\n    cell is interactable, as well as the selection state via `aria-pressed`. See #23476 for\\n    background.\\n  -->\\n  <td\\n    *ngFor=\\\"let item of row; let colIndex = index\\\"\\n    role=\\\"gridcell\\\"\\n    class=\\\"mat-calendar-body-cell-container\\\"\\n    [style.width]=\\\"_cellWidth\\\"\\n    [style.paddingTop]=\\\"_cellPadding\\\"\\n    [style.paddingBottom]=\\\"_cellPadding\\\"\\n    [attr.data-mat-row]=\\\"rowIndex\\\"\\n    [attr.data-mat-col]=\\\"colIndex\\\"\\n  >\\n    <button\\n        type=\\\"button\\\"\\n        class=\\\"mat-calendar-body-cell\\\"\\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        [class.mat-calendar-body-range-start]=\\\"_isRangeStart(item.compareValue)\\\"\\n        [class.mat-calendar-body-range-end]=\\\"_isRangeEnd(item.compareValue)\\\"\\n        [class.mat-calendar-body-in-range]=\\\"_isInRange(item.compareValue)\\\"\\n        [class.mat-calendar-body-comparison-bridge-start]=\\\"_isComparisonBridgeStart(item.compareValue, rowIndex, colIndex)\\\"\\n        [class.mat-calendar-body-comparison-bridge-end]=\\\"_isComparisonBridgeEnd(item.compareValue, rowIndex, colIndex)\\\"\\n        [class.mat-calendar-body-comparison-start]=\\\"_isComparisonStart(item.compareValue)\\\"\\n        [class.mat-calendar-body-comparison-end]=\\\"_isComparisonEnd(item.compareValue)\\\"\\n        [class.mat-calendar-body-in-comparison-range]=\\\"_isInComparisonRange(item.compareValue)\\\"\\n        [class.mat-calendar-body-preview-start]=\\\"_isPreviewStart(item.compareValue)\\\"\\n        [class.mat-calendar-body-preview-end]=\\\"_isPreviewEnd(item.compareValue)\\\"\\n        [class.mat-calendar-body-in-preview]=\\\"_isInPreview(item.compareValue)\\\"\\n        [attr.aria-label]=\\\"item.ariaLabel\\\"\\n        [attr.aria-disabled]=\\\"!item.enabled || null\\\"\\n        [attr.aria-pressed]=\\\"_isSelected(item.compareValue)\\\"\\n        [attr.aria-current]=\\\"todayValue === item.compareValue ? 'date' : null\\\"\\n        (click)=\\\"_cellClicked(item, $event)\\\">\\n        <div class=\\\"mat-calendar-body-cell-content mat-focus-indicator\\\"\\n          [class.mat-calendar-body-selected]=\\\"_isSelected(item.compareValue)\\\"\\n          [class.mat-calendar-body-comparison-identical]=\\\"_isComparisonIdentical(item.compareValue)\\\"\\n          [class.mat-calendar-body-today]=\\\"todayValue === item.compareValue\\\">\\n          {{item.displayValue}}\\n        </div>\\n        <div class=\\\"mat-calendar-body-cell-preview\\\" aria-hidden=\\\"true\\\"></div>\\n    </button>\\n  </td>\\n</tr>\\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-container{position:relative;height:0;line-height:0}.mat-calendar-body-cell{-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;position:absolute;top:0;left:0;width:100%;height:100%;background:none;text-align:center;outline:none;font-family:inherit;margin:0}.mat-calendar-body-cell::-moz-focus-inner{border:0}.mat-calendar-body-cell::before,.mat-calendar-body-cell::after,.mat-calendar-body-cell-preview{content:\\\"\\\";position:absolute;top:5%;left:0;z-index:0;box-sizing:border-box;height:90%;width:100%}.mat-calendar-body-range-start:not(.mat-calendar-body-in-comparison-range)::before,.mat-calendar-body-range-start::after,.mat-calendar-body-comparison-start:not(.mat-calendar-body-comparison-bridge-start)::before,.mat-calendar-body-comparison-start::after,.mat-calendar-body-preview-start .mat-calendar-body-cell-preview{left:5%;width:95%;border-top-left-radius:999px;border-bottom-left-radius:999px}[dir=rtl] .mat-calendar-body-range-start:not(.mat-calendar-body-in-comparison-range)::before,[dir=rtl] .mat-calendar-body-range-start::after,[dir=rtl] .mat-calendar-body-comparison-start:not(.mat-calendar-body-comparison-bridge-start)::before,[dir=rtl] .mat-calendar-body-comparison-start::after,[dir=rtl] .mat-calendar-body-preview-start .mat-calendar-body-cell-preview{left:0;border-radius:0;border-top-right-radius:999px;border-bottom-right-radius:999px}.mat-calendar-body-range-end:not(.mat-calendar-body-in-comparison-range)::before,.mat-calendar-body-range-end::after,.mat-calendar-body-comparison-end:not(.mat-calendar-body-comparison-bridge-end)::before,.mat-calendar-body-comparison-end::after,.mat-calendar-body-preview-end .mat-calendar-body-cell-preview{width:95%;border-top-right-radius:999px;border-bottom-right-radius:999px}[dir=rtl] .mat-calendar-body-range-end:not(.mat-calendar-body-in-comparison-range)::before,[dir=rtl] .mat-calendar-body-range-end::after,[dir=rtl] .mat-calendar-body-comparison-end:not(.mat-calendar-body-comparison-bridge-end)::before,[dir=rtl] .mat-calendar-body-comparison-end::after,[dir=rtl] .mat-calendar-body-preview-end .mat-calendar-body-cell-preview{left:5%;border-radius:0;border-top-left-radius:999px;border-bottom-left-radius:999px}[dir=rtl] .mat-calendar-body-comparison-bridge-start.mat-calendar-body-range-end::after,[dir=rtl] .mat-calendar-body-comparison-bridge-end.mat-calendar-body-range-start::after{width:95%;border-top-right-radius:999px;border-bottom-right-radius:999px}.mat-calendar-body-comparison-start.mat-calendar-body-range-end::after,[dir=rtl] .mat-calendar-body-comparison-start.mat-calendar-body-range-end::after,.mat-calendar-body-comparison-end.mat-calendar-body-range-start::after,[dir=rtl] .mat-calendar-body-comparison-end.mat-calendar-body-range-start::after{width:90%}.mat-calendar-body-in-preview .mat-calendar-body-cell-preview{border-top:dashed 1px;border-bottom:dashed 1px}.mat-calendar-body-preview-start .mat-calendar-body-cell-preview{border-left:dashed 1px}[dir=rtl] .mat-calendar-body-preview-start .mat-calendar-body-cell-preview{border-left:0;border-right:dashed 1px}.mat-calendar-body-preview-end .mat-calendar-body-cell-preview{border-right:dashed 1px}[dir=rtl] .mat-calendar-body-preview-end .mat-calendar-body-cell-preview{border-right:0;border-left:dashed 1px}.mat-calendar-body-disabled{cursor:default}.cdk-high-contrast-active .mat-calendar-body-disabled{opacity:.5}.mat-calendar-body-cell-content{top:5%;left:5%;z-index:1;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}.mat-calendar-body-cell-content.mat-focus-indicator{position:absolute}.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-cell:not(.mat-calendar-body-in-range) .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,.cdk-high-contrast-active .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content{outline:dotted 2px}.cdk-high-contrast-active .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content.mat-calendar-body-selected,.cdk-high-contrast-active .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content.mat-calendar-body-selected{outline:solid 3px}.cdk-high-contrast-active .mat-calendar-body-cell::before,.cdk-high-contrast-active .mat-calendar-body-cell::after,.cdk-high-contrast-active .mat-calendar-body-selected{background:none}.cdk-high-contrast-active .mat-calendar-body-in-range::before,.cdk-high-contrast-active .mat-calendar-body-comparison-bridge-start::before,.cdk-high-contrast-active .mat-calendar-body-comparison-bridge-end::before{border-top:solid 1px;border-bottom:solid 1px}.cdk-high-contrast-active .mat-calendar-body-range-start::before{border-left:solid 1px}[dir=rtl] .cdk-high-contrast-active .mat-calendar-body-range-start::before{border-left:0;border-right:solid 1px}.cdk-high-contrast-active .mat-calendar-body-range-end::before{border-right:solid 1px}[dir=rtl] .cdk-high-contrast-active .mat-calendar-body-range-end::before{border-right:0;border-left:solid 1px}.cdk-high-contrast-active .mat-calendar-body-in-comparison-range::before{border-top:dashed 1px;border-bottom:dashed 1px}.cdk-high-contrast-active .mat-calendar-body-comparison-start::before{border-left:dashed 1px}[dir=rtl] .cdk-high-contrast-active .mat-calendar-body-comparison-start::before{border-left:0;border-right:dashed 1px}.cdk-high-contrast-active .mat-calendar-body-comparison-end::before{border-right:dashed 1px}[dir=rtl] .cdk-high-contrast-active .mat-calendar-body-comparison-end::before{border-right:0;border-left:dashed 1px}[dir=rtl] .mat-calendar-body-label{text-align:right}\\n\"] }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }]; }, propDecorators: { label: [{\n                type: Input\n            }], rows: [{\n                type: Input\n            }], todayValue: [{\n                type: Input\n            }], startValue: [{\n                type: Input\n            }], endValue: [{\n                type: Input\n            }], labelMinRequiredCells: [{\n                type: Input\n            }], numCols: [{\n                type: Input\n            }], activeCell: [{\n                type: Input\n            }], isRange: [{\n                type: Input\n            }], cellAspectRatio: [{\n                type: Input\n            }], comparisonStart: [{\n                type: Input\n            }], comparisonEnd: [{\n                type: Input\n            }], previewStart: [{\n                type: Input\n            }], previewEnd: [{\n                type: Input\n            }], selectedValueChange: [{\n                type: Output\n            }], previewChange: [{\n                type: Output\n            }] } });\n/** Checks whether a node is a table cell element. */\nfunction isTableCell(node) {\n    return node.nodeName === 'TD';\n}\n/** Checks whether a value is the start of a range. */\nfunction isStart(value, start, end) {\n    return end !== null && start !== end && value < end && value === start;\n}\n/** Checks whether a value is the end of a range. */\nfunction isEnd(value, start, end) {\n    return start !== null && start !== end && value >= start && value === end;\n}\n/** Checks whether a value is inside of a range. */\nfunction isInRange(value, start, end, rangeEnabled) {\n    return (rangeEnabled &&\n        start !== null &&\n        end !== null &&\n        start !== end &&\n        value >= start &&\n        value <= end);\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/** A class representing a range of dates. */\nclass DateRange {\n    constructor(\n    /** The start date of the range. */\n    start, \n    /** The end date of the range. */\n    end) {\n        this.start = start;\n        this.end = end;\n    }\n}\n/**\n * A selection model containing a date selection.\n * @docs-private\n */\nclass MatDateSelectionModel {\n    constructor(\n    /** The current selection. */\n    selection, _adapter) {\n        this.selection = selection;\n        this._adapter = _adapter;\n        this._selectionChanged = new Subject();\n        /** Emits when the selection has changed. */\n        this.selectionChanged = this._selectionChanged;\n        this.selection = selection;\n    }\n    /**\n     * Updates the current selection in the model.\n     * @param value New selection that should be assigned.\n     * @param source Object that triggered the selection change.\n     */\n    updateSelection(value, source) {\n        const oldValue = this.selection;\n        this.selection = value;\n        this._selectionChanged.next({ selection: value, source, oldValue });\n    }\n    ngOnDestroy() {\n        this._selectionChanged.complete();\n    }\n    _isValidDateInstance(date) {\n        return this._adapter.isDateInstance(date) && this._adapter.isValid(date);\n    }\n}\nMatDateSelectionModel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDateSelectionModel, deps: \"invalid\", target: i0.ɵɵFactoryTarget.Injectable });\nMatDateSelectionModel.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDateSelectionModel });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDateSelectionModel, decorators: [{\n            type: Injectable\n        }], ctorParameters: function () { return [{ type: undefined }, { type: i1$1.DateAdapter }]; } });\n/**\n * A selection model that contains a single date.\n * @docs-private\n */\nclass MatSingleDateSelectionModel extends MatDateSelectionModel {\n    constructor(adapter) {\n        super(null, adapter);\n    }\n    /**\n     * Adds a date to the current selection. In the case of a single date selection, the added date\n     * simply overwrites the previous selection\n     */\n    add(date) {\n        super.updateSelection(date, this);\n    }\n    /** Checks whether the current selection is valid. */\n    isValid() {\n        return this.selection != null && this._isValidDateInstance(this.selection);\n    }\n    /**\n     * Checks whether the current selection is complete. In the case of a single date selection, this\n     * is true if the current selection is not null.\n     */\n    isComplete() {\n        return this.selection != null;\n    }\n    /** Clones the selection model. */\n    clone() {\n        const clone = new MatSingleDateSelectionModel(this._adapter);\n        clone.updateSelection(this.selection, this);\n        return clone;\n    }\n}\nMatSingleDateSelectionModel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSingleDateSelectionModel, deps: [{ token: i1$1.DateAdapter }], target: i0.ɵɵFactoryTarget.Injectable });\nMatSingleDateSelectionModel.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSingleDateSelectionModel });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSingleDateSelectionModel, decorators: [{\n            type: Injectable\n        }], ctorParameters: function () { return [{ type: i1$1.DateAdapter }]; } });\n/**\n * A selection model that contains a date range.\n * @docs-private\n */\nclass MatRangeDateSelectionModel extends MatDateSelectionModel {\n    constructor(adapter) {\n        super(new DateRange(null, null), adapter);\n    }\n    /**\n     * Adds a date to the current selection. In the case of a date range selection, the added date\n     * fills in the next `null` value in the range. If both the start and the end already have a date,\n     * the selection is reset so that the given date is the new `start` and the `end` is null.\n     */\n    add(date) {\n        let { start, end } = this.selection;\n        if (start == null) {\n            start = date;\n        }\n        else if (end == null) {\n            end = date;\n        }\n        else {\n            start = date;\n            end = null;\n        }\n        super.updateSelection(new DateRange(start, end), this);\n    }\n    /** Checks whether the current selection is valid. */\n    isValid() {\n        const { start, end } = this.selection;\n        // Empty ranges are valid.\n        if (start == null && end == null) {\n            return true;\n        }\n        // Complete ranges are only valid if both dates are valid and the start is before the end.\n        if (start != null && end != null) {\n            return (this._isValidDateInstance(start) &&\n                this._isValidDateInstance(end) &&\n                this._adapter.compareDate(start, end) <= 0);\n        }\n        // Partial ranges are valid if the start/end is valid.\n        return ((start == null || this._isValidDateInstance(start)) &&\n            (end == null || this._isValidDateInstance(end)));\n    }\n    /**\n     * Checks whether the current selection is complete. In the case of a date range selection, this\n     * is true if the current selection has a non-null `start` and `end`.\n     */\n    isComplete() {\n        return this.selection.start != null && this.selection.end != null;\n    }\n    /** Clones the selection model. */\n    clone() {\n        const clone = new MatRangeDateSelectionModel(this._adapter);\n        clone.updateSelection(this.selection, this);\n        return clone;\n    }\n}\nMatRangeDateSelectionModel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRangeDateSelectionModel, deps: [{ token: i1$1.DateAdapter }], target: i0.ɵɵFactoryTarget.Injectable });\nMatRangeDateSelectionModel.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRangeDateSelectionModel });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRangeDateSelectionModel, decorators: [{\n            type: Injectable\n        }], ctorParameters: function () { return [{ type: i1$1.DateAdapter }]; } });\n/** @docs-private */\nfunction MAT_SINGLE_DATE_SELECTION_MODEL_FACTORY(parent, adapter) {\n    return parent || new MatSingleDateSelectionModel(adapter);\n}\n/**\n * Used to provide a single selection model to a component.\n * @docs-private\n */\nconst MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER = {\n    provide: MatDateSelectionModel,\n    deps: [[new Optional(), new SkipSelf(), MatDateSelectionModel], DateAdapter],\n    useFactory: MAT_SINGLE_DATE_SELECTION_MODEL_FACTORY,\n};\n/** @docs-private */\nfunction MAT_RANGE_DATE_SELECTION_MODEL_FACTORY(parent, adapter) {\n    return parent || new MatRangeDateSelectionModel(adapter);\n}\n/**\n * Used to provide a range selection model to a component.\n * @docs-private\n */\nconst MAT_RANGE_DATE_SELECTION_MODEL_PROVIDER = {\n    provide: MatDateSelectionModel,\n    deps: [[new Optional(), new SkipSelf(), MatDateSelectionModel], DateAdapter],\n    useFactory: MAT_RANGE_DATE_SELECTION_MODEL_FACTORY,\n};\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Injection token used to customize the date range selection behavior. */\nconst MAT_DATE_RANGE_SELECTION_STRATEGY = new InjectionToken('MAT_DATE_RANGE_SELECTION_STRATEGY');\n/** Provides the default date range selection behavior. */\nclass DefaultMatCalendarRangeStrategy {\n    constructor(_dateAdapter) {\n        this._dateAdapter = _dateAdapter;\n    }\n    selectionFinished(date, currentRange) {\n        let { start, end } = currentRange;\n        if (start == null) {\n            start = date;\n        }\n        else if (end == null && date && this._dateAdapter.compareDate(date, start) >= 0) {\n            end = date;\n        }\n        else {\n            start = date;\n            end = null;\n        }\n        return new DateRange(start, end);\n    }\n    createPreview(activeDate, currentRange) {\n        let start = null;\n        let end = null;\n        if (currentRange.start && !currentRange.end && activeDate) {\n            start = currentRange.start;\n            end = activeDate;\n        }\n        return new DateRange(start, end);\n    }\n}\nDefaultMatCalendarRangeStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: DefaultMatCalendarRangeStrategy, deps: [{ token: i1$1.DateAdapter }], target: i0.ɵɵFactoryTarget.Injectable });\nDefaultMatCalendarRangeStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: DefaultMatCalendarRangeStrategy });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: DefaultMatCalendarRangeStrategy, decorators: [{\n            type: Injectable\n        }], ctorParameters: function () { return [{ type: i1$1.DateAdapter }]; } });\n/** @docs-private */\nfunction MAT_CALENDAR_RANGE_STRATEGY_PROVIDER_FACTORY(parent, adapter) {\n    return parent || new DefaultMatCalendarRangeStrategy(adapter);\n}\n/** @docs-private */\nconst MAT_CALENDAR_RANGE_STRATEGY_PROVIDER = {\n    provide: MAT_DATE_RANGE_SELECTION_STRATEGY,\n    deps: [[new Optional(), new SkipSelf(), MAT_DATE_RANGE_SELECTION_STRATEGY], DateAdapter],\n    useFactory: MAT_CALENDAR_RANGE_STRATEGY_PROVIDER_FACTORY,\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 */\nconst DAYS_PER_WEEK = 7;\n/**\n * An internal component used to display a single month in the datepicker.\n * @docs-private\n */\nclass MatMonthView {\n    constructor(_changeDetectorRef, _dateFormats, _dateAdapter, _dir, _rangeStrategy) {\n        this._changeDetectorRef = _changeDetectorRef;\n        this._dateFormats = _dateFormats;\n        this._dateAdapter = _dateAdapter;\n        this._dir = _dir;\n        this._rangeStrategy = _rangeStrategy;\n        this._rerenderSubscription = Subscription.EMPTY;\n        /** Emits when a new date is selected. */\n        this.selectedChange = new EventEmitter();\n        /** Emits when any date is selected. */\n        this._userSelection = new EventEmitter();\n        /** Emits when any date is activated. */\n        this.activeDateChange = new EventEmitter();\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            if (!this._dateAdapter) {\n                throw createMissingDateImplError('DateAdapter');\n            }\n            if (!this._dateFormats) {\n                throw createMissingDateImplError('MAT_DATE_FORMATS');\n            }\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     */\n    get activeDate() {\n        return this._activeDate;\n    }\n    set activeDate(value) {\n        const oldActiveDate = this._activeDate;\n        const validDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value)) ||\n            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    /** The currently selected date. */\n    get selected() {\n        return this._selected;\n    }\n    set selected(value) {\n        if (value instanceof DateRange) {\n            this._selected = value;\n        }\n        else {\n            this._selected = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n        }\n        this._setRanges(this._selected);\n    }\n    /** The minimum selectable date. */\n    get minDate() {\n        return this._minDate;\n    }\n    set minDate(value) {\n        this._minDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /** The maximum selectable date. */\n    get maxDate() {\n        return this._maxDate;\n    }\n    set maxDate(value) {\n        this._maxDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    ngAfterContentInit() {\n        this._rerenderSubscription = this._dateAdapter.localeChanges\n            .pipe(startWith(null))\n            .subscribe(() => this._init());\n    }\n    ngOnChanges(changes) {\n        const comparisonChange = changes['comparisonStart'] || changes['comparisonEnd'];\n        if (comparisonChange && !comparisonChange.firstChange) {\n            this._setRanges(this.selected);\n        }\n    }\n    ngOnDestroy() {\n        this._rerenderSubscription.unsubscribe();\n    }\n    /** Handles when a new date is selected. */\n    _dateSelected(event) {\n        const date = event.value;\n        const selectedYear = this._dateAdapter.getYear(this.activeDate);\n        const selectedMonth = this._dateAdapter.getMonth(this.activeDate);\n        const selectedDate = this._dateAdapter.createDate(selectedYear, selectedMonth, date);\n        let rangeStartDate;\n        let rangeEndDate;\n        if (this._selected instanceof DateRange) {\n            rangeStartDate = this._getDateInCurrentMonth(this._selected.start);\n            rangeEndDate = this._getDateInCurrentMonth(this._selected.end);\n        }\n        else {\n            rangeStartDate = rangeEndDate = this._getDateInCurrentMonth(this._selected);\n        }\n        if (rangeStartDate !== date || rangeEndDate !== date) {\n            this.selectedChange.emit(selectedDate);\n        }\n        this._userSelection.emit({ value: selectedDate, event: event.event });\n        this._previewStart = this._previewEnd = null;\n        this._changeDetectorRef.markForCheck();\n    }\n    /** Handles keydown events on the calendar body when calendar is in month view. */\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        const oldActiveDate = this._activeDate;\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                this._selectionKeyPressed = true;\n                if (this._canSelect(this._activeDate)) {\n                    // Prevent unexpected default actions such as form submission.\n                    // Note that we only prevent the default action here while the selection happens in\n                    // `keyup` below. We can't do the selection here, because it can cause the calendar to\n                    // reopen if focus is restored immediately. We also can't call `preventDefault` on `keyup`\n                    // because it's too late (see #23305).\n                    event.preventDefault();\n                }\n                return;\n            case ESCAPE:\n                // Abort the current range selection if the user presses escape mid-selection.\n                if (this._previewEnd != null && !hasModifierKey(event)) {\n                    this._previewStart = this._previewEnd = null;\n                    this.selectedChange.emit(null);\n                    this._userSelection.emit({ value: null, event });\n                    event.preventDefault();\n                    event.stopPropagation(); // Prevents the overlay from closing.\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    /** Handles keyup events on the calendar body when calendar is in month view. */\n    _handleCalendarBodyKeyup(event) {\n        if (event.keyCode === SPACE || event.keyCode === ENTER) {\n            if (this._selectionKeyPressed && this._canSelect(this._activeDate)) {\n                this._dateSelected({ value: this._dateAdapter.getDate(this._activeDate), event });\n            }\n            this._selectionKeyPressed = false;\n        }\n    }\n    /** Initializes this month view. */\n    _init() {\n        this._setRanges(this.selected);\n        this._todayDate = this._getCellCompareValue(this._dateAdapter.today());\n        this._monthLabel = this._dateFormats.display.monthLabel\n            ? this._dateAdapter.format(this.activeDate, this._dateFormats.display.monthLabel)\n            : this._dateAdapter\n                .getMonthNames('short')[this._dateAdapter.getMonth(this.activeDate)].toLocaleUpperCase();\n        let firstOfMonth = this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), this._dateAdapter.getMonth(this.activeDate), 1);\n        this._firstWeekOffset =\n            (DAYS_PER_WEEK +\n                this._dateAdapter.getDayOfWeek(firstOfMonth) -\n                this._dateAdapter.getFirstDayOfWeek()) %\n                DAYS_PER_WEEK;\n        this._initWeekdays();\n        this._createWeekCells();\n        this._changeDetectorRef.markForCheck();\n    }\n    /** Focuses the active cell after the microtask queue is empty. */\n    _focusActiveCell(movePreview) {\n        this._matCalendarBody._focusActiveCell(movePreview);\n    }\n    /** Called when the user has activated a new cell and the preview needs to be updated. */\n    _previewChanged({ event, value: cell }) {\n        if (this._rangeStrategy) {\n            // We can assume that this will be a range, because preview\n            // events aren't fired for single date selections.\n            const value = cell ? cell.rawValue : null;\n            const previewRange = this._rangeStrategy.createPreview(value, this.selected, event);\n            this._previewStart = this._getCellCompareValue(previewRange.start);\n            this._previewEnd = this._getCellCompareValue(previewRange.end);\n            // Note that here we need to use `detectChanges`, rather than `markForCheck`, because\n            // the way `_focusActiveCell` is set up at the moment makes it fire at the wrong time\n            // when navigating one month back using the keyboard which will cause this handler\n            // to throw a \"changed after checked\" error when updating the preview state.\n            this._changeDetectorRef.detectChanges();\n        }\n    }\n    /** Initializes the weekdays. */\n    _initWeekdays() {\n        const firstDayOfWeek = this._dateAdapter.getFirstDayOfWeek();\n        const narrowWeekdays = this._dateAdapter.getDayOfWeekNames('narrow');\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        let weekdays = longWeekdays.map((long, i) => {\n            return { long, narrow: narrowWeekdays[i] };\n        });\n        this._weekdays = weekdays.slice(firstDayOfWeek).concat(weekdays.slice(0, firstDayOfWeek));\n    }\n    /** Creates MatCalendarCells for the dates in this month. */\n    _createWeekCells() {\n        const daysInMonth = this._dateAdapter.getNumDaysInMonth(this.activeDate);\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            const date = this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), this._dateAdapter.getMonth(this.activeDate), i + 1);\n            const enabled = this._shouldEnableDate(date);\n            const ariaLabel = this._dateAdapter.format(date, this._dateFormats.display.dateA11yLabel);\n            const cellClasses = this.dateClass ? this.dateClass(date, 'month') : undefined;\n            this._weeks[this._weeks.length - 1].push(new MatCalendarCell(i + 1, dateNames[i], ariaLabel, enabled, cellClasses, this._getCellCompareValue(date), date));\n        }\n    }\n    /** Date filter for the month */\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     */\n    _getDateInCurrentMonth(date) {\n        return date && this._hasSameMonthAndYear(date, this.activeDate)\n            ? this._dateAdapter.getDate(date)\n            : null;\n    }\n    /** Checks whether the 2 dates are non-null and fall within the same month of the same year. */\n    _hasSameMonthAndYear(d1, d2) {\n        return !!(d1 &&\n            d2 &&\n            this._dateAdapter.getMonth(d1) == this._dateAdapter.getMonth(d2) &&\n            this._dateAdapter.getYear(d1) == this._dateAdapter.getYear(d2));\n    }\n    /** Gets the value that will be used to one cell to another. */\n    _getCellCompareValue(date) {\n        if (date) {\n            // We use the time since the Unix epoch to compare dates in this view, rather than the\n            // cell values, because we need to support ranges that span across multiple months/years.\n            const year = this._dateAdapter.getYear(date);\n            const month = this._dateAdapter.getMonth(date);\n            const day = this._dateAdapter.getDate(date);\n            return new Date(year, month, day).getTime();\n        }\n        return null;\n    }\n    /** Determines whether the user has the RTL layout direction. */\n    _isRtl() {\n        return this._dir && this._dir.value === 'rtl';\n    }\n    /** Sets the current range based on a model value. */\n    _setRanges(selectedValue) {\n        if (selectedValue instanceof DateRange) {\n            this._rangeStart = this._getCellCompareValue(selectedValue.start);\n            this._rangeEnd = this._getCellCompareValue(selectedValue.end);\n            this._isRange = true;\n        }\n        else {\n            this._rangeStart = this._rangeEnd = this._getCellCompareValue(selectedValue);\n            this._isRange = false;\n        }\n        this._comparisonRangeStart = this._getCellCompareValue(this.comparisonStart);\n        this._comparisonRangeEnd = this._getCellCompareValue(this.comparisonEnd);\n    }\n    /** Gets whether a date can be selected in the month view. */\n    _canSelect(date) {\n        return !this.dateFilter || this.dateFilter(date);\n    }\n}\nMatMonthView.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatMonthView, deps: [{ token: i0.ChangeDetectorRef }, { token: MAT_DATE_FORMATS, optional: true }, { token: i1$1.DateAdapter, optional: true }, { token: i2.Directionality, optional: true }, { token: MAT_DATE_RANGE_SELECTION_STRATEGY, optional: true }], target: i0.ɵɵFactoryTarget.Component });\nMatMonthView.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatMonthView, selector: \"mat-month-view\", inputs: { activeDate: \"activeDate\", selected: \"selected\", minDate: \"minDate\", maxDate: \"maxDate\", dateFilter: \"dateFilter\", dateClass: \"dateClass\", comparisonStart: \"comparisonStart\", comparisonEnd: \"comparisonEnd\" }, outputs: { selectedChange: \"selectedChange\", _userSelection: \"_userSelection\", activeDateChange: \"activeDateChange\" }, viewQueries: [{ propertyName: \"_matCalendarBody\", first: true, predicate: MatCalendarBody, descendants: true }], exportAs: [\"matMonthView\"], usesOnChanges: true, ngImport: i0, template: \"<table class=\\\"mat-calendar-table\\\" role=\\\"grid\\\">\\n  <thead class=\\\"mat-calendar-table-header\\\">\\n    <tr>\\n      <th scope=\\\"col\\\" *ngFor=\\\"let day of _weekdays\\\">\\n        <span class=\\\"cdk-visually-hidden\\\">{{day.long}}</span>\\n        <span aria-hidden=\\\"true\\\">{{day.narrow}}</span>\\n      </th>\\n    </tr>\\n    <tr><th aria-hidden=\\\"true\\\" class=\\\"mat-calendar-table-header-divider\\\" colspan=\\\"7\\\"></th></tr>\\n  </thead>\\n  <tbody mat-calendar-body\\n         [label]=\\\"_monthLabel\\\"\\n         [rows]=\\\"_weeks\\\"\\n         [todayValue]=\\\"_todayDate!\\\"\\n         [startValue]=\\\"_rangeStart!\\\"\\n         [endValue]=\\\"_rangeEnd!\\\"\\n         [comparisonStart]=\\\"_comparisonRangeStart\\\"\\n         [comparisonEnd]=\\\"_comparisonRangeEnd\\\"\\n         [previewStart]=\\\"_previewStart\\\"\\n         [previewEnd]=\\\"_previewEnd\\\"\\n         [isRange]=\\\"_isRange\\\"\\n         [labelMinRequiredCells]=\\\"3\\\"\\n         [activeCell]=\\\"_dateAdapter.getDate(activeDate) - 1\\\"\\n         (selectedValueChange)=\\\"_dateSelected($event)\\\"\\n         (previewChange)=\\\"_previewChanged($event)\\\"\\n         (keyup)=\\\"_handleCalendarBodyKeyup($event)\\\"\\n         (keydown)=\\\"_handleCalendarBodyKeydown($event)\\\">\\n  </tbody>\\n</table>\\n\", components: [{ type: MatCalendarBody, selector: \"[mat-calendar-body]\", inputs: [\"label\", \"rows\", \"todayValue\", \"startValue\", \"endValue\", \"labelMinRequiredCells\", \"numCols\", \"activeCell\", \"isRange\", \"cellAspectRatio\", \"comparisonStart\", \"comparisonEnd\", \"previewStart\", \"previewEnd\"], outputs: [\"selectedValueChange\", \"previewChange\"], exportAs: [\"matCalendarBody\"] }], directives: [{ type: i1.NgForOf, selector: \"[ngFor][ngForOf]\", inputs: [\"ngForOf\", \"ngForTrackBy\", \"ngForTemplate\"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatMonthView, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-month-view', exportAs: 'matMonthView', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: \"<table class=\\\"mat-calendar-table\\\" role=\\\"grid\\\">\\n  <thead class=\\\"mat-calendar-table-header\\\">\\n    <tr>\\n      <th scope=\\\"col\\\" *ngFor=\\\"let day of _weekdays\\\">\\n        <span class=\\\"cdk-visually-hidden\\\">{{day.long}}</span>\\n        <span aria-hidden=\\\"true\\\">{{day.narrow}}</span>\\n      </th>\\n    </tr>\\n    <tr><th aria-hidden=\\\"true\\\" class=\\\"mat-calendar-table-header-divider\\\" colspan=\\\"7\\\"></th></tr>\\n  </thead>\\n  <tbody mat-calendar-body\\n         [label]=\\\"_monthLabel\\\"\\n         [rows]=\\\"_weeks\\\"\\n         [todayValue]=\\\"_todayDate!\\\"\\n         [startValue]=\\\"_rangeStart!\\\"\\n         [endValue]=\\\"_rangeEnd!\\\"\\n         [comparisonStart]=\\\"_comparisonRangeStart\\\"\\n         [comparisonEnd]=\\\"_comparisonRangeEnd\\\"\\n         [previewStart]=\\\"_previewStart\\\"\\n         [previewEnd]=\\\"_previewEnd\\\"\\n         [isRange]=\\\"_isRange\\\"\\n         [labelMinRequiredCells]=\\\"3\\\"\\n         [activeCell]=\\\"_dateAdapter.getDate(activeDate) - 1\\\"\\n         (selectedValueChange)=\\\"_dateSelected($event)\\\"\\n         (previewChange)=\\\"_previewChanged($event)\\\"\\n         (keyup)=\\\"_handleCalendarBodyKeyup($event)\\\"\\n         (keydown)=\\\"_handleCalendarBodyKeydown($event)\\\">\\n  </tbody>\\n</table>\\n\" }]\n        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_DATE_FORMATS]\n                }] }, { type: i1$1.DateAdapter, decorators: [{\n                    type: Optional\n                }] }, { type: i2.Directionality, decorators: [{\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_DATE_RANGE_SELECTION_STRATEGY]\n                }, {\n                    type: Optional\n                }] }]; }, propDecorators: { 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            }], comparisonStart: [{\n                type: Input\n            }], comparisonEnd: [{\n                type: Input\n            }], selectedChange: [{\n                type: Output\n            }], _userSelection: [{\n                type: Output\n            }], activeDateChange: [{\n                type: Output\n            }], _matCalendarBody: [{\n                type: ViewChild,\n                args: [MatCalendarBody]\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 */\nconst yearsPerPage = 24;\nconst yearsPerRow = 4;\n/**\n * An internal component used to display a year selector in the datepicker.\n * @docs-private\n */\nclass MatMultiYearView {\n    constructor(_changeDetectorRef, _dateAdapter, _dir) {\n        this._changeDetectorRef = _changeDetectorRef;\n        this._dateAdapter = _dateAdapter;\n        this._dir = _dir;\n        this._rerenderSubscription = Subscription.EMPTY;\n        /** Emits when a new year is selected. */\n        this.selectedChange = new EventEmitter();\n        /** Emits the selected year. This doesn't imply a change on the selected date */\n        this.yearSelected = new EventEmitter();\n        /** Emits when any date is activated. */\n        this.activeDateChange = new EventEmitter();\n        if (!this._dateAdapter && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw createMissingDateImplError('DateAdapter');\n        }\n        this._activeDate = this._dateAdapter.today();\n    }\n    /** The date to display in this multi-year view (everything other than the year is ignored). */\n    get activeDate() {\n        return this._activeDate;\n    }\n    set activeDate(value) {\n        let oldActiveDate = this._activeDate;\n        const validDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value)) ||\n            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    /** The currently selected date. */\n    get selected() {\n        return this._selected;\n    }\n    set selected(value) {\n        if (value instanceof DateRange) {\n            this._selected = value;\n        }\n        else {\n            this._selected = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n        }\n        this._setSelectedYear(value);\n    }\n    /** The minimum selectable date. */\n    get minDate() {\n        return this._minDate;\n    }\n    set minDate(value) {\n        this._minDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /** The maximum selectable date. */\n    get maxDate() {\n        return this._maxDate;\n    }\n    set maxDate(value) {\n        this._maxDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    ngAfterContentInit() {\n        this._rerenderSubscription = this._dateAdapter.localeChanges\n            .pipe(startWith(null))\n            .subscribe(() => this._init());\n    }\n    ngOnDestroy() {\n        this._rerenderSubscription.unsubscribe();\n    }\n    /** Initializes this multi-year view. */\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        const activeYear = this._dateAdapter.getYear(this._activeDate);\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(year => this._createCellForYear(year)));\n                row = [];\n            }\n        }\n        this._changeDetectorRef.markForCheck();\n    }\n    /** Handles when a new year is selected. */\n    _yearSelected(event) {\n        const year = event.value;\n        this.yearSelected.emit(this._dateAdapter.createDate(year, 0, 1));\n        let month = this._dateAdapter.getMonth(this.activeDate);\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    /** Handles keydown events on the calendar body when calendar is in multi-year view. */\n    _handleCalendarBodyKeydown(event) {\n        const oldActiveDate = this._activeDate;\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 -\n                    getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate) -\n                    1);\n                break;\n            case PAGE_UP:\n                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? -yearsPerPage * 10 : -yearsPerPage);\n                break;\n            case PAGE_DOWN:\n                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? yearsPerPage * 10 : yearsPerPage);\n                break;\n            case ENTER:\n            case SPACE:\n                // Note that we only prevent the default action here while the selection happens in\n                // `keyup` below. We can't do the selection here, because it can cause the calendar to\n                // reopen if focus is restored immediately. We also can't call `preventDefault` on `keyup`\n                // because it's too late (see #23305).\n                this._selectionKeyPressed = true;\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    /** Handles keyup events on the calendar body when calendar is in multi-year view. */\n    _handleCalendarBodyKeyup(event) {\n        if (event.keyCode === SPACE || event.keyCode === ENTER) {\n            if (this._selectionKeyPressed) {\n                this._yearSelected({ value: this._dateAdapter.getYear(this._activeDate), event });\n            }\n            this._selectionKeyPressed = false;\n        }\n    }\n    _getActiveCell() {\n        return getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate);\n    }\n    /** Focuses the active cell after the microtask queue is empty. */\n    _focusActiveCell() {\n        this._matCalendarBody._focusActiveCell();\n    }\n    /** Creates an MatCalendarCell for the given year. */\n    _createCellForYear(year) {\n        const date = this._dateAdapter.createDate(year, 0, 1);\n        const yearName = this._dateAdapter.getYearName(date);\n        const cellClasses = this.dateClass ? this.dateClass(date, 'multi-year') : undefined;\n        return new MatCalendarCell(year, yearName, yearName, this._shouldEnableYear(year), cellClasses);\n    }\n    /** Whether the given year is enabled. */\n    _shouldEnableYear(year) {\n        // disable if the year is greater than maxDate lower than minDate\n        if (year === undefined ||\n            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        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    /** Determines whether the user has the RTL layout direction. */\n    _isRtl() {\n        return this._dir && this._dir.value === 'rtl';\n    }\n    /** Sets the currently-highlighted year based on a model value. */\n    _setSelectedYear(value) {\n        this._selectedYear = null;\n        if (value instanceof DateRange) {\n            const displayValue = value.start || value.end;\n            if (displayValue) {\n                this._selectedYear = this._dateAdapter.getYear(displayValue);\n            }\n        }\n        else if (value) {\n            this._selectedYear = this._dateAdapter.getYear(value);\n        }\n    }\n}\nMatMultiYearView.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatMultiYearView, deps: [{ token: i0.ChangeDetectorRef }, { token: i1$1.DateAdapter, optional: true }, { token: i2.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Component });\nMatMultiYearView.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatMultiYearView, selector: \"mat-multi-year-view\", inputs: { activeDate: \"activeDate\", selected: \"selected\", minDate: \"minDate\", maxDate: \"maxDate\", dateFilter: \"dateFilter\", dateClass: \"dateClass\" }, outputs: { selectedChange: \"selectedChange\", yearSelected: \"yearSelected\", activeDateChange: \"activeDateChange\" }, viewQueries: [{ propertyName: \"_matCalendarBody\", first: true, predicate: MatCalendarBody, descendants: true }], exportAs: [\"matMultiYearView\"], ngImport: i0, template: \"<table class=\\\"mat-calendar-table\\\" role=\\\"grid\\\">\\n  <thead aria-hidden=\\\"true\\\" 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         [startValue]=\\\"_selectedYear!\\\"\\n         [endValue]=\\\"_selectedYear!\\\"\\n         [numCols]=\\\"4\\\"\\n         [cellAspectRatio]=\\\"4 / 7\\\"\\n         [activeCell]=\\\"_getActiveCell()\\\"\\n         (selectedValueChange)=\\\"_yearSelected($event)\\\"\\n         (keyup)=\\\"_handleCalendarBodyKeyup($event)\\\"\\n         (keydown)=\\\"_handleCalendarBodyKeydown($event)\\\">\\n  </tbody>\\n</table>\\n\", components: [{ type: MatCalendarBody, selector: \"[mat-calendar-body]\", inputs: [\"label\", \"rows\", \"todayValue\", \"startValue\", \"endValue\", \"labelMinRequiredCells\", \"numCols\", \"activeCell\", \"isRange\", \"cellAspectRatio\", \"comparisonStart\", \"comparisonEnd\", \"previewStart\", \"previewEnd\"], outputs: [\"selectedValueChange\", \"previewChange\"], exportAs: [\"matCalendarBody\"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatMultiYearView, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-multi-year-view', exportAs: 'matMultiYearView', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: \"<table class=\\\"mat-calendar-table\\\" role=\\\"grid\\\">\\n  <thead aria-hidden=\\\"true\\\" 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         [startValue]=\\\"_selectedYear!\\\"\\n         [endValue]=\\\"_selectedYear!\\\"\\n         [numCols]=\\\"4\\\"\\n         [cellAspectRatio]=\\\"4 / 7\\\"\\n         [activeCell]=\\\"_getActiveCell()\\\"\\n         (selectedValueChange)=\\\"_yearSelected($event)\\\"\\n         (keyup)=\\\"_handleCalendarBodyKeyup($event)\\\"\\n         (keydown)=\\\"_handleCalendarBodyKeydown($event)\\\">\\n  </tbody>\\n</table>\\n\" }]\n        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1$1.DateAdapter, decorators: [{\n                    type: Optional\n                }] }, { type: i2.Directionality, decorators: [{\n                    type: Optional\n                }] }]; }, propDecorators: { 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            }], selectedChange: [{\n                type: Output\n            }], yearSelected: [{\n                type: Output\n            }], activeDateChange: [{\n                type: Output\n            }], _matCalendarBody: [{\n                type: ViewChild,\n                args: [MatCalendarBody]\n            }] } });\nfunction isSameMultiYearView(dateAdapter, date1, date2, minDate, maxDate) {\n    const year1 = dateAdapter.getYear(date1);\n    const year2 = dateAdapter.getYear(date2);\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 */\nfunction getActiveOffset(dateAdapter, activeDate, minDate, maxDate) {\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 */\nfunction getStartingYear(dateAdapter, minDate, maxDate) {\n    let startingYear = 0;\n    if (maxDate) {\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/** Gets remainder that is non-negative, even if first number is negative */\nfunction euclideanModulo(a, b) {\n    return ((a % b) + b) % b;\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 * An internal component used to display a single year in the datepicker.\n * @docs-private\n */\nclass MatYearView {\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        /** Emits when a new month is selected. */\n        this.selectedChange = new EventEmitter();\n        /** Emits the selected month. This doesn't imply a change on the selected date */\n        this.monthSelected = new EventEmitter();\n        /** Emits when any date is activated. */\n        this.activeDateChange = new EventEmitter();\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            if (!this._dateAdapter) {\n                throw createMissingDateImplError('DateAdapter');\n            }\n            if (!this._dateFormats) {\n                throw createMissingDateImplError('MAT_DATE_FORMATS');\n            }\n        }\n        this._activeDate = this._dateAdapter.today();\n    }\n    /** The date to display in this year view (everything other than the year is ignored). */\n    get activeDate() {\n        return this._activeDate;\n    }\n    set activeDate(value) {\n        let oldActiveDate = this._activeDate;\n        const validDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value)) ||\n            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    /** The currently selected date. */\n    get selected() {\n        return this._selected;\n    }\n    set selected(value) {\n        if (value instanceof DateRange) {\n            this._selected = value;\n        }\n        else {\n            this._selected = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n        }\n        this._setSelectedMonth(value);\n    }\n    /** The minimum selectable date. */\n    get minDate() {\n        return this._minDate;\n    }\n    set minDate(value) {\n        this._minDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /** The maximum selectable date. */\n    get maxDate() {\n        return this._maxDate;\n    }\n    set maxDate(value) {\n        this._maxDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    ngAfterContentInit() {\n        this._rerenderSubscription = this._dateAdapter.localeChanges\n            .pipe(startWith(null))\n            .subscribe(() => this._init());\n    }\n    ngOnDestroy() {\n        this._rerenderSubscription.unsubscribe();\n    }\n    /** Handles when a new month is selected. */\n    _monthSelected(event) {\n        const month = event.value;\n        const normalizedDate = this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), month, 1);\n        this.monthSelected.emit(normalizedDate);\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    /** Handles keydown events on the calendar body when calendar is in year view. */\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        const oldActiveDate = this._activeDate;\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 = this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? -10 : -1);\n                break;\n            case PAGE_DOWN:\n                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? 10 : 1);\n                break;\n            case ENTER:\n            case SPACE:\n                // Note that we only prevent the default action here while the selection happens in\n                // `keyup` below. We can't do the selection here, because it can cause the calendar to\n                // reopen if focus is restored immediately. We also can't call `preventDefault` on `keyup`\n                // because it's too late (see #23305).\n                this._selectionKeyPressed = true;\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    /** Handles keyup events on the calendar body when calendar is in year view. */\n    _handleCalendarBodyKeyup(event) {\n        if (event.keyCode === SPACE || event.keyCode === ENTER) {\n            if (this._selectionKeyPressed) {\n                this._monthSelected({ value: this._dateAdapter.getMonth(this._activeDate), event });\n            }\n            this._selectionKeyPressed = false;\n        }\n    }\n    /** Initializes this year view. */\n    _init() {\n        this._setSelectedMonth(this.selected);\n        this._todayMonth = this._getMonthInCurrentYear(this._dateAdapter.today());\n        this._yearLabel = this._dateAdapter.getYearName(this.activeDate);\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 = [\n            [0, 1, 2, 3],\n            [4, 5, 6, 7],\n            [8, 9, 10, 11],\n        ].map(row => row.map(month => this._createCellForMonth(month, monthNames[month])));\n        this._changeDetectorRef.markForCheck();\n    }\n    /** Focuses the active cell after the microtask queue is empty. */\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     */\n    _getMonthInCurrentYear(date) {\n        return date && this._dateAdapter.getYear(date) == this._dateAdapter.getYear(this.activeDate)\n            ? this._dateAdapter.getMonth(date)\n            : null;\n    }\n    /** Creates an MatCalendarCell for the given month. */\n    _createCellForMonth(month, monthName) {\n        const date = this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), month, 1);\n        const ariaLabel = this._dateAdapter.format(date, this._dateFormats.display.monthYearA11yLabel);\n        const cellClasses = this.dateClass ? this.dateClass(date, 'year') : undefined;\n        return new MatCalendarCell(month, monthName.toLocaleUpperCase(), ariaLabel, this._shouldEnableMonth(month), cellClasses);\n    }\n    /** Whether the given month is enabled. */\n    _shouldEnableMonth(month) {\n        const activeYear = this._dateAdapter.getYear(this.activeDate);\n        if (month === undefined ||\n            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        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     */\n    _isYearAndMonthAfterMaxDate(year, month) {\n        if (this.maxDate) {\n            const maxYear = this._dateAdapter.getYear(this.maxDate);\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     */\n    _isYearAndMonthBeforeMinDate(year, month) {\n        if (this.minDate) {\n            const minYear = this._dateAdapter.getYear(this.minDate);\n            const minMonth = this._dateAdapter.getMonth(this.minDate);\n            return year < minYear || (year === minYear && month < minMonth);\n        }\n        return false;\n    }\n    /** Determines whether the user has the RTL layout direction. */\n    _isRtl() {\n        return this._dir && this._dir.value === 'rtl';\n    }\n    /** Sets the currently-selected month based on a model value. */\n    _setSelectedMonth(value) {\n        if (value instanceof DateRange) {\n            this._selectedMonth =\n                this._getMonthInCurrentYear(value.start) || this._getMonthInCurrentYear(value.end);\n        }\n        else {\n            this._selectedMonth = this._getMonthInCurrentYear(value);\n        }\n    }\n}\nMatYearView.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatYearView, deps: [{ token: i0.ChangeDetectorRef }, { token: MAT_DATE_FORMATS, optional: true }, { token: i1$1.DateAdapter, optional: true }, { token: i2.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Component });\nMatYearView.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatYearView, selector: \"mat-year-view\", inputs: { activeDate: \"activeDate\", selected: \"selected\", minDate: \"minDate\", maxDate: \"maxDate\", dateFilter: \"dateFilter\", dateClass: \"dateClass\" }, outputs: { selectedChange: \"selectedChange\", monthSelected: \"monthSelected\", activeDateChange: \"activeDateChange\" }, viewQueries: [{ propertyName: \"_matCalendarBody\", first: true, predicate: MatCalendarBody, descendants: true }], exportAs: [\"matYearView\"], ngImport: i0, template: \"<table class=\\\"mat-calendar-table\\\" role=\\\"grid\\\">\\n  <thead aria-hidden=\\\"true\\\" 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         [startValue]=\\\"_selectedMonth!\\\"\\n         [endValue]=\\\"_selectedMonth!\\\"\\n         [labelMinRequiredCells]=\\\"2\\\"\\n         [numCols]=\\\"4\\\"\\n         [cellAspectRatio]=\\\"4 / 7\\\"\\n         [activeCell]=\\\"_dateAdapter.getMonth(activeDate)\\\"\\n         (selectedValueChange)=\\\"_monthSelected($event)\\\"\\n         (keyup)=\\\"_handleCalendarBodyKeyup($event)\\\"\\n         (keydown)=\\\"_handleCalendarBodyKeydown($event)\\\">\\n  </tbody>\\n</table>\\n\", components: [{ type: MatCalendarBody, selector: \"[mat-calendar-body]\", inputs: [\"label\", \"rows\", \"todayValue\", \"startValue\", \"endValue\", \"labelMinRequiredCells\", \"numCols\", \"activeCell\", \"isRange\", \"cellAspectRatio\", \"comparisonStart\", \"comparisonEnd\", \"previewStart\", \"previewEnd\"], outputs: [\"selectedValueChange\", \"previewChange\"], exportAs: [\"matCalendarBody\"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatYearView, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-year-view', exportAs: 'matYearView', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: \"<table class=\\\"mat-calendar-table\\\" role=\\\"grid\\\">\\n  <thead aria-hidden=\\\"true\\\" 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         [startValue]=\\\"_selectedMonth!\\\"\\n         [endValue]=\\\"_selectedMonth!\\\"\\n         [labelMinRequiredCells]=\\\"2\\\"\\n         [numCols]=\\\"4\\\"\\n         [cellAspectRatio]=\\\"4 / 7\\\"\\n         [activeCell]=\\\"_dateAdapter.getMonth(activeDate)\\\"\\n         (selectedValueChange)=\\\"_monthSelected($event)\\\"\\n         (keyup)=\\\"_handleCalendarBodyKeyup($event)\\\"\\n         (keydown)=\\\"_handleCalendarBodyKeydown($event)\\\">\\n  </tbody>\\n</table>\\n\" }]\n        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_DATE_FORMATS]\n                }] }, { type: i1$1.DateAdapter, decorators: [{\n                    type: Optional\n                }] }, { type: i2.Directionality, decorators: [{\n                    type: Optional\n                }] }]; }, propDecorators: { 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            }], selectedChange: [{\n                type: Output\n            }], monthSelected: [{\n                type: Output\n            }], activeDateChange: [{\n                type: Output\n            }], _matCalendarBody: [{\n                type: ViewChild,\n                args: [MatCalendarBody]\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Counter used to generate unique IDs. */\nlet uniqueId = 0;\n/** Default header for MatCalendar */\nclass MatCalendarHeader {\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._buttonDescriptionId = `mat-calendar-button-${uniqueId++}`;\n        this.calendar.stateChanges.subscribe(() => changeDetectorRef.markForCheck());\n    }\n    /** The label for the current calendar view. */\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        const activeYear = this._dateAdapter.getYear(this.calendar.activeDate);\n        const minYearOfPage = activeYear -\n            getActiveOffset(this._dateAdapter, this.calendar.activeDate, this.calendar.minDate, this.calendar.maxDate);\n        const maxYearOfPage = minYearOfPage + yearsPerPage - 1;\n        const minYearName = this._dateAdapter.getYearName(this._dateAdapter.createDate(minYearOfPage, 0, 1));\n        const maxYearName = this._dateAdapter.getYearName(this._dateAdapter.createDate(maxYearOfPage, 0, 1));\n        return this._intl.formatYearRange(minYearName, maxYearName);\n    }\n    get periodButtonLabel() {\n        return this.calendar.currentView == 'month'\n            ? this._intl.switchToMultiYearViewLabel\n            : this._intl.switchToMonthViewLabel;\n    }\n    /** The label for the previous button. */\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    /** The label for the next button. */\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    /** Handles user clicks on the period label. */\n    currentPeriodClicked() {\n        this.calendar.currentView = this.calendar.currentView == 'month' ? 'multi-year' : 'month';\n    }\n    /** Handles user clicks on the previous button. */\n    previousClicked() {\n        this.calendar.activeDate =\n            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    /** Handles user clicks on the next button. */\n    nextClicked() {\n        this.calendar.activeDate =\n            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    /** Whether the previous period button is enabled. */\n    previousEnabled() {\n        if (!this.calendar.minDate) {\n            return true;\n        }\n        return (!this.calendar.minDate || !this._isSameView(this.calendar.activeDate, this.calendar.minDate));\n    }\n    /** Whether the next period button is enabled. */\n    nextEnabled() {\n        return (!this.calendar.maxDate || !this._isSameView(this.calendar.activeDate, this.calendar.maxDate));\n    }\n    /** Whether the two dates represent the same view in the current view mode (month or year). */\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 = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCalendarHeader, deps: [{ token: MatDatepickerIntl }, { token: forwardRef(() => MatCalendar) }, { token: i1$1.DateAdapter, optional: true }, { token: MAT_DATE_FORMATS, optional: true }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });\nMatCalendarHeader.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatCalendarHeader, selector: \"mat-calendar-header\", exportAs: [\"matCalendarHeader\"], ngImport: i0, 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            [attr.aria-describedby]=\\\"_buttonDescriptionId\\\"\\n            aria-live=\\\"polite\\\">\\n      <span [attr.id]=\\\"_buttonDescriptionId\\\">{{periodButtonText}}</span>\\n      <svg class=\\\"mat-calendar-arrow\\\" [class.mat-calendar-invert]=\\\"calendar.currentView !== 'month'\\\"\\n           viewBox=\\\"0 0 10 5\\\" focusable=\\\"false\\\">\\n           <polygon points=\\\"0,0 5,5 10,0\\\"/>\\n      </svg>\\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\", components: [{ type: i3.MatButton, selector: \"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]\", inputs: [\"disabled\", \"disableRipple\", \"color\"], exportAs: [\"matButton\"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCalendarHeader, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-calendar-header', exportAs: 'matCalendarHeader', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, 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            [attr.aria-describedby]=\\\"_buttonDescriptionId\\\"\\n            aria-live=\\\"polite\\\">\\n      <span [attr.id]=\\\"_buttonDescriptionId\\\">{{periodButtonText}}</span>\\n      <svg class=\\\"mat-calendar-arrow\\\" [class.mat-calendar-invert]=\\\"calendar.currentView !== 'month'\\\"\\n           viewBox=\\\"0 0 10 5\\\" focusable=\\\"false\\\">\\n           <polygon points=\\\"0,0 5,5 10,0\\\"/>\\n      </svg>\\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        }], ctorParameters: function () { return [{ type: MatDatepickerIntl }, { type: MatCalendar, decorators: [{\n                    type: Inject,\n                    args: [forwardRef(() => MatCalendar)]\n                }] }, { type: i1$1.DateAdapter, decorators: [{\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_DATE_FORMATS]\n                }] }, { type: i0.ChangeDetectorRef }]; } });\n/** A calendar that is used as part of the datepicker. */\nclass MatCalendar {\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        /** Whether the calendar should be started in month or year view. */\n        this.startView = 'month';\n        /** Emits when the currently selected date changes. */\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 the current view changes.\n         */\n        this.viewChanged = new EventEmitter(true);\n        /** Emits when any date is selected. */\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 (typeof ngDevMode === 'undefined' || ngDevMode) {\n            if (!this._dateAdapter) {\n                throw createMissingDateImplError('DateAdapter');\n            }\n            if (!this._dateFormats) {\n                throw createMissingDateImplError('MAT_DATE_FORMATS');\n            }\n        }\n        this._intlChanges = _intl.changes.subscribe(() => {\n            _changeDetectorRef.markForCheck();\n            this.stateChanges.next();\n        });\n    }\n    /** A date representing the period (month or year) to start the calendar in. */\n    get startAt() {\n        return this._startAt;\n    }\n    set startAt(value) {\n        this._startAt = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /** The currently selected date. */\n    get selected() {\n        return this._selected;\n    }\n    set selected(value) {\n        if (value instanceof DateRange) {\n            this._selected = value;\n        }\n        else {\n            this._selected = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n        }\n    }\n    /** The minimum selectable date. */\n    get minDate() {\n        return this._minDate;\n    }\n    set minDate(value) {\n        this._minDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /** The maximum selectable date. */\n    get maxDate() {\n        return this._maxDate;\n    }\n    set maxDate(value) {\n        this._maxDate = this._dateAdapter.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     */\n    get activeDate() {\n        return this._clampedActiveDate;\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    /** Whether the calendar is in month view. */\n    get currentView() {\n        return this._currentView;\n    }\n    set currentView(value) {\n        const viewChangedResult = this._currentView !== value ? value : null;\n        this._currentView = value;\n        this._moveFocusOnNextTick = true;\n        this._changeDetectorRef.markForCheck();\n        if (viewChangedResult) {\n            this.viewChanged.emit(viewChangedResult);\n        }\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    ngAfterViewChecked() {\n        if (this._moveFocusOnNextTick) {\n            this._moveFocusOnNextTick = false;\n            this.focusActiveCell();\n        }\n    }\n    ngOnDestroy() {\n        this._intlChanges.unsubscribe();\n        this.stateChanges.complete();\n    }\n    ngOnChanges(changes) {\n        // Ignore date changes that are at a different time on the same day. This fixes issues where\n        // the calendar re-renders when there is no meaningful change to [minDate] or [maxDate]\n        // (#24435).\n        const minDateChange = changes['minDate'] &&\n            !this._dateAdapter.sameDate(changes['minDate'].previousValue, changes['minDate'].currentValue)\n            ? changes['minDate']\n            : undefined;\n        const maxDateChange = changes['maxDate'] &&\n            !this._dateAdapter.sameDate(changes['maxDate'].previousValue, changes['maxDate'].currentValue)\n            ? changes['maxDate']\n            : undefined;\n        const change = minDateChange || maxDateChange || changes['dateFilter'];\n        if (change && !change.firstChange) {\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    /** Focuses the active date. */\n    focusActiveCell() {\n        this._getCurrentViewComponent()._focusActiveCell(false);\n    }\n    /** Updates today's date after an update of the active date */\n    updateTodaysDate() {\n        this._getCurrentViewComponent()._init();\n    }\n    /** Handles date selection in the month view. */\n    _dateSelected(event) {\n        const date = event.value;\n        if (this.selected instanceof DateRange ||\n            (date && !this._dateAdapter.sameDate(date, this.selected))) {\n            this.selectedChange.emit(date);\n        }\n        this._userSelection.emit(event);\n    }\n    /** Handles year selection in the multiyear view. */\n    _yearSelectedInMultiYearView(normalizedYear) {\n        this.yearSelected.emit(normalizedYear);\n    }\n    /** Handles month selection in the year view. */\n    _monthSelectedInYearView(normalizedMonth) {\n        this.monthSelected.emit(normalizedMonth);\n    }\n    /** Handles year/month selection in the multi-year/year views. */\n    _goToDateInView(date, view) {\n        this.activeDate = date;\n        this.currentView = view;\n    }\n    /** Returns the component instance that corresponds to the current calendar view. */\n    _getCurrentViewComponent() {\n        // The return type is explicitly written as a union to ensure that the Closure compiler does\n        // not optimize calls to _init(). Without the explict return type, TypeScript narrows it to\n        // only the first component type. See https://github.com/angular/components/issues/22996.\n        return this.monthView || this.yearView || this.multiYearView;\n    }\n}\nMatCalendar.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCalendar, deps: [{ token: MatDatepickerIntl }, { token: i1$1.DateAdapter, optional: true }, { token: MAT_DATE_FORMATS, optional: true }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });\nMatCalendar.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatCalendar, selector: \"mat-calendar\", inputs: { headerComponent: \"headerComponent\", startAt: \"startAt\", startView: \"startView\", selected: \"selected\", minDate: \"minDate\", maxDate: \"maxDate\", dateFilter: \"dateFilter\", dateClass: \"dateClass\", comparisonStart: \"comparisonStart\", comparisonEnd: \"comparisonEnd\" }, outputs: { selectedChange: \"selectedChange\", yearSelected: \"yearSelected\", monthSelected: \"monthSelected\", viewChanged: \"viewChanged\", _userSelection: \"_userSelection\" }, host: { classAttribute: \"mat-calendar\" }, providers: [MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER], viewQueries: [{ propertyName: \"monthView\", first: true, predicate: MatMonthView, descendants: true }, { propertyName: \"yearView\", first: true, predicate: MatYearView, descendants: true }, { propertyName: \"multiYearView\", first: true, predicate: MatMultiYearView, descendants: true }], exportAs: [\"matCalendar\"], usesOnChanges: true, ngImport: i0, template: \"<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      [comparisonStart]=\\\"comparisonStart\\\"\\n      [comparisonEnd]=\\\"comparisonEnd\\\"\\n      (_userSelection)=\\\"_dateSelected($event)\\\">\\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      [dateClass]=\\\"dateClass\\\"\\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      [dateClass]=\\\"dateClass\\\"\\n      (yearSelected)=\\\"_yearSelectedInMultiYearView($event)\\\"\\n      (selectedChange)=\\\"_goToDateInView($event, 'year')\\\">\\n  </mat-multi-year-view>\\n</div>\\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(4.7142857143% - 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:10px;height:5px;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}.cdk-high-contrast-active .mat-calendar-arrow{fill:CanvasText}.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\"], components: [{ type: MatMonthView, selector: \"mat-month-view\", inputs: [\"activeDate\", \"selected\", \"minDate\", \"maxDate\", \"dateFilter\", \"dateClass\", \"comparisonStart\", \"comparisonEnd\"], outputs: [\"selectedChange\", \"_userSelection\", \"activeDateChange\"], exportAs: [\"matMonthView\"] }, { type: MatYearView, selector: \"mat-year-view\", inputs: [\"activeDate\", \"selected\", \"minDate\", \"maxDate\", \"dateFilter\", \"dateClass\"], outputs: [\"selectedChange\", \"monthSelected\", \"activeDateChange\"], exportAs: [\"matYearView\"] }, { type: MatMultiYearView, selector: \"mat-multi-year-view\", inputs: [\"activeDate\", \"selected\", \"minDate\", \"maxDate\", \"dateFilter\", \"dateClass\"], outputs: [\"selectedChange\", \"yearSelected\", \"activeDateChange\"], exportAs: [\"matMultiYearView\"] }], directives: [{ type: i7.CdkPortalOutlet, selector: \"[cdkPortalOutlet]\", inputs: [\"cdkPortalOutlet\"], outputs: [\"attached\"], exportAs: [\"cdkPortalOutlet\"] }, { type: i8.CdkMonitorFocus, selector: \"[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]\", outputs: [\"cdkFocusChange\"] }, { type: i1.NgSwitch, selector: \"[ngSwitch]\", inputs: [\"ngSwitch\"] }, { type: i1.NgSwitchCase, selector: \"[ngSwitchCase]\", inputs: [\"ngSwitchCase\"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCalendar, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-calendar', host: {\n                        'class': 'mat-calendar',\n                    }, exportAs: 'matCalendar', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER], template: \"<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      [comparisonStart]=\\\"comparisonStart\\\"\\n      [comparisonEnd]=\\\"comparisonEnd\\\"\\n      (_userSelection)=\\\"_dateSelected($event)\\\">\\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      [dateClass]=\\\"dateClass\\\"\\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      [dateClass]=\\\"dateClass\\\"\\n      (yearSelected)=\\\"_yearSelectedInMultiYearView($event)\\\"\\n      (selectedChange)=\\\"_goToDateInView($event, 'year')\\\">\\n  </mat-multi-year-view>\\n</div>\\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(4.7142857143% - 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:10px;height:5px;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}.cdk-high-contrast-active .mat-calendar-arrow{fill:CanvasText}.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        }], ctorParameters: function () { return [{ type: MatDatepickerIntl }, { type: i1$1.DateAdapter, decorators: [{\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_DATE_FORMATS]\n                }] }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { headerComponent: [{\n                type: Input\n            }], startAt: [{\n                type: Input\n            }], startView: [{\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            }], comparisonStart: [{\n                type: Input\n            }], comparisonEnd: [{\n                type: Input\n            }], selectedChange: [{\n                type: Output\n            }], yearSelected: [{\n                type: Output\n            }], monthSelected: [{\n                type: Output\n            }], viewChanged: [{\n                type: Output\n            }], _userSelection: [{\n                type: Output\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            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Animations used by the Material datepicker.\n * @docs-private\n */\nconst matDatepickerAnimations = {\n    /** Transforms the height of the datepicker's calendar. */\n    transformPanel: trigger('transformPanel', [\n        transition('void => enter-dropdown', animate('120ms cubic-bezier(0, 0, 0.2, 1)', keyframes([\n            style({ opacity: 0, transform: 'scale(1, 0.8)' }),\n            style({ opacity: 1, transform: 'scale(1, 1)' }),\n        ]))),\n        transition('void => enter-dialog', animate('150ms cubic-bezier(0, 0, 0.2, 1)', keyframes([\n            style({ opacity: 0, transform: 'scale(0.7)' }),\n            style({ transform: 'none', opacity: 1 }),\n        ]))),\n        transition('* => void', animate('100ms linear', style({ opacity: 0 }))),\n    ]),\n    /** Fades in the content of the calendar. */\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 * @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/** Used to generate a unique ID for each datepicker instance. */\nlet datepickerUid = 0;\n/** Injection token that determines the scroll handling while the calendar is open. */\nconst MAT_DATEPICKER_SCROLL_STRATEGY = new InjectionToken('mat-datepicker-scroll-strategy');\n/** @docs-private */\nfunction MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY(overlay) {\n    return () => overlay.scrollStrategies.reposition();\n}\n/** @docs-private */\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/** @docs-private */\nconst _MatDatepickerContentBase = mixinColor(class {\n    constructor(_elementRef) {\n        this._elementRef = _elementRef;\n    }\n});\n/**\n * Component used as the content for the datepicker overlay. 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 overlay that are not part of the calendar itself in the\n * future. (e.g. confirmation buttons).\n * @docs-private\n */\nclass MatDatepickerContent extends _MatDatepickerContentBase {\n    constructor(elementRef, _changeDetectorRef, _globalModel, _dateAdapter, _rangeSelectionStrategy, intl) {\n        super(elementRef);\n        this._changeDetectorRef = _changeDetectorRef;\n        this._globalModel = _globalModel;\n        this._dateAdapter = _dateAdapter;\n        this._rangeSelectionStrategy = _rangeSelectionStrategy;\n        this._subscriptions = new Subscription();\n        /** Emits when an animation has finished. */\n        this._animationDone = new Subject();\n        /** Portal with projected action buttons. */\n        this._actionsPortal = null;\n        this._closeButtonText = intl.closeCalendarLabel;\n    }\n    ngOnInit() {\n        // If we have actions, clone the model so that we have the ability to cancel the selection,\n        // otherwise update the global model directly. Note that we want to assign this as soon as\n        // possible, but `_actionsPortal` isn't available in the constructor so we do it in `ngOnInit`.\n        this._model = this._actionsPortal ? this._globalModel.clone() : this._globalModel;\n        this._animationState = this.datepicker.touchUi ? 'enter-dialog' : 'enter-dropdown';\n    }\n    ngAfterViewInit() {\n        this._subscriptions.add(this.datepicker.stateChanges.subscribe(() => {\n            this._changeDetectorRef.markForCheck();\n        }));\n        this._calendar.focusActiveCell();\n    }\n    ngOnDestroy() {\n        this._subscriptions.unsubscribe();\n        this._animationDone.complete();\n    }\n    _handleUserSelection(event) {\n        const selection = this._model.selection;\n        const value = event.value;\n        const isRange = selection instanceof DateRange;\n        // If we're selecting a range and we have a selection strategy, always pass the value through\n        // there. Otherwise don't assign null values to the model, unless we're selecting a range.\n        // A null value when picking a range means that the user cancelled the selection (e.g. by\n        // pressing escape), whereas when selecting a single value it means that the value didn't\n        // change. This isn't very intuitive, but it's here for backwards-compatibility.\n        if (isRange && this._rangeSelectionStrategy) {\n            const newSelection = this._rangeSelectionStrategy.selectionFinished(value, selection, event.event);\n            this._model.updateSelection(newSelection, this);\n        }\n        else if (value &&\n            (isRange || !this._dateAdapter.sameDate(value, selection))) {\n            this._model.add(value);\n        }\n        // Delegate closing the overlay to the actions.\n        if ((!this._model || this._model.isComplete()) && !this._actionsPortal) {\n            this.datepicker.close();\n        }\n    }\n    _startExitAnimation() {\n        this._animationState = 'void';\n        this._changeDetectorRef.markForCheck();\n    }\n    _getSelected() {\n        return this._model.selection;\n    }\n    /** Applies the current pending selection to the global model. */\n    _applyPendingSelection() {\n        if (this._model !== this._globalModel) {\n            this._globalModel.updateSelection(this._model.selection, this);\n        }\n    }\n}\nMatDatepickerContent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerContent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: MatDateSelectionModel }, { token: i1$1.DateAdapter }, { token: MAT_DATE_RANGE_SELECTION_STRATEGY, optional: true }, { token: MatDatepickerIntl }], target: i0.ɵɵFactoryTarget.Component });\nMatDatepickerContent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDatepickerContent, selector: \"mat-datepicker-content\", inputs: { color: \"color\" }, host: { listeners: { \"@transformPanel.done\": \"_animationDone.next()\" }, properties: { \"@transformPanel\": \"_animationState\", \"class.mat-datepicker-content-touch\": \"datepicker.touchUi\" }, classAttribute: \"mat-datepicker-content\" }, viewQueries: [{ propertyName: \"_calendar\", first: true, predicate: MatCalendar, descendants: true }], exportAs: [\"matDatepickerContent\"], usesInheritance: true, ngImport: i0, template: \"<div\\n  cdkTrapFocus\\n  role=\\\"dialog\\\"\\n  [attr.aria-modal]=\\\"true\\\"\\n  [attr.aria-labelledby]=\\\"_dialogLabelId ?? undefined\\\"\\n  class=\\\"mat-datepicker-content-container\\\"\\n  [class.mat-datepicker-content-container-with-custom-header]=\\\"datepicker.calendarHeaderComponent\\\"\\n  [class.mat-datepicker-content-container-with-actions]=\\\"_actionsPortal\\\">\\n  <mat-calendar\\n    [id]=\\\"datepicker.id\\\"\\n    [ngClass]=\\\"datepicker.panelClass\\\"\\n    [startAt]=\\\"datepicker.startAt\\\"\\n    [startView]=\\\"datepicker.startView\\\"\\n    [minDate]=\\\"datepicker._getMinDate()\\\"\\n    [maxDate]=\\\"datepicker._getMaxDate()\\\"\\n    [dateFilter]=\\\"datepicker._getDateFilter()\\\"\\n    [headerComponent]=\\\"datepicker.calendarHeaderComponent\\\"\\n    [selected]=\\\"_getSelected()\\\"\\n    [dateClass]=\\\"datepicker.dateClass\\\"\\n    [comparisonStart]=\\\"comparisonStart\\\"\\n    [comparisonEnd]=\\\"comparisonEnd\\\"\\n    [@fadeInCalendar]=\\\"'enter'\\\"\\n    (yearSelected)=\\\"datepicker._selectYear($event)\\\"\\n    (monthSelected)=\\\"datepicker._selectMonth($event)\\\"\\n    (viewChanged)=\\\"datepicker._viewChanged($event)\\\"\\n    (_userSelection)=\\\"_handleUserSelection($event)\\\"></mat-calendar>\\n\\n  <ng-template [cdkPortalOutlet]=\\\"_actionsPortal\\\"></ng-template>\\n\\n  <!-- Invisible close button for screen reader users. -->\\n  <button\\n    type=\\\"button\\\"\\n    mat-raised-button\\n    [color]=\\\"color || 'primary'\\\"\\n    class=\\\"mat-datepicker-close-button\\\"\\n    [class.cdk-visually-hidden]=\\\"!_closeButtonFocused\\\"\\n    (focus)=\\\"_closeButtonFocused = true\\\"\\n    (blur)=\\\"_closeButtonFocused = false\\\"\\n    (click)=\\\"datepicker.close()\\\">{{ _closeButtonText }}</button>\\n</div>\\n\", styles: [\".mat-datepicker-content{display:block;border-radius:4px}.mat-datepicker-content .mat-calendar{width:296px;height:354px}.mat-datepicker-content .mat-datepicker-content-container-with-custom-header .mat-calendar{height:auto}.mat-datepicker-content .mat-datepicker-close-button{position:absolute;top:100%;left:0;margin-top:8px}.ng-animating .mat-datepicker-content .mat-datepicker-close-button{display:none}.mat-datepicker-content-container{display:flex;flex-direction:column;justify-content:space-between}.mat-datepicker-content-touch{display:block;max-height:80vh;position:relative;overflow:visible}.mat-datepicker-content-touch .mat-datepicker-content-container{min-height:312px;max-height:788px;min-width:250px;max-width:750px}.mat-datepicker-content-touch .mat-calendar{width:100%;height:auto}@media all and (orientation: landscape){.mat-datepicker-content-touch .mat-datepicker-content-container{width:64vh;height:80vh}}@media all and (orientation: portrait){.mat-datepicker-content-touch .mat-datepicker-content-container{width:80vw;height:100vw}.mat-datepicker-content-touch .mat-datepicker-content-container-with-actions{height:115vw}}\\n\"], components: [{ type: MatCalendar, selector: \"mat-calendar\", inputs: [\"headerComponent\", \"startAt\", \"startView\", \"selected\", \"minDate\", \"maxDate\", \"dateFilter\", \"dateClass\", \"comparisonStart\", \"comparisonEnd\"], outputs: [\"selectedChange\", \"yearSelected\", \"monthSelected\", \"viewChanged\", \"_userSelection\"], exportAs: [\"matCalendar\"] }, { type: i3.MatButton, selector: \"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]\", inputs: [\"disabled\", \"disableRipple\", \"color\"], exportAs: [\"matButton\"] }], directives: [{ type: i8.CdkTrapFocus, selector: \"[cdkTrapFocus]\", inputs: [\"cdkTrapFocus\", \"cdkTrapFocusAutoCapture\"], exportAs: [\"cdkTrapFocus\"] }, { type: i1.NgClass, selector: \"[ngClass]\", inputs: [\"class\", \"ngClass\"] }, { type: i7.CdkPortalOutlet, selector: \"[cdkPortalOutlet]\", inputs: [\"cdkPortalOutlet\"], outputs: [\"attached\"], exportAs: [\"cdkPortalOutlet\"] }], animations: [matDatepickerAnimations.transformPanel, matDatepickerAnimations.fadeInCalendar], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerContent, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-datepicker-content', host: {\n                        'class': 'mat-datepicker-content',\n                        '[@transformPanel]': '_animationState',\n                        '(@transformPanel.done)': '_animationDone.next()',\n                        '[class.mat-datepicker-content-touch]': 'datepicker.touchUi',\n                    }, animations: [matDatepickerAnimations.transformPanel, matDatepickerAnimations.fadeInCalendar], exportAs: 'matDatepickerContent', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, inputs: ['color'], template: \"<div\\n  cdkTrapFocus\\n  role=\\\"dialog\\\"\\n  [attr.aria-modal]=\\\"true\\\"\\n  [attr.aria-labelledby]=\\\"_dialogLabelId ?? undefined\\\"\\n  class=\\\"mat-datepicker-content-container\\\"\\n  [class.mat-datepicker-content-container-with-custom-header]=\\\"datepicker.calendarHeaderComponent\\\"\\n  [class.mat-datepicker-content-container-with-actions]=\\\"_actionsPortal\\\">\\n  <mat-calendar\\n    [id]=\\\"datepicker.id\\\"\\n    [ngClass]=\\\"datepicker.panelClass\\\"\\n    [startAt]=\\\"datepicker.startAt\\\"\\n    [startView]=\\\"datepicker.startView\\\"\\n    [minDate]=\\\"datepicker._getMinDate()\\\"\\n    [maxDate]=\\\"datepicker._getMaxDate()\\\"\\n    [dateFilter]=\\\"datepicker._getDateFilter()\\\"\\n    [headerComponent]=\\\"datepicker.calendarHeaderComponent\\\"\\n    [selected]=\\\"_getSelected()\\\"\\n    [dateClass]=\\\"datepicker.dateClass\\\"\\n    [comparisonStart]=\\\"comparisonStart\\\"\\n    [comparisonEnd]=\\\"comparisonEnd\\\"\\n    [@fadeInCalendar]=\\\"'enter'\\\"\\n    (yearSelected)=\\\"datepicker._selectYear($event)\\\"\\n    (monthSelected)=\\\"datepicker._selectMonth($event)\\\"\\n    (viewChanged)=\\\"datepicker._viewChanged($event)\\\"\\n    (_userSelection)=\\\"_handleUserSelection($event)\\\"></mat-calendar>\\n\\n  <ng-template [cdkPortalOutlet]=\\\"_actionsPortal\\\"></ng-template>\\n\\n  <!-- Invisible close button for screen reader users. -->\\n  <button\\n    type=\\\"button\\\"\\n    mat-raised-button\\n    [color]=\\\"color || 'primary'\\\"\\n    class=\\\"mat-datepicker-close-button\\\"\\n    [class.cdk-visually-hidden]=\\\"!_closeButtonFocused\\\"\\n    (focus)=\\\"_closeButtonFocused = true\\\"\\n    (blur)=\\\"_closeButtonFocused = false\\\"\\n    (click)=\\\"datepicker.close()\\\">{{ _closeButtonText }}</button>\\n</div>\\n\", styles: [\".mat-datepicker-content{display:block;border-radius:4px}.mat-datepicker-content .mat-calendar{width:296px;height:354px}.mat-datepicker-content .mat-datepicker-content-container-with-custom-header .mat-calendar{height:auto}.mat-datepicker-content .mat-datepicker-close-button{position:absolute;top:100%;left:0;margin-top:8px}.ng-animating .mat-datepicker-content .mat-datepicker-close-button{display:none}.mat-datepicker-content-container{display:flex;flex-direction:column;justify-content:space-between}.mat-datepicker-content-touch{display:block;max-height:80vh;position:relative;overflow:visible}.mat-datepicker-content-touch .mat-datepicker-content-container{min-height:312px;max-height:788px;min-width:250px;max-width:750px}.mat-datepicker-content-touch .mat-calendar{width:100%;height:auto}@media all and (orientation: landscape){.mat-datepicker-content-touch .mat-datepicker-content-container{width:64vh;height:80vh}}@media all and (orientation: portrait){.mat-datepicker-content-touch .mat-datepicker-content-container{width:80vw;height:100vw}.mat-datepicker-content-touch .mat-datepicker-content-container-with-actions{height:115vw}}\\n\"] }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: MatDateSelectionModel }, { type: i1$1.DateAdapter }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_DATE_RANGE_SELECTION_STRATEGY]\n                }] }, { type: MatDatepickerIntl }]; }, propDecorators: { _calendar: [{\n                type: ViewChild,\n                args: [MatCalendar]\n            }] } });\n/** Base class for a datepicker. */\nclass MatDatepickerBase {\n    constructor(_overlay, _ngZone, _viewContainerRef, scrollStrategy, _dateAdapter, _dir, _model) {\n        this._overlay = _overlay;\n        this._ngZone = _ngZone;\n        this._viewContainerRef = _viewContainerRef;\n        this._dateAdapter = _dateAdapter;\n        this._dir = _dir;\n        this._model = _model;\n        this._inputStateChanges = Subscription.EMPTY;\n        /** The view that the calendar should start in. */\n        this.startView = 'month';\n        this._touchUi = false;\n        /** Preferred position of the datepicker in the X axis. */\n        this.xPosition = 'start';\n        /** Preferred position of the datepicker in the Y axis. */\n        this.yPosition = 'below';\n        this._restoreFocus = true;\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 current view changes.\n         */\n        this.viewChanged = new EventEmitter(true);\n        /** Emits when the datepicker has been opened. */\n        this.openedStream = new EventEmitter();\n        /** Emits when the datepicker has been closed. */\n        this.closedStream = new EventEmitter();\n        this._opened = false;\n        /** The id for the datepicker calendar. */\n        this.id = `mat-datepicker-${datepickerUid++}`;\n        /** The element that was focused before the datepicker was opened. */\n        this._focusedElementBeforeOpen = null;\n        /** Unique class that will be added to the backdrop so that the test harnesses can look it up. */\n        this._backdropHarnessClass = `${this.id}-backdrop`;\n        /** Emits when the datepicker's state changes. */\n        this.stateChanges = new Subject();\n        if (!this._dateAdapter && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw createMissingDateImplError('DateAdapter');\n        }\n        this._scrollStrategy = scrollStrategy;\n    }\n    /** The date to open the calendar to initially. */\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.getStartValue() : null);\n    }\n    set startAt(value) {\n        this._startAt = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    /** Color palette to use on the datepicker's calendar. */\n    get color() {\n        return (this._color || (this.datepickerInput ? this.datepickerInput.getThemePalette() : undefined));\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 dropdown and elements have more padding to allow for bigger touch targets.\n     */\n    get touchUi() {\n        return this._touchUi;\n    }\n    set touchUi(value) {\n        this._touchUi = coerceBooleanProperty(value);\n    }\n    /** Whether the datepicker pop-up should be disabled. */\n    get disabled() {\n        return this._disabled === undefined && this.datepickerInput\n            ? this.datepickerInput.disabled\n            : !!this._disabled;\n    }\n    set disabled(value) {\n        const newValue = coerceBooleanProperty(value);\n        if (newValue !== this._disabled) {\n            this._disabled = newValue;\n            this.stateChanges.next(undefined);\n        }\n    }\n    /**\n     * Whether to restore focus to the previously-focused element when the calendar is closed.\n     * Note that automatic focus restoration is an accessibility feature and it is recommended that\n     * you provide your own equivalent, if you decide to turn it off.\n     */\n    get restoreFocus() {\n        return this._restoreFocus;\n    }\n    set restoreFocus(value) {\n        this._restoreFocus = coerceBooleanProperty(value);\n    }\n    /**\n     * Classes to be passed to the date picker panel.\n     * Supports string and string array values, similar to `ngClass`.\n     */\n    get panelClass() {\n        return this._panelClass;\n    }\n    set panelClass(value) {\n        this._panelClass = coerceStringArray(value);\n    }\n    /** Whether the calendar is open. */\n    get opened() {\n        return this._opened;\n    }\n    set opened(value) {\n        coerceBooleanProperty(value) ? this.open() : this.close();\n    }\n    /** The minimum selectable date. */\n    _getMinDate() {\n        return this.datepickerInput && this.datepickerInput.min;\n    }\n    /** The maximum selectable date. */\n    _getMaxDate() {\n        return this.datepickerInput && this.datepickerInput.max;\n    }\n    _getDateFilter() {\n        return this.datepickerInput && this.datepickerInput.dateFilter;\n    }\n    ngOnChanges(changes) {\n        const positionChange = changes['xPosition'] || changes['yPosition'];\n        if (positionChange && !positionChange.firstChange && this._overlayRef) {\n            const positionStrategy = this._overlayRef.getConfig().positionStrategy;\n            if (positionStrategy instanceof FlexibleConnectedPositionStrategy) {\n                this._setConnectedPositions(positionStrategy);\n                if (this.opened) {\n                    this._overlayRef.updatePosition();\n                }\n            }\n        }\n        this.stateChanges.next(undefined);\n    }\n    ngOnDestroy() {\n        this._destroyOverlay();\n        this.close();\n        this._inputStateChanges.unsubscribe();\n        this.stateChanges.complete();\n    }\n    /** Selects the given date */\n    select(date) {\n        this._model.add(date);\n    }\n    /** Emits the selected year in multiyear view */\n    _selectYear(normalizedYear) {\n        this.yearSelected.emit(normalizedYear);\n    }\n    /** Emits selected month in year view */\n    _selectMonth(normalizedMonth) {\n        this.monthSelected.emit(normalizedMonth);\n    }\n    /** Emits changed view */\n    _viewChanged(view) {\n        this.viewChanged.emit(view);\n    }\n    /**\n     * Register an input with this datepicker.\n     * @param input The datepicker input to register with this datepicker.\n     * @returns Selection model that the input should hook itself up to.\n     */\n    registerInput(input) {\n        if (this.datepickerInput && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw Error('A MatDatepicker can only be associated with a single input.');\n        }\n        this._inputStateChanges.unsubscribe();\n        this.datepickerInput = input;\n        this._inputStateChanges = input.stateChanges.subscribe(() => this.stateChanges.next(undefined));\n        return this._model;\n    }\n    /**\n     * Registers a portal containing action buttons with the datepicker.\n     * @param portal Portal to be registered.\n     */\n    registerActions(portal) {\n        if (this._actionsPortal && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw Error('A MatDatepicker can only be associated with a single actions row.');\n        }\n        this._actionsPortal = portal;\n    }\n    /**\n     * Removes a portal containing action buttons from the datepicker.\n     * @param portal Portal to be removed.\n     */\n    removeActions(portal) {\n        if (portal === this._actionsPortal) {\n            this._actionsPortal = null;\n        }\n    }\n    /** Open the calendar. */\n    open() {\n        if (this._opened || this.disabled) {\n            return;\n        }\n        if (!this.datepickerInput && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw Error('Attempted to open an MatDatepicker with no associated input.');\n        }\n        this._focusedElementBeforeOpen = _getFocusedElementPierceShadowDom();\n        this._openOverlay();\n        this._opened = true;\n        this.openedStream.emit();\n    }\n    /** Close the calendar. */\n    close() {\n        if (!this._opened) {\n            return;\n        }\n        if (this._componentRef) {\n            const instance = this._componentRef.instance;\n            instance._startExitAnimation();\n            instance._animationDone.pipe(take(1)).subscribe(() => this._destroyOverlay());\n        }\n        const completeClose = () => {\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._restoreFocus &&\n            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    /** Applies the current pending selection on the overlay to the model. */\n    _applyPendingSelection() {\n        this._componentRef?.instance?._applyPendingSelection();\n    }\n    /** Forwards relevant values from the datepicker to the datepicker content inside the overlay. */\n    _forwardContentValues(instance) {\n        instance.datepicker = this;\n        instance.color = this.color;\n        instance._actionsPortal = this._actionsPortal;\n        instance._dialogLabelId = this.datepickerInput.getOverlayLabelId();\n    }\n    /** Opens the overlay with the calendar. */\n    _openOverlay() {\n        this._destroyOverlay();\n        const isDialog = this.touchUi;\n        const portal = new ComponentPortal(MatDatepickerContent, this._viewContainerRef);\n        const overlayRef = (this._overlayRef = this._overlay.create(new OverlayConfig({\n            positionStrategy: isDialog ? this._getDialogStrategy() : this._getDropdownStrategy(),\n            hasBackdrop: true,\n            backdropClass: [\n                isDialog ? 'cdk-overlay-dark-backdrop' : 'mat-overlay-transparent-backdrop',\n                this._backdropHarnessClass,\n            ],\n            direction: this._dir,\n            scrollStrategy: isDialog ? this._overlay.scrollStrategies.block() : this._scrollStrategy(),\n            panelClass: `mat-datepicker-${isDialog ? 'dialog' : 'popup'}`,\n        })));\n        this._getCloseStream(overlayRef).subscribe(event => {\n            if (event) {\n                event.preventDefault();\n            }\n            this.close();\n        });\n        // The `preventDefault` call happens inside the calendar as well, however focus moves into\n        // it inside a timeout which can give browsers a chance to fire off a keyboard event in-between\n        // that can scroll the page (see #24969). Always block default actions of arrow keys for the\n        // entire overlay so the page doesn't get scrolled by accident.\n        overlayRef.keydownEvents().subscribe(event => {\n            const keyCode = event.keyCode;\n            if (keyCode === UP_ARROW ||\n                keyCode === DOWN_ARROW ||\n                keyCode === LEFT_ARROW ||\n                keyCode === RIGHT_ARROW ||\n                keyCode === PAGE_UP ||\n                keyCode === PAGE_DOWN) {\n                event.preventDefault();\n            }\n        });\n        this._componentRef = overlayRef.attach(portal);\n        this._forwardContentValues(this._componentRef.instance);\n        // Update the position once the calendar has rendered. Only relevant in dropdown mode.\n        if (!isDialog) {\n            this._ngZone.onStable.pipe(take(1)).subscribe(() => overlayRef.updatePosition());\n        }\n    }\n    /** Destroys the current overlay. */\n    _destroyOverlay() {\n        if (this._overlayRef) {\n            this._overlayRef.dispose();\n            this._overlayRef = this._componentRef = null;\n        }\n    }\n    /** Gets a position strategy that will open the calendar as a dropdown. */\n    _getDialogStrategy() {\n        return this._overlay.position().global().centerHorizontally().centerVertically();\n    }\n    /** Gets a position strategy that will open the calendar as a dropdown. */\n    _getDropdownStrategy() {\n        const strategy = this._overlay\n            .position()\n            .flexibleConnectedTo(this.datepickerInput.getConnectedOverlayOrigin())\n            .withTransformOriginOn('.mat-datepicker-content')\n            .withFlexibleDimensions(false)\n            .withViewportMargin(8)\n            .withLockedPosition();\n        return this._setConnectedPositions(strategy);\n    }\n    /** Sets the positions of the datepicker in dropdown mode based on the current configuration. */\n    _setConnectedPositions(strategy) {\n        const primaryX = this.xPosition === 'end' ? 'end' : 'start';\n        const secondaryX = primaryX === 'start' ? 'end' : 'start';\n        const primaryY = this.yPosition === 'above' ? 'bottom' : 'top';\n        const secondaryY = primaryY === 'top' ? 'bottom' : 'top';\n        return strategy.withPositions([\n            {\n                originX: primaryX,\n                originY: secondaryY,\n                overlayX: primaryX,\n                overlayY: primaryY,\n            },\n            {\n                originX: primaryX,\n                originY: primaryY,\n                overlayX: primaryX,\n                overlayY: secondaryY,\n            },\n            {\n                originX: secondaryX,\n                originY: secondaryY,\n                overlayX: secondaryX,\n                overlayY: primaryY,\n            },\n            {\n                originX: secondaryX,\n                originY: primaryY,\n                overlayX: secondaryX,\n                overlayY: secondaryY,\n            },\n        ]);\n    }\n    /** Gets an observable that will emit when the overlay is supposed to be closed. */\n    _getCloseStream(overlayRef) {\n        return merge(overlayRef.backdropClick(), overlayRef.detachments(), overlayRef.keydownEvents().pipe(filter(event => {\n            // Closing on alt + up is only valid when there's an input associated with the datepicker.\n            return ((event.keyCode === ESCAPE && !hasModifierKey(event)) ||\n                (this.datepickerInput && hasModifierKey(event, 'altKey') && event.keyCode === UP_ARROW));\n        })));\n    }\n}\nMatDatepickerBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerBase, deps: [{ token: i9.Overlay }, { token: i0.NgZone }, { token: i0.ViewContainerRef }, { token: MAT_DATEPICKER_SCROLL_STRATEGY }, { token: i1$1.DateAdapter, optional: true }, { token: i2.Directionality, optional: true }, { token: MatDateSelectionModel }], target: i0.ɵɵFactoryTarget.Directive });\nMatDatepickerBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDatepickerBase, inputs: { calendarHeaderComponent: \"calendarHeaderComponent\", startAt: \"startAt\", startView: \"startView\", color: \"color\", touchUi: \"touchUi\", disabled: \"disabled\", xPosition: \"xPosition\", yPosition: \"yPosition\", restoreFocus: \"restoreFocus\", dateClass: \"dateClass\", panelClass: \"panelClass\", opened: \"opened\" }, outputs: { yearSelected: \"yearSelected\", monthSelected: \"monthSelected\", viewChanged: \"viewChanged\", openedStream: \"opened\", closedStream: \"closed\" }, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i9.Overlay }, { type: i0.NgZone }, { type: i0.ViewContainerRef }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_DATEPICKER_SCROLL_STRATEGY]\n                }] }, { type: i1$1.DateAdapter, decorators: [{\n                    type: Optional\n                }] }, { type: i2.Directionality, decorators: [{\n                    type: Optional\n                }] }, { type: MatDateSelectionModel }]; }, propDecorators: { calendarHeaderComponent: [{\n                type: Input\n            }], startAt: [{\n                type: Input\n            }], startView: [{\n                type: Input\n            }], color: [{\n                type: Input\n            }], touchUi: [{\n                type: Input\n            }], disabled: [{\n                type: Input\n            }], xPosition: [{\n                type: Input\n            }], yPosition: [{\n                type: Input\n            }], restoreFocus: [{\n                type: Input\n            }], yearSelected: [{\n                type: Output\n            }], monthSelected: [{\n                type: Output\n            }], viewChanged: [{\n                type: Output\n            }], dateClass: [{\n                type: Input\n            }], openedStream: [{\n                type: Output,\n                args: ['opened']\n            }], closedStream: [{\n                type: Output,\n                args: ['closed']\n            }], panelClass: [{\n                type: Input\n            }], opened: [{\n                type: Input\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// TODO(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/** Component responsible for managing the datepicker popup/dialog. */\nclass MatDatepicker extends MatDatepickerBase {\n}\nMatDatepicker.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepicker, deps: null, target: i0.ɵɵFactoryTarget.Component });\nMatDatepicker.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDatepicker, selector: \"mat-datepicker\", providers: [\n        MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER,\n        { provide: MatDatepickerBase, useExisting: MatDatepicker },\n    ], exportAs: [\"matDatepicker\"], usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepicker, decorators: [{\n            type: Component,\n            args: [{\n                    selector: 'mat-datepicker',\n                    template: '',\n                    exportAs: 'matDatepicker',\n                    changeDetection: ChangeDetectionStrategy.OnPush,\n                    encapsulation: ViewEncapsulation.None,\n                    providers: [\n                        MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER,\n                        { provide: MatDatepickerBase, useExisting: MatDatepicker },\n                    ],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\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 */\nclass MatDatepickerInputEvent {\n    constructor(\n    /** Reference to the datepicker input component that emitted the event. */\n    target, \n    /** Reference to the native input element associated with the datepicker input. */\n    targetElement) {\n        this.target = target;\n        this.targetElement = targetElement;\n        this.value = this.target.value;\n    }\n}\n/** Base class for datepicker inputs. */\nclass MatDatepickerInputBase {\n    constructor(_elementRef, _dateAdapter, _dateFormats) {\n        this._elementRef = _elementRef;\n        this._dateAdapter = _dateAdapter;\n        this._dateFormats = _dateFormats;\n        /** Emits when a `change` event is fired on this `<input>`. */\n        this.dateChange = new EventEmitter();\n        /** Emits when an `input` event is fired on this `<input>`. */\n        this.dateInput = new EventEmitter();\n        /** Emits when the internal state has changed */\n        this.stateChanges = new Subject();\n        this._onTouched = () => { };\n        this._validatorOnChange = () => { };\n        this._cvaOnChange = () => { };\n        this._valueChangesSubscription = Subscription.EMPTY;\n        this._localeSubscription = Subscription.EMPTY;\n        /** The form control validator for whether the input parses. */\n        this._parseValidator = () => {\n            return this._lastValueValid\n                ? null\n                : { 'matDatepickerParse': { 'text': this._elementRef.nativeElement.value } };\n        };\n        /** The form control validator for the date filter. */\n        this._filterValidator = (control) => {\n            const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n            return !controlValue || this._matchesFilter(controlValue)\n                ? null\n                : { 'matDatepickerFilter': true };\n        };\n        /** The form control validator for the min date. */\n        this._minValidator = (control) => {\n            const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n            const min = this._getMinDate();\n            return !min || !controlValue || this._dateAdapter.compareDate(min, controlValue) <= 0\n                ? null\n                : { 'matDatepickerMin': { 'min': min, 'actual': controlValue } };\n        };\n        /** The form control validator for the max date. */\n        this._maxValidator = (control) => {\n            const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n            const max = this._getMaxDate();\n            return !max || !controlValue || this._dateAdapter.compareDate(max, controlValue) >= 0\n                ? null\n                : { 'matDatepickerMax': { 'max': max, 'actual': controlValue } };\n        };\n        /** Whether the last value set on the input was valid. */\n        this._lastValueValid = false;\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            if (!this._dateAdapter) {\n                throw createMissingDateImplError('DateAdapter');\n            }\n            if (!this._dateFormats) {\n                throw createMissingDateImplError('MAT_DATE_FORMATS');\n            }\n        }\n        // Update the displayed date when the locale changes.\n        this._localeSubscription = _dateAdapter.localeChanges.subscribe(() => {\n            this._assignValueProgrammatically(this.value);\n        });\n    }\n    /** The value of the input. */\n    get value() {\n        return this._model ? this._getValueFromModel(this._model.selection) : this._pendingValue;\n    }\n    set value(value) {\n        this._assignValueProgrammatically(value);\n    }\n    /** Whether the datepicker-input is disabled. */\n    get disabled() {\n        return !!this._disabled || this._parentDisabled();\n    }\n    set disabled(value) {\n        const newValue = coerceBooleanProperty(value);\n        const element = this._elementRef.nativeElement;\n        if (this._disabled !== newValue) {\n            this._disabled = newValue;\n            this.stateChanges.next(undefined);\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    /** Gets the base validator functions. */\n    _getValidators() {\n        return [this._parseValidator, this._minValidator, this._maxValidator, this._filterValidator];\n    }\n    /** Registers a date selection model with the input. */\n    _registerModel(model) {\n        this._model = model;\n        this._valueChangesSubscription.unsubscribe();\n        if (this._pendingValue) {\n            this._assignValue(this._pendingValue);\n        }\n        this._valueChangesSubscription = this._model.selectionChanged.subscribe(event => {\n            if (this._shouldHandleChangeEvent(event)) {\n                const value = this._getValueFromModel(event.selection);\n                this._lastValueValid = this._isValidValue(value);\n                this._cvaOnChange(value);\n                this._onTouched();\n                this._formatValue(value);\n                this.dateInput.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));\n                this.dateChange.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));\n            }\n        });\n    }\n    ngAfterViewInit() {\n        this._isInitialized = true;\n    }\n    ngOnChanges(changes) {\n        if (dateInputsHaveChanged(changes, this._dateAdapter)) {\n            this.stateChanges.next(undefined);\n        }\n    }\n    ngOnDestroy() {\n        this._valueChangesSubscription.unsubscribe();\n        this._localeSubscription.unsubscribe();\n        this.stateChanges.complete();\n    }\n    /** @docs-private */\n    registerOnValidatorChange(fn) {\n        this._validatorOnChange = fn;\n    }\n    /** @docs-private */\n    validate(c) {\n        return this._validator ? this._validator(c) : null;\n    }\n    // Implemented as part of ControlValueAccessor.\n    writeValue(value) {\n        this._assignValueProgrammatically(value);\n    }\n    // Implemented as part of ControlValueAccessor.\n    registerOnChange(fn) {\n        this._cvaOnChange = fn;\n    }\n    // Implemented as part of ControlValueAccessor.\n    registerOnTouched(fn) {\n        this._onTouched = fn;\n    }\n    // Implemented as part of ControlValueAccessor.\n    setDisabledState(isDisabled) {\n        this.disabled = isDisabled;\n    }\n    _onKeydown(event) {\n        const isAltDownArrow = event.altKey && event.keyCode === DOWN_ARROW;\n        if (isAltDownArrow && !this._elementRef.nativeElement.readOnly) {\n            this._openPopup();\n            event.preventDefault();\n        }\n    }\n    _onInput(value) {\n        const lastValueWasValid = this._lastValueValid;\n        let date = this._dateAdapter.parse(value, this._dateFormats.parse.dateInput);\n        this._lastValueValid = this._isValidValue(date);\n        date = this._dateAdapter.getValidDateOrNull(date);\n        const hasChanged = !this._dateAdapter.sameDate(date, this.value);\n        // We need to fire the CVA change event for all\n        // nulls, otherwise the validators won't run.\n        if (!date || hasChanged) {\n            this._cvaOnChange(date);\n        }\n        else {\n            // Call the CVA change handler for invalid values\n            // since this is what marks the control as dirty.\n            if (value && !this.value) {\n                this._cvaOnChange(date);\n            }\n            if (lastValueWasValid !== this._lastValueValid) {\n                this._validatorOnChange();\n            }\n        }\n        if (hasChanged) {\n            this._assignValue(date);\n            this.dateInput.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));\n        }\n    }\n    _onChange() {\n        this.dateChange.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));\n    }\n    /** Handles blur events on the input. */\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    /** Formats a value and sets it on the input element. */\n    _formatValue(value) {\n        this._elementRef.nativeElement.value =\n            value != null ? this._dateAdapter.format(value, this._dateFormats.display.dateInput) : '';\n    }\n    /** Assigns a value to the model. */\n    _assignValue(value) {\n        // We may get some incoming values before the model was\n        // assigned. Save the value so that we can assign it later.\n        if (this._model) {\n            this._assignValueToModel(value);\n            this._pendingValue = null;\n        }\n        else {\n            this._pendingValue = value;\n        }\n    }\n    /** Whether a value is considered valid. */\n    _isValidValue(value) {\n        return !value || this._dateAdapter.isValid(value);\n    }\n    /**\n     * Checks whether a parent control is disabled. This is in place so that it can be overridden\n     * by inputs extending this one which can be placed inside of a group that can be disabled.\n     */\n    _parentDisabled() {\n        return false;\n    }\n    /** Programmatically assigns a value to the input. */\n    _assignValueProgrammatically(value) {\n        value = this._dateAdapter.deserialize(value);\n        this._lastValueValid = this._isValidValue(value);\n        value = this._dateAdapter.getValidDateOrNull(value);\n        this._assignValue(value);\n        this._formatValue(value);\n    }\n    /** Gets whether a value matches the current date filter. */\n    _matchesFilter(value) {\n        const filter = this._getDateFilter();\n        return !filter || filter(value);\n    }\n}\nMatDatepickerInputBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerInputBase, deps: [{ token: i0.ElementRef }, { token: i1$1.DateAdapter, optional: true }, { token: MAT_DATE_FORMATS, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nMatDatepickerInputBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDatepickerInputBase, inputs: { value: \"value\", disabled: \"disabled\" }, outputs: { dateChange: \"dateChange\", dateInput: \"dateInput\" }, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerInputBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1$1.DateAdapter, decorators: [{\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_DATE_FORMATS]\n                }] }]; }, propDecorators: { value: [{\n                type: Input\n            }], disabled: [{\n                type: Input\n            }], dateChange: [{\n                type: Output\n            }], dateInput: [{\n                type: Output\n            }] } });\n/**\n * Checks whether the `SimpleChanges` object from an `ngOnChanges`\n * callback has any changes, accounting for date objects.\n */\nfunction dateInputsHaveChanged(changes, adapter) {\n    const keys = Object.keys(changes);\n    for (let key of keys) {\n        const { previousValue, currentValue } = changes[key];\n        if (adapter.isDateInstance(previousValue) && adapter.isDateInstance(currentValue)) {\n            if (!adapter.sameDate(previousValue, currentValue)) {\n                return true;\n            }\n        }\n        else {\n            return true;\n        }\n    }\n    return 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 */\n/** @docs-private */\nconst MAT_DATEPICKER_VALUE_ACCESSOR = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => MatDatepickerInput),\n    multi: true,\n};\n/** @docs-private */\nconst MAT_DATEPICKER_VALIDATORS = {\n    provide: NG_VALIDATORS,\n    useExisting: forwardRef(() => MatDatepickerInput),\n    multi: true,\n};\n/** Directive used to connect an input to a MatDatepicker. */\nclass MatDatepickerInput extends MatDatepickerInputBase {\n    constructor(elementRef, dateAdapter, dateFormats, _formField) {\n        super(elementRef, dateAdapter, dateFormats);\n        this._formField = _formField;\n        this._closedSubscription = Subscription.EMPTY;\n        this._validator = Validators.compose(super._getValidators());\n    }\n    /** The datepicker that this input is associated with. */\n    set matDatepicker(datepicker) {\n        if (datepicker) {\n            this._datepicker = datepicker;\n            this._closedSubscription = datepicker.closedStream.subscribe(() => this._onTouched());\n            this._registerModel(datepicker.registerInput(this));\n        }\n    }\n    /** The minimum valid date. */\n    get min() {\n        return this._min;\n    }\n    set min(value) {\n        const validValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n        if (!this._dateAdapter.sameDate(validValue, this._min)) {\n            this._min = validValue;\n            this._validatorOnChange();\n        }\n    }\n    /** The maximum valid date. */\n    get max() {\n        return this._max;\n    }\n    set max(value) {\n        const validValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n        if (!this._dateAdapter.sameDate(validValue, this._max)) {\n            this._max = validValue;\n            this._validatorOnChange();\n        }\n    }\n    /** Function that can be used to filter out dates within the datepicker. */\n    get dateFilter() {\n        return this._dateFilter;\n    }\n    set dateFilter(value) {\n        const wasMatchingValue = this._matchesFilter(this.value);\n        this._dateFilter = value;\n        if (this._matchesFilter(this.value) !== wasMatchingValue) {\n            this._validatorOnChange();\n        }\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    /** Gets the ID of an element that should be used a description for the calendar overlay. */\n    getOverlayLabelId() {\n        if (this._formField) {\n            return this._formField.getLabelId();\n        }\n        return this._elementRef.nativeElement.getAttribute('aria-labelledby');\n    }\n    /** Returns the palette used by the input's form field, if any. */\n    getThemePalette() {\n        return this._formField ? this._formField.color : undefined;\n    }\n    /** Gets the value at which the calendar should start. */\n    getStartValue() {\n        return this.value;\n    }\n    ngOnDestroy() {\n        super.ngOnDestroy();\n        this._closedSubscription.unsubscribe();\n    }\n    /** Opens the associated datepicker. */\n    _openPopup() {\n        if (this._datepicker) {\n            this._datepicker.open();\n        }\n    }\n    _getValueFromModel(modelValue) {\n        return modelValue;\n    }\n    _assignValueToModel(value) {\n        if (this._model) {\n            this._model.updateSelection(value, this);\n        }\n    }\n    /** Gets the input's minimum date. */\n    _getMinDate() {\n        return this._min;\n    }\n    /** Gets the input's maximum date. */\n    _getMaxDate() {\n        return this._max;\n    }\n    /** Gets the input's date filtering function. */\n    _getDateFilter() {\n        return this._dateFilter;\n    }\n    _shouldHandleChangeEvent(event) {\n        return event.source !== this;\n    }\n}\nMatDatepickerInput.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerInput, deps: [{ token: i0.ElementRef }, { token: i1$1.DateAdapter, optional: true }, { token: MAT_DATE_FORMATS, optional: true }, { token: MAT_FORM_FIELD, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nMatDatepickerInput.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDatepickerInput, selector: \"input[matDatepicker]\", inputs: { matDatepicker: \"matDatepicker\", min: \"min\", max: \"max\", dateFilter: [\"matDatepickerFilter\", \"dateFilter\"] }, host: { listeners: { \"input\": \"_onInput($event.target.value)\", \"change\": \"_onChange()\", \"blur\": \"_onBlur()\", \"keydown\": \"_onKeydown($event)\" }, properties: { \"attr.aria-haspopup\": \"_datepicker ? \\\"dialog\\\" : null\", \"attr.aria-owns\": \"(_datepicker?.opened && _datepicker.id) || null\", \"attr.min\": \"min ? _dateAdapter.toIso8601(min) : null\", \"attr.max\": \"max ? _dateAdapter.toIso8601(max) : null\", \"attr.data-mat-calendar\": \"_datepicker ? _datepicker.id : null\", \"disabled\": \"disabled\" }, classAttribute: \"mat-datepicker-input\" }, providers: [\n        MAT_DATEPICKER_VALUE_ACCESSOR,\n        MAT_DATEPICKER_VALIDATORS,\n        { provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: MatDatepickerInput },\n    ], exportAs: [\"matDatepickerInput\"], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerInput, decorators: [{\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                        'class': 'mat-datepicker-input',\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                        // Used by the test harness to tie this input to its calendar. We can't depend on\n                        // `aria-owns` for this, because it's only defined while the calendar is open.\n                        '[attr.data-mat-calendar]': '_datepicker ? _datepicker.id : 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        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1$1.DateAdapter, decorators: [{\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_DATE_FORMATS]\n                }] }, { type: i2$1.MatFormField, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_FORM_FIELD]\n                }] }]; }, propDecorators: { matDatepicker: [{\n                type: Input\n            }], min: [{\n                type: Input\n            }], max: [{\n                type: Input\n            }], dateFilter: [{\n                type: Input,\n                args: ['matDatepickerFilter']\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/** Can be used to override the icon of a `matDatepickerToggle`. */\nclass MatDatepickerToggleIcon {\n}\nMatDatepickerToggleIcon.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerToggleIcon, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatDatepickerToggleIcon.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDatepickerToggleIcon, selector: \"[matDatepickerToggleIcon]\", ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerToggleIcon, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matDatepickerToggleIcon]',\n                }]\n        }] });\nclass MatDatepickerToggle {\n    constructor(_intl, _changeDetectorRef, defaultTabIndex) {\n        this._intl = _intl;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._stateChanges = Subscription.EMPTY;\n        const parsedTabIndex = Number(defaultTabIndex);\n        this.tabIndex = parsedTabIndex || parsedTabIndex === 0 ? parsedTabIndex : null;\n    }\n    /** Whether the toggle button is disabled. */\n    get disabled() {\n        if (this._disabled === undefined && this.datepicker) {\n            return this.datepicker.disabled;\n        }\n        return !!this._disabled;\n    }\n    set disabled(value) {\n        this._disabled = coerceBooleanProperty(value);\n    }\n    ngOnChanges(changes) {\n        if (changes['datepicker']) {\n            this._watchStateChanges();\n        }\n    }\n    ngOnDestroy() {\n        this._stateChanges.unsubscribe();\n    }\n    ngAfterContentInit() {\n        this._watchStateChanges();\n    }\n    _open(event) {\n        if (this.datepicker && !this.disabled) {\n            this.datepicker.open();\n            event.stopPropagation();\n        }\n    }\n    _watchStateChanges() {\n        const datepickerStateChanged = this.datepicker ? this.datepicker.stateChanges : of();\n        const inputStateChanged = this.datepicker && this.datepicker.datepickerInput\n            ? this.datepicker.datepickerInput.stateChanges\n            : of();\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, datepickerStateChanged, inputStateChanged, datepickerToggled).subscribe(() => this._changeDetectorRef.markForCheck());\n    }\n}\nMatDatepickerToggle.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerToggle, deps: [{ token: MatDatepickerIntl }, { token: i0.ChangeDetectorRef }, { token: 'tabindex', attribute: true }], target: i0.ɵɵFactoryTarget.Component });\nMatDatepickerToggle.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDatepickerToggle, selector: \"mat-datepicker-toggle\", inputs: { datepicker: [\"for\", \"datepicker\"], tabIndex: \"tabIndex\", ariaLabel: [\"aria-label\", \"ariaLabel\"], disabled: \"disabled\", disableRipple: \"disableRipple\" }, host: { listeners: { \"click\": \"_open($event)\" }, properties: { \"attr.tabindex\": \"null\", \"class.mat-datepicker-toggle-active\": \"datepicker && datepicker.opened\", \"class.mat-accent\": \"datepicker && datepicker.color === \\\"accent\\\"\", \"class.mat-warn\": \"datepicker && datepicker.color === \\\"warn\\\"\", \"attr.data-mat-calendar\": \"datepicker ? datepicker.id : null\" }, classAttribute: \"mat-datepicker-toggle\" }, queries: [{ propertyName: \"_customIcon\", first: true, predicate: MatDatepickerToggleIcon, descendants: true }], viewQueries: [{ propertyName: \"_button\", first: true, predicate: [\"button\"], descendants: true }], exportAs: [\"matDatepickerToggle\"], usesOnChanges: true, ngImport: i0, template: \"<button\\n  #button\\n  mat-icon-button\\n  type=\\\"button\\\"\\n  [attr.aria-haspopup]=\\\"datepicker ? 'dialog' : null\\\"\\n  [attr.aria-label]=\\\"ariaLabel || _intl.openCalendarLabel\\\"\\n  [attr.tabindex]=\\\"disabled ? -1 : tabIndex\\\"\\n  [disabled]=\\\"disabled\\\"\\n  [disableRipple]=\\\"disableRipple\\\">\\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\", 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}.cdk-high-contrast-active .mat-datepicker-toggle-default-icon{color:CanvasText}\\n\"], components: [{ type: i3.MatButton, selector: \"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]\", inputs: [\"disabled\", \"disableRipple\", \"color\"], exportAs: [\"matButton\"] }], directives: [{ type: i1.NgIf, selector: \"[ngIf]\", inputs: [\"ngIf\", \"ngIfThen\", \"ngIfElse\"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerToggle, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-datepicker-toggle', host: {\n                        'class': 'mat-datepicker-toggle',\n                        '[attr.tabindex]': 'null',\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                        // Used by the test harness to tie this toggle to its datepicker.\n                        '[attr.data-mat-calendar]': 'datepicker ? datepicker.id : null',\n                        // Bind the `click` on the host, rather than the inner `button`, so that we can call\n                        // `stopPropagation` on it without affecting the user's `click` handlers. We need to stop\n                        // it so that the input doesn't get focused automatically by the form field (See #21836).\n                        '(click)': '_open($event)',\n                    }, exportAs: 'matDatepickerToggle', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: \"<button\\n  #button\\n  mat-icon-button\\n  type=\\\"button\\\"\\n  [attr.aria-haspopup]=\\\"datepicker ? 'dialog' : null\\\"\\n  [attr.aria-label]=\\\"ariaLabel || _intl.openCalendarLabel\\\"\\n  [attr.tabindex]=\\\"disabled ? -1 : tabIndex\\\"\\n  [disabled]=\\\"disabled\\\"\\n  [disableRipple]=\\\"disableRipple\\\">\\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\", 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}.cdk-high-contrast-active .mat-datepicker-toggle-default-icon{color:CanvasText}\\n\"] }]\n        }], ctorParameters: function () { return [{ type: MatDatepickerIntl }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{\n                    type: Attribute,\n                    args: ['tabindex']\n                }] }]; }, propDecorators: { datepicker: [{\n                type: Input,\n                args: ['for']\n            }], tabIndex: [{\n                type: Input\n            }], ariaLabel: [{\n                type: Input,\n                args: ['aria-label']\n            }], disabled: [{\n                type: Input\n            }], disableRipple: [{\n                type: Input\n            }], _customIcon: [{\n                type: ContentChild,\n                args: [MatDatepickerToggleIcon]\n            }], _button: [{\n                type: ViewChild,\n                args: ['button']\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 * Used to provide the date range input wrapper component\n * to the parts without circular dependencies.\n */\nconst MAT_DATE_RANGE_INPUT_PARENT = new InjectionToken('MAT_DATE_RANGE_INPUT_PARENT');\n/**\n * Base class for the individual inputs that can be projected inside a `mat-date-range-input`.\n */\nclass MatDateRangeInputPartBase extends MatDatepickerInputBase {\n    constructor(_rangeInput, elementRef, _defaultErrorStateMatcher, _injector, _parentForm, _parentFormGroup, dateAdapter, dateFormats) {\n        super(elementRef, dateAdapter, dateFormats);\n        this._rangeInput = _rangeInput;\n        this._defaultErrorStateMatcher = _defaultErrorStateMatcher;\n        this._injector = _injector;\n        this._parentForm = _parentForm;\n        this._parentFormGroup = _parentFormGroup;\n    }\n    ngOnInit() {\n        // We need the date input to provide itself as a `ControlValueAccessor` and a `Validator`, while\n        // injecting its `NgControl` so that the error state is handled correctly. This introduces a\n        // circular dependency, because both `ControlValueAccessor` and `Validator` depend on the input\n        // itself. Usually we can work around it for the CVA, but there's no API to do it for the\n        // validator. We work around it here by injecting the `NgControl` in `ngOnInit`, after\n        // everything has been resolved.\n        // tslint:disable-next-line:no-bitwise\n        const ngControl = this._injector.get(NgControl, null, InjectFlags.Self | InjectFlags.Optional);\n        if (ngControl) {\n            this.ngControl = ngControl;\n        }\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    }\n    /** Gets whether the input is empty. */\n    isEmpty() {\n        return this._elementRef.nativeElement.value.length === 0;\n    }\n    /** Gets the placeholder of the input. */\n    _getPlaceholder() {\n        return this._elementRef.nativeElement.placeholder;\n    }\n    /** Focuses the input. */\n    focus() {\n        this._elementRef.nativeElement.focus();\n    }\n    /** Handles `input` events on the input element. */\n    _onInput(value) {\n        super._onInput(value);\n        this._rangeInput._handleChildValueChange();\n    }\n    /** Opens the datepicker associated with the input. */\n    _openPopup() {\n        this._rangeInput._openDatepicker();\n    }\n    /** Gets the minimum date from the range input. */\n    _getMinDate() {\n        return this._rangeInput.min;\n    }\n    /** Gets the maximum date from the range input. */\n    _getMaxDate() {\n        return this._rangeInput.max;\n    }\n    /** Gets the date filter function from the range input. */\n    _getDateFilter() {\n        return this._rangeInput.dateFilter;\n    }\n    _parentDisabled() {\n        return this._rangeInput._groupDisabled;\n    }\n    _shouldHandleChangeEvent({ source }) {\n        return source !== this._rangeInput._startInput && source !== this._rangeInput._endInput;\n    }\n    _assignValueProgrammatically(value) {\n        super._assignValueProgrammatically(value);\n        const opposite = (this === this._rangeInput._startInput\n            ? this._rangeInput._endInput\n            : this._rangeInput._startInput);\n        opposite?._validatorOnChange();\n    }\n}\nMatDateRangeInputPartBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDateRangeInputPartBase, deps: [{ token: MAT_DATE_RANGE_INPUT_PARENT }, { token: i0.ElementRef }, { token: i1$1.ErrorStateMatcher }, { token: i0.Injector }, { token: i2$2.NgForm, optional: true }, { token: i2$2.FormGroupDirective, optional: true }, { token: i1$1.DateAdapter, optional: true }, { token: MAT_DATE_FORMATS, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nMatDateRangeInputPartBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDateRangeInputPartBase, usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDateRangeInputPartBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_DATE_RANGE_INPUT_PARENT]\n                }] }, { type: i0.ElementRef }, { type: i1$1.ErrorStateMatcher }, { type: i0.Injector }, { type: i2$2.NgForm, decorators: [{\n                    type: Optional\n                }] }, { type: i2$2.FormGroupDirective, decorators: [{\n                    type: Optional\n                }] }, { type: i1$1.DateAdapter, decorators: [{\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_DATE_FORMATS]\n                }] }]; } });\nconst _MatDateRangeInputBase = mixinErrorState(MatDateRangeInputPartBase);\n/** Input for entering the start date in a `mat-date-range-input`. */\nclass MatStartDate extends _MatDateRangeInputBase {\n    constructor(rangeInput, elementRef, defaultErrorStateMatcher, injector, parentForm, parentFormGroup, dateAdapter, dateFormats) {\n        super(rangeInput, elementRef, defaultErrorStateMatcher, injector, parentForm, parentFormGroup, dateAdapter, dateFormats);\n        /** Validator that checks that the start date isn't after the end date. */\n        this._startValidator = (control) => {\n            const start = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n            const end = this._model ? this._model.selection.end : null;\n            return !start || !end || this._dateAdapter.compareDate(start, end) <= 0\n                ? null\n                : { 'matStartDateInvalid': { 'end': end, 'actual': start } };\n        };\n        this._validator = Validators.compose([...super._getValidators(), this._startValidator]);\n    }\n    _getValueFromModel(modelValue) {\n        return modelValue.start;\n    }\n    _shouldHandleChangeEvent(change) {\n        if (!super._shouldHandleChangeEvent(change)) {\n            return false;\n        }\n        else {\n            return !change.oldValue?.start\n                ? !!change.selection.start\n                : !change.selection.start ||\n                    !!this._dateAdapter.compareDate(change.oldValue.start, change.selection.start);\n        }\n    }\n    _assignValueToModel(value) {\n        if (this._model) {\n            const range = new DateRange(value, this._model.selection.end);\n            this._model.updateSelection(range, this);\n        }\n    }\n    _formatValue(value) {\n        super._formatValue(value);\n        // Any time the input value is reformatted we need to tell the parent.\n        this._rangeInput._handleChildValueChange();\n    }\n    /** Gets the value that should be used when mirroring the input's size. */\n    getMirrorValue() {\n        const element = this._elementRef.nativeElement;\n        const value = element.value;\n        return value.length > 0 ? value : element.placeholder;\n    }\n}\nMatStartDate.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatStartDate, deps: [{ token: MAT_DATE_RANGE_INPUT_PARENT }, { token: i0.ElementRef }, { token: i1$1.ErrorStateMatcher }, { token: i0.Injector }, { token: i2$2.NgForm, optional: true }, { token: i2$2.FormGroupDirective, optional: true }, { token: i1$1.DateAdapter, optional: true }, { token: MAT_DATE_FORMATS, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nMatStartDate.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatStartDate, selector: \"input[matStartDate]\", inputs: { errorStateMatcher: \"errorStateMatcher\" }, outputs: { dateChange: \"dateChange\", dateInput: \"dateInput\" }, host: { attributes: { \"type\": \"text\" }, listeners: { \"input\": \"_onInput($event.target.value)\", \"change\": \"_onChange()\", \"keydown\": \"_onKeydown($event)\", \"blur\": \"_onBlur()\" }, properties: { \"disabled\": \"disabled\", \"attr.id\": \"_rangeInput.id\", \"attr.aria-haspopup\": \"_rangeInput.rangePicker ? \\\"dialog\\\" : null\", \"attr.aria-owns\": \"(_rangeInput.rangePicker?.opened && _rangeInput.rangePicker.id) || null\", \"attr.min\": \"_getMinDate() ? _dateAdapter.toIso8601(_getMinDate()) : null\", \"attr.max\": \"_getMaxDate() ? _dateAdapter.toIso8601(_getMaxDate()) : null\" }, classAttribute: \"mat-start-date mat-date-range-input-inner\" }, providers: [\n        { provide: NG_VALUE_ACCESSOR, useExisting: MatStartDate, multi: true },\n        { provide: NG_VALIDATORS, useExisting: MatStartDate, multi: true },\n    ], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatStartDate, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'input[matStartDate]',\n                    host: {\n                        'class': 'mat-start-date mat-date-range-input-inner',\n                        '[disabled]': 'disabled',\n                        '(input)': '_onInput($event.target.value)',\n                        '(change)': '_onChange()',\n                        '(keydown)': '_onKeydown($event)',\n                        '[attr.id]': '_rangeInput.id',\n                        '[attr.aria-haspopup]': '_rangeInput.rangePicker ? \"dialog\" : null',\n                        '[attr.aria-owns]': '(_rangeInput.rangePicker?.opened && _rangeInput.rangePicker.id) || null',\n                        '[attr.min]': '_getMinDate() ? _dateAdapter.toIso8601(_getMinDate()) : null',\n                        '[attr.max]': '_getMaxDate() ? _dateAdapter.toIso8601(_getMaxDate()) : null',\n                        '(blur)': '_onBlur()',\n                        'type': 'text',\n                    },\n                    providers: [\n                        { provide: NG_VALUE_ACCESSOR, useExisting: MatStartDate, multi: true },\n                        { provide: NG_VALIDATORS, useExisting: MatStartDate, multi: true },\n                    ],\n                    // These need to be specified explicitly, because some tooling doesn't\n                    // seem to pick them up from the base class. See #20932.\n                    outputs: ['dateChange', 'dateInput'],\n                    inputs: ['errorStateMatcher'],\n                }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_DATE_RANGE_INPUT_PARENT]\n                }] }, { type: i0.ElementRef }, { type: i1$1.ErrorStateMatcher }, { type: i0.Injector }, { type: i2$2.NgForm, decorators: [{\n                    type: Optional\n                }] }, { type: i2$2.FormGroupDirective, decorators: [{\n                    type: Optional\n                }] }, { type: i1$1.DateAdapter, decorators: [{\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_DATE_FORMATS]\n                }] }]; } });\n/** Input for entering the end date in a `mat-date-range-input`. */\nclass MatEndDate extends _MatDateRangeInputBase {\n    constructor(rangeInput, elementRef, defaultErrorStateMatcher, injector, parentForm, parentFormGroup, dateAdapter, dateFormats) {\n        super(rangeInput, elementRef, defaultErrorStateMatcher, injector, parentForm, parentFormGroup, dateAdapter, dateFormats);\n        /** Validator that checks that the end date isn't before the start date. */\n        this._endValidator = (control) => {\n            const end = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n            const start = this._model ? this._model.selection.start : null;\n            return !end || !start || this._dateAdapter.compareDate(end, start) >= 0\n                ? null\n                : { 'matEndDateInvalid': { 'start': start, 'actual': end } };\n        };\n        this._validator = Validators.compose([...super._getValidators(), this._endValidator]);\n    }\n    _getValueFromModel(modelValue) {\n        return modelValue.end;\n    }\n    _shouldHandleChangeEvent(change) {\n        if (!super._shouldHandleChangeEvent(change)) {\n            return false;\n        }\n        else {\n            return !change.oldValue?.end\n                ? !!change.selection.end\n                : !change.selection.end ||\n                    !!this._dateAdapter.compareDate(change.oldValue.end, change.selection.end);\n        }\n    }\n    _assignValueToModel(value) {\n        if (this._model) {\n            const range = new DateRange(this._model.selection.start, value);\n            this._model.updateSelection(range, this);\n        }\n    }\n    _onKeydown(event) {\n        // If the user is pressing backspace on an empty end input, move focus back to the start.\n        if (event.keyCode === BACKSPACE && !this._elementRef.nativeElement.value) {\n            this._rangeInput._startInput.focus();\n        }\n        super._onKeydown(event);\n    }\n}\nMatEndDate.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatEndDate, deps: [{ token: MAT_DATE_RANGE_INPUT_PARENT }, { token: i0.ElementRef }, { token: i1$1.ErrorStateMatcher }, { token: i0.Injector }, { token: i2$2.NgForm, optional: true }, { token: i2$2.FormGroupDirective, optional: true }, { token: i1$1.DateAdapter, optional: true }, { token: MAT_DATE_FORMATS, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nMatEndDate.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatEndDate, selector: \"input[matEndDate]\", inputs: { errorStateMatcher: \"errorStateMatcher\" }, outputs: { dateChange: \"dateChange\", dateInput: \"dateInput\" }, host: { attributes: { \"type\": \"text\" }, listeners: { \"input\": \"_onInput($event.target.value)\", \"change\": \"_onChange()\", \"keydown\": \"_onKeydown($event)\", \"blur\": \"_onBlur()\" }, properties: { \"disabled\": \"disabled\", \"attr.aria-haspopup\": \"_rangeInput.rangePicker ? \\\"dialog\\\" : null\", \"attr.aria-owns\": \"(_rangeInput.rangePicker?.opened && _rangeInput.rangePicker.id) || null\", \"attr.min\": \"_getMinDate() ? _dateAdapter.toIso8601(_getMinDate()) : null\", \"attr.max\": \"_getMaxDate() ? _dateAdapter.toIso8601(_getMaxDate()) : null\" }, classAttribute: \"mat-end-date mat-date-range-input-inner\" }, providers: [\n        { provide: NG_VALUE_ACCESSOR, useExisting: MatEndDate, multi: true },\n        { provide: NG_VALIDATORS, useExisting: MatEndDate, multi: true },\n    ], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatEndDate, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'input[matEndDate]',\n                    host: {\n                        'class': 'mat-end-date mat-date-range-input-inner',\n                        '[disabled]': 'disabled',\n                        '(input)': '_onInput($event.target.value)',\n                        '(change)': '_onChange()',\n                        '(keydown)': '_onKeydown($event)',\n                        '[attr.aria-haspopup]': '_rangeInput.rangePicker ? \"dialog\" : null',\n                        '[attr.aria-owns]': '(_rangeInput.rangePicker?.opened && _rangeInput.rangePicker.id) || null',\n                        '[attr.min]': '_getMinDate() ? _dateAdapter.toIso8601(_getMinDate()) : null',\n                        '[attr.max]': '_getMaxDate() ? _dateAdapter.toIso8601(_getMaxDate()) : null',\n                        '(blur)': '_onBlur()',\n                        'type': 'text',\n                    },\n                    providers: [\n                        { provide: NG_VALUE_ACCESSOR, useExisting: MatEndDate, multi: true },\n                        { provide: NG_VALIDATORS, useExisting: MatEndDate, multi: true },\n                    ],\n                    // These need to be specified explicitly, because some tooling doesn't\n                    // seem to pick them up from the base class. See #20932.\n                    outputs: ['dateChange', 'dateInput'],\n                    inputs: ['errorStateMatcher'],\n                }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_DATE_RANGE_INPUT_PARENT]\n                }] }, { type: i0.ElementRef }, { type: i1$1.ErrorStateMatcher }, { type: i0.Injector }, { type: i2$2.NgForm, decorators: [{\n                    type: Optional\n                }] }, { type: i2$2.FormGroupDirective, decorators: [{\n                    type: Optional\n                }] }, { type: i1$1.DateAdapter, decorators: [{\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_DATE_FORMATS]\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 */\nlet nextUniqueId = 0;\nclass MatDateRangeInput {\n    constructor(_changeDetectorRef, _elementRef, control, _dateAdapter, _formField) {\n        this._changeDetectorRef = _changeDetectorRef;\n        this._elementRef = _elementRef;\n        this._dateAdapter = _dateAdapter;\n        this._formField = _formField;\n        this._closedSubscription = Subscription.EMPTY;\n        /** Unique ID for the input. */\n        this.id = `mat-date-range-input-${nextUniqueId++}`;\n        /** Whether the control is focused. */\n        this.focused = false;\n        /** Name of the form control. */\n        this.controlType = 'mat-date-range-input';\n        this._groupDisabled = false;\n        /** Value for the `aria-describedby` attribute of the inputs. */\n        this._ariaDescribedBy = null;\n        /** Separator text to be shown between the inputs. */\n        this.separator = '–';\n        /** Start of the comparison range that should be shown in the calendar. */\n        this.comparisonStart = null;\n        /** End of the comparison range that should be shown in the calendar. */\n        this.comparisonEnd = null;\n        /** Emits when the input's state has changed. */\n        this.stateChanges = new Subject();\n        if (!_dateAdapter && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw createMissingDateImplError('DateAdapter');\n        }\n        // The datepicker module can be used both with MDC and non-MDC form fields. We have\n        // to conditionally add the MDC input class so that the range picker looks correctly.\n        if (_formField?._elementRef.nativeElement.classList.contains('mat-mdc-form-field')) {\n            const classList = _elementRef.nativeElement.classList;\n            classList.add('mat-mdc-input-element');\n            classList.add('mat-mdc-form-field-input-control');\n        }\n        // TODO(crisbeto): remove `as any` after #18206 lands.\n        this.ngControl = control;\n    }\n    /** Current value of the range input. */\n    get value() {\n        return this._model ? this._model.selection : null;\n    }\n    /** Whether the control's label should float. */\n    get shouldLabelFloat() {\n        return this.focused || !this.empty;\n    }\n    /**\n     * Implemented as a part of `MatFormFieldControl`.\n     * Set the placeholder attribute on `matStartDate` and `matEndDate`.\n     * @docs-private\n     */\n    get placeholder() {\n        const start = this._startInput?._getPlaceholder() || '';\n        const end = this._endInput?._getPlaceholder() || '';\n        return start || end ? `${start} ${this.separator} ${end}` : '';\n    }\n    /** The range picker that this input is associated with. */\n    get rangePicker() {\n        return this._rangePicker;\n    }\n    set rangePicker(rangePicker) {\n        if (rangePicker) {\n            this._model = rangePicker.registerInput(this);\n            this._rangePicker = rangePicker;\n            this._closedSubscription.unsubscribe();\n            this._closedSubscription = rangePicker.closedStream.subscribe(() => {\n                this._startInput?._onTouched();\n                this._endInput?._onTouched();\n            });\n            this._registerModel(this._model);\n        }\n    }\n    /** Whether the input is required. */\n    get required() {\n        return !!this._required;\n    }\n    set required(value) {\n        this._required = coerceBooleanProperty(value);\n    }\n    /** Function that can be used to filter out dates within the date range picker. */\n    get dateFilter() {\n        return this._dateFilter;\n    }\n    set dateFilter(value) {\n        const start = this._startInput;\n        const end = this._endInput;\n        const wasMatchingStart = start && start._matchesFilter(start.value);\n        const wasMatchingEnd = end && end._matchesFilter(start.value);\n        this._dateFilter = value;\n        if (start && start._matchesFilter(start.value) !== wasMatchingStart) {\n            start._validatorOnChange();\n        }\n        if (end && end._matchesFilter(end.value) !== wasMatchingEnd) {\n            end._validatorOnChange();\n        }\n    }\n    /** The minimum valid date. */\n    get min() {\n        return this._min;\n    }\n    set min(value) {\n        const validValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n        if (!this._dateAdapter.sameDate(validValue, this._min)) {\n            this._min = validValue;\n            this._revalidate();\n        }\n    }\n    /** The maximum valid date. */\n    get max() {\n        return this._max;\n    }\n    set max(value) {\n        const validValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n        if (!this._dateAdapter.sameDate(validValue, this._max)) {\n            this._max = validValue;\n            this._revalidate();\n        }\n    }\n    /** Whether the input is disabled. */\n    get disabled() {\n        return this._startInput && this._endInput\n            ? this._startInput.disabled && this._endInput.disabled\n            : this._groupDisabled;\n    }\n    set disabled(value) {\n        const newValue = coerceBooleanProperty(value);\n        if (newValue !== this._groupDisabled) {\n            this._groupDisabled = newValue;\n            this.stateChanges.next(undefined);\n        }\n    }\n    /** Whether the input is in an error state. */\n    get errorState() {\n        if (this._startInput && this._endInput) {\n            return this._startInput.errorState || this._endInput.errorState;\n        }\n        return false;\n    }\n    /** Whether the datepicker input is empty. */\n    get empty() {\n        const startEmpty = this._startInput ? this._startInput.isEmpty() : false;\n        const endEmpty = this._endInput ? this._endInput.isEmpty() : false;\n        return startEmpty && endEmpty;\n    }\n    /**\n     * Implemented as a part of `MatFormFieldControl`.\n     * @docs-private\n     */\n    setDescribedByIds(ids) {\n        this._ariaDescribedBy = ids.length ? ids.join(' ') : null;\n    }\n    /**\n     * Implemented as a part of `MatFormFieldControl`.\n     * @docs-private\n     */\n    onContainerClick() {\n        if (!this.focused && !this.disabled) {\n            if (!this._model || !this._model.selection.start) {\n                this._startInput.focus();\n            }\n            else {\n                this._endInput.focus();\n            }\n        }\n    }\n    ngAfterContentInit() {\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            if (!this._startInput) {\n                throw Error('mat-date-range-input must contain a matStartDate input');\n            }\n            if (!this._endInput) {\n                throw Error('mat-date-range-input must contain a matEndDate input');\n            }\n        }\n        if (this._model) {\n            this._registerModel(this._model);\n        }\n        // We don't need to unsubscribe from this, because we\n        // know that the input streams will be completed on destroy.\n        merge(this._startInput.stateChanges, this._endInput.stateChanges).subscribe(() => {\n            this.stateChanges.next(undefined);\n        });\n    }\n    ngOnChanges(changes) {\n        if (dateInputsHaveChanged(changes, this._dateAdapter)) {\n            this.stateChanges.next(undefined);\n        }\n    }\n    ngOnDestroy() {\n        this._closedSubscription.unsubscribe();\n        this.stateChanges.complete();\n    }\n    /** Gets the date at which the calendar should start. */\n    getStartValue() {\n        return this.value ? this.value.start : null;\n    }\n    /** Gets the input's theme palette. */\n    getThemePalette() {\n        return this._formField ? this._formField.color : undefined;\n    }\n    /** Gets the element to which the calendar overlay should be attached. */\n    getConnectedOverlayOrigin() {\n        return this._formField ? this._formField.getConnectedOverlayOrigin() : this._elementRef;\n    }\n    /** Gets the ID of an element that should be used a description for the calendar overlay. */\n    getOverlayLabelId() {\n        return this._formField ? this._formField.getLabelId() : null;\n    }\n    /** Gets the value that is used to mirror the state input. */\n    _getInputMirrorValue() {\n        return this._startInput ? this._startInput.getMirrorValue() : '';\n    }\n    /** Whether the input placeholders should be hidden. */\n    _shouldHidePlaceholders() {\n        return this._startInput ? !this._startInput.isEmpty() : false;\n    }\n    /** Handles the value in one of the child inputs changing. */\n    _handleChildValueChange() {\n        this.stateChanges.next(undefined);\n        this._changeDetectorRef.markForCheck();\n    }\n    /** Opens the date range picker associated with the input. */\n    _openDatepicker() {\n        if (this._rangePicker) {\n            this._rangePicker.open();\n        }\n    }\n    /** Whether the separate text should be hidden. */\n    _shouldHideSeparator() {\n        return ((!this._formField ||\n            (this._formField.getLabelId() && !this._formField._shouldLabelFloat())) &&\n            this.empty);\n    }\n    /** Gets the value for the `aria-labelledby` attribute of the inputs. */\n    _getAriaLabelledby() {\n        const formField = this._formField;\n        return formField && formField._hasFloatingLabel() ? formField._labelId : null;\n    }\n    /** Updates the focused state of the range input. */\n    _updateFocus(origin) {\n        this.focused = origin !== null;\n        this.stateChanges.next();\n    }\n    /** Re-runs the validators on the start/end inputs. */\n    _revalidate() {\n        if (this._startInput) {\n            this._startInput._validatorOnChange();\n        }\n        if (this._endInput) {\n            this._endInput._validatorOnChange();\n        }\n    }\n    /** Registers the current date selection model with the start/end inputs. */\n    _registerModel(model) {\n        if (this._startInput) {\n            this._startInput._registerModel(model);\n        }\n        if (this._endInput) {\n            this._endInput._registerModel(model);\n        }\n    }\n}\nMatDateRangeInput.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDateRangeInput, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i2$2.ControlContainer, optional: true, self: true }, { token: i1$1.DateAdapter, optional: true }, { token: MAT_FORM_FIELD, optional: true }], target: i0.ɵɵFactoryTarget.Component });\nMatDateRangeInput.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDateRangeInput, selector: \"mat-date-range-input\", inputs: { rangePicker: \"rangePicker\", required: \"required\", dateFilter: \"dateFilter\", min: \"min\", max: \"max\", disabled: \"disabled\", separator: \"separator\", comparisonStart: \"comparisonStart\", comparisonEnd: \"comparisonEnd\" }, host: { attributes: { \"role\": \"group\" }, properties: { \"class.mat-date-range-input-hide-placeholders\": \"_shouldHidePlaceholders()\", \"class.mat-date-range-input-required\": \"required\", \"attr.id\": \"null\", \"attr.aria-labelledby\": \"_getAriaLabelledby()\", \"attr.aria-describedby\": \"_ariaDescribedBy\", \"attr.data-mat-calendar\": \"rangePicker ? rangePicker.id : null\" }, classAttribute: \"mat-date-range-input\" }, providers: [\n        { provide: MatFormFieldControl, useExisting: MatDateRangeInput },\n        { provide: MAT_DATE_RANGE_INPUT_PARENT, useExisting: MatDateRangeInput },\n    ], queries: [{ propertyName: \"_startInput\", first: true, predicate: MatStartDate, descendants: true }, { propertyName: \"_endInput\", first: true, predicate: MatEndDate, descendants: true }], exportAs: [\"matDateRangeInput\"], usesOnChanges: true, ngImport: i0, template: \"<div\\n  class=\\\"mat-date-range-input-container\\\"\\n  cdkMonitorSubtreeFocus\\n  (cdkFocusChange)=\\\"_updateFocus($event)\\\">\\n  <div class=\\\"mat-date-range-input-start-wrapper\\\">\\n    <ng-content select=\\\"input[matStartDate]\\\"></ng-content>\\n    <span\\n      class=\\\"mat-date-range-input-mirror\\\"\\n      aria-hidden=\\\"true\\\">{{_getInputMirrorValue()}}</span>\\n  </div>\\n\\n  <span\\n    class=\\\"mat-date-range-input-separator\\\"\\n    [class.mat-date-range-input-separator-hidden]=\\\"_shouldHideSeparator()\\\">{{separator}}</span>\\n\\n  <div class=\\\"mat-date-range-input-end-wrapper\\\">\\n    <ng-content select=\\\"input[matEndDate]\\\"></ng-content>\\n  </div>\\n</div>\\n\\n\", styles: [\".mat-date-range-input{display:block;width:100%}.mat-date-range-input-container{display:flex;align-items:center}.mat-date-range-input-separator{transition:opacity 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1);margin:0 4px}.mat-date-range-input-separator-hidden{-webkit-user-select:none;user-select:none;opacity:0;transition:none}.mat-date-range-input-inner{font:inherit;background:transparent;color:currentColor;border:none;outline:none;padding:0;margin:0;vertical-align:bottom;text-align:inherit;-webkit-appearance:none;width:100%}.mat-date-range-input-inner:-moz-ui-invalid{box-shadow:none}.mat-date-range-input-inner::placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-date-range-input-inner::-moz-placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-date-range-input-inner::-webkit-input-placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-date-range-input-inner:-ms-input-placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-hide-placeholder .mat-date-range-input-inner::placeholder,.mat-date-range-input-hide-placeholders .mat-date-range-input-inner::placeholder{-webkit-user-select:none;user-select:none;color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-date-range-input-inner::placeholder,.cdk-high-contrast-active .mat-date-range-input-hide-placeholders .mat-date-range-input-inner::placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-date-range-input-inner::-moz-placeholder,.mat-date-range-input-hide-placeholders .mat-date-range-input-inner::-moz-placeholder{-webkit-user-select:none;user-select:none;color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-date-range-input-inner::-moz-placeholder,.cdk-high-contrast-active .mat-date-range-input-hide-placeholders .mat-date-range-input-inner::-moz-placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-date-range-input-inner::-webkit-input-placeholder,.mat-date-range-input-hide-placeholders .mat-date-range-input-inner::-webkit-input-placeholder{-webkit-user-select:none;user-select:none;color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-date-range-input-inner::-webkit-input-placeholder,.cdk-high-contrast-active .mat-date-range-input-hide-placeholders .mat-date-range-input-inner::-webkit-input-placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-date-range-input-inner:-ms-input-placeholder,.mat-date-range-input-hide-placeholders .mat-date-range-input-inner:-ms-input-placeholder{-webkit-user-select:none;user-select:none;color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-date-range-input-inner:-ms-input-placeholder,.cdk-high-contrast-active .mat-date-range-input-hide-placeholders .mat-date-range-input-inner:-ms-input-placeholder{opacity:0}.mat-date-range-input-mirror{-webkit-user-select:none;user-select:none;visibility:hidden;white-space:nowrap;display:inline-block;min-width:2px}.mat-date-range-input-start-wrapper{position:relative;overflow:hidden;max-width:calc(50% - 4px)}.mat-date-range-input-start-wrapper .mat-date-range-input-inner{position:absolute;top:0;left:0}.mat-date-range-input-end-wrapper{flex-grow:1;max-width:calc(50% - 4px)}.mat-form-field-type-mat-date-range-input .mat-form-field-infix{width:200px}\\n\"], directives: [{ type: i8.CdkMonitorFocus, selector: \"[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]\", outputs: [\"cdkFocusChange\"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDateRangeInput, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-date-range-input', exportAs: 'matDateRangeInput', host: {\n                        'class': 'mat-date-range-input',\n                        '[class.mat-date-range-input-hide-placeholders]': '_shouldHidePlaceholders()',\n                        '[class.mat-date-range-input-required]': 'required',\n                        '[attr.id]': 'null',\n                        'role': 'group',\n                        '[attr.aria-labelledby]': '_getAriaLabelledby()',\n                        '[attr.aria-describedby]': '_ariaDescribedBy',\n                        // Used by the test harness to tie this input to its calendar. We can't depend on\n                        // `aria-owns` for this, because it's only defined while the calendar is open.\n                        '[attr.data-mat-calendar]': 'rangePicker ? rangePicker.id : null',\n                    }, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, providers: [\n                        { provide: MatFormFieldControl, useExisting: MatDateRangeInput },\n                        { provide: MAT_DATE_RANGE_INPUT_PARENT, useExisting: MatDateRangeInput },\n                    ], template: \"<div\\n  class=\\\"mat-date-range-input-container\\\"\\n  cdkMonitorSubtreeFocus\\n  (cdkFocusChange)=\\\"_updateFocus($event)\\\">\\n  <div class=\\\"mat-date-range-input-start-wrapper\\\">\\n    <ng-content select=\\\"input[matStartDate]\\\"></ng-content>\\n    <span\\n      class=\\\"mat-date-range-input-mirror\\\"\\n      aria-hidden=\\\"true\\\">{{_getInputMirrorValue()}}</span>\\n  </div>\\n\\n  <span\\n    class=\\\"mat-date-range-input-separator\\\"\\n    [class.mat-date-range-input-separator-hidden]=\\\"_shouldHideSeparator()\\\">{{separator}}</span>\\n\\n  <div class=\\\"mat-date-range-input-end-wrapper\\\">\\n    <ng-content select=\\\"input[matEndDate]\\\"></ng-content>\\n  </div>\\n</div>\\n\\n\", styles: [\".mat-date-range-input{display:block;width:100%}.mat-date-range-input-container{display:flex;align-items:center}.mat-date-range-input-separator{transition:opacity 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1);margin:0 4px}.mat-date-range-input-separator-hidden{-webkit-user-select:none;user-select:none;opacity:0;transition:none}.mat-date-range-input-inner{font:inherit;background:transparent;color:currentColor;border:none;outline:none;padding:0;margin:0;vertical-align:bottom;text-align:inherit;-webkit-appearance:none;width:100%}.mat-date-range-input-inner:-moz-ui-invalid{box-shadow:none}.mat-date-range-input-inner::placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-date-range-input-inner::-moz-placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-date-range-input-inner::-webkit-input-placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-date-range-input-inner:-ms-input-placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-hide-placeholder .mat-date-range-input-inner::placeholder,.mat-date-range-input-hide-placeholders .mat-date-range-input-inner::placeholder{-webkit-user-select:none;user-select:none;color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-date-range-input-inner::placeholder,.cdk-high-contrast-active .mat-date-range-input-hide-placeholders .mat-date-range-input-inner::placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-date-range-input-inner::-moz-placeholder,.mat-date-range-input-hide-placeholders .mat-date-range-input-inner::-moz-placeholder{-webkit-user-select:none;user-select:none;color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-date-range-input-inner::-moz-placeholder,.cdk-high-contrast-active .mat-date-range-input-hide-placeholders .mat-date-range-input-inner::-moz-placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-date-range-input-inner::-webkit-input-placeholder,.mat-date-range-input-hide-placeholders .mat-date-range-input-inner::-webkit-input-placeholder{-webkit-user-select:none;user-select:none;color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-date-range-input-inner::-webkit-input-placeholder,.cdk-high-contrast-active .mat-date-range-input-hide-placeholders .mat-date-range-input-inner::-webkit-input-placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-date-range-input-inner:-ms-input-placeholder,.mat-date-range-input-hide-placeholders .mat-date-range-input-inner:-ms-input-placeholder{-webkit-user-select:none;user-select:none;color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-date-range-input-inner:-ms-input-placeholder,.cdk-high-contrast-active .mat-date-range-input-hide-placeholders .mat-date-range-input-inner:-ms-input-placeholder{opacity:0}.mat-date-range-input-mirror{-webkit-user-select:none;user-select:none;visibility:hidden;white-space:nowrap;display:inline-block;min-width:2px}.mat-date-range-input-start-wrapper{position:relative;overflow:hidden;max-width:calc(50% - 4px)}.mat-date-range-input-start-wrapper .mat-date-range-input-inner{position:absolute;top:0;left:0}.mat-date-range-input-end-wrapper{flex-grow:1;max-width:calc(50% - 4px)}.mat-form-field-type-mat-date-range-input .mat-form-field-infix{width:200px}\\n\"] }]\n        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i2$2.ControlContainer, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }] }, { type: i1$1.DateAdapter, decorators: [{\n                    type: Optional\n                }] }, { type: i2$1.MatFormField, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_FORM_FIELD]\n                }] }]; }, propDecorators: { rangePicker: [{\n                type: Input\n            }], required: [{\n                type: Input\n            }], dateFilter: [{\n                type: Input\n            }], min: [{\n                type: Input\n            }], max: [{\n                type: Input\n            }], disabled: [{\n                type: Input\n            }], separator: [{\n                type: Input\n            }], comparisonStart: [{\n                type: Input\n            }], comparisonEnd: [{\n                type: Input\n            }], _startInput: [{\n                type: ContentChild,\n                args: [MatStartDate]\n            }], _endInput: [{\n                type: ContentChild,\n                args: [MatEndDate]\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// TODO(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=\"matDateRangePicker\"). We can change this to a\n// directive if angular adds support for `exportAs: '$implicit'` on directives.\n/** Component responsible for managing the date range picker popup/dialog. */\nclass MatDateRangePicker extends MatDatepickerBase {\n    _forwardContentValues(instance) {\n        super._forwardContentValues(instance);\n        const input = this.datepickerInput;\n        if (input) {\n            instance.comparisonStart = input.comparisonStart;\n            instance.comparisonEnd = input.comparisonEnd;\n        }\n    }\n}\nMatDateRangePicker.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDateRangePicker, deps: null, target: i0.ɵɵFactoryTarget.Component });\nMatDateRangePicker.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDateRangePicker, selector: \"mat-date-range-picker\", providers: [\n        MAT_RANGE_DATE_SELECTION_MODEL_PROVIDER,\n        MAT_CALENDAR_RANGE_STRATEGY_PROVIDER,\n        { provide: MatDatepickerBase, useExisting: MatDateRangePicker },\n    ], exportAs: [\"matDateRangePicker\"], usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDateRangePicker, decorators: [{\n            type: Component,\n            args: [{\n                    selector: 'mat-date-range-picker',\n                    template: '',\n                    exportAs: 'matDateRangePicker',\n                    changeDetection: ChangeDetectionStrategy.OnPush,\n                    encapsulation: ViewEncapsulation.None,\n                    providers: [\n                        MAT_RANGE_DATE_SELECTION_MODEL_PROVIDER,\n                        MAT_CALENDAR_RANGE_STRATEGY_PROVIDER,\n                        { provide: MatDatepickerBase, useExisting: MatDateRangePicker },\n                    ],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Button that will close the datepicker and assign the current selection to the data model. */\nclass MatDatepickerApply {\n    constructor(_datepicker) {\n        this._datepicker = _datepicker;\n    }\n    _applySelection() {\n        this._datepicker._applyPendingSelection();\n        this._datepicker.close();\n    }\n}\nMatDatepickerApply.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerApply, deps: [{ token: MatDatepickerBase }], target: i0.ɵɵFactoryTarget.Directive });\nMatDatepickerApply.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDatepickerApply, selector: \"[matDatepickerApply], [matDateRangePickerApply]\", host: { listeners: { \"click\": \"_applySelection()\" } }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerApply, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matDatepickerApply], [matDateRangePickerApply]',\n                    host: { '(click)': '_applySelection()' },\n                }]\n        }], ctorParameters: function () { return [{ type: MatDatepickerBase }]; } });\n/** Button that will close the datepicker and discard the current selection. */\nclass MatDatepickerCancel {\n    constructor(_datepicker) {\n        this._datepicker = _datepicker;\n    }\n}\nMatDatepickerCancel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerCancel, deps: [{ token: MatDatepickerBase }], target: i0.ɵɵFactoryTarget.Directive });\nMatDatepickerCancel.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDatepickerCancel, selector: \"[matDatepickerCancel], [matDateRangePickerCancel]\", host: { listeners: { \"click\": \"_datepicker.close()\" } }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerCancel, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matDatepickerCancel], [matDateRangePickerCancel]',\n                    host: { '(click)': '_datepicker.close()' },\n                }]\n        }], ctorParameters: function () { return [{ type: MatDatepickerBase }]; } });\n/**\n * Container that can be used to project a row of action buttons\n * to the bottom of a datepicker or date range picker.\n */\nclass MatDatepickerActions {\n    constructor(_datepicker, _viewContainerRef) {\n        this._datepicker = _datepicker;\n        this._viewContainerRef = _viewContainerRef;\n    }\n    ngAfterViewInit() {\n        this._portal = new TemplatePortal(this._template, this._viewContainerRef);\n        this._datepicker.registerActions(this._portal);\n    }\n    ngOnDestroy() {\n        this._datepicker.removeActions(this._portal);\n        // Needs to be null checked since we initialize it in `ngAfterViewInit`.\n        if (this._portal && this._portal.isAttached) {\n            this._portal?.detach();\n        }\n    }\n}\nMatDatepickerActions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerActions, deps: [{ token: MatDatepickerBase }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Component });\nMatDatepickerActions.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDatepickerActions, selector: \"mat-datepicker-actions, mat-date-range-picker-actions\", viewQueries: [{ propertyName: \"_template\", first: true, predicate: TemplateRef, descendants: true }], ngImport: i0, template: `\n    <ng-template>\n      <div class=\"mat-datepicker-actions\">\n        <ng-content></ng-content>\n      </div>\n    </ng-template>\n  `, isInline: true, styles: [\".mat-datepicker-actions{display:flex;justify-content:flex-end;align-items:center;padding:0 8px 8px 8px}.mat-datepicker-actions .mat-button-base+.mat-button-base{margin-left:8px}[dir=rtl] .mat-datepicker-actions .mat-button-base+.mat-button-base{margin-left:0;margin-right:8px}\\n\"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerActions, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-datepicker-actions, mat-date-range-picker-actions', template: `\n    <ng-template>\n      <div class=\"mat-datepicker-actions\">\n        <ng-content></ng-content>\n      </div>\n    </ng-template>\n  `, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, styles: [\".mat-datepicker-actions{display:flex;justify-content:flex-end;align-items:center;padding:0 8px 8px 8px}.mat-datepicker-actions .mat-button-base+.mat-button-base{margin-left:8px}[dir=rtl] .mat-datepicker-actions .mat-button-base+.mat-button-base{margin-left:0;margin-right:8px}\\n\"] }]\n        }], ctorParameters: function () { return [{ type: MatDatepickerBase }, { type: i0.ViewContainerRef }]; }, propDecorators: { _template: [{\n                type: ViewChild,\n                args: [TemplateRef]\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatDatepickerModule {\n}\nMatDatepickerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatDatepickerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerModule, declarations: [MatCalendar,\n        MatCalendarBody,\n        MatDatepicker,\n        MatDatepickerContent,\n        MatDatepickerInput,\n        MatDatepickerToggle,\n        MatDatepickerToggleIcon,\n        MatMonthView,\n        MatYearView,\n        MatMultiYearView,\n        MatCalendarHeader,\n        MatDateRangeInput,\n        MatStartDate,\n        MatEndDate,\n        MatDateRangePicker,\n        MatDatepickerActions,\n        MatDatepickerCancel,\n        MatDatepickerApply], imports: [CommonModule,\n        MatButtonModule,\n        OverlayModule,\n        A11yModule,\n        PortalModule,\n        MatCommonModule], exports: [CdkScrollableModule,\n        MatCalendar,\n        MatCalendarBody,\n        MatDatepicker,\n        MatDatepickerContent,\n        MatDatepickerInput,\n        MatDatepickerToggle,\n        MatDatepickerToggleIcon,\n        MatMonthView,\n        MatYearView,\n        MatMultiYearView,\n        MatCalendarHeader,\n        MatDateRangeInput,\n        MatStartDate,\n        MatEndDate,\n        MatDateRangePicker,\n        MatDatepickerActions,\n        MatDatepickerCancel,\n        MatDatepickerApply] });\nMatDatepickerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerModule, providers: [MatDatepickerIntl, MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER], imports: [[\n            CommonModule,\n            MatButtonModule,\n            OverlayModule,\n            A11yModule,\n            PortalModule,\n            MatCommonModule,\n        ], CdkScrollableModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDatepickerModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [\n                        CommonModule,\n                        MatButtonModule,\n                        OverlayModule,\n                        A11yModule,\n                        PortalModule,\n                        MatCommonModule,\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                        MatDateRangeInput,\n                        MatStartDate,\n                        MatEndDate,\n                        MatDateRangePicker,\n                        MatDatepickerActions,\n                        MatDatepickerCancel,\n                        MatDatepickerApply,\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                        MatDateRangeInput,\n                        MatStartDate,\n                        MatEndDate,\n                        MatDateRangePicker,\n                        MatDatepickerActions,\n                        MatDatepickerCancel,\n                        MatDatepickerApply,\n                    ],\n                    providers: [MatDatepickerIntl, MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { DateRange, DefaultMatCalendarRangeStrategy, MAT_DATEPICKER_SCROLL_STRATEGY, MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY, MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER, MAT_DATEPICKER_VALIDATORS, MAT_DATEPICKER_VALUE_ACCESSOR, MAT_DATE_RANGE_SELECTION_STRATEGY, MAT_RANGE_DATE_SELECTION_MODEL_FACTORY, MAT_RANGE_DATE_SELECTION_MODEL_PROVIDER, MAT_SINGLE_DATE_SELECTION_MODEL_FACTORY, MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER, MatCalendar, MatCalendarBody, MatCalendarCell, MatCalendarHeader, MatDateRangeInput, MatDateRangePicker, MatDateSelectionModel, MatDatepicker, MatDatepickerActions, MatDatepickerApply, MatDatepickerCancel, MatDatepickerContent, MatDatepickerInput, MatDatepickerInputEvent, MatDatepickerIntl, MatDatepickerModule, MatDatepickerToggle, MatDatepickerToggleIcon, MatEndDate, MatMonthView, MatMultiYearView, MatRangeDateSelectionModel, MatSingleDateSelectionModel, MatStartDate, MatYearView, matDatepickerAnimations, yearsPerPage, yearsPerRow };\n","import * as i0 from '@angular/core';\nimport { InjectionToken, Directive, Input, EventEmitter, Optional, Inject, SkipSelf, Output, NgModule } from '@angular/core';\nimport * as i1 from '@angular/cdk/collections';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { Subject, Subscription } from 'rxjs';\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/** Used to generate unique ID for each accordion. */\nlet nextId$1 = 0;\n/**\n * Injection token that can be used to reference instances of `CdkAccordion`. It serves\n * as alternative token to the actual `CdkAccordion` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */\nconst CDK_ACCORDION = new InjectionToken('CdkAccordion');\n/**\n * Directive whose purpose is to manage the expanded state of CdkAccordionItem children.\n */\nclass CdkAccordion {\n    constructor() {\n        /** Emits when the state of the accordion changes */\n        this._stateChanges = new Subject();\n        /** Stream that emits true/false when openAll/closeAll is triggered. */\n        this._openCloseAllActions = new Subject();\n        /** A readonly id value to use for unique selection coordination. */\n        this.id = `cdk-accordion-${nextId$1++}`;\n        this._multi = false;\n    }\n    /** Whether the accordion should allow multiple expanded accordion items simultaneously. */\n    get multi() {\n        return this._multi;\n    }\n    set multi(multi) {\n        this._multi = coerceBooleanProperty(multi);\n    }\n    /** Opens all enabled accordion items in an accordion where multi is enabled. */\n    openAll() {\n        if (this._multi) {\n            this._openCloseAllActions.next(true);\n        }\n    }\n    /** Closes all enabled accordion items in an accordion where multi is enabled. */\n    closeAll() {\n        this._openCloseAllActions.next(false);\n    }\n    ngOnChanges(changes) {\n        this._stateChanges.next(changes);\n    }\n    ngOnDestroy() {\n        this._stateChanges.complete();\n        this._openCloseAllActions.complete();\n    }\n}\nCdkAccordion.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkAccordion, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nCdkAccordion.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkAccordion, selector: \"cdk-accordion, [cdkAccordion]\", inputs: { multi: \"multi\" }, providers: [{ provide: CDK_ACCORDION, useExisting: CdkAccordion }], exportAs: [\"cdkAccordion\"], usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkAccordion, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'cdk-accordion, [cdkAccordion]',\n                    exportAs: 'cdkAccordion',\n                    providers: [{ provide: CDK_ACCORDION, useExisting: CdkAccordion }],\n                }]\n        }], propDecorators: { multi: [{\n                type: Input\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/** Used to generate unique ID for each accordion item. */\nlet nextId = 0;\n/**\n * An basic directive expected to be extended and decorated as a component.  Sets up all\n * events and attributes needed to be managed by a CdkAccordion parent.\n */\nclass CdkAccordionItem {\n    constructor(accordion, _changeDetectorRef, _expansionDispatcher) {\n        this.accordion = accordion;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._expansionDispatcher = _expansionDispatcher;\n        /** Subscription to openAll/closeAll events. */\n        this._openCloseAllSubscription = Subscription.EMPTY;\n        /** Event emitted every time the AccordionItem is closed. */\n        this.closed = new EventEmitter();\n        /** Event emitted every time the AccordionItem is opened. */\n        this.opened = new EventEmitter();\n        /** Event emitted when the AccordionItem is destroyed. */\n        this.destroyed = new EventEmitter();\n        /**\n         * Emits whenever the expanded state of the accordion changes.\n         * Primarily used to facilitate two-way binding.\n         * @docs-private\n         */\n        this.expandedChange = new EventEmitter();\n        /** The unique AccordionItem id. */\n        this.id = `cdk-accordion-child-${nextId++}`;\n        this._expanded = false;\n        this._disabled = false;\n        /** Unregister function for _expansionDispatcher. */\n        this._removeUniqueSelectionListener = () => { };\n        this._removeUniqueSelectionListener = _expansionDispatcher.listen((id, accordionId) => {\n            if (this.accordion &&\n                !this.accordion.multi &&\n                this.accordion.id === accordionId &&\n                this.id !== id) {\n                this.expanded = false;\n            }\n        });\n        // When an accordion item is hosted in an accordion, subscribe to open/close events.\n        if (this.accordion) {\n            this._openCloseAllSubscription = this._subscribeToOpenCloseAllActions();\n        }\n    }\n    /** Whether the AccordionItem is expanded. */\n    get expanded() {\n        return this._expanded;\n    }\n    set expanded(expanded) {\n        expanded = coerceBooleanProperty(expanded);\n        // Only emit events and update the internal value if the value changes.\n        if (this._expanded !== expanded) {\n            this._expanded = expanded;\n            this.expandedChange.emit(expanded);\n            if (expanded) {\n                this.opened.emit();\n                /**\n                 * In the unique selection dispatcher, the id parameter is the id of the CdkAccordionItem,\n                 * the name value is the id of the accordion.\n                 */\n                const accordionId = this.accordion ? this.accordion.id : this.id;\n                this._expansionDispatcher.notify(this.id, accordionId);\n            }\n            else {\n                this.closed.emit();\n            }\n            // Ensures that the animation will run when the value is set outside of an `@Input`.\n            // This includes cases like the open, close and toggle methods.\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n    /** Whether the AccordionItem is disabled. */\n    get disabled() {\n        return this._disabled;\n    }\n    set disabled(disabled) {\n        this._disabled = coerceBooleanProperty(disabled);\n    }\n    /** Emits an event for the accordion item being destroyed. */\n    ngOnDestroy() {\n        this.opened.complete();\n        this.closed.complete();\n        this.destroyed.emit();\n        this.destroyed.complete();\n        this._removeUniqueSelectionListener();\n        this._openCloseAllSubscription.unsubscribe();\n    }\n    /** Toggles the expanded state of the accordion item. */\n    toggle() {\n        if (!this.disabled) {\n            this.expanded = !this.expanded;\n        }\n    }\n    /** Sets the expanded state of the accordion item to false. */\n    close() {\n        if (!this.disabled) {\n            this.expanded = false;\n        }\n    }\n    /** Sets the expanded state of the accordion item to true. */\n    open() {\n        if (!this.disabled) {\n            this.expanded = true;\n        }\n    }\n    _subscribeToOpenCloseAllActions() {\n        return this.accordion._openCloseAllActions.subscribe(expanded => {\n            // Only change expanded state if item is enabled\n            if (!this.disabled) {\n                this.expanded = expanded;\n            }\n        });\n    }\n}\nCdkAccordionItem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkAccordionItem, deps: [{ token: CDK_ACCORDION, optional: true, skipSelf: true }, { token: i0.ChangeDetectorRef }, { token: i1.UniqueSelectionDispatcher }], target: i0.ɵɵFactoryTarget.Directive });\nCdkAccordionItem.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkAccordionItem, selector: \"cdk-accordion-item, [cdkAccordionItem]\", inputs: { expanded: \"expanded\", disabled: \"disabled\" }, outputs: { closed: \"closed\", opened: \"opened\", destroyed: \"destroyed\", expandedChange: \"expandedChange\" }, providers: [\n        // Provide `CDK_ACCORDION` as undefined to prevent nested accordion items from\n        // registering to the same accordion.\n        { provide: CDK_ACCORDION, useValue: undefined },\n    ], exportAs: [\"cdkAccordionItem\"], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkAccordionItem, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'cdk-accordion-item, [cdkAccordionItem]',\n                    exportAs: 'cdkAccordionItem',\n                    providers: [\n                        // Provide `CDK_ACCORDION` as undefined to prevent nested accordion items from\n                        // registering to the same accordion.\n                        { provide: CDK_ACCORDION, useValue: undefined },\n                    ],\n                }]\n        }], ctorParameters: function () { return [{ type: CdkAccordion, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [CDK_ACCORDION]\n                }, {\n                    type: SkipSelf\n                }] }, { type: i0.ChangeDetectorRef }, { type: i1.UniqueSelectionDispatcher }]; }, propDecorators: { closed: [{\n                type: Output\n            }], opened: [{\n                type: Output\n            }], destroyed: [{\n                type: Output\n            }], expandedChange: [{\n                type: Output\n            }], expanded: [{\n                type: Input\n            }], disabled: [{\n                type: Input\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass CdkAccordionModule {\n}\nCdkAccordionModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkAccordionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nCdkAccordionModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkAccordionModule, declarations: [CdkAccordion, CdkAccordionItem], exports: [CdkAccordion, CdkAccordionItem] });\nCdkAccordionModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkAccordionModule });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkAccordionModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    exports: [CdkAccordion, CdkAccordionItem],\n                    declarations: [CdkAccordion, CdkAccordionItem],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { CdkAccordion, CdkAccordionItem, CdkAccordionModule };\n","import { CdkAccordionItem, CdkAccordion, CdkAccordionModule } from '@angular/cdk/accordion';\nimport * as i2 from '@angular/cdk/portal';\nimport { TemplatePortal, PortalModule } from '@angular/cdk/portal';\nimport * as i3 from '@angular/common';\nimport { DOCUMENT, CommonModule } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { InjectionToken, Directive, EventEmitter, Component, ViewEncapsulation, ChangeDetectionStrategy, Optional, SkipSelf, Inject, Input, Output, ContentChild, ViewChild, Host, Attribute, QueryList, ContentChildren, NgModule } from '@angular/core';\nimport { mixinTabIndex, MatCommonModule } from '@angular/material/core';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport * as i2$1 from '@angular/cdk/a11y';\nimport { FocusKeyManager } from '@angular/cdk/a11y';\nimport { distinctUntilChanged, startWith, filter, take } from 'rxjs/operators';\nimport { ENTER, hasModifierKey, SPACE } from '@angular/cdk/keycodes';\nimport { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';\nimport { Subject, Subscription, EMPTY, merge } from 'rxjs';\nimport { trigger, state, style, transition, animate } from '@angular/animations';\nimport * as i1 from '@angular/cdk/collections';\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 * Token used to provide a `MatAccordion` to `MatExpansionPanel`.\n * Used primarily to avoid circular imports between `MatAccordion` and `MatExpansionPanel`.\n */\nconst MAT_ACCORDION = new InjectionToken('MAT_ACCORDION');\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/** Time and timing curve for expansion panel animations. */\n// Note: Keep this in sync with the Sass variable for the panel header animation.\nconst EXPANSION_PANEL_ANIMATION_TIMING = '225ms cubic-bezier(0.4,0.0,0.2,1)';\n/**\n * Animations used by the Material expansion panel.\n *\n * A bug in angular animation's `state` when ViewContainers are moved using ViewContainerRef.move()\n * causes the animation state of moved components to become `void` upon exit, and not update again\n * upon reentry into the DOM.  This can lead a to situation for the expansion panel where the state\n * of the panel is `expanded` or `collapsed` but the animation state is `void`.\n *\n * To correctly handle animating to the next state, we animate between `void` and `collapsed` which\n * are defined to have the same styles. Since angular animates from the current styles to the\n * destination state's style definition, in situations where we are moving from `void`'s styles to\n * `collapsed` this acts a noop since no style values change.\n *\n * In the case where angular's animation state is out of sync with the expansion panel's state, the\n * expansion panel being `expanded` and angular animations being `void`, the animation from the\n * `expanded`'s effective styles (though in a `void` animation state) to the collapsed state will\n * occur as expected.\n *\n * Angular Bug: https://github.com/angular/angular/issues/18847\n *\n * @docs-private\n */\nconst matExpansionAnimations = {\n    /** Animation that rotates the indicator arrow. */\n    indicatorRotate: trigger('indicatorRotate', [\n        state('collapsed, void', style({ transform: 'rotate(0deg)' })),\n        state('expanded', style({ transform: 'rotate(180deg)' })),\n        transition('expanded <=> collapsed, void => collapsed', animate(EXPANSION_PANEL_ANIMATION_TIMING)),\n    ]),\n    /** Animation that expands and collapses the panel content. */\n    bodyExpansion: trigger('bodyExpansion', [\n        state('collapsed, void', style({ height: '0px', visibility: 'hidden' })),\n        state('expanded', style({ height: '*', visibility: 'visible' })),\n        transition('expanded <=> collapsed, void => collapsed', animate(EXPANSION_PANEL_ANIMATION_TIMING)),\n    ]),\n};\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Expansion panel content that will be rendered lazily\n * after the panel is opened for the first time.\n */\nclass MatExpansionPanelContent {\n    constructor(_template) {\n        this._template = _template;\n    }\n}\nMatExpansionPanelContent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatExpansionPanelContent, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });\nMatExpansionPanelContent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatExpansionPanelContent, selector: \"ng-template[matExpansionPanelContent]\", ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatExpansionPanelContent, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'ng-template[matExpansionPanelContent]',\n                }]\n        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });\n\n/** Counter for generating unique element ids. */\nlet uniqueId = 0;\n/**\n * Injection token that can be used to configure the default\n * options for the expansion panel component.\n */\nconst MAT_EXPANSION_PANEL_DEFAULT_OPTIONS = new InjectionToken('MAT_EXPANSION_PANEL_DEFAULT_OPTIONS');\n/**\n * This component can be used as a single element to show expandable content, or as one of\n * multiple children of an element with the MatAccordion directive attached.\n */\nclass MatExpansionPanel extends CdkAccordionItem {\n    constructor(accordion, _changeDetectorRef, _uniqueSelectionDispatcher, _viewContainerRef, _document, _animationMode, defaultOptions) {\n        super(accordion, _changeDetectorRef, _uniqueSelectionDispatcher);\n        this._viewContainerRef = _viewContainerRef;\n        this._animationMode = _animationMode;\n        this._hideToggle = false;\n        /** An event emitted after the body's expansion animation happens. */\n        this.afterExpand = new EventEmitter();\n        /** An event emitted after the body's collapse animation happens. */\n        this.afterCollapse = new EventEmitter();\n        /** Stream that emits for changes in `@Input` properties. */\n        this._inputChanges = new Subject();\n        /** ID for the associated header element. Used for a11y labelling. */\n        this._headerId = `mat-expansion-panel-header-${uniqueId++}`;\n        /** Stream of body animation done events. */\n        this._bodyAnimationDone = new Subject();\n        this.accordion = accordion;\n        this._document = _document;\n        // We need a Subject with distinctUntilChanged, because the `done` event\n        // fires twice on some browsers. See https://github.com/angular/angular/issues/24084\n        this._bodyAnimationDone\n            .pipe(distinctUntilChanged((x, y) => {\n            return x.fromState === y.fromState && x.toState === y.toState;\n        }))\n            .subscribe(event => {\n            if (event.fromState !== 'void') {\n                if (event.toState === 'expanded') {\n                    this.afterExpand.emit();\n                }\n                else if (event.toState === 'collapsed') {\n                    this.afterCollapse.emit();\n                }\n            }\n        });\n        if (defaultOptions) {\n            this.hideToggle = defaultOptions.hideToggle;\n        }\n    }\n    /** Whether the toggle indicator should be hidden. */\n    get hideToggle() {\n        return this._hideToggle || (this.accordion && this.accordion.hideToggle);\n    }\n    set hideToggle(value) {\n        this._hideToggle = coerceBooleanProperty(value);\n    }\n    /** The position of the expansion indicator. */\n    get togglePosition() {\n        return this._togglePosition || (this.accordion && this.accordion.togglePosition);\n    }\n    set togglePosition(value) {\n        this._togglePosition = value;\n    }\n    /** Determines whether the expansion panel should have spacing between it and its siblings. */\n    _hasSpacing() {\n        if (this.accordion) {\n            return this.expanded && this.accordion.displayMode === 'default';\n        }\n        return false;\n    }\n    /** Gets the expanded state string. */\n    _getExpandedState() {\n        return this.expanded ? 'expanded' : 'collapsed';\n    }\n    /** Toggles the expanded state of the expansion panel. */\n    toggle() {\n        this.expanded = !this.expanded;\n    }\n    /** Sets the expanded state of the expansion panel to false. */\n    close() {\n        this.expanded = false;\n    }\n    /** Sets the expanded state of the expansion panel to true. */\n    open() {\n        this.expanded = true;\n    }\n    ngAfterContentInit() {\n        if (this._lazyContent) {\n            // Render the content as soon as the panel becomes open.\n            this.opened\n                .pipe(startWith(null), filter(() => this.expanded && !this._portal), take(1))\n                .subscribe(() => {\n                this._portal = new TemplatePortal(this._lazyContent._template, this._viewContainerRef);\n            });\n        }\n    }\n    ngOnChanges(changes) {\n        this._inputChanges.next(changes);\n    }\n    ngOnDestroy() {\n        super.ngOnDestroy();\n        this._bodyAnimationDone.complete();\n        this._inputChanges.complete();\n    }\n    /** Checks whether the expansion panel's content contains the currently-focused element. */\n    _containsFocus() {\n        if (this._body) {\n            const focusedElement = this._document.activeElement;\n            const bodyElement = this._body.nativeElement;\n            return focusedElement === bodyElement || bodyElement.contains(focusedElement);\n        }\n        return false;\n    }\n}\nMatExpansionPanel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatExpansionPanel, deps: [{ token: MAT_ACCORDION, optional: true, skipSelf: true }, { token: i0.ChangeDetectorRef }, { token: i1.UniqueSelectionDispatcher }, { token: i0.ViewContainerRef }, { token: DOCUMENT }, { token: ANIMATION_MODULE_TYPE, optional: true }, { token: MAT_EXPANSION_PANEL_DEFAULT_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Component });\nMatExpansionPanel.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatExpansionPanel, selector: \"mat-expansion-panel\", inputs: { disabled: \"disabled\", expanded: \"expanded\", hideToggle: \"hideToggle\", togglePosition: \"togglePosition\" }, outputs: { opened: \"opened\", closed: \"closed\", expandedChange: \"expandedChange\", afterExpand: \"afterExpand\", afterCollapse: \"afterCollapse\" }, host: { properties: { \"class.mat-expanded\": \"expanded\", \"class._mat-animation-noopable\": \"_animationMode === \\\"NoopAnimations\\\"\", \"class.mat-expansion-panel-spacing\": \"_hasSpacing()\" }, classAttribute: \"mat-expansion-panel\" }, providers: [\n        // Provide MatAccordion as undefined to prevent nested expansion panels from registering\n        // to the same accordion.\n        { provide: MAT_ACCORDION, useValue: undefined },\n    ], queries: [{ propertyName: \"_lazyContent\", first: true, predicate: MatExpansionPanelContent, descendants: true }], viewQueries: [{ propertyName: \"_body\", first: true, predicate: [\"body\"], descendants: true }], exportAs: [\"matExpansionPanel\"], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: \"<ng-content select=\\\"mat-expansion-panel-header\\\"></ng-content>\\n<div class=\\\"mat-expansion-panel-content\\\"\\n     role=\\\"region\\\"\\n     [@bodyExpansion]=\\\"_getExpandedState()\\\"\\n     (@bodyExpansion.done)=\\\"_bodyAnimationDone.next($event)\\\"\\n     [attr.aria-labelledby]=\\\"_headerId\\\"\\n     [id]=\\\"id\\\"\\n     #body>\\n  <div class=\\\"mat-expansion-panel-body\\\">\\n    <ng-content></ng-content>\\n    <ng-template [cdkPortalOutlet]=\\\"_portal\\\"></ng-template>\\n  </div>\\n  <ng-content select=\\\"mat-action-row\\\"></ng-content>\\n</div>\\n\", styles: [\".mat-expansion-panel{box-sizing:content-box;display:block;margin:0;border-radius:4px;overflow:hidden;transition:margin 225ms cubic-bezier(0.4, 0, 0.2, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);position:relative}.mat-accordion .mat-expansion-panel:not(.mat-expanded),.mat-accordion .mat-expansion-panel:not(.mat-expansion-panel-spacing){border-radius:0}.mat-accordion .mat-expansion-panel:first-of-type{border-top-right-radius:4px;border-top-left-radius:4px}.mat-accordion .mat-expansion-panel:last-of-type{border-bottom-right-radius:4px;border-bottom-left-radius:4px}.cdk-high-contrast-active .mat-expansion-panel{outline:solid 1px}.mat-expansion-panel.ng-animate-disabled,.ng-animate-disabled .mat-expansion-panel,.mat-expansion-panel._mat-animation-noopable{transition:none}.mat-expansion-panel-content{display:flex;flex-direction:column;overflow:visible}.mat-expansion-panel-content[style*=\\\"visibility: hidden\\\"] *{visibility:hidden !important}.mat-expansion-panel-body{padding:0 24px 16px}.mat-expansion-panel-spacing{margin:16px 0}.mat-accordion>.mat-expansion-panel-spacing:first-child,.mat-accordion>*:first-child:not(.mat-expansion-panel) .mat-expansion-panel-spacing{margin-top:0}.mat-accordion>.mat-expansion-panel-spacing:last-child,.mat-accordion>*:last-child:not(.mat-expansion-panel) .mat-expansion-panel-spacing{margin-bottom:0}.mat-action-row{border-top-style:solid;border-top-width:1px;display:flex;flex-direction:row;justify-content:flex-end;padding:16px 8px 16px 24px}.mat-action-row .mat-button-base,.mat-action-row .mat-mdc-button-base{margin-left:8px}[dir=rtl] .mat-action-row .mat-button-base,[dir=rtl] .mat-action-row .mat-mdc-button-base{margin-left:0;margin-right:8px}\\n\"], directives: [{ type: i2.CdkPortalOutlet, selector: \"[cdkPortalOutlet]\", inputs: [\"cdkPortalOutlet\"], outputs: [\"attached\"], exportAs: [\"cdkPortalOutlet\"] }], animations: [matExpansionAnimations.bodyExpansion], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatExpansionPanel, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-expansion-panel', exportAs: 'matExpansionPanel', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, inputs: ['disabled', 'expanded'], outputs: ['opened', 'closed', 'expandedChange'], animations: [matExpansionAnimations.bodyExpansion], providers: [\n                        // Provide MatAccordion as undefined to prevent nested expansion panels from registering\n                        // to the same accordion.\n                        { provide: MAT_ACCORDION, useValue: undefined },\n                    ], host: {\n                        'class': 'mat-expansion-panel',\n                        '[class.mat-expanded]': 'expanded',\n                        '[class._mat-animation-noopable]': '_animationMode === \"NoopAnimations\"',\n                        '[class.mat-expansion-panel-spacing]': '_hasSpacing()',\n                    }, template: \"<ng-content select=\\\"mat-expansion-panel-header\\\"></ng-content>\\n<div class=\\\"mat-expansion-panel-content\\\"\\n     role=\\\"region\\\"\\n     [@bodyExpansion]=\\\"_getExpandedState()\\\"\\n     (@bodyExpansion.done)=\\\"_bodyAnimationDone.next($event)\\\"\\n     [attr.aria-labelledby]=\\\"_headerId\\\"\\n     [id]=\\\"id\\\"\\n     #body>\\n  <div class=\\\"mat-expansion-panel-body\\\">\\n    <ng-content></ng-content>\\n    <ng-template [cdkPortalOutlet]=\\\"_portal\\\"></ng-template>\\n  </div>\\n  <ng-content select=\\\"mat-action-row\\\"></ng-content>\\n</div>\\n\", styles: [\".mat-expansion-panel{box-sizing:content-box;display:block;margin:0;border-radius:4px;overflow:hidden;transition:margin 225ms cubic-bezier(0.4, 0, 0.2, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);position:relative}.mat-accordion .mat-expansion-panel:not(.mat-expanded),.mat-accordion .mat-expansion-panel:not(.mat-expansion-panel-spacing){border-radius:0}.mat-accordion .mat-expansion-panel:first-of-type{border-top-right-radius:4px;border-top-left-radius:4px}.mat-accordion .mat-expansion-panel:last-of-type{border-bottom-right-radius:4px;border-bottom-left-radius:4px}.cdk-high-contrast-active .mat-expansion-panel{outline:solid 1px}.mat-expansion-panel.ng-animate-disabled,.ng-animate-disabled .mat-expansion-panel,.mat-expansion-panel._mat-animation-noopable{transition:none}.mat-expansion-panel-content{display:flex;flex-direction:column;overflow:visible}.mat-expansion-panel-content[style*=\\\"visibility: hidden\\\"] *{visibility:hidden !important}.mat-expansion-panel-body{padding:0 24px 16px}.mat-expansion-panel-spacing{margin:16px 0}.mat-accordion>.mat-expansion-panel-spacing:first-child,.mat-accordion>*:first-child:not(.mat-expansion-panel) .mat-expansion-panel-spacing{margin-top:0}.mat-accordion>.mat-expansion-panel-spacing:last-child,.mat-accordion>*:last-child:not(.mat-expansion-panel) .mat-expansion-panel-spacing{margin-bottom:0}.mat-action-row{border-top-style:solid;border-top-width:1px;display:flex;flex-direction:row;justify-content:flex-end;padding:16px 8px 16px 24px}.mat-action-row .mat-button-base,.mat-action-row .mat-mdc-button-base{margin-left:8px}[dir=rtl] .mat-action-row .mat-button-base,[dir=rtl] .mat-action-row .mat-mdc-button-base{margin-left:0;margin-right:8px}\\n\"] }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: SkipSelf\n                }, {\n                    type: Inject,\n                    args: [MAT_ACCORDION]\n                }] }, { type: i0.ChangeDetectorRef }, { type: i1.UniqueSelectionDispatcher }, { type: i0.ViewContainerRef }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [ANIMATION_MODULE_TYPE]\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_EXPANSION_PANEL_DEFAULT_OPTIONS]\n                }, {\n                    type: Optional\n                }] }]; }, propDecorators: { hideToggle: [{\n                type: Input\n            }], togglePosition: [{\n                type: Input\n            }], afterExpand: [{\n                type: Output\n            }], afterCollapse: [{\n                type: Output\n            }], _lazyContent: [{\n                type: ContentChild,\n                args: [MatExpansionPanelContent]\n            }], _body: [{\n                type: ViewChild,\n                args: ['body']\n            }] } });\n/**\n * Actions of a `<mat-expansion-panel>`.\n */\nclass MatExpansionPanelActionRow {\n}\nMatExpansionPanelActionRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatExpansionPanelActionRow, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatExpansionPanelActionRow.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatExpansionPanelActionRow, selector: \"mat-action-row\", host: { classAttribute: \"mat-action-row\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatExpansionPanelActionRow, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-action-row',\n                    host: {\n                        class: 'mat-action-row',\n                    },\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// Boilerplate for applying mixins to MatExpansionPanelHeader.\n/** @docs-private */\nclass MatExpansionPanelHeaderBase {\n}\nconst _MatExpansionPanelHeaderMixinBase = mixinTabIndex(MatExpansionPanelHeaderBase);\n/**\n * Header element of a `<mat-expansion-panel>`.\n */\nclass MatExpansionPanelHeader extends _MatExpansionPanelHeaderMixinBase {\n    constructor(panel, _element, _focusMonitor, _changeDetectorRef, defaultOptions, _animationMode, tabIndex) {\n        super();\n        this.panel = panel;\n        this._element = _element;\n        this._focusMonitor = _focusMonitor;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._animationMode = _animationMode;\n        this._parentChangeSubscription = Subscription.EMPTY;\n        const accordionHideToggleChange = panel.accordion\n            ? panel.accordion._stateChanges.pipe(filter(changes => !!(changes['hideToggle'] || changes['togglePosition'])))\n            : EMPTY;\n        this.tabIndex = parseInt(tabIndex || '') || 0;\n        // Since the toggle state depends on an @Input on the panel, we\n        // need to subscribe and trigger change detection manually.\n        this._parentChangeSubscription = merge(panel.opened, panel.closed, accordionHideToggleChange, panel._inputChanges.pipe(filter(changes => {\n            return !!(changes['hideToggle'] || changes['disabled'] || changes['togglePosition']);\n        }))).subscribe(() => this._changeDetectorRef.markForCheck());\n        // Avoids focus being lost if the panel contained the focused element and was closed.\n        panel.closed\n            .pipe(filter(() => panel._containsFocus()))\n            .subscribe(() => _focusMonitor.focusVia(_element, 'program'));\n        if (defaultOptions) {\n            this.expandedHeight = defaultOptions.expandedHeight;\n            this.collapsedHeight = defaultOptions.collapsedHeight;\n        }\n    }\n    /**\n     * Whether the associated panel is disabled. Implemented as a part of `FocusableOption`.\n     * @docs-private\n     */\n    get disabled() {\n        return this.panel.disabled;\n    }\n    /** Toggles the expanded state of the panel. */\n    _toggle() {\n        if (!this.disabled) {\n            this.panel.toggle();\n        }\n    }\n    /** Gets whether the panel is expanded. */\n    _isExpanded() {\n        return this.panel.expanded;\n    }\n    /** Gets the expanded state string of the panel. */\n    _getExpandedState() {\n        return this.panel._getExpandedState();\n    }\n    /** Gets the panel id. */\n    _getPanelId() {\n        return this.panel.id;\n    }\n    /** Gets the toggle position for the header. */\n    _getTogglePosition() {\n        return this.panel.togglePosition;\n    }\n    /** Gets whether the expand indicator should be shown. */\n    _showToggle() {\n        return !this.panel.hideToggle && !this.panel.disabled;\n    }\n    /**\n     * Gets the current height of the header. Null if no custom height has been\n     * specified, and if the default height from the stylesheet should be used.\n     */\n    _getHeaderHeight() {\n        const isExpanded = this._isExpanded();\n        if (isExpanded && this.expandedHeight) {\n            return this.expandedHeight;\n        }\n        else if (!isExpanded && this.collapsedHeight) {\n            return this.collapsedHeight;\n        }\n        return null;\n    }\n    /** Handle keydown event calling to toggle() if appropriate. */\n    _keydown(event) {\n        switch (event.keyCode) {\n            // Toggle for space and enter keys.\n            case SPACE:\n            case ENTER:\n                if (!hasModifierKey(event)) {\n                    event.preventDefault();\n                    this._toggle();\n                }\n                break;\n            default:\n                if (this.panel.accordion) {\n                    this.panel.accordion._handleHeaderKeydown(event);\n                }\n                return;\n        }\n    }\n    /**\n     * Focuses the panel header. Implemented as a part of `FocusableOption`.\n     * @param origin Origin of the action that triggered the focus.\n     * @docs-private\n     */\n    focus(origin, options) {\n        if (origin) {\n            this._focusMonitor.focusVia(this._element, origin, options);\n        }\n        else {\n            this._element.nativeElement.focus(options);\n        }\n    }\n    ngAfterViewInit() {\n        this._focusMonitor.monitor(this._element).subscribe(origin => {\n            if (origin && this.panel.accordion) {\n                this.panel.accordion._handleHeaderFocus(this);\n            }\n        });\n    }\n    ngOnDestroy() {\n        this._parentChangeSubscription.unsubscribe();\n        this._focusMonitor.stopMonitoring(this._element);\n    }\n}\nMatExpansionPanelHeader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatExpansionPanelHeader, deps: [{ token: MatExpansionPanel, host: true }, { token: i0.ElementRef }, { token: i2$1.FocusMonitor }, { token: i0.ChangeDetectorRef }, { token: MAT_EXPANSION_PANEL_DEFAULT_OPTIONS, optional: true }, { token: ANIMATION_MODULE_TYPE, optional: true }, { token: 'tabindex', attribute: true }], target: i0.ɵɵFactoryTarget.Component });\nMatExpansionPanelHeader.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatExpansionPanelHeader, selector: \"mat-expansion-panel-header\", inputs: { tabIndex: \"tabIndex\", expandedHeight: \"expandedHeight\", collapsedHeight: \"collapsedHeight\" }, host: { attributes: { \"role\": \"button\" }, listeners: { \"click\": \"_toggle()\", \"keydown\": \"_keydown($event)\" }, properties: { \"attr.id\": \"panel._headerId\", \"attr.tabindex\": \"tabIndex\", \"attr.aria-controls\": \"_getPanelId()\", \"attr.aria-expanded\": \"_isExpanded()\", \"attr.aria-disabled\": \"panel.disabled\", \"class.mat-expanded\": \"_isExpanded()\", \"class.mat-expansion-toggle-indicator-after\": \"_getTogglePosition() === 'after'\", \"class.mat-expansion-toggle-indicator-before\": \"_getTogglePosition() === 'before'\", \"class._mat-animation-noopable\": \"_animationMode === \\\"NoopAnimations\\\"\", \"style.height\": \"_getHeaderHeight()\" }, classAttribute: \"mat-expansion-panel-header mat-focus-indicator\" }, usesInheritance: true, ngImport: i0, template: \"<span class=\\\"mat-content\\\">\\n  <ng-content select=\\\"mat-panel-title\\\"></ng-content>\\n  <ng-content select=\\\"mat-panel-description\\\"></ng-content>\\n  <ng-content></ng-content>\\n</span>\\n<span [@indicatorRotate]=\\\"_getExpandedState()\\\" *ngIf=\\\"_showToggle()\\\"\\n      class=\\\"mat-expansion-indicator\\\"></span>\\n\", styles: [\".mat-expansion-panel-header{display:flex;flex-direction:row;align-items:center;padding:0 24px;border-radius:inherit;transition:height 225ms cubic-bezier(0.4, 0, 0.2, 1)}.mat-expansion-panel-header._mat-animation-noopable{transition:none}.mat-expansion-panel-header:focus,.mat-expansion-panel-header:hover{outline:none}.mat-expansion-panel-header.mat-expanded:focus,.mat-expansion-panel-header.mat-expanded:hover{background:inherit}.mat-expansion-panel-header:not([aria-disabled=true]){cursor:pointer}.mat-expansion-panel-header.mat-expansion-toggle-indicator-before{flex-direction:row-reverse}.mat-expansion-panel-header.mat-expansion-toggle-indicator-before .mat-expansion-indicator{margin:0 16px 0 0}[dir=rtl] .mat-expansion-panel-header.mat-expansion-toggle-indicator-before .mat-expansion-indicator{margin:0 0 0 16px}.mat-content{display:flex;flex:1;flex-direction:row;overflow:hidden}.mat-expansion-panel-header-title,.mat-expansion-panel-header-description{display:flex;flex-grow:1;margin-right:16px;align-items:center}[dir=rtl] .mat-expansion-panel-header-title,[dir=rtl] .mat-expansion-panel-header-description{margin-right:0;margin-left:16px}.mat-expansion-panel-header-description{flex-grow:2}.mat-expansion-indicator::after{border-style:solid;border-width:0 2px 2px 0;content:\\\"\\\";display:inline-block;padding:3px;transform:rotate(45deg);vertical-align:middle}.cdk-high-contrast-active .mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true])::before,.cdk-high-contrast-active .mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true])::before,.cdk-high-contrast-active .mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true])::before{top:0;left:0;right:0;bottom:0;position:absolute;box-sizing:border-box;pointer-events:none;border:3px solid;border-radius:4px;content:\\\"\\\"}.cdk-high-contrast-active .mat-expansion-panel-content{border-top:1px solid;border-top-left-radius:0;border-top-right-radius:0}\\n\"], directives: [{ type: i3.NgIf, selector: \"[ngIf]\", inputs: [\"ngIf\", \"ngIfThen\", \"ngIfElse\"] }], animations: [matExpansionAnimations.indicatorRotate], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatExpansionPanelHeader, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-expansion-panel-header', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, inputs: ['tabIndex'], animations: [matExpansionAnimations.indicatorRotate], host: {\n                        'class': 'mat-expansion-panel-header mat-focus-indicator',\n                        'role': 'button',\n                        '[attr.id]': 'panel._headerId',\n                        '[attr.tabindex]': 'tabIndex',\n                        '[attr.aria-controls]': '_getPanelId()',\n                        '[attr.aria-expanded]': '_isExpanded()',\n                        '[attr.aria-disabled]': 'panel.disabled',\n                        '[class.mat-expanded]': '_isExpanded()',\n                        '[class.mat-expansion-toggle-indicator-after]': `_getTogglePosition() === 'after'`,\n                        '[class.mat-expansion-toggle-indicator-before]': `_getTogglePosition() === 'before'`,\n                        '[class._mat-animation-noopable]': '_animationMode === \"NoopAnimations\"',\n                        '[style.height]': '_getHeaderHeight()',\n                        '(click)': '_toggle()',\n                        '(keydown)': '_keydown($event)',\n                    }, template: \"<span class=\\\"mat-content\\\">\\n  <ng-content select=\\\"mat-panel-title\\\"></ng-content>\\n  <ng-content select=\\\"mat-panel-description\\\"></ng-content>\\n  <ng-content></ng-content>\\n</span>\\n<span [@indicatorRotate]=\\\"_getExpandedState()\\\" *ngIf=\\\"_showToggle()\\\"\\n      class=\\\"mat-expansion-indicator\\\"></span>\\n\", styles: [\".mat-expansion-panel-header{display:flex;flex-direction:row;align-items:center;padding:0 24px;border-radius:inherit;transition:height 225ms cubic-bezier(0.4, 0, 0.2, 1)}.mat-expansion-panel-header._mat-animation-noopable{transition:none}.mat-expansion-panel-header:focus,.mat-expansion-panel-header:hover{outline:none}.mat-expansion-panel-header.mat-expanded:focus,.mat-expansion-panel-header.mat-expanded:hover{background:inherit}.mat-expansion-panel-header:not([aria-disabled=true]){cursor:pointer}.mat-expansion-panel-header.mat-expansion-toggle-indicator-before{flex-direction:row-reverse}.mat-expansion-panel-header.mat-expansion-toggle-indicator-before .mat-expansion-indicator{margin:0 16px 0 0}[dir=rtl] .mat-expansion-panel-header.mat-expansion-toggle-indicator-before .mat-expansion-indicator{margin:0 0 0 16px}.mat-content{display:flex;flex:1;flex-direction:row;overflow:hidden}.mat-expansion-panel-header-title,.mat-expansion-panel-header-description{display:flex;flex-grow:1;margin-right:16px;align-items:center}[dir=rtl] .mat-expansion-panel-header-title,[dir=rtl] .mat-expansion-panel-header-description{margin-right:0;margin-left:16px}.mat-expansion-panel-header-description{flex-grow:2}.mat-expansion-indicator::after{border-style:solid;border-width:0 2px 2px 0;content:\\\"\\\";display:inline-block;padding:3px;transform:rotate(45deg);vertical-align:middle}.cdk-high-contrast-active .mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true])::before,.cdk-high-contrast-active .mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true])::before,.cdk-high-contrast-active .mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true])::before{top:0;left:0;right:0;bottom:0;position:absolute;box-sizing:border-box;pointer-events:none;border:3px solid;border-radius:4px;content:\\\"\\\"}.cdk-high-contrast-active .mat-expansion-panel-content{border-top:1px solid;border-top-left-radius:0;border-top-right-radius:0}\\n\"] }]\n        }], ctorParameters: function () { return [{ type: MatExpansionPanel, decorators: [{\n                    type: Host\n                }] }, { type: i0.ElementRef }, { type: i2$1.FocusMonitor }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_EXPANSION_PANEL_DEFAULT_OPTIONS]\n                }, {\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [ANIMATION_MODULE_TYPE]\n                }] }, { type: undefined, decorators: [{\n                    type: Attribute,\n                    args: ['tabindex']\n                }] }]; }, propDecorators: { expandedHeight: [{\n                type: Input\n            }], collapsedHeight: [{\n                type: Input\n            }] } });\n/**\n * Description element of a `<mat-expansion-panel-header>`.\n */\nclass MatExpansionPanelDescription {\n}\nMatExpansionPanelDescription.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatExpansionPanelDescription, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatExpansionPanelDescription.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatExpansionPanelDescription, selector: \"mat-panel-description\", host: { classAttribute: \"mat-expansion-panel-header-description\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatExpansionPanelDescription, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-panel-description',\n                    host: {\n                        class: 'mat-expansion-panel-header-description',\n                    },\n                }]\n        }] });\n/**\n * Title element of a `<mat-expansion-panel-header>`.\n */\nclass MatExpansionPanelTitle {\n}\nMatExpansionPanelTitle.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatExpansionPanelTitle, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatExpansionPanelTitle.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatExpansionPanelTitle, selector: \"mat-panel-title\", host: { classAttribute: \"mat-expansion-panel-header-title\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatExpansionPanelTitle, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-panel-title',\n                    host: {\n                        class: 'mat-expansion-panel-header-title',\n                    },\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Directive for a Material Design Accordion.\n */\nclass MatAccordion extends CdkAccordion {\n    constructor() {\n        super(...arguments);\n        /** Headers belonging to this accordion. */\n        this._ownHeaders = new QueryList();\n        this._hideToggle = false;\n        /**\n         * Display mode used for all expansion panels in the accordion. Currently two display\n         * modes exist:\n         *  default - a gutter-like spacing is placed around any expanded panel, placing the expanded\n         *     panel at a different elevation from the rest of the accordion.\n         *  flat - no spacing is placed around expanded panels, showing all panels at the same\n         *     elevation.\n         */\n        this.displayMode = 'default';\n        /** The position of the expansion indicator. */\n        this.togglePosition = 'after';\n    }\n    /** Whether the expansion indicator should be hidden. */\n    get hideToggle() {\n        return this._hideToggle;\n    }\n    set hideToggle(show) {\n        this._hideToggle = coerceBooleanProperty(show);\n    }\n    ngAfterContentInit() {\n        this._headers.changes\n            .pipe(startWith(this._headers))\n            .subscribe((headers) => {\n            this._ownHeaders.reset(headers.filter(header => header.panel.accordion === this));\n            this._ownHeaders.notifyOnChanges();\n        });\n        this._keyManager = new FocusKeyManager(this._ownHeaders).withWrap().withHomeAndEnd();\n    }\n    /** Handles keyboard events coming in from the panel headers. */\n    _handleHeaderKeydown(event) {\n        this._keyManager.onKeydown(event);\n    }\n    _handleHeaderFocus(header) {\n        this._keyManager.updateActiveItem(header);\n    }\n    ngOnDestroy() {\n        super.ngOnDestroy();\n        this._ownHeaders.destroy();\n    }\n}\nMatAccordion.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatAccordion, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatAccordion.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatAccordion, selector: \"mat-accordion\", inputs: { multi: \"multi\", hideToggle: \"hideToggle\", displayMode: \"displayMode\", togglePosition: \"togglePosition\" }, host: { properties: { \"class.mat-accordion-multi\": \"this.multi\" }, classAttribute: \"mat-accordion\" }, providers: [\n        {\n            provide: MAT_ACCORDION,\n            useExisting: MatAccordion,\n        },\n    ], queries: [{ propertyName: \"_headers\", predicate: MatExpansionPanelHeader, descendants: true }], exportAs: [\"matAccordion\"], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatAccordion, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-accordion',\n                    exportAs: 'matAccordion',\n                    inputs: ['multi'],\n                    providers: [\n                        {\n                            provide: MAT_ACCORDION,\n                            useExisting: MatAccordion,\n                        },\n                    ],\n                    host: {\n                        class: 'mat-accordion',\n                        // Class binding which is only used by the test harness as there is no other\n                        // way for the harness to detect if multiple panel support is enabled.\n                        '[class.mat-accordion-multi]': 'this.multi',\n                    },\n                }]\n        }], propDecorators: { _headers: [{\n                type: ContentChildren,\n                args: [MatExpansionPanelHeader, { descendants: true }]\n            }], hideToggle: [{\n                type: Input\n            }], displayMode: [{\n                type: Input\n            }], togglePosition: [{\n                type: Input\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatExpansionModule {\n}\nMatExpansionModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatExpansionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatExpansionModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatExpansionModule, declarations: [MatAccordion,\n        MatExpansionPanel,\n        MatExpansionPanelActionRow,\n        MatExpansionPanelHeader,\n        MatExpansionPanelTitle,\n        MatExpansionPanelDescription,\n        MatExpansionPanelContent], imports: [CommonModule, MatCommonModule, CdkAccordionModule, PortalModule], exports: [MatAccordion,\n        MatExpansionPanel,\n        MatExpansionPanelActionRow,\n        MatExpansionPanelHeader,\n        MatExpansionPanelTitle,\n        MatExpansionPanelDescription,\n        MatExpansionPanelContent] });\nMatExpansionModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatExpansionModule, imports: [[CommonModule, MatCommonModule, CdkAccordionModule, PortalModule]] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatExpansionModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [CommonModule, MatCommonModule, CdkAccordionModule, PortalModule],\n                    exports: [\n                        MatAccordion,\n                        MatExpansionPanel,\n                        MatExpansionPanelActionRow,\n                        MatExpansionPanelHeader,\n                        MatExpansionPanelTitle,\n                        MatExpansionPanelDescription,\n                        MatExpansionPanelContent,\n                    ],\n                    declarations: [\n                        MatAccordion,\n                        MatExpansionPanel,\n                        MatExpansionPanelActionRow,\n                        MatExpansionPanelHeader,\n                        MatExpansionPanelTitle,\n                        MatExpansionPanelDescription,\n                        MatExpansionPanelContent,\n                    ],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { EXPANSION_PANEL_ANIMATION_TIMING, MAT_ACCORDION, MAT_EXPANSION_PANEL_DEFAULT_OPTIONS, MatAccordion, MatExpansionModule, MatExpansionPanel, MatExpansionPanelActionRow, MatExpansionPanelContent, MatExpansionPanelDescription, MatExpansionPanelHeader, MatExpansionPanelTitle, matExpansionAnimations };\n","import * as i4 from '@angular/cdk/observers';\nimport { ObserversModule } from '@angular/cdk/observers';\nimport * as i3 from '@angular/common';\nimport { CommonModule } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { InjectionToken, Directive, Attribute, Input, Component, ViewEncapsulation, ChangeDetectionStrategy, Optional, Inject, ViewChild, ContentChild, ContentChildren, NgModule } from '@angular/core';\nimport { mixinColor, MatCommonModule } from '@angular/material/core';\nimport * as i1 from '@angular/cdk/bidi';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { Subject, merge, fromEvent } from 'rxjs';\nimport { startWith, takeUntil, take } from 'rxjs/operators';\nimport { trigger, state, style, transition, animate } from '@angular/animations';\nimport * as i2 from '@angular/cdk/platform';\nimport { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nlet nextUniqueId$2 = 0;\n/**\n * Injection token that can be used to reference instances of `MatError`. It serves as\n * alternative token to the actual `MatError` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */\nconst MAT_ERROR = new InjectionToken('MatError');\n/** Single error message to be shown underneath the form field. */\nclass MatError {\n    constructor(ariaLive, elementRef) {\n        this.id = `mat-error-${nextUniqueId$2++}`;\n        // If no aria-live value is set add 'polite' as a default. This is preferred over setting\n        // role='alert' so that screen readers do not interrupt the current task to read this aloud.\n        if (!ariaLive) {\n            elementRef.nativeElement.setAttribute('aria-live', 'polite');\n        }\n    }\n}\nMatError.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatError, deps: [{ token: 'aria-live', attribute: true }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });\nMatError.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatError, selector: \"mat-error\", inputs: { id: \"id\" }, host: { attributes: { \"aria-atomic\": \"true\" }, properties: { \"attr.id\": \"id\" }, classAttribute: \"mat-error\" }, providers: [{ provide: MAT_ERROR, useExisting: MatError }], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatError, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-error',\n                    host: {\n                        'class': 'mat-error',\n                        '[attr.id]': 'id',\n                        'aria-atomic': 'true',\n                    },\n                    providers: [{ provide: MAT_ERROR, useExisting: MatError }],\n                }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Attribute,\n                    args: ['aria-live']\n                }] }, { type: i0.ElementRef }]; }, propDecorators: { id: [{\n                type: Input\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Animations used by the MatFormField.\n * @docs-private\n */\nconst matFormFieldAnimations = {\n    /** Animation that transitions the form field's error and hint messages. */\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(-5px)' }),\n            animate('300ms cubic-bezier(0.55, 0, 0.55, 0.2)'),\n        ]),\n    ]),\n};\n\n/** An interface which allows a control to work inside of a `MatFormField`. */\nclass MatFormFieldControl {\n}\nMatFormFieldControl.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatFormFieldControl, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatFormFieldControl.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatFormFieldControl, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatFormFieldControl, decorators: [{\n            type: Directive\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/** @docs-private */\nfunction getMatFormFieldPlaceholderConflictError() {\n    return Error('Placeholder attribute and child element were both specified.');\n}\n/** @docs-private */\nfunction getMatFormFieldDuplicatedHintError(align) {\n    return Error(`A hint was already declared for 'align=\"${align}\"'.`);\n}\n/** @docs-private */\nfunction getMatFormFieldMissingControlError() {\n    return Error('mat-form-field must contain a MatFormFieldControl.');\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 */\nlet nextUniqueId$1 = 0;\n/**\n * Injection token that can be used to reference instances of `MatHint`. It serves as\n * alternative token to the actual `MatHint` class which could cause unnecessary\n * retention of the class and its directive metadata.\n *\n * *Note*: This is not part of the public API as the MDC-based form-field will not\n * need a lightweight token for `MatHint` and we want to reduce breaking changes.\n */\nconst _MAT_HINT = new InjectionToken('MatHint');\n/** Hint text to be shown underneath the form field control. */\nclass MatHint {\n    constructor() {\n        /** Whether to align the hint label at the start or end of the line. */\n        this.align = 'start';\n        /** Unique ID for the hint. Used for the aria-describedby on the form field control. */\n        this.id = `mat-hint-${nextUniqueId$1++}`;\n    }\n}\nMatHint.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatHint, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatHint.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatHint, selector: \"mat-hint\", inputs: { align: \"align\", id: \"id\" }, host: { properties: { \"class.mat-form-field-hint-end\": \"align === \\\"end\\\"\", \"attr.id\": \"id\", \"attr.align\": \"null\" }, classAttribute: \"mat-hint\" }, providers: [{ provide: _MAT_HINT, useExisting: MatHint }], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatHint, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-hint',\n                    host: {\n                        'class': 'mat-hint',\n                        '[class.mat-form-field-hint-end]': 'align === \"end\"',\n                        '[attr.id]': 'id',\n                        // Remove align attribute to prevent it from interfering with layout.\n                        '[attr.align]': 'null',\n                    },\n                    providers: [{ provide: _MAT_HINT, useExisting: MatHint }],\n                }]\n        }], propDecorators: { align: [{\n                type: Input\n            }], id: [{\n                type: Input\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/** The floating label for a `mat-form-field`. */\nclass MatLabel {\n}\nMatLabel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatLabel, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatLabel.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatLabel, selector: \"mat-label\", ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatLabel, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-label',\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * 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 = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatPlaceholder, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatPlaceholder.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatPlaceholder, selector: \"mat-placeholder\", ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatPlaceholder, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-placeholder',\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Injection token that can be used to reference instances of `MatPrefix`. It serves as\n * alternative token to the actual `MatPrefix` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */\nconst MAT_PREFIX = new InjectionToken('MatPrefix');\n/** Prefix to be placed in front of the form field. */\nclass MatPrefix {\n}\nMatPrefix.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatPrefix, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatPrefix.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatPrefix, selector: \"[matPrefix]\", providers: [{ provide: MAT_PREFIX, useExisting: MatPrefix }], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatPrefix, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matPrefix]',\n                    providers: [{ provide: MAT_PREFIX, useExisting: MatPrefix }],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Injection token that can be used to reference instances of `MatSuffix`. It serves as\n * alternative token to the actual `MatSuffix` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */\nconst MAT_SUFFIX = new InjectionToken('MatSuffix');\n/** Suffix to be placed at the end of the form field. */\nclass MatSuffix {\n}\nMatSuffix.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSuffix, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatSuffix.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatSuffix, selector: \"[matSuffix]\", providers: [{ provide: MAT_SUFFIX, useExisting: MatSuffix }], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSuffix, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matSuffix]',\n                    providers: [{ provide: MAT_SUFFIX, useExisting: MatSuffix }],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nlet nextUniqueId = 0;\nconst floatingLabelScale = 0.75;\nconst outlineGapPadding = 5;\n/**\n * Boilerplate for applying mixins to MatFormField.\n * @docs-private\n */\nconst _MatFormFieldBase = mixinColor(class {\n    constructor(_elementRef) {\n        this._elementRef = _elementRef;\n    }\n}, 'primary');\n/**\n * Injection token that can be used to configure the\n * default options for all form field within an app.\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 */\nconst MAT_FORM_FIELD = new InjectionToken('MatFormField');\n/** Container for form controls that applies Material Design styling and behavior. */\nclass MatFormField extends _MatFormFieldBase {\n    constructor(elementRef, _changeDetectorRef, _dir, _defaults, _platform, _ngZone, _animationMode) {\n        super(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        /** Whether the outline gap needs to be calculated next time the zone has stabilized. */\n        this._outlineGapCalculationNeededOnStable = false;\n        this._destroyed = new Subject();\n        /** Override for the logic that disables the label animation in certain cases. */\n        this._showAlwaysAnimate = false;\n        /** State of the mat-hint and mat-error animations. */\n        this._subscriptAnimationState = '';\n        this._hintLabel = '';\n        // Unique id for the hint label.\n        this._hintLabelId = `mat-hint-${nextUniqueId++}`;\n        // Unique id for the label element.\n        this._labelId = `mat-form-field-label-${nextUniqueId++}`;\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 =\n            _defaults && _defaults.hideRequiredMarker != null ? _defaults.hideRequiredMarker : false;\n    }\n    /** The form-field appearance style. */\n    get appearance() {\n        return this._appearance;\n    }\n    set appearance(value) {\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    /** Whether the required marker should be hidden. */\n    get hideRequiredMarker() {\n        return this._hideRequiredMarker;\n    }\n    set hideRequiredMarker(value) {\n        this._hideRequiredMarker = coerceBooleanProperty(value);\n    }\n    /** Whether the floating label should always float or not. */\n    _shouldAlwaysFloat() {\n        return this.floatLabel === 'always' && !this._showAlwaysAnimate;\n    }\n    /** Whether the label can float or not. */\n    _canLabelFloat() {\n        return this.floatLabel !== 'never';\n    }\n    /** Text for the form field hint. */\n    get hintLabel() {\n        return this._hintLabel;\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     */\n    get floatLabel() {\n        return this.appearance !== 'legacy' && this._floatLabel === 'never' ? 'auto' : this._floatLabel;\n    }\n    set floatLabel(value) {\n        if (value !== this._floatLabel) {\n            this._floatLabel = value || this._getDefaultFloatLabelState();\n            this._changeDetectorRef.markForCheck();\n        }\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    set _control(value) {\n        this._explicitFormFieldControl = value;\n    }\n    /**\n     * Gets the id of the label element. If no label is present, returns `null`.\n     */\n    getLabelId() {\n        return this._hasFloatingLabel() ? this._labelId : null;\n    }\n    /**\n     * Gets an ElementRef for the element that a overlay attached to the form-field should be\n     * positioned relative to.\n     */\n    getConnectedOverlayOrigin() {\n        return this._connectionContainerRef || this._elementRef;\n    }\n    ngAfterContentInit() {\n        this._validateControlChild();\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(null)).subscribe(() => {\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(() => 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            this._ngZone.onStable.pipe(takeUntil(this._destroyed)).subscribe(() => {\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            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            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            this._syncDescribedByIds();\n            this._changeDetectorRef.markForCheck();\n        });\n        if (this._dir) {\n            this._dir.change.pipe(takeUntil(this._destroyed)).subscribe(() => {\n                if (typeof requestAnimationFrame === 'function') {\n                    this._ngZone.runOutsideAngular(() => {\n                        requestAnimationFrame(() => this.updateOutlineGap());\n                    });\n                }\n                else {\n                    this.updateOutlineGap();\n                }\n            });\n        }\n    }\n    ngAfterContentChecked() {\n        this._validateControlChild();\n        if (this._outlineGapCalculationNeededImmediately) {\n            this.updateOutlineGap();\n        }\n    }\n    ngAfterViewInit() {\n        // Avoid animations on load.\n        this._subscriptAnimationState = 'enter';\n        this._changeDetectorRef.detectChanges();\n    }\n    ngOnDestroy() {\n        this._destroyed.next();\n        this._destroyed.complete();\n    }\n    /** Determines whether a class from the NgControl should be forwarded to the host element. */\n    _shouldForward(prop) {\n        const ngControl = this._control ? this._control.ngControl : null;\n        return ngControl && ngControl[prop];\n    }\n    _hasPlaceholder() {\n        return !!((this._control && this._control.placeholder) || this._placeholderChild);\n    }\n    _hasLabel() {\n        return !!(this._labelChildNonStatic || this._labelChildStatic);\n    }\n    _shouldLabelFloat() {\n        return (this._canLabelFloat() &&\n            ((this._control && this._control.shouldLabelFloat) || this._shouldAlwaysFloat()));\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    _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    /** Determines whether to display hints or errors. */\n    _getDisplayedMessages() {\n        return this._errorChildren && this._errorChildren.length > 0 && this._control.errorState\n            ? 'error'\n            : 'hint';\n    }\n    /** Animates the placeholder up and locks it in position. */\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')\n                    .pipe(take(1))\n                    .subscribe(() => {\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     */\n    _validatePlaceholders() {\n        if (this._control.placeholder &&\n            this._placeholderChild &&\n            (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getMatFormFieldPlaceholderConflictError();\n        }\n    }\n    /** Does any extra processing that is required when handling the hints. */\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     */\n    _validateHints() {\n        if (this._hintChildren && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            let startHint;\n            let endHint;\n            this._hintChildren.forEach((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    /** Gets the default float label state. */\n    _getDefaultFloatLabelState() {\n        return (this._defaults && this._defaults.floatLabel) || '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     */\n    _syncDescribedByIds() {\n        if (this._control) {\n            let ids = [];\n            // TODO(wagnermaciel): Remove the type check when we find the root cause of this bug.\n            if (this._control.userAriaDescribedBy &&\n                typeof this._control.userAriaDescribedBy === 'string') {\n                ids.push(...this._control.userAriaDescribedBy.split(' '));\n            }\n            if (this._getDisplayedMessages() === 'hint') {\n                const startHint = this._hintChildren\n                    ? this._hintChildren.find(hint => hint.align === 'start')\n                    : null;\n                const endHint = this._hintChildren\n                    ? this._hintChildren.find(hint => hint.align === 'end')\n                    : 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.push(...this._errorChildren.map(error => error.id));\n            }\n            this._control.setDescribedByIds(ids);\n        }\n    }\n    /** Throws an error if the form field's control is missing. */\n    _validateControlChild() {\n        if (!this._control && (typeof ngDevMode === 'undefined' || ngDevMode)) {\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     */\n    updateOutlineGap() {\n        const labelEl = this._label ? this._label.nativeElement : null;\n        const container = this._connectionContainerRef.nativeElement;\n        const outlineStartSelector = '.mat-form-field-outline-start';\n        const outlineGapSelector = '.mat-form-field-outline-gap';\n        // getBoundingClientRect isn't available on the server.\n        if (this.appearance !== 'outline' || !this._platform.isBrowser) {\n            return;\n        }\n        // If there is no content, set the gap elements to zero.\n        if (!labelEl || !labelEl.children.length || !labelEl.textContent.trim()) {\n            const gapElements = container.querySelectorAll(`${outlineStartSelector}, ${outlineGapSelector}`);\n            for (let i = 0; i < gapElements.length; i++) {\n                gapElements[i].style.width = '0';\n            }\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        let startWidth = 0;\n        let gapWidth = 0;\n        const startEls = container.querySelectorAll(outlineStartSelector);\n        const gapEls = container.querySelectorAll(outlineGapSelector);\n        if (this._label && this._label.nativeElement.children.length) {\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            const containerStart = this._getStartEnd(containerRect);\n            const labelChildren = labelEl.children;\n            const labelStart = this._getStartEnd(labelChildren[0].getBoundingClientRect());\n            let labelWidth = 0;\n            for (let i = 0; i < labelChildren.length; i++) {\n                labelWidth += labelChildren[i].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 = this._outlineGapCalculationNeededImmediately =\n            false;\n    }\n    /** Gets the start end of the rect considering the current directionality. */\n    _getStartEnd(rect) {\n        return this._dir && this._dir.value === 'rtl' ? rect.right : rect.left;\n    }\n    /** Checks whether the form field is attached to the DOM. */\n    _isAttachedToDOM() {\n        const element = this._elementRef.nativeElement;\n        if (element.getRootNode) {\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 document.documentElement.contains(element);\n    }\n}\nMatFormField.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatFormField, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i1.Directionality, optional: true }, { token: MAT_FORM_FIELD_DEFAULT_OPTIONS, optional: true }, { token: i2.Platform }, { token: i0.NgZone }, { token: ANIMATION_MODULE_TYPE, optional: true }], target: i0.ɵɵFactoryTarget.Component });\nMatFormField.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatFormField, selector: \"mat-form-field\", inputs: { color: \"color\", appearance: \"appearance\", hideRequiredMarker: \"hideRequiredMarker\", hintLabel: \"hintLabel\", floatLabel: \"floatLabel\" }, host: { properties: { \"class.mat-form-field-appearance-standard\": \"appearance == \\\"standard\\\"\", \"class.mat-form-field-appearance-fill\": \"appearance == \\\"fill\\\"\", \"class.mat-form-field-appearance-outline\": \"appearance == \\\"outline\\\"\", \"class.mat-form-field-appearance-legacy\": \"appearance == \\\"legacy\\\"\", \"class.mat-form-field-invalid\": \"_control.errorState\", \"class.mat-form-field-can-float\": \"_canLabelFloat()\", \"class.mat-form-field-should-float\": \"_shouldLabelFloat()\", \"class.mat-form-field-has-label\": \"_hasFloatingLabel()\", \"class.mat-form-field-hide-placeholder\": \"_hideControlPlaceholder()\", \"class.mat-form-field-disabled\": \"_control.disabled\", \"class.mat-form-field-autofilled\": \"_control.autofilled\", \"class.mat-focused\": \"_control.focused\", \"class.ng-untouched\": \"_shouldForward(\\\"untouched\\\")\", \"class.ng-touched\": \"_shouldForward(\\\"touched\\\")\", \"class.ng-pristine\": \"_shouldForward(\\\"pristine\\\")\", \"class.ng-dirty\": \"_shouldForward(\\\"dirty\\\")\", \"class.ng-valid\": \"_shouldForward(\\\"valid\\\")\", \"class.ng-invalid\": \"_shouldForward(\\\"invalid\\\")\", \"class.ng-pending\": \"_shouldForward(\\\"pending\\\")\", \"class._mat-animation-noopable\": \"!_animationsEnabled\" }, classAttribute: \"mat-form-field\" }, providers: [{ provide: MAT_FORM_FIELD, useExisting: MatFormField }], queries: [{ propertyName: \"_controlNonStatic\", first: true, predicate: MatFormFieldControl, descendants: true }, { propertyName: \"_controlStatic\", first: true, predicate: MatFormFieldControl, descendants: true, static: true }, { propertyName: \"_labelChildNonStatic\", first: true, predicate: MatLabel, descendants: true }, { propertyName: \"_labelChildStatic\", first: true, predicate: MatLabel, descendants: true, static: true }, { propertyName: \"_placeholderChild\", first: true, predicate: MatPlaceholder, descendants: true }, { propertyName: \"_errorChildren\", predicate: MAT_ERROR, descendants: true }, { propertyName: \"_hintChildren\", predicate: _MAT_HINT, descendants: true }, { propertyName: \"_prefixChildren\", predicate: MAT_PREFIX, descendants: true }, { propertyName: \"_suffixChildren\", predicate: MAT_SUFFIX, descendants: true }], viewQueries: [{ propertyName: \"_connectionContainerRef\", first: true, predicate: [\"connectionContainer\"], descendants: true, static: true }, { propertyName: \"_inputContainerRef\", first: true, predicate: [\"inputContainer\"], descendants: true }, { propertyName: \"_label\", first: true, predicate: [\"label\"], descendants: true }], exportAs: [\"matFormField\"], usesInheritance: true, ngImport: i0, 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\\n      class=\\\"mat-form-field-prefix\\\"\\n      *ngIf=\\\"_prefixChildren.length\\\"\\n      (cdkObserveContent)=\\\"updateOutlineGap()\\\"\\n      [cdkObserveContentDisabled]=\\\"appearance != 'outline'\\\">\\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\\\"\\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\", 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}.cdk-high-contrast-active .mat-form-field-disabled .mat-form-field-label{color:GrayText}.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:none;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-hint-end{order:1}.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}.cdk-high-contrast-active .mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-flex{outline-color:GrayText}.cdk-high-contrast-active .mat-form-field-appearance-fill.mat-focused .mat-form-field-flex{outline:dashed 3px}.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}.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;box-sizing:content-box}.mat-input-element:-moz-ui-invalid{box-shadow: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:not([type=password])::-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;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element::-moz-placeholder{-webkit-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{-webkit-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{-webkit-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-hide-placeholder .mat-input-element::placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-input-element::placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-input-element::-moz-placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-input-element::-moz-placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-input-element::-webkit-input-placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-input-element::-webkit-input-placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-input-element:-ms-input-placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-input-element:-ms-input-placeholder{opacity:0}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::-moz-focus-inner{border:0}select.mat-input-element:not(:disabled){cursor:pointer}.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)}.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;border-top-color:GrayText}.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}.cdk-high-contrast-active .mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick{border:3px dashed}.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}.cdk-high-contrast-active .mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-outline{color:GrayText}.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:solid 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\"], directives: [{ type: i3.NgIf, selector: \"[ngIf]\", inputs: [\"ngIf\", \"ngIfThen\", \"ngIfElse\"] }, { type: i4.CdkObserveContent, selector: \"[cdkObserveContent]\", inputs: [\"cdkObserveContentDisabled\", \"debounce\"], outputs: [\"cdkObserveContent\"], exportAs: [\"cdkObserveContent\"] }, { type: i3.NgSwitch, selector: \"[ngSwitch]\", inputs: [\"ngSwitch\"] }, { type: i3.NgSwitchCase, selector: \"[ngSwitchCase]\", inputs: [\"ngSwitchCase\"] }], animations: [matFormFieldAnimations.transitionMessages], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatFormField, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-form-field', exportAs: 'matFormField', animations: [matFormFieldAnimations.transitionMessages], 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.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                    }, inputs: ['color'], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [{ provide: MAT_FORM_FIELD, useExisting: MatFormField }], 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\\n      class=\\\"mat-form-field-prefix\\\"\\n      *ngIf=\\\"_prefixChildren.length\\\"\\n      (cdkObserveContent)=\\\"updateOutlineGap()\\\"\\n      [cdkObserveContentDisabled]=\\\"appearance != 'outline'\\\">\\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\\\"\\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\", 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}.cdk-high-contrast-active .mat-form-field-disabled .mat-form-field-label{color:GrayText}.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:none;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-hint-end{order:1}.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}.cdk-high-contrast-active .mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-flex{outline-color:GrayText}.cdk-high-contrast-active .mat-form-field-appearance-fill.mat-focused .mat-form-field-flex{outline:dashed 3px}.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}.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;box-sizing:content-box}.mat-input-element:-moz-ui-invalid{box-shadow: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:not([type=password])::-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;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element::-moz-placeholder{-webkit-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{-webkit-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{-webkit-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-hide-placeholder .mat-input-element::placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-input-element::placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-input-element::-moz-placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-input-element::-moz-placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-input-element::-webkit-input-placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-input-element::-webkit-input-placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-input-element:-ms-input-placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-input-element:-ms-input-placeholder{opacity:0}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::-moz-focus-inner{border:0}select.mat-input-element:not(:disabled){cursor:pointer}.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)}.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;border-top-color:GrayText}.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}.cdk-high-contrast-active .mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick{border:3px dashed}.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}.cdk-high-contrast-active .mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-outline{color:GrayText}.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:solid 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        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i1.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: i2.Platform }, { type: i0.NgZone }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [ANIMATION_MODULE_TYPE]\n                }] }]; }, propDecorators: { appearance: [{\n                type: Input\n            }], hideRequiredMarker: [{\n                type: Input\n            }], hintLabel: [{\n                type: Input\n            }], floatLabel: [{\n                type: Input\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: [MAT_ERROR, { descendants: true }]\n            }], _hintChildren: [{\n                type: ContentChildren,\n                args: [_MAT_HINT, { descendants: true }]\n            }], _prefixChildren: [{\n                type: ContentChildren,\n                args: [MAT_PREFIX, { descendants: true }]\n            }], _suffixChildren: [{\n                type: ContentChildren,\n                args: [MAT_SUFFIX, { descendants: true }]\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatFormFieldModule {\n}\nMatFormFieldModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatFormFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatFormFieldModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatFormFieldModule, declarations: [MatError, MatFormField, MatHint, MatLabel, MatPlaceholder, MatPrefix, MatSuffix], imports: [CommonModule, MatCommonModule, ObserversModule], exports: [MatCommonModule,\n        MatError,\n        MatFormField,\n        MatHint,\n        MatLabel,\n        MatPlaceholder,\n        MatPrefix,\n        MatSuffix] });\nMatFormFieldModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatFormFieldModule, imports: [[CommonModule, MatCommonModule, ObserversModule], MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatFormFieldModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    declarations: [MatError, MatFormField, MatHint, MatLabel, MatPlaceholder, MatPrefix, MatSuffix],\n                    imports: [CommonModule, MatCommonModule, ObserversModule],\n                    exports: [\n                        MatCommonModule,\n                        MatError,\n                        MatFormField,\n                        MatHint,\n                        MatLabel,\n                        MatPlaceholder,\n                        MatPrefix,\n                        MatSuffix,\n                    ],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_ERROR, MAT_FORM_FIELD, MAT_FORM_FIELD_DEFAULT_OPTIONS, MAT_PREFIX, MAT_SUFFIX, MatError, MatFormField, MatFormFieldControl, MatFormFieldModule, MatHint, MatLabel, MatPlaceholder, MatPrefix, MatSuffix, _MAT_HINT, getMatFormFieldDuplicatedHintError, getMatFormFieldMissingControlError, getMatFormFieldPlaceholderConflictError, matFormFieldAnimations };\n","import * as i0 from '@angular/core';\nimport { SecurityContext, Injectable, Optional, Inject, SkipSelf, ErrorHandler, InjectionToken, inject, Component, ViewEncapsulation, ChangeDetectionStrategy, 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 { of, throwError, forkJoin, Subscription } from 'rxjs';\nimport { tap, map, catchError, finalize, share, take } from 'rxjs/operators';\nimport * as i1 from '@angular/common/http';\nimport { HttpClient } from '@angular/common/http';\nimport * as i2 from '@angular/platform-browser';\nimport { DomSanitizer } from '@angular/platform-browser';\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 * The Trusted Types policy, or null if Trusted Types are not\n * enabled/supported, or undefined if the policy has not been created yet.\n */\nlet policy;\n/**\n * Returns the Trusted Types policy, or null if Trusted Types are not\n * enabled/supported. The first call to this function will create the policy.\n */\nfunction getPolicy() {\n    if (policy === undefined) {\n        policy = null;\n        if (typeof window !== 'undefined') {\n            const ttWindow = window;\n            if (ttWindow.trustedTypes !== undefined) {\n                policy = ttWindow.trustedTypes.createPolicy('angular#components', {\n                    createHTML: (s) => s,\n                });\n            }\n        }\n    }\n    return policy;\n}\n/**\n * Unsafely promote a string to a TrustedHTML, falling back to strings when\n * Trusted Types are not available.\n * @security This is a security-sensitive function; any use of this function\n * must go through security review. In particular, it must be assured that the\n * provided string will never cause an XSS vulnerability if used in a context\n * that will be interpreted as HTML by a browser, e.g. when assigning to\n * element.innerHTML.\n */\nfunction trustedHTMLFromString(html) {\n    return getPolicy()?.createHTML(html) || html;\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 * 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 */\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 */\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 * @param url URL that was attempted to be sanitized.\n * @docs-private\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 * @param literal HTML that was attempted to be sanitized.\n * @docs-private\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 * Configuration for an icon, including the URL and possibly the cached SVG element.\n * @docs-private\n */\nclass SvgIconConfig {\n    constructor(url, svgText, options) {\n        this.url = url;\n        this.svgText = svgText;\n        this.options = options;\n    }\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    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        /** Cache for icons loaded by direct URLs. */\n        this._cachedIconsByUrl = new Map();\n        /** In-progress icon fetches. Used to coalesce multiple requests to the same URL. */\n        this._inProgressUrlFetches = new Map();\n        /** Map from font identifiers to their CSS class names. Used for icon fonts. */\n        this._fontCssClassesByAlias = new Map();\n        /** Registered icon resolver functions. */\n        this._resolvers = [];\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     * @param iconName Name under which the icon should be registered.\n     * @param url\n     */\n    addSvgIcon(iconName, url, options) {\n        return this.addSvgIconInNamespace('', iconName, url, options);\n    }\n    /**\n     * Registers an icon using an HTML string in the default namespace.\n     * @param iconName Name under which the icon should be registered.\n     * @param literal SVG source of the icon.\n     */\n    addSvgIconLiteral(iconName, literal, options) {\n        return this.addSvgIconLiteralInNamespace('', iconName, literal, options);\n    }\n    /**\n     * Registers an icon by URL in the specified namespace.\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     */\n    addSvgIconInNamespace(namespace, iconName, url, options) {\n        return this._addSvgIconConfig(namespace, iconName, new SvgIconConfig(url, null, options));\n    }\n    /**\n     * Registers an icon resolver function with the registry. The function will be invoked with the\n     * name and namespace of an icon when the registry tries to resolve the URL from which to fetch\n     * the icon. The resolver is expected to return a `SafeResourceUrl` that points to the icon,\n     * an object with the icon URL and icon options, or `null` if the icon is not supported. Resolvers\n     * will be invoked in the order in which they have been registered.\n     * @param resolver Resolver function to be registered.\n     */\n    addSvgIconResolver(resolver) {\n        this._resolvers.push(resolver);\n        return this;\n    }\n    /**\n     * Registers an icon using an HTML string in the specified namespace.\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     */\n    addSvgIconLiteralInNamespace(namespace, iconName, literal, options) {\n        const cleanLiteral = this._sanitizer.sanitize(SecurityContext.HTML, literal);\n        // TODO: add an ngDevMode check\n        if (!cleanLiteral) {\n            throw getMatIconFailedToSanitizeLiteralError(literal);\n        }\n        // Security: The literal is passed in as SafeHtml, and is thus trusted.\n        const trustedLiteral = trustedHTMLFromString(cleanLiteral);\n        return this._addSvgIconConfig(namespace, iconName, new SvgIconConfig('', trustedLiteral, options));\n    }\n    /**\n     * Registers an icon set by URL in the default namespace.\n     * @param url\n     */\n    addSvgIconSet(url, options) {\n        return this.addSvgIconSetInNamespace('', url, options);\n    }\n    /**\n     * Registers an icon set using an HTML string in the default namespace.\n     * @param literal SVG source of the icon set.\n     */\n    addSvgIconSetLiteral(literal, options) {\n        return this.addSvgIconSetLiteralInNamespace('', literal, options);\n    }\n    /**\n     * Registers an icon set by URL in the specified namespace.\n     * @param namespace Namespace in which to register the icon set.\n     * @param url\n     */\n    addSvgIconSetInNamespace(namespace, url, options) {\n        return this._addSvgIconSetConfig(namespace, new SvgIconConfig(url, null, options));\n    }\n    /**\n     * Registers an icon set using an HTML string in the specified namespace.\n     * @param namespace Namespace in which to register the icon set.\n     * @param literal SVG source of the icon set.\n     */\n    addSvgIconSetLiteralInNamespace(namespace, literal, options) {\n        const cleanLiteral = this._sanitizer.sanitize(SecurityContext.HTML, literal);\n        if (!cleanLiteral) {\n            throw getMatIconFailedToSanitizeLiteralError(literal);\n        }\n        // Security: The literal is passed in as SafeHtml, and is thus trusted.\n        const trustedLiteral = trustedHTMLFromString(cleanLiteral);\n        return this._addSvgIconSetConfig(namespace, new SvgIconConfig('', trustedLiteral, 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     * @param alias Alias for the font.\n     * @param className Class name override to be used instead of the alias.\n     */\n    registerFontClassAlias(alias, className = alias) {\n        this._fontCssClassesByAlias.set(alias, className);\n        return 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     */\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     * @param className\n     */\n    setDefaultFontSetClass(className) {\n        this._defaultFontSetClass = className;\n        return 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     */\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     */\n    getSvgIconFromUrl(safeUrl) {\n        const url = this._sanitizer.sanitize(SecurityContext.RESOURCE_URL, safeUrl);\n        if (!url) {\n            throw getMatIconFailedToSanitizeUrlError(safeUrl);\n        }\n        const cachedIcon = this._cachedIconsByUrl.get(url);\n        if (cachedIcon) {\n            return of(cloneSvg(cachedIcon));\n        }\n        return this._loadSvgIconFromConfig(new SvgIconConfig(safeUrl, null)).pipe(tap(svg => this._cachedIconsByUrl.set(url, svg)), map(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     */\n    getNamedSvgIcon(name, namespace = '') {\n        const key = iconKey(namespace, name);\n        let config = this._svgIconConfigs.get(key);\n        // Return (copy of) cached icon if possible.\n        if (config) {\n            return this._getSvgFromConfig(config);\n        }\n        // Otherwise try to resolve the config from one of the resolver functions.\n        config = this._getIconConfigFromResolvers(namespace, name);\n        if (config) {\n            this._svgIconConfigs.set(key, config);\n            return this._getSvgFromConfig(config);\n        }\n        // See if we have any icon sets registered for the namespace.\n        const iconSetConfigs = this._iconSetConfigs.get(namespace);\n        if (iconSetConfigs) {\n            return this._getSvgFromIconSetConfigs(name, iconSetConfigs);\n        }\n        return throwError(getMatIconNameNotFoundError(key));\n    }\n    ngOnDestroy() {\n        this._resolvers = [];\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     */\n    _getSvgFromConfig(config) {\n        if (config.svgText) {\n            // We already have the SVG element for this icon, return a copy.\n            return of(cloneSvg(this._svgElementFromConfig(config)));\n        }\n        else {\n            // Fetch the icon from the config's URL, cache it, and return a copy.\n            return this._loadSvgIconFromConfig(config).pipe(map(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     */\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        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        const iconSetFetchRequests = iconSetConfigs\n            .filter(iconSetConfig => !iconSetConfig.svgText)\n            .map(iconSetConfig => {\n            return this._loadSvgIconSetFromConfig(iconSetConfig).pipe(catchError((err) => {\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                const errorMessage = `Loading icon set URL: ${url} failed: ${err.message}`;\n                this._errorHandler.handleError(new Error(errorMessage));\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            const foundIcon = this._extractIconWithNameFromAnySet(name, iconSetConfigs);\n            // TODO: add an ngDevMode check\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     */\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            const config = iconSetConfigs[i];\n            // Parsing the icon set's text into an SVG element can be expensive. We can avoid some of\n            // the parsing by doing a quick check using `indexOf` to see if there's any chance for the\n            // icon to be in the set. This won't be 100% accurate, but it should help us avoid at least\n            // some of the parsing.\n            if (config.svgText && config.svgText.toString().indexOf(iconName) > -1) {\n                const svg = this._svgElementFromConfig(config);\n                const foundIcon = this._extractSvgIconFromSet(svg, 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     */\n    _loadSvgIconFromConfig(config) {\n        return this._fetchIcon(config).pipe(tap(svgText => (config.svgText = svgText)), map(() => this._svgElementFromConfig(config)));\n    }\n    /**\n     * Loads the content of the icon set URL specified in the\n     * SvgIconConfig and attaches it to the config.\n     */\n    _loadSvgIconSetFromConfig(config) {\n        if (config.svgText) {\n            return of(null);\n        }\n        return this._fetchIcon(config).pipe(tap(svgText => (config.svgText = svgText)));\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     */\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        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        const iconElement = 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(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        const svg = this._svgElementFromString(trustedHTMLFromString('<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     */\n    _svgElementFromString(str) {\n        const div = this._document.createElement('DIV');\n        div.innerHTML = str;\n        const svg = div.querySelector('svg');\n        // TODO: add an ngDevMode check\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     */\n    _toSvgElement(element) {\n        const svg = this._svgElementFromString(trustedHTMLFromString('<svg></svg>'));\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     */\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 icon. Results may be\n     * cached, so future calls with the same URL may not cause another HTTP request.\n     */\n    _fetchIcon(iconConfig) {\n        const { url: safeUrl, options } = iconConfig;\n        const withCredentials = options?.withCredentials ?? false;\n        if (!this._httpClient) {\n            throw getMatIconNoHttpProviderError();\n        }\n        // TODO: add an ngDevMode check\n        if (safeUrl == null) {\n            throw Error(`Cannot fetch icon from URL \"${safeUrl}\".`);\n        }\n        const url = this._sanitizer.sanitize(SecurityContext.RESOURCE_URL, safeUrl);\n        // TODO: add an ngDevMode check\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        const inProgressFetch = this._inProgressUrlFetches.get(url);\n        if (inProgressFetch) {\n            return inProgressFetch;\n        }\n        const req = this._httpClient.get(url, { responseType: 'text', withCredentials }).pipe(map(svg => {\n            // Security: This SVG is fetched from a SafeResourceUrl, and is thus\n            // trusted HTML.\n            return trustedHTMLFromString(svg);\n        }), finalize(() => 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     * @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     */\n    _addSvgIconConfig(namespace, iconName, config) {\n        this._svgIconConfigs.set(iconKey(namespace, iconName), config);\n        return this;\n    }\n    /**\n     * Registers an icon set config in the specified namespace.\n     * @param namespace Namespace in which to register the icon config.\n     * @param config Config to be registered.\n     */\n    _addSvgIconSetConfig(namespace, config) {\n        const configNamespace = this._iconSetConfigs.get(namespace);\n        if (configNamespace) {\n            configNamespace.push(config);\n        }\n        else {\n            this._iconSetConfigs.set(namespace, [config]);\n        }\n        return this;\n    }\n    /** Parses a config's text into an SVG element. */\n    _svgElementFromConfig(config) {\n        if (!config.svgElement) {\n            const svg = this._svgElementFromString(config.svgText);\n            this._setSvgAttributes(svg, config.options);\n            config.svgElement = svg;\n        }\n        return config.svgElement;\n    }\n    /** Tries to create an icon config through the registered resolver functions. */\n    _getIconConfigFromResolvers(namespace, name) {\n        for (let i = 0; i < this._resolvers.length; i++) {\n            const result = this._resolvers[i](name, namespace);\n            if (result) {\n                return isSafeUrlWithOptions(result)\n                    ? new SvgIconConfig(result.url, null, result.options)\n                    : new SvgIconConfig(result, null);\n            }\n        }\n        return undefined;\n    }\n}\nMatIconRegistry.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIconRegistry, deps: [{ token: i1.HttpClient, optional: true }, { token: i2.DomSanitizer }, { token: DOCUMENT, optional: true }, { token: i0.ErrorHandler }], target: i0.ɵɵFactoryTarget.Injectable });\nMatIconRegistry.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIconRegistry, providedIn: 'root' });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIconRegistry, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: i1.HttpClient, decorators: [{\n                    type: Optional\n                }] }, { type: i2.DomSanitizer }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: i0.ErrorHandler }]; } });\n/** @docs-private */\nfunction ICON_REGISTRY_PROVIDER_FACTORY(parentRegistry, httpClient, sanitizer, errorHandler, document) {\n    return parentRegistry || new MatIconRegistry(httpClient, sanitizer, document, errorHandler);\n}\n/** @docs-private */\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        ErrorHandler,\n        [new Optional(), DOCUMENT],\n    ],\n    useFactory: ICON_REGISTRY_PROVIDER_FACTORY,\n};\n/** Clones an SVGElement while preserving type information. */\nfunction cloneSvg(svg) {\n    return svg.cloneNode(true);\n}\n/** Returns the cache key to use for an icon namespace and name. */\nfunction iconKey(namespace, name) {\n    return namespace + ':' + name;\n}\nfunction isSafeUrlWithOptions(value) {\n    return !!(value.url && value.options);\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// Boilerplate for applying mixins to MatIcon.\n/** @docs-private */\nconst _MatIconBase = mixinColor(class {\n    constructor(_elementRef) {\n        this._elementRef = _elementRef;\n    }\n});\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 */\nconst MAT_ICON_LOCATION = new InjectionToken('mat-icon-location', {\n    providedIn: 'root',\n    factory: MAT_ICON_LOCATION_FACTORY,\n});\n/** @docs-private */\nfunction MAT_ICON_LOCATION_FACTORY() {\n    const _document = inject(DOCUMENT);\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: () => (_location ? _location.pathname + _location.search : ''),\n    };\n}\n/** SVG attributes that accept a FuncIRI (e.g. `url(<something>)`). */\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];\n/** Selector that can be used to find all elements that are using a `FuncIRI`. */\nconst funcIriAttributeSelector = funcIriAttributes.map(attr => `[${attr}]`).join(', ');\n/** Regex that can be used to extract the id out of a FuncIRI. */\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 _MatIconBase {\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        /** Subscription to the current in-progress SVG icon request. */\n        this._currentIconFetch = Subscription.EMPTY;\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     */\n    get inline() {\n        return this._inline;\n    }\n    set inline(inline) {\n        this._inline = coerceBooleanProperty(inline);\n    }\n    /** Name of the icon in the SVG icon set. */\n    get svgIcon() {\n        return this._svgIcon;\n    }\n    set svgIcon(value) {\n        if (value !== this._svgIcon) {\n            if (value) {\n                this._updateSvgIcon(value);\n            }\n            else if (this._svgIcon) {\n                this._clearSvgElement();\n            }\n            this._svgIcon = value;\n        }\n    }\n    /** Font set that the icon is a part of. */\n    get fontSet() {\n        return this._fontSet;\n    }\n    set fontSet(value) {\n        const newValue = this._cleanupFontValue(value);\n        if (newValue !== this._fontSet) {\n            this._fontSet = newValue;\n            this._updateFontIconClasses();\n        }\n    }\n    /** Name of an icon within a font set. */\n    get fontIcon() {\n        return this._fontIcon;\n    }\n    set fontIcon(value) {\n        const newValue = this._cleanupFontValue(value);\n        if (newValue !== this._fontIcon) {\n            this._fontIcon = newValue;\n            this._updateFontIconClasses();\n        }\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     */\n    _splitIconName(iconName) {\n        if (!iconName) {\n            return ['', ''];\n        }\n        const parts = iconName.split(':');\n        switch (parts.length) {\n            case 1:\n                return ['', parts[0]]; // Use default namespace.\n            case 2:\n                return parts;\n            default:\n                throw Error(`Invalid icon name: \"${iconName}\"`); // TODO: add an ngDevMode check\n        }\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        this._updateFontIconClasses();\n    }\n    ngAfterViewChecked() {\n        const cachedElements = this._elementsWithExternalReferences;\n        if (cachedElements && cachedElements.size) {\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    ngOnDestroy() {\n        this._currentIconFetch.unsubscribe();\n        if (this._elementsWithExternalReferences) {\n            this._elementsWithExternalReferences.clear();\n        }\n    }\n    _usingFontIcon() {\n        return !this.svgIcon;\n    }\n    _setSvgElement(svg) {\n        this._clearSvgElement();\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        const path = this._location.getPathname();\n        this._previousPath = path;\n        this._cacheChildrenWithExternalReferences(svg);\n        this._prependPathToReferences(path);\n        this._elementRef.nativeElement.appendChild(svg);\n    }\n    _clearSvgElement() {\n        const layoutElement = this._elementRef.nativeElement;\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            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                child.remove();\n            }\n        }\n    }\n    _updateFontIconClasses() {\n        if (!this._usingFontIcon()) {\n            return;\n        }\n        const elem = this._elementRef.nativeElement;\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     */\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     */\n    _prependPathToReferences(path) {\n        const elements = this._elementsWithExternalReferences;\n        if (elements) {\n            elements.forEach((attrs, element) => {\n                attrs.forEach(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     */\n    _cacheChildrenWithExternalReferences(element) {\n        const elementsWithFuncIri = element.querySelectorAll(funcIriAttributeSelector);\n        const elements = (this._elementsWithExternalReferences =\n            this._elementsWithExternalReferences || new Map());\n        for (let i = 0; i < elementsWithFuncIri.length; i++) {\n            funcIriAttributes.forEach(attr => {\n                const elementWithReference = elementsWithFuncIri[i];\n                const value = elementWithReference.getAttribute(attr);\n                const match = value ? value.match(funcIriPattern) : null;\n                if (match) {\n                    let attributes = elements.get(elementWithReference);\n                    if (!attributes) {\n                        attributes = [];\n                        elements.set(elementWithReference, attributes);\n                    }\n                    attributes.push({ name: attr, value: match[1] });\n                }\n            });\n        }\n    }\n    /** Sets a new SVG icon with a particular name. */\n    _updateSvgIcon(rawName) {\n        this._svgNamespace = null;\n        this._svgName = null;\n        this._currentIconFetch.unsubscribe();\n        if (rawName) {\n            const [namespace, iconName] = this._splitIconName(rawName);\n            if (namespace) {\n                this._svgNamespace = namespace;\n            }\n            if (iconName) {\n                this._svgName = iconName;\n            }\n            this._currentIconFetch = this._iconRegistry\n                .getNamedSvgIcon(iconName, namespace)\n                .pipe(take(1))\n                .subscribe(svg => this._setSvgElement(svg), (err) => {\n                const errorMessage = `Error retrieving icon ${namespace}:${iconName}! ${err.message}`;\n                this._errorHandler.handleError(new Error(errorMessage));\n            });\n        }\n    }\n}\nMatIcon.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIcon, deps: [{ token: i0.ElementRef }, { token: MatIconRegistry }, { token: 'aria-hidden', attribute: true }, { token: MAT_ICON_LOCATION }, { token: i0.ErrorHandler }], target: i0.ɵɵFactoryTarget.Component });\nMatIcon.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatIcon, selector: \"mat-icon\", inputs: { color: \"color\", inline: \"inline\", svgIcon: \"svgIcon\", fontSet: \"fontSet\", fontIcon: \"fontIcon\" }, host: { attributes: { \"role\": \"img\" }, properties: { \"attr.data-mat-icon-type\": \"_usingFontIcon() ? \\\"font\\\" : \\\"svg\\\"\", \"attr.data-mat-icon-name\": \"_svgName || fontIcon\", \"attr.data-mat-icon-namespace\": \"_svgNamespace || fontSet\", \"class.mat-icon-inline\": \"inline\", \"class.mat-icon-no-color\": \"color !== \\\"primary\\\" && color !== \\\"accent\\\" && color !== \\\"warn\\\"\" }, classAttribute: \"mat-icon notranslate\" }, exportAs: [\"matIcon\"], usesInheritance: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, styles: [\".mat-icon{-webkit-user-select:none;user-select:none;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\"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIcon, decorators: [{\n            type: Component,\n            args: [{ template: '<ng-content></ng-content>', selector: 'mat-icon', exportAs: 'matIcon', inputs: ['color'], host: {\n                        'role': 'img',\n                        'class': 'mat-icon notranslate',\n                        '[attr.data-mat-icon-type]': '_usingFontIcon() ? \"font\" : \"svg\"',\n                        '[attr.data-mat-icon-name]': '_svgName || fontIcon',\n                        '[attr.data-mat-icon-namespace]': '_svgNamespace || fontSet',\n                        '[class.mat-icon-inline]': 'inline',\n                        '[class.mat-icon-no-color]': 'color !== \"primary\" && color !== \"accent\" && color !== \"warn\"',\n                    }, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, styles: [\".mat-icon{-webkit-user-select:none;user-select:none;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        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: MatIconRegistry }, { type: undefined, decorators: [{\n                    type: Attribute,\n                    args: ['aria-hidden']\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_ICON_LOCATION]\n                }] }, { type: i0.ErrorHandler }]; }, propDecorators: { inline: [{\n                type: Input\n            }], svgIcon: [{\n                type: Input\n            }], fontSet: [{\n                type: Input\n            }], fontIcon: [{\n                type: Input\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatIconModule {\n}\nMatIconModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIconModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatIconModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIconModule, declarations: [MatIcon], imports: [MatCommonModule], exports: [MatIcon, MatCommonModule] });\nMatIconModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIconModule, imports: [[MatCommonModule], MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIconModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [MatCommonModule],\n                    exports: [MatIcon, MatCommonModule],\n                    declarations: [MatIcon],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { ICON_REGISTRY_PROVIDER, ICON_REGISTRY_PROVIDER_FACTORY, MAT_ICON_LOCATION, MAT_ICON_LOCATION_FACTORY, MatIcon, MatIconModule, MatIconRegistry, getMatIconFailedToSanitizeLiteralError, getMatIconFailedToSanitizeUrlError, getMatIconNameNotFoundError, getMatIconNoHttpProviderError };\n","import * as i1 from '@angular/cdk/platform';\nimport { normalizePassiveListenerOptions } from '@angular/cdk/platform';\nimport * as i0 from '@angular/core';\nimport { Injectable, EventEmitter, Directive, Output, Optional, Inject, Input, NgModule } from '@angular/core';\nimport { coerceElement, coerceNumberProperty, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { EMPTY, Subject, fromEvent } from 'rxjs';\nimport { auditTime, takeUntil } from 'rxjs/operators';\nimport { DOCUMENT } from '@angular/common';\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/** Options to pass to the animationstart listener. */\nconst listenerOptions = normalizePassiveListenerOptions({ passive: true });\n/**\n * An injectable service that can be used to monitor the autofill state of an input.\n * Based on the following blog post:\n * https://medium.com/@brunn/detecting-autofilled-fields-in-javascript-aed598d25da7\n */\nclass AutofillMonitor {\n    constructor(_platform, _ngZone) {\n        this._platform = _platform;\n        this._ngZone = _ngZone;\n        this._monitoredElements = new Map();\n    }\n    monitor(elementOrRef) {\n        if (!this._platform.isBrowser) {\n            return EMPTY;\n        }\n        const element = coerceElement(elementOrRef);\n        const info = this._monitoredElements.get(element);\n        if (info) {\n            return info.subject;\n        }\n        const result = new Subject();\n        const cssClass = 'cdk-text-field-autofilled';\n        const listener = ((event) => {\n            // Animation events fire on initial element render, we check for the presence of the autofill\n            // CSS class to make sure this is a real change in state, not just the initial render before\n            // we fire off events.\n            if (event.animationName === 'cdk-text-field-autofill-start' &&\n                !element.classList.contains(cssClass)) {\n                element.classList.add(cssClass);\n                this._ngZone.run(() => result.next({ target: event.target, isAutofilled: true }));\n            }\n            else if (event.animationName === 'cdk-text-field-autofill-end' &&\n                element.classList.contains(cssClass)) {\n                element.classList.remove(cssClass);\n                this._ngZone.run(() => result.next({ target: event.target, isAutofilled: false }));\n            }\n        });\n        this._ngZone.runOutsideAngular(() => {\n            element.addEventListener('animationstart', listener, listenerOptions);\n            element.classList.add('cdk-text-field-autofill-monitored');\n        });\n        this._monitoredElements.set(element, {\n            subject: result,\n            unlisten: () => {\n                element.removeEventListener('animationstart', listener, listenerOptions);\n            },\n        });\n        return result;\n    }\n    stopMonitoring(elementOrRef) {\n        const element = coerceElement(elementOrRef);\n        const info = this._monitoredElements.get(element);\n        if (info) {\n            info.unlisten();\n            info.subject.complete();\n            element.classList.remove('cdk-text-field-autofill-monitored');\n            element.classList.remove('cdk-text-field-autofilled');\n            this._monitoredElements.delete(element);\n        }\n    }\n    ngOnDestroy() {\n        this._monitoredElements.forEach((_info, element) => this.stopMonitoring(element));\n    }\n}\nAutofillMonitor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: AutofillMonitor, deps: [{ token: i1.Platform }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });\nAutofillMonitor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: AutofillMonitor, providedIn: 'root' });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: AutofillMonitor, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: i1.Platform }, { type: i0.NgZone }]; } });\n/** A directive that can be used to monitor the autofill state of an input. */\nclass CdkAutofill {\n    constructor(_elementRef, _autofillMonitor) {\n        this._elementRef = _elementRef;\n        this._autofillMonitor = _autofillMonitor;\n        /** Emits when the autofill state of the element changes. */\n        this.cdkAutofill = new EventEmitter();\n    }\n    ngOnInit() {\n        this._autofillMonitor\n            .monitor(this._elementRef)\n            .subscribe(event => this.cdkAutofill.emit(event));\n    }\n    ngOnDestroy() {\n        this._autofillMonitor.stopMonitoring(this._elementRef);\n    }\n}\nCdkAutofill.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkAutofill, deps: [{ token: i0.ElementRef }, { token: AutofillMonitor }], target: i0.ɵɵFactoryTarget.Directive });\nCdkAutofill.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkAutofill, selector: \"[cdkAutofill]\", outputs: { cdkAutofill: \"cdkAutofill\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkAutofill, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdkAutofill]',\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: AutofillMonitor }]; }, propDecorators: { cdkAutofill: [{\n                type: Output\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/** Directive to automatically resize a textarea to fit its content. */\nclass CdkTextareaAutosize {\n    constructor(_elementRef, _platform, _ngZone, \n    /** @breaking-change 11.0.0 make document required */\n    document) {\n        this._elementRef = _elementRef;\n        this._platform = _platform;\n        this._ngZone = _ngZone;\n        this._destroyed = new Subject();\n        this._enabled = true;\n        /**\n         * Value of minRows as of last resize. If the minRows has decreased, the\n         * height of the textarea needs to be recomputed to reflect the new minimum. The maxHeight\n         * does not have the same problem because it does not affect the textarea's scrollHeight.\n         */\n        this._previousMinRows = -1;\n        this._isViewInited = false;\n        /** Handles `focus` and `blur` events. */\n        this._handleFocusEvent = (event) => {\n            this._hasFocus = event.type === 'focus';\n        };\n        this._document = document;\n        this._textareaElement = this._elementRef.nativeElement;\n    }\n    /** Minimum amount of rows in the textarea. */\n    get minRows() {\n        return this._minRows;\n    }\n    set minRows(value) {\n        this._minRows = coerceNumberProperty(value);\n        this._setMinHeight();\n    }\n    /** Maximum amount of rows in the textarea. */\n    get maxRows() {\n        return this._maxRows;\n    }\n    set maxRows(value) {\n        this._maxRows = coerceNumberProperty(value);\n        this._setMaxHeight();\n    }\n    /** Whether autosizing is enabled or not */\n    get enabled() {\n        return this._enabled;\n    }\n    set enabled(value) {\n        value = coerceBooleanProperty(value);\n        // Only act if the actual value changed. This specifically helps to not run\n        // resizeToFitContent too early (i.e. before ngAfterViewInit)\n        if (this._enabled !== value) {\n            (this._enabled = value) ? this.resizeToFitContent(true) : this.reset();\n        }\n    }\n    get placeholder() {\n        return this._textareaElement.placeholder;\n    }\n    set placeholder(value) {\n        this._cachedPlaceholderHeight = undefined;\n        if (value) {\n            this._textareaElement.setAttribute('placeholder', value);\n        }\n        else {\n            this._textareaElement.removeAttribute('placeholder');\n        }\n        this._cacheTextareaPlaceholderHeight();\n    }\n    /** Sets the minimum height of the textarea as determined by minRows. */\n    _setMinHeight() {\n        const minHeight = this.minRows && this._cachedLineHeight ? `${this.minRows * this._cachedLineHeight}px` : null;\n        if (minHeight) {\n            this._textareaElement.style.minHeight = minHeight;\n        }\n    }\n    /** Sets the maximum height of the textarea as determined by maxRows. */\n    _setMaxHeight() {\n        const maxHeight = this.maxRows && this._cachedLineHeight ? `${this.maxRows * this._cachedLineHeight}px` : null;\n        if (maxHeight) {\n            this._textareaElement.style.maxHeight = maxHeight;\n        }\n    }\n    ngAfterViewInit() {\n        if (this._platform.isBrowser) {\n            // Remember the height which we started with in case autosizing is disabled\n            this._initialHeight = this._textareaElement.style.height;\n            this.resizeToFitContent();\n            this._ngZone.runOutsideAngular(() => {\n                const window = this._getWindow();\n                fromEvent(window, 'resize')\n                    .pipe(auditTime(16), takeUntil(this._destroyed))\n                    .subscribe(() => this.resizeToFitContent(true));\n                this._textareaElement.addEventListener('focus', this._handleFocusEvent);\n                this._textareaElement.addEventListener('blur', this._handleFocusEvent);\n            });\n            this._isViewInited = true;\n            this.resizeToFitContent(true);\n        }\n    }\n    ngOnDestroy() {\n        this._textareaElement.removeEventListener('focus', this._handleFocusEvent);\n        this._textareaElement.removeEventListener('blur', this._handleFocusEvent);\n        this._destroyed.next();\n        this._destroyed.complete();\n    }\n    /**\n     * Cache the height of a single-row textarea if it has not already been cached.\n     *\n     * We need to know how large a single \"row\" of a textarea is in order to apply minRows and\n     * maxRows. For the initial version, we will assume that the height of a single line in the\n     * textarea does not ever change.\n     */\n    _cacheTextareaLineHeight() {\n        if (this._cachedLineHeight) {\n            return;\n        }\n        // Use a clone element because we have to override some styles.\n        let textareaClone = this._textareaElement.cloneNode(false);\n        textareaClone.rows = 1;\n        // Use `position: absolute` so that this doesn't cause a browser layout and use\n        // `visibility: hidden` so that nothing is rendered. Clear any other styles that\n        // would affect the height.\n        textareaClone.style.position = 'absolute';\n        textareaClone.style.visibility = 'hidden';\n        textareaClone.style.border = 'none';\n        textareaClone.style.padding = '0';\n        textareaClone.style.height = '';\n        textareaClone.style.minHeight = '';\n        textareaClone.style.maxHeight = '';\n        // In Firefox it happens that textarea elements are always bigger than the specified amount\n        // of rows. This is because Firefox tries to add extra space for the horizontal scrollbar.\n        // As a workaround that removes the extra space for the scrollbar, we can just set overflow\n        // to hidden. This ensures that there is no invalid calculation of the line height.\n        // See Firefox bug report: https://bugzilla.mozilla.org/show_bug.cgi?id=33654\n        textareaClone.style.overflow = 'hidden';\n        this._textareaElement.parentNode.appendChild(textareaClone);\n        this._cachedLineHeight = textareaClone.clientHeight;\n        textareaClone.remove();\n        // Min and max heights have to be re-calculated if the cached line height changes\n        this._setMinHeight();\n        this._setMaxHeight();\n    }\n    _measureScrollHeight() {\n        const element = this._textareaElement;\n        const previousMargin = element.style.marginBottom || '';\n        const isFirefox = this._platform.FIREFOX;\n        const needsMarginFiller = isFirefox && this._hasFocus;\n        const measuringClass = isFirefox\n            ? 'cdk-textarea-autosize-measuring-firefox'\n            : 'cdk-textarea-autosize-measuring';\n        // In some cases the page might move around while we're measuring the `textarea` on Firefox. We\n        // work around it by assigning a temporary margin with the same height as the `textarea` so that\n        // it occupies the same amount of space. See #23233.\n        if (needsMarginFiller) {\n            element.style.marginBottom = `${element.clientHeight}px`;\n        }\n        // Reset the textarea height to auto in order to shrink back to its default size.\n        // Also temporarily force overflow:hidden, so scroll bars do not interfere with calculations.\n        element.classList.add(measuringClass);\n        // The measuring class includes a 2px padding to workaround an issue with Chrome,\n        // so we account for that extra space here by subtracting 4 (2px top + 2px bottom).\n        const scrollHeight = element.scrollHeight - 4;\n        element.classList.remove(measuringClass);\n        if (needsMarginFiller) {\n            element.style.marginBottom = previousMargin;\n        }\n        return scrollHeight;\n    }\n    _cacheTextareaPlaceholderHeight() {\n        if (!this._isViewInited || this._cachedPlaceholderHeight != undefined) {\n            return;\n        }\n        if (!this.placeholder) {\n            this._cachedPlaceholderHeight = 0;\n            return;\n        }\n        const value = this._textareaElement.value;\n        this._textareaElement.value = this._textareaElement.placeholder;\n        this._cachedPlaceholderHeight = this._measureScrollHeight();\n        this._textareaElement.value = value;\n    }\n    ngDoCheck() {\n        if (this._platform.isBrowser) {\n            this.resizeToFitContent();\n        }\n    }\n    /**\n     * Resize the textarea to fit its content.\n     * @param force Whether to force a height recalculation. By default the height will be\n     *    recalculated only if the value changed since the last call.\n     */\n    resizeToFitContent(force = false) {\n        // If autosizing is disabled, just skip everything else\n        if (!this._enabled) {\n            return;\n        }\n        this._cacheTextareaLineHeight();\n        this._cacheTextareaPlaceholderHeight();\n        // If we haven't determined the line-height yet, we know we're still hidden and there's no point\n        // in checking the height of the textarea.\n        if (!this._cachedLineHeight) {\n            return;\n        }\n        const textarea = this._elementRef.nativeElement;\n        const value = textarea.value;\n        // Only resize if the value or minRows have changed since these calculations can be expensive.\n        if (!force && this._minRows === this._previousMinRows && value === this._previousValue) {\n            return;\n        }\n        const scrollHeight = this._measureScrollHeight();\n        const height = Math.max(scrollHeight, this._cachedPlaceholderHeight || 0);\n        // Use the scrollHeight to know how large the textarea *would* be if fit its entire value.\n        textarea.style.height = `${height}px`;\n        this._ngZone.runOutsideAngular(() => {\n            if (typeof requestAnimationFrame !== 'undefined') {\n                requestAnimationFrame(() => this._scrollToCaretPosition(textarea));\n            }\n            else {\n                setTimeout(() => this._scrollToCaretPosition(textarea));\n            }\n        });\n        this._previousValue = value;\n        this._previousMinRows = this._minRows;\n    }\n    /**\n     * Resets the textarea to its original size\n     */\n    reset() {\n        // Do not try to change the textarea, if the initialHeight has not been determined yet\n        // This might potentially remove styles when reset() is called before ngAfterViewInit\n        if (this._initialHeight !== undefined) {\n            this._textareaElement.style.height = this._initialHeight;\n        }\n    }\n    _noopInputHandler() {\n        // no-op handler that ensures we're running change detection on input events.\n    }\n    /** Access injected document if available or fallback to global document reference */\n    _getDocument() {\n        return this._document || document;\n    }\n    /** Use defaultView of injected document if available or fallback to global window reference */\n    _getWindow() {\n        const doc = this._getDocument();\n        return doc.defaultView || window;\n    }\n    /**\n     * Scrolls a textarea to the caret position. On Firefox resizing the textarea will\n     * prevent it from scrolling to the caret position. We need to re-set the selection\n     * in order for it to scroll to the proper position.\n     */\n    _scrollToCaretPosition(textarea) {\n        const { selectionStart, selectionEnd } = textarea;\n        // IE will throw an \"Unspecified error\" if we try to set the selection range after the\n        // element has been removed from the DOM. Assert that the directive hasn't been destroyed\n        // between the time we requested the animation frame and when it was executed.\n        // Also note that we have to assert that the textarea is focused before we set the\n        // selection range. Setting the selection range on a non-focused textarea will cause\n        // it to receive focus on IE and Edge.\n        if (!this._destroyed.isStopped && this._hasFocus) {\n            textarea.setSelectionRange(selectionStart, selectionEnd);\n        }\n    }\n}\nCdkTextareaAutosize.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkTextareaAutosize, deps: [{ token: i0.ElementRef }, { token: i1.Platform }, { token: i0.NgZone }, { token: DOCUMENT, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nCdkTextareaAutosize.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkTextareaAutosize, selector: \"textarea[cdkTextareaAutosize]\", inputs: { minRows: [\"cdkAutosizeMinRows\", \"minRows\"], maxRows: [\"cdkAutosizeMaxRows\", \"maxRows\"], enabled: [\"cdkTextareaAutosize\", \"enabled\"], placeholder: \"placeholder\" }, host: { attributes: { \"rows\": \"1\" }, listeners: { \"input\": \"_noopInputHandler()\" }, classAttribute: \"cdk-textarea-autosize\" }, exportAs: [\"cdkTextareaAutosize\"], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkTextareaAutosize, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'textarea[cdkTextareaAutosize]',\n                    exportAs: 'cdkTextareaAutosize',\n                    host: {\n                        'class': 'cdk-textarea-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                        '(input)': '_noopInputHandler()',\n                    },\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.Platform }, { type: i0.NgZone }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }]; }, propDecorators: { minRows: [{\n                type: Input,\n                args: ['cdkAutosizeMinRows']\n            }], maxRows: [{\n                type: Input,\n                args: ['cdkAutosizeMaxRows']\n            }], enabled: [{\n                type: Input,\n                args: ['cdkTextareaAutosize']\n            }], placeholder: [{\n                type: Input\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass TextFieldModule {\n}\nTextFieldModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: TextFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nTextFieldModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: TextFieldModule, declarations: [CdkAutofill, CdkTextareaAutosize], exports: [CdkAutofill, CdkTextareaAutosize] });\nTextFieldModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: TextFieldModule });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: TextFieldModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    declarations: [CdkAutofill, CdkTextareaAutosize],\n                    exports: [CdkAutofill, CdkTextareaAutosize],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { AutofillMonitor, CdkAutofill, CdkTextareaAutosize, TextFieldModule };\n","import { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport * as i1 from '@angular/cdk/platform';\nimport { getSupportedInputTypes } from '@angular/cdk/platform';\nimport * as i4 from '@angular/cdk/text-field';\nimport { TextFieldModule } from '@angular/cdk/text-field';\nimport * as i0 from '@angular/core';\nimport { InjectionToken, Directive, Optional, Self, Inject, Input, NgModule } from '@angular/core';\nimport * as i2 from '@angular/forms';\nimport { Validators } from '@angular/forms';\nimport * as i3 from '@angular/material/core';\nimport { mixinErrorState, MatCommonModule, ErrorStateMatcher } from '@angular/material/core';\nimport * as i5 from '@angular/material/form-field';\nimport { MAT_FORM_FIELD, MatFormFieldControl, MatFormFieldModule } from '@angular/material/form-field';\nimport { Subject } from 'rxjs';\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/** @docs-private */\nfunction getMatInputUnsupportedTypeError(type) {\n    return Error(`Input type \"${type}\" isn't supported by matInput.`);\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 * 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 */\nconst MAT_INPUT_VALUE_ACCESSOR = new InjectionToken('MAT_INPUT_VALUE_ACCESSOR');\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// Invalid input type. Using one of these will throw an MatInputUnsupportedTypeError.\nconst MAT_INPUT_INVALID_TYPES = [\n    'button',\n    'checkbox',\n    'file',\n    'hidden',\n    'image',\n    'radio',\n    'range',\n    'reset',\n    'submit',\n];\nlet nextUniqueId = 0;\n// Boilerplate for applying mixins to MatInput.\n/** @docs-private */\nconst _MatInputBase = mixinErrorState(class {\n    constructor(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, \n    /** @docs-private */\n    ngControl) {\n        this._defaultErrorStateMatcher = _defaultErrorStateMatcher;\n        this._parentForm = _parentForm;\n        this._parentFormGroup = _parentFormGroup;\n        this.ngControl = ngControl;\n    }\n});\n/** Directive that allows a native input to work inside a `MatFormField`. */\nclass MatInput extends _MatInputBase {\n    constructor(_elementRef, _platform, ngControl, _parentForm, _parentFormGroup, _defaultErrorStateMatcher, inputValueAccessor, _autofillMonitor, ngZone, \n    // TODO: Remove this once the legacy appearance has been removed. We only need\n    // to inject the form-field for determining whether the placeholder has been promoted.\n    _formField) {\n        super(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl);\n        this._elementRef = _elementRef;\n        this._platform = _platform;\n        this._autofillMonitor = _autofillMonitor;\n        this._formField = _formField;\n        this._uid = `mat-input-${nextUniqueId++}`;\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._type = 'text';\n        this._readonly = false;\n        this._neverEmptyInputTypes = [\n            'date',\n            'datetime',\n            'datetime-local',\n            'month',\n            'time',\n            'week',\n        ].filter(t => getSupportedInputTypes().has(t));\n        this._iOSKeyupListener = (event) => {\n            const el = event.target;\n            // Note: We specifically check for 0, rather than `!el.selectionStart`, because the two\n            // indicate different things. If the value is 0, it means that the caret is at the start\n            // of the input, whereas a value of `null` means that the input doesn't support\n            // manipulating the selection range. Inputs that don't support setting the selection range\n            // will throw an error so we want to avoid calling `setSelectionRange` on them. See:\n            // https://html.spec.whatwg.org/multipage/input.html#do-not-apply\n            if (!el.value && el.selectionStart === 0 && el.selectionEnd === 0) {\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        const element = this._elementRef.nativeElement;\n        const nodeName = element.nodeName.toLowerCase();\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                _elementRef.nativeElement.addEventListener('keyup', this._iOSKeyupListener);\n            });\n        }\n        this._isServer = !this._platform.isBrowser;\n        this._isNativeSelect = nodeName === 'select';\n        this._isTextarea = nodeName === 'textarea';\n        this._isInFormField = !!_formField;\n        if (this._isNativeSelect) {\n            this.controlType = element.multiple\n                ? 'mat-native-select-multiple'\n                : 'mat-native-select';\n        }\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get disabled() {\n        if (this.ngControl && this.ngControl.disabled !== null) {\n            return this.ngControl.disabled;\n        }\n        return this._disabled;\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     */\n    get id() {\n        return this._id;\n    }\n    set id(value) {\n        this._id = value || this._uid;\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get required() {\n        return this._required ?? this.ngControl?.control?.hasValidator(Validators.required) ?? false;\n    }\n    set required(value) {\n        this._required = coerceBooleanProperty(value);\n    }\n    /** Input type of the element. */\n    get type() {\n        return this._type;\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            this._elementRef.nativeElement.type = this._type;\n        }\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get value() {\n        return this._inputValueAccessor.value;\n    }\n    set value(value) {\n        if (value !== this.value) {\n            this._inputValueAccessor.value = value;\n            this.stateChanges.next();\n        }\n    }\n    /** Whether the element is readonly. */\n    get readonly() {\n        return this._readonly;\n    }\n    set readonly(value) {\n        this._readonly = coerceBooleanProperty(value);\n    }\n    ngAfterViewInit() {\n        if (this._platform.isBrowser) {\n            this._autofillMonitor.monitor(this._elementRef.nativeElement).subscribe(event => {\n                this.autofilled = event.isAutofilled;\n                this.stateChanges.next();\n            });\n        }\n    }\n    ngOnChanges() {\n        this.stateChanges.next();\n    }\n    ngOnDestroy() {\n        this.stateChanges.complete();\n        if (this._platform.isBrowser) {\n            this._autofillMonitor.stopMonitoring(this._elementRef.nativeElement);\n        }\n        if (this._platform.IOS) {\n            this._elementRef.nativeElement.removeEventListener('keyup', this._iOSKeyupListener);\n        }\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        // We need to dirty-check and set the placeholder attribute ourselves, because whether it's\n        // present or not depends on a query which is prone to \"changed after checked\" errors.\n        this._dirtyCheckPlaceholder();\n    }\n    /** Focuses the input. */\n    focus(options) {\n        this._elementRef.nativeElement.focus(options);\n    }\n    /** Callback for the cases where the focused state of the input changes. */\n    _focusChanged(isFocused) {\n        if (isFocused !== this.focused) {\n            this.focused = isFocused;\n            this.stateChanges.next();\n        }\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    /** Does some manual dirty checking on the native input `placeholder` attribute. */\n    _dirtyCheckPlaceholder() {\n        // If we're hiding the native placeholder, it should also be cleared from the DOM, otherwise\n        // screen readers will read it out twice: once from the label and once from the attribute.\n        // TODO: can be removed once we get rid of the `legacy` style for the form field, because it's\n        // the only one that supports promoting the placeholder to a label.\n        const placeholder = this._formField?._hideControlPlaceholder?.() ? null : this.placeholder;\n        if (placeholder !== this._previousPlaceholder) {\n            const element = this._elementRef.nativeElement;\n            this._previousPlaceholder = placeholder;\n            placeholder\n                ? element.setAttribute('placeholder', placeholder)\n                : element.removeAttribute('placeholder');\n        }\n    }\n    /** Does some manual dirty checking on the native input `value` property. */\n    _dirtyCheckNativeValue() {\n        const newValue = this._elementRef.nativeElement.value;\n        if (this._previousNativeValue !== newValue) {\n            this._previousNativeValue = newValue;\n            this.stateChanges.next();\n        }\n    }\n    /** Make sure the input is a supported type. */\n    _validateType() {\n        if (MAT_INPUT_INVALID_TYPES.indexOf(this._type) > -1 &&\n            (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getMatInputUnsupportedTypeError(this._type);\n        }\n    }\n    /** Checks whether the input type is one of the types that are never empty. */\n    _isNeverEmpty() {\n        return this._neverEmptyInputTypes.indexOf(this._type) > -1;\n    }\n    /** Checks whether the input is invalid based on the native validation. */\n    _isBadInput() {\n        // The `validity` property won't be present on platform-server.\n        let validity = this._elementRef.nativeElement.validity;\n        return validity && validity.badInput;\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get empty() {\n        return (!this._isNeverEmpty() &&\n            !this._elementRef.nativeElement.value &&\n            !this._isBadInput() &&\n            !this.autofilled);\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\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            const selectElement = this._elementRef.nativeElement;\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 ||\n                selectElement.multiple ||\n                !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     */\n    setDescribedByIds(ids) {\n        if (ids.length) {\n            this._elementRef.nativeElement.setAttribute('aria-describedby', ids.join(' '));\n        }\n        else {\n            this._elementRef.nativeElement.removeAttribute('aria-describedby');\n        }\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\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    /** Whether the form control is a native select that is displayed inline. */\n    _isInlineSelect() {\n        const element = this._elementRef.nativeElement;\n        return this._isNativeSelect && (element.multiple || element.size > 1);\n    }\n}\nMatInput.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatInput, deps: [{ token: i0.ElementRef }, { token: i1.Platform }, { token: i2.NgControl, optional: true, self: true }, { token: i2.NgForm, optional: true }, { token: i2.FormGroupDirective, optional: true }, { token: i3.ErrorStateMatcher }, { token: MAT_INPUT_VALUE_ACCESSOR, optional: true, self: true }, { token: i4.AutofillMonitor }, { token: i0.NgZone }, { token: MAT_FORM_FIELD, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nMatInput.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatInput, selector: \"input[matInput], textarea[matInput], select[matNativeControl],\\n      input[matNativeControl], textarea[matNativeControl]\", inputs: { disabled: \"disabled\", id: \"id\", placeholder: \"placeholder\", name: \"name\", required: \"required\", type: \"type\", errorStateMatcher: \"errorStateMatcher\", userAriaDescribedBy: [\"aria-describedby\", \"userAriaDescribedBy\"], value: \"value\", readonly: \"readonly\" }, host: { listeners: { \"focus\": \"_focusChanged(true)\", \"blur\": \"_focusChanged(false)\", \"input\": \"_onInput()\" }, properties: { \"class.mat-input-server\": \"_isServer\", \"attr.id\": \"id\", \"attr.data-placeholder\": \"placeholder\", \"disabled\": \"disabled\", \"required\": \"required\", \"attr.name\": \"name || null\", \"attr.readonly\": \"readonly && !_isNativeSelect || null\", \"class.mat-native-select-inline\": \"_isInlineSelect()\", \"attr.aria-invalid\": \"(empty && required) ? null : errorState\", \"attr.aria-required\": \"required\" }, classAttribute: \"mat-input-element mat-form-field-autofill-control\" }, providers: [{ provide: MatFormFieldControl, useExisting: MatInput }], exportAs: [\"matInput\"], usesInheritance: true, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatInput, decorators: [{\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                        // At the time of writing, we have a lot of customer tests that look up the input based on its\n                        // placeholder. Since we sometimes omit the placeholder attribute from the DOM to prevent screen\n                        // readers from reading it twice, we have to keep it somewhere in the DOM for the lookup.\n                        '[attr.data-placeholder]': 'placeholder',\n                        '[disabled]': 'disabled',\n                        '[required]': 'required',\n                        '[attr.name]': 'name || null',\n                        '[attr.readonly]': 'readonly && !_isNativeSelect || null',\n                        '[class.mat-native-select-inline]': '_isInlineSelect()',\n                        // Only mark the input as invalid for assistive technology if it has a value since the\n                        // state usually overlaps with `aria-required` when the input is empty and can be redundant.\n                        '[attr.aria-invalid]': '(empty && required) ? null : errorState',\n                        '[attr.aria-required]': 'required',\n                        '(focus)': '_focusChanged(true)',\n                        '(blur)': '_focusChanged(false)',\n                        '(input)': '_onInput()',\n                    },\n                    providers: [{ provide: MatFormFieldControl, useExisting: MatInput }],\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.Platform }, { type: i2.NgControl, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }] }, { type: i2.NgForm, decorators: [{\n                    type: Optional\n                }] }, { type: i2.FormGroupDirective, decorators: [{\n                    type: Optional\n                }] }, { type: i3.ErrorStateMatcher }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [MAT_INPUT_VALUE_ACCESSOR]\n                }] }, { type: i4.AutofillMonitor }, { type: i0.NgZone }, { type: i5.MatFormField, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_FORM_FIELD]\n                }] }]; }, propDecorators: { disabled: [{\n                type: Input\n            }], id: [{\n                type: Input\n            }], placeholder: [{\n                type: Input\n            }], name: [{\n                type: Input\n            }], required: [{\n                type: Input\n            }], type: [{\n                type: Input\n            }], errorStateMatcher: [{\n                type: Input\n            }], userAriaDescribedBy: [{\n                type: Input,\n                args: ['aria-describedby']\n            }], value: [{\n                type: Input\n            }], readonly: [{\n                type: Input\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatInputModule {\n}\nMatInputModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatInputModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatInputModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatInputModule, declarations: [MatInput], imports: [TextFieldModule, MatFormFieldModule, MatCommonModule], exports: [TextFieldModule,\n        // We re-export the `MatFormFieldModule` since `MatInput` will almost always\n        // be used together with `MatFormField`.\n        MatFormFieldModule,\n        MatInput] });\nMatInputModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatInputModule, providers: [ErrorStateMatcher], imports: [[TextFieldModule, MatFormFieldModule, MatCommonModule], TextFieldModule,\n        // We re-export the `MatFormFieldModule` since `MatInput` will almost always\n        // be used together with `MatFormField`.\n        MatFormFieldModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatInputModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    declarations: [MatInput],\n                    imports: [TextFieldModule, MatFormFieldModule, MatCommonModule],\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                    ],\n                    providers: [ErrorStateMatcher],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_INPUT_VALUE_ACCESSOR, MatInput, MatInputModule, getMatInputUnsupportedTypeError };\n","import * as i0 from '@angular/core';\nimport { InjectionToken, inject, EventEmitter, Component, ChangeDetectionStrategy, ViewEncapsulation, Optional, Inject, Input, ViewChild, Output, NgModule } from '@angular/core';\nimport * as i1 from '@angular/common';\nimport { DOCUMENT, CommonModule } from '@angular/common';\nimport { mixinColor, MatCommonModule } from '@angular/material/core';\nimport { coerceNumberProperty } from '@angular/cdk/coercion';\nimport { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';\nimport { Subscription, fromEvent } from 'rxjs';\nimport { filter } from 'rxjs/operators';\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// Boilerplate for applying mixins to MatProgressBar.\n/** @docs-private */\nconst _MatProgressBarBase = mixinColor(class {\n    constructor(_elementRef) {\n        this._elementRef = _elementRef;\n    }\n}, 'primary');\n/**\n * Injection token used to provide the current location to `MatProgressBar`.\n * Used to handle server-side rendering and to stub out during unit tests.\n * @docs-private\n */\nconst MAT_PROGRESS_BAR_LOCATION = new InjectionToken('mat-progress-bar-location', { providedIn: 'root', factory: MAT_PROGRESS_BAR_LOCATION_FACTORY });\n/** @docs-private */\nfunction MAT_PROGRESS_BAR_LOCATION_FACTORY() {\n    const _document = inject(DOCUMENT);\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: () => (_location ? _location.pathname + _location.search : ''),\n    };\n}\n/** Injection token to be used to override the default options for `mat-progress-bar`. */\nconst MAT_PROGRESS_BAR_DEFAULT_OPTIONS = new InjectionToken('MAT_PROGRESS_BAR_DEFAULT_OPTIONS');\n/** Counter used to generate unique IDs for progress bars. */\nlet progressbarId = 0;\n/**\n * `<mat-progress-bar>` component.\n */\nclass MatProgressBar extends _MatProgressBarBase {\n    constructor(elementRef, _ngZone, _animationMode, \n    /**\n     * @deprecated `location` parameter to be made required.\n     * @breaking-change 8.0.0\n     */\n    location, defaults, \n    /**\n     * @deprecated `_changeDetectorRef` parameter to be made required.\n     * @breaking-change 11.0.0\n     */\n    _changeDetectorRef) {\n        super(elementRef);\n        this._ngZone = _ngZone;\n        this._animationMode = _animationMode;\n        this._changeDetectorRef = _changeDetectorRef;\n        /** Flag that indicates whether NoopAnimations mode is set to true. */\n        this._isNoopAnimation = false;\n        this._value = 0;\n        this._bufferValue = 0;\n        /**\n         * Event emitted when animation of the primary progress bar completes. This event will not\n         * be emitted when animations are disabled, nor will it be emitted for modes with continuous\n         * animations (indeterminate and query).\n         */\n        this.animationEnd = new EventEmitter();\n        /** Reference to animation end subscription to be unsubscribed on destroy. */\n        this._animationEndSubscription = Subscription.EMPTY;\n        /**\n         * Mode of the progress bar.\n         *\n         * Input must be one of these values: determinate, indeterminate, buffer, query, defaults to\n         * 'determinate'.\n         * Mirrored to mode attribute.\n         */\n        this.mode = 'determinate';\n        /** ID of the progress bar. */\n        this.progressbarId = `mat-progress-bar-${progressbarId++}`;\n        // We need to prefix the SVG reference with the current path, otherwise they won't work\n        // in Safari if the page has a `<base>` tag. Note that we need quotes inside the `url()`,\n        // because named route URLs can contain parentheses (see #12338). Also we don't use `Location`\n        // since we can't tell the difference between whether the consumer is using the hash location\n        // strategy or not, because `Location` normalizes both `/#/foo/bar` and `/foo/bar` to\n        // the same thing.\n        const path = location ? location.getPathname().split('#')[0] : '';\n        this._rectangleFillValue = `url('${path}#${this.progressbarId}')`;\n        this._isNoopAnimation = _animationMode === 'NoopAnimations';\n        if (defaults) {\n            if (defaults.color) {\n                this.color = this.defaultColor = defaults.color;\n            }\n            this.mode = defaults.mode || this.mode;\n        }\n    }\n    /** Value of the progress bar. Defaults to zero. Mirrored to aria-valuenow. */\n    get value() {\n        return this._value;\n    }\n    set value(v) {\n        this._value = clamp(coerceNumberProperty(v) || 0);\n        // @breaking-change 11.0.0 Remove null check for _changeDetectorRef.\n        this._changeDetectorRef?.markForCheck();\n    }\n    /** Buffer value of the progress bar. Defaults to zero. */\n    get bufferValue() {\n        return this._bufferValue;\n    }\n    set bufferValue(v) {\n        this._bufferValue = clamp(v || 0);\n        // @breaking-change 11.0.0 Remove null check for _changeDetectorRef.\n        this._changeDetectorRef?.markForCheck();\n    }\n    /** Gets the current transform value for the progress bar's primary indicator. */\n    _primaryTransform() {\n        // We use a 3d transform to work around some rendering issues in iOS Safari. See #19328.\n        const scale = this.value / 100;\n        return { transform: `scale3d(${scale}, 1, 1)` };\n    }\n    /**\n     * Gets the current transform value for the progress bar's buffer indicator. Only used if the\n     * progress mode is set to buffer, otherwise returns an undefined, causing no transformation.\n     */\n    _bufferTransform() {\n        if (this.mode === 'buffer') {\n            // We use a 3d transform to work around some rendering issues in iOS Safari. See #19328.\n            const scale = this.bufferValue / 100;\n            return { transform: `scale3d(${scale}, 1, 1)` };\n        }\n        return null;\n    }\n    ngAfterViewInit() {\n        // Run outside angular so change detection didn't get triggered on every transition end\n        // instead only on the animation that we care about (primary value bar's transitionend)\n        this._ngZone.runOutsideAngular(() => {\n            const element = this._primaryValueBar.nativeElement;\n            this._animationEndSubscription = fromEvent(element, 'transitionend')\n                .pipe(filter((e) => e.target === element))\n                .subscribe(() => {\n                if (this.animationEnd.observers.length === 0) {\n                    return;\n                }\n                if (this.mode === 'determinate' || this.mode === 'buffer') {\n                    this._ngZone.run(() => this.animationEnd.next({ value: this.value }));\n                }\n            });\n        });\n    }\n    ngOnDestroy() {\n        this._animationEndSubscription.unsubscribe();\n    }\n}\nMatProgressBar.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatProgressBar, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: ANIMATION_MODULE_TYPE, optional: true }, { token: MAT_PROGRESS_BAR_LOCATION, optional: true }, { token: MAT_PROGRESS_BAR_DEFAULT_OPTIONS, optional: true }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });\nMatProgressBar.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatProgressBar, selector: \"mat-progress-bar\", inputs: { color: \"color\", value: \"value\", bufferValue: \"bufferValue\", mode: \"mode\" }, outputs: { animationEnd: \"animationEnd\" }, host: { attributes: { \"role\": \"progressbar\", \"aria-valuemin\": \"0\", \"aria-valuemax\": \"100\", \"tabindex\": \"-1\" }, properties: { \"attr.aria-valuenow\": \"(mode === \\\"indeterminate\\\" || mode === \\\"query\\\") ? null : value\", \"attr.mode\": \"mode\", \"class._mat-animation-noopable\": \"_isNoopAnimation\" }, classAttribute: \"mat-progress-bar\" }, viewQueries: [{ propertyName: \"_primaryValueBar\", first: true, predicate: [\"primaryValueBar\"], descendants: true }], exportAs: [\"matProgressBar\"], usesInheritance: true, ngImport: i0, template: \"<!--\\n  All children need to be hidden for screen readers in order to support ChromeVox.\\n  More context in the issue: https://github.com/angular/components/issues/22165.\\n-->\\n<div aria-hidden=\\\"true\\\">\\n  <svg width=\\\"100%\\\" height=\\\"4\\\" focusable=\\\"false\\\" class=\\\"mat-progress-bar-background mat-progress-bar-element\\\">\\n    <defs>\\n      <pattern [id]=\\\"progressbarId\\\" x=\\\"4\\\" y=\\\"0\\\" width=\\\"8\\\" height=\\\"4\\\" patternUnits=\\\"userSpaceOnUse\\\">\\n        <circle cx=\\\"2\\\" cy=\\\"2\\\" r=\\\"2\\\"/>\\n      </pattern>\\n    </defs>\\n    <rect [attr.fill]=\\\"_rectangleFillValue\\\" width=\\\"100%\\\" height=\\\"100%\\\"/>\\n  </svg>\\n  <!--\\n    The background div is named as such because it appears below the other divs and is not sized based\\n    on values.\\n  -->\\n  <div class=\\\"mat-progress-bar-buffer mat-progress-bar-element\\\" [ngStyle]=\\\"_bufferTransform()\\\"></div>\\n  <div class=\\\"mat-progress-bar-primary mat-progress-bar-fill mat-progress-bar-element\\\" [ngStyle]=\\\"_primaryTransform()\\\" #primaryValueBar></div>\\n  <div class=\\\"mat-progress-bar-secondary mat-progress-bar-fill mat-progress-bar-element\\\"></div>\\n</div>\\n\", styles: [\".mat-progress-bar{display:block;height:4px;overflow:hidden;position:relative;transition:opacity 250ms linear;width:100%}._mat-animation-noopable.mat-progress-bar{transition:none;animation:none}.mat-progress-bar .mat-progress-bar-element,.mat-progress-bar .mat-progress-bar-fill::after{height:100%;position:absolute;width:100%}.mat-progress-bar .mat-progress-bar-background{width:calc(100% + 10px)}.cdk-high-contrast-active .mat-progress-bar .mat-progress-bar-background{display:none}.mat-progress-bar .mat-progress-bar-buffer{transform-origin:top left;transition:transform 250ms ease}.cdk-high-contrast-active .mat-progress-bar .mat-progress-bar-buffer{border-top:solid 5px;opacity:.5}.mat-progress-bar .mat-progress-bar-secondary{display:none}.mat-progress-bar .mat-progress-bar-fill{animation:none;transform-origin:top left;transition:transform 250ms ease}.cdk-high-contrast-active .mat-progress-bar .mat-progress-bar-fill{border-top:solid 4px}.mat-progress-bar .mat-progress-bar-fill::after{animation:none;content:\\\"\\\";display:inline-block;left:0}.mat-progress-bar[dir=rtl],[dir=rtl] .mat-progress-bar{transform:rotateY(180deg)}.mat-progress-bar[mode=query]{transform:rotateZ(180deg)}.mat-progress-bar[mode=query][dir=rtl],[dir=rtl] .mat-progress-bar[mode=query]{transform:rotateZ(180deg) rotateY(180deg)}.mat-progress-bar[mode=indeterminate] .mat-progress-bar-fill,.mat-progress-bar[mode=query] .mat-progress-bar-fill{transition:none}.mat-progress-bar[mode=indeterminate] .mat-progress-bar-primary,.mat-progress-bar[mode=query] .mat-progress-bar-primary{-webkit-backface-visibility:hidden;backface-visibility:hidden;animation:mat-progress-bar-primary-indeterminate-translate 2000ms infinite linear;left:-145.166611%}.mat-progress-bar[mode=indeterminate] .mat-progress-bar-primary.mat-progress-bar-fill::after,.mat-progress-bar[mode=query] .mat-progress-bar-primary.mat-progress-bar-fill::after{-webkit-backface-visibility:hidden;backface-visibility:hidden;animation:mat-progress-bar-primary-indeterminate-scale 2000ms infinite linear}.mat-progress-bar[mode=indeterminate] .mat-progress-bar-secondary,.mat-progress-bar[mode=query] .mat-progress-bar-secondary{-webkit-backface-visibility:hidden;backface-visibility:hidden;animation:mat-progress-bar-secondary-indeterminate-translate 2000ms infinite linear;left:-54.888891%;display:block}.mat-progress-bar[mode=indeterminate] .mat-progress-bar-secondary.mat-progress-bar-fill::after,.mat-progress-bar[mode=query] .mat-progress-bar-secondary.mat-progress-bar-fill::after{-webkit-backface-visibility:hidden;backface-visibility:hidden;animation:mat-progress-bar-secondary-indeterminate-scale 2000ms infinite linear}.mat-progress-bar[mode=buffer] .mat-progress-bar-background{-webkit-backface-visibility:hidden;backface-visibility:hidden;animation:mat-progress-bar-background-scroll 250ms infinite linear;display:block}.mat-progress-bar._mat-animation-noopable .mat-progress-bar-fill,.mat-progress-bar._mat-animation-noopable .mat-progress-bar-fill::after,.mat-progress-bar._mat-animation-noopable .mat-progress-bar-buffer,.mat-progress-bar._mat-animation-noopable .mat-progress-bar-primary,.mat-progress-bar._mat-animation-noopable .mat-progress-bar-primary.mat-progress-bar-fill::after,.mat-progress-bar._mat-animation-noopable .mat-progress-bar-secondary,.mat-progress-bar._mat-animation-noopable .mat-progress-bar-secondary.mat-progress-bar-fill::after,.mat-progress-bar._mat-animation-noopable .mat-progress-bar-background{animation:none;transition-duration:1ms}@keyframes mat-progress-bar-primary-indeterminate-translate{0%{transform:translateX(0)}20%{animation-timing-function:cubic-bezier(0.5, 0, 0.701732, 0.495819);transform:translateX(0)}59.15%{animation-timing-function:cubic-bezier(0.302435, 0.381352, 0.55, 0.956352);transform:translateX(83.67142%)}100%{transform:translateX(200.611057%)}}@keyframes mat-progress-bar-primary-indeterminate-scale{0%{transform:scaleX(0.08)}36.65%{animation-timing-function:cubic-bezier(0.334731, 0.12482, 0.785844, 1);transform:scaleX(0.08)}69.15%{animation-timing-function:cubic-bezier(0.06, 0.11, 0.6, 1);transform:scaleX(0.661479)}100%{transform:scaleX(0.08)}}@keyframes mat-progress-bar-secondary-indeterminate-translate{0%{animation-timing-function:cubic-bezier(0.15, 0, 0.515058, 0.409685);transform:translateX(0)}25%{animation-timing-function:cubic-bezier(0.31033, 0.284058, 0.8, 0.733712);transform:translateX(37.651913%)}48.35%{animation-timing-function:cubic-bezier(0.4, 0.627035, 0.6, 0.902026);transform:translateX(84.386165%)}100%{transform:translateX(160.277782%)}}@keyframes mat-progress-bar-secondary-indeterminate-scale{0%{animation-timing-function:cubic-bezier(0.15, 0, 0.515058, 0.409685);transform:scaleX(0.08)}19.15%{animation-timing-function:cubic-bezier(0.31033, 0.284058, 0.8, 0.733712);transform:scaleX(0.457104)}44.15%{animation-timing-function:cubic-bezier(0.4, 0.627035, 0.6, 0.902026);transform:scaleX(0.72796)}100%{transform:scaleX(0.08)}}@keyframes mat-progress-bar-background-scroll{to{transform:translateX(-8px)}}\\n\"], directives: [{ type: i1.NgStyle, selector: \"[ngStyle]\", inputs: [\"ngStyle\"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatProgressBar, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-progress-bar', exportAs: 'matProgressBar', host: {\n                        'role': 'progressbar',\n                        'aria-valuemin': '0',\n                        'aria-valuemax': '100',\n                        // set tab index to -1 so screen readers will read the aria-label\n                        // Note: there is a known issue with JAWS that does not read progressbar aria labels on FireFox\n                        'tabindex': '-1',\n                        '[attr.aria-valuenow]': '(mode === \"indeterminate\" || mode === \"query\") ? null : value',\n                        '[attr.mode]': 'mode',\n                        'class': 'mat-progress-bar',\n                        '[class._mat-animation-noopable]': '_isNoopAnimation',\n                    }, inputs: ['color'], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: \"<!--\\n  All children need to be hidden for screen readers in order to support ChromeVox.\\n  More context in the issue: https://github.com/angular/components/issues/22165.\\n-->\\n<div aria-hidden=\\\"true\\\">\\n  <svg width=\\\"100%\\\" height=\\\"4\\\" focusable=\\\"false\\\" class=\\\"mat-progress-bar-background mat-progress-bar-element\\\">\\n    <defs>\\n      <pattern [id]=\\\"progressbarId\\\" x=\\\"4\\\" y=\\\"0\\\" width=\\\"8\\\" height=\\\"4\\\" patternUnits=\\\"userSpaceOnUse\\\">\\n        <circle cx=\\\"2\\\" cy=\\\"2\\\" r=\\\"2\\\"/>\\n      </pattern>\\n    </defs>\\n    <rect [attr.fill]=\\\"_rectangleFillValue\\\" width=\\\"100%\\\" height=\\\"100%\\\"/>\\n  </svg>\\n  <!--\\n    The background div is named as such because it appears below the other divs and is not sized based\\n    on values.\\n  -->\\n  <div class=\\\"mat-progress-bar-buffer mat-progress-bar-element\\\" [ngStyle]=\\\"_bufferTransform()\\\"></div>\\n  <div class=\\\"mat-progress-bar-primary mat-progress-bar-fill mat-progress-bar-element\\\" [ngStyle]=\\\"_primaryTransform()\\\" #primaryValueBar></div>\\n  <div class=\\\"mat-progress-bar-secondary mat-progress-bar-fill mat-progress-bar-element\\\"></div>\\n</div>\\n\", styles: [\".mat-progress-bar{display:block;height:4px;overflow:hidden;position:relative;transition:opacity 250ms linear;width:100%}._mat-animation-noopable.mat-progress-bar{transition:none;animation:none}.mat-progress-bar .mat-progress-bar-element,.mat-progress-bar .mat-progress-bar-fill::after{height:100%;position:absolute;width:100%}.mat-progress-bar .mat-progress-bar-background{width:calc(100% + 10px)}.cdk-high-contrast-active .mat-progress-bar .mat-progress-bar-background{display:none}.mat-progress-bar .mat-progress-bar-buffer{transform-origin:top left;transition:transform 250ms ease}.cdk-high-contrast-active .mat-progress-bar .mat-progress-bar-buffer{border-top:solid 5px;opacity:.5}.mat-progress-bar .mat-progress-bar-secondary{display:none}.mat-progress-bar .mat-progress-bar-fill{animation:none;transform-origin:top left;transition:transform 250ms ease}.cdk-high-contrast-active .mat-progress-bar .mat-progress-bar-fill{border-top:solid 4px}.mat-progress-bar .mat-progress-bar-fill::after{animation:none;content:\\\"\\\";display:inline-block;left:0}.mat-progress-bar[dir=rtl],[dir=rtl] .mat-progress-bar{transform:rotateY(180deg)}.mat-progress-bar[mode=query]{transform:rotateZ(180deg)}.mat-progress-bar[mode=query][dir=rtl],[dir=rtl] .mat-progress-bar[mode=query]{transform:rotateZ(180deg) rotateY(180deg)}.mat-progress-bar[mode=indeterminate] .mat-progress-bar-fill,.mat-progress-bar[mode=query] .mat-progress-bar-fill{transition:none}.mat-progress-bar[mode=indeterminate] .mat-progress-bar-primary,.mat-progress-bar[mode=query] .mat-progress-bar-primary{-webkit-backface-visibility:hidden;backface-visibility:hidden;animation:mat-progress-bar-primary-indeterminate-translate 2000ms infinite linear;left:-145.166611%}.mat-progress-bar[mode=indeterminate] .mat-progress-bar-primary.mat-progress-bar-fill::after,.mat-progress-bar[mode=query] .mat-progress-bar-primary.mat-progress-bar-fill::after{-webkit-backface-visibility:hidden;backface-visibility:hidden;animation:mat-progress-bar-primary-indeterminate-scale 2000ms infinite linear}.mat-progress-bar[mode=indeterminate] .mat-progress-bar-secondary,.mat-progress-bar[mode=query] .mat-progress-bar-secondary{-webkit-backface-visibility:hidden;backface-visibility:hidden;animation:mat-progress-bar-secondary-indeterminate-translate 2000ms infinite linear;left:-54.888891%;display:block}.mat-progress-bar[mode=indeterminate] .mat-progress-bar-secondary.mat-progress-bar-fill::after,.mat-progress-bar[mode=query] .mat-progress-bar-secondary.mat-progress-bar-fill::after{-webkit-backface-visibility:hidden;backface-visibility:hidden;animation:mat-progress-bar-secondary-indeterminate-scale 2000ms infinite linear}.mat-progress-bar[mode=buffer] .mat-progress-bar-background{-webkit-backface-visibility:hidden;backface-visibility:hidden;animation:mat-progress-bar-background-scroll 250ms infinite linear;display:block}.mat-progress-bar._mat-animation-noopable .mat-progress-bar-fill,.mat-progress-bar._mat-animation-noopable .mat-progress-bar-fill::after,.mat-progress-bar._mat-animation-noopable .mat-progress-bar-buffer,.mat-progress-bar._mat-animation-noopable .mat-progress-bar-primary,.mat-progress-bar._mat-animation-noopable .mat-progress-bar-primary.mat-progress-bar-fill::after,.mat-progress-bar._mat-animation-noopable .mat-progress-bar-secondary,.mat-progress-bar._mat-animation-noopable .mat-progress-bar-secondary.mat-progress-bar-fill::after,.mat-progress-bar._mat-animation-noopable .mat-progress-bar-background{animation:none;transition-duration:1ms}@keyframes mat-progress-bar-primary-indeterminate-translate{0%{transform:translateX(0)}20%{animation-timing-function:cubic-bezier(0.5, 0, 0.701732, 0.495819);transform:translateX(0)}59.15%{animation-timing-function:cubic-bezier(0.302435, 0.381352, 0.55, 0.956352);transform:translateX(83.67142%)}100%{transform:translateX(200.611057%)}}@keyframes mat-progress-bar-primary-indeterminate-scale{0%{transform:scaleX(0.08)}36.65%{animation-timing-function:cubic-bezier(0.334731, 0.12482, 0.785844, 1);transform:scaleX(0.08)}69.15%{animation-timing-function:cubic-bezier(0.06, 0.11, 0.6, 1);transform:scaleX(0.661479)}100%{transform:scaleX(0.08)}}@keyframes mat-progress-bar-secondary-indeterminate-translate{0%{animation-timing-function:cubic-bezier(0.15, 0, 0.515058, 0.409685);transform:translateX(0)}25%{animation-timing-function:cubic-bezier(0.31033, 0.284058, 0.8, 0.733712);transform:translateX(37.651913%)}48.35%{animation-timing-function:cubic-bezier(0.4, 0.627035, 0.6, 0.902026);transform:translateX(84.386165%)}100%{transform:translateX(160.277782%)}}@keyframes mat-progress-bar-secondary-indeterminate-scale{0%{animation-timing-function:cubic-bezier(0.15, 0, 0.515058, 0.409685);transform:scaleX(0.08)}19.15%{animation-timing-function:cubic-bezier(0.31033, 0.284058, 0.8, 0.733712);transform:scaleX(0.457104)}44.15%{animation-timing-function:cubic-bezier(0.4, 0.627035, 0.6, 0.902026);transform:scaleX(0.72796)}100%{transform:scaleX(0.08)}}@keyframes mat-progress-bar-background-scroll{to{transform:translateX(-8px)}}\\n\"] }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [ANIMATION_MODULE_TYPE]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_PROGRESS_BAR_LOCATION]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_PROGRESS_BAR_DEFAULT_OPTIONS]\n                }] }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { value: [{\n                type: Input\n            }], bufferValue: [{\n                type: Input\n            }], _primaryValueBar: [{\n                type: ViewChild,\n                args: ['primaryValueBar']\n            }], animationEnd: [{\n                type: Output\n            }], mode: [{\n                type: Input\n            }] } });\n/** Clamps a value to be between two numbers, by default 0 and 100. */\nfunction clamp(v, min = 0, max = 100) {\n    return Math.max(min, Math.min(max, v));\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatProgressBarModule {\n}\nMatProgressBarModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatProgressBarModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatProgressBarModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatProgressBarModule, declarations: [MatProgressBar], imports: [CommonModule, MatCommonModule], exports: [MatProgressBar, MatCommonModule] });\nMatProgressBarModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatProgressBarModule, imports: [[CommonModule, MatCommonModule], MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatProgressBarModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [CommonModule, MatCommonModule],\n                    exports: [MatProgressBar, MatCommonModule],\n                    declarations: [MatProgressBar],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_PROGRESS_BAR_DEFAULT_OPTIONS, MAT_PROGRESS_BAR_LOCATION, MAT_PROGRESS_BAR_LOCATION_FACTORY, MatProgressBar, MatProgressBarModule };\n","import * as i0 from '@angular/core';\nimport { InjectionToken, forwardRef, EventEmitter, Directive, Output, Input, ContentChildren, ViewChild, Component, ViewEncapsulation, ChangeDetectionStrategy, Optional, Inject, Attribute, NgModule } from '@angular/core';\nimport * as i3 from '@angular/material/core';\nimport { mixinDisableRipple, mixinTabIndex, MatRippleModule, MatCommonModule } from '@angular/material/core';\nimport * as i1 from '@angular/cdk/a11y';\nimport { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';\nimport * as i2 from '@angular/cdk/collections';\nimport { NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst MAT_RADIO_DEFAULT_OPTIONS = new InjectionToken('mat-radio-default-options', {\n    providedIn: 'root',\n    factory: MAT_RADIO_DEFAULT_OPTIONS_FACTORY,\n});\nfunction MAT_RADIO_DEFAULT_OPTIONS_FACTORY() {\n    return {\n        color: 'accent',\n    };\n}\n// Increasing integer for generating unique ids for radio components.\nlet nextUniqueId = 0;\n/**\n * Provider Expression that allows mat-radio-group to register as a ControlValueAccessor. This\n * allows it to support [(ngModel)] and ngControl.\n * @docs-private\n */\nconst MAT_RADIO_GROUP_CONTROL_VALUE_ACCESSOR = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => MatRadioGroup),\n    multi: true,\n};\n/** Change event object emitted by MatRadio and MatRadioGroup. */\nclass MatRadioChange {\n    constructor(\n    /** The MatRadioButton that emits the change event. */\n    source, \n    /** The value of the MatRadioButton. */\n    value) {\n        this.source = source;\n        this.value = value;\n    }\n}\n/**\n * Injection token that can be used to inject instances of `MatRadioGroup`. It serves as\n * alternative token to the actual `MatRadioGroup` class which could cause unnecessary\n * retention of the class and its component metadata.\n */\nconst MAT_RADIO_GROUP = new InjectionToken('MatRadioGroup');\n/**\n * Base class with all of the `MatRadioGroup` functionality.\n * @docs-private\n */\nclass _MatRadioGroupBase {\n    constructor(_changeDetector) {\n        this._changeDetector = _changeDetector;\n        /** Selected value for the radio group. */\n        this._value = null;\n        /** The HTML name attribute applied to radio buttons in this group. */\n        this._name = `mat-radio-group-${nextUniqueId++}`;\n        /** The currently selected radio button. Should match value. */\n        this._selected = null;\n        /** Whether the `value` has been set to its initial value. */\n        this._isInitialized = false;\n        /** Whether the labels should appear after or before the radio-buttons. Defaults to 'after' */\n        this._labelPosition = 'after';\n        /** Whether the radio group is disabled. */\n        this._disabled = false;\n        /** Whether the radio group is required. */\n        this._required = false;\n        /** The method to be called in order to update ngModel */\n        this._controlValueAccessorChangeFn = () => { };\n        /**\n         * onTouch function registered via registerOnTouch (ControlValueAccessor).\n         * @docs-private\n         */\n        this.onTouched = () => { };\n        /**\n         * Event emitted when the group value changes.\n         * Change events are only emitted when the value changes due to user interaction with\n         * a radio button (the same behavior as `<input type-\"radio\">`).\n         */\n        this.change = new EventEmitter();\n    }\n    /** Name of the radio button group. All radio buttons inside this group will use this name. */\n    get name() {\n        return this._name;\n    }\n    set name(value) {\n        this._name = value;\n        this._updateRadioButtonNames();\n    }\n    /** Whether the labels should appear after or before the radio-buttons. Defaults to 'after' */\n    get labelPosition() {\n        return this._labelPosition;\n    }\n    set labelPosition(v) {\n        this._labelPosition = v === 'before' ? 'before' : 'after';\n        this._markRadiosForCheck();\n    }\n    /**\n     * Value for the radio-group. Should equal the value of the selected radio button if there is\n     * a corresponding radio button with a matching value. If there is not such a corresponding\n     * radio button, this value persists to be applied in case a new radio button is added with a\n     * matching value.\n     */\n    get value() {\n        return this._value;\n    }\n    set value(newValue) {\n        if (this._value !== newValue) {\n            // Set this before proceeding to ensure no circular loop occurs with selection.\n            this._value = newValue;\n            this._updateSelectedRadioFromValue();\n            this._checkSelectedRadioButton();\n        }\n    }\n    _checkSelectedRadioButton() {\n        if (this._selected && !this._selected.checked) {\n            this._selected.checked = true;\n        }\n    }\n    /**\n     * The currently selected radio button. If set to a new radio button, the radio group value\n     * will be updated to match the new selected button.\n     */\n    get selected() {\n        return this._selected;\n    }\n    set selected(selected) {\n        this._selected = selected;\n        this.value = selected ? selected.value : null;\n        this._checkSelectedRadioButton();\n    }\n    /** Whether the radio group is disabled */\n    get disabled() {\n        return this._disabled;\n    }\n    set disabled(value) {\n        this._disabled = coerceBooleanProperty(value);\n        this._markRadiosForCheck();\n    }\n    /** Whether the radio group is required */\n    get required() {\n        return this._required;\n    }\n    set required(value) {\n        this._required = coerceBooleanProperty(value);\n        this._markRadiosForCheck();\n    }\n    /**\n     * Initialize properties once content children are available.\n     * This allows us to propagate relevant attributes to associated buttons.\n     */\n    ngAfterContentInit() {\n        // Mark this component as initialized in AfterContentInit because the initial value can\n        // possibly be set by NgModel on MatRadioGroup, and it is possible that the OnInit of the\n        // NgModel occurs *after* the OnInit of the MatRadioGroup.\n        this._isInitialized = true;\n    }\n    /**\n     * Mark this group as being \"touched\" (for ngModel). Meant to be called by the contained\n     * radio buttons upon their blur.\n     */\n    _touch() {\n        if (this.onTouched) {\n            this.onTouched();\n        }\n    }\n    _updateRadioButtonNames() {\n        if (this._radios) {\n            this._radios.forEach(radio => {\n                radio.name = this.name;\n                radio._markForCheck();\n            });\n        }\n    }\n    /** Updates the `selected` radio button from the internal _value state. */\n    _updateSelectedRadioFromValue() {\n        // If the value already matches the selected radio, do nothing.\n        const isAlreadySelected = this._selected !== null && this._selected.value === this._value;\n        if (this._radios && !isAlreadySelected) {\n            this._selected = null;\n            this._radios.forEach(radio => {\n                radio.checked = this.value === radio.value;\n                if (radio.checked) {\n                    this._selected = radio;\n                }\n            });\n        }\n    }\n    /** Dispatch change event with current selection and group value. */\n    _emitChangeEvent() {\n        if (this._isInitialized) {\n            this.change.emit(new MatRadioChange(this._selected, this._value));\n        }\n    }\n    _markRadiosForCheck() {\n        if (this._radios) {\n            this._radios.forEach(radio => radio._markForCheck());\n        }\n    }\n    /**\n     * Sets the model value. Implemented as part of ControlValueAccessor.\n     * @param value\n     */\n    writeValue(value) {\n        this.value = value;\n        this._changeDetector.markForCheck();\n    }\n    /**\n     * Registers a callback to be triggered when the model value changes.\n     * Implemented as part of ControlValueAccessor.\n     * @param fn Callback to be registered.\n     */\n    registerOnChange(fn) {\n        this._controlValueAccessorChangeFn = fn;\n    }\n    /**\n     * Registers a callback to be triggered when the control is touched.\n     * Implemented as part of ControlValueAccessor.\n     * @param fn Callback to be registered.\n     */\n    registerOnTouched(fn) {\n        this.onTouched = fn;\n    }\n    /**\n     * Sets the disabled state of the control. Implemented as a part of ControlValueAccessor.\n     * @param isDisabled Whether the control should be disabled.\n     */\n    setDisabledState(isDisabled) {\n        this.disabled = isDisabled;\n        this._changeDetector.markForCheck();\n    }\n}\n_MatRadioGroupBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatRadioGroupBase, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });\n_MatRadioGroupBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: _MatRadioGroupBase, inputs: { color: \"color\", name: \"name\", labelPosition: \"labelPosition\", value: \"value\", selected: \"selected\", disabled: \"disabled\", required: \"required\" }, outputs: { change: \"change\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatRadioGroupBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { change: [{\n                type: Output\n            }], color: [{\n                type: Input\n            }], name: [{\n                type: Input\n            }], labelPosition: [{\n                type: Input\n            }], value: [{\n                type: Input\n            }], selected: [{\n                type: Input\n            }], disabled: [{\n                type: Input\n            }], required: [{\n                type: Input\n            }] } });\n/**\n * A group of radio buttons. May contain one or more `<mat-radio-button>` elements.\n */\nclass MatRadioGroup extends _MatRadioGroupBase {\n}\nMatRadioGroup.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRadioGroup, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatRadioGroup.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatRadioGroup, selector: \"mat-radio-group\", host: { attributes: { \"role\": \"radiogroup\" }, classAttribute: \"mat-radio-group\" }, providers: [\n        MAT_RADIO_GROUP_CONTROL_VALUE_ACCESSOR,\n        { provide: MAT_RADIO_GROUP, useExisting: MatRadioGroup },\n    ], queries: [{ propertyName: \"_radios\", predicate: i0.forwardRef(function () { return MatRadioButton; }), descendants: true }], exportAs: [\"matRadioGroup\"], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRadioGroup, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-radio-group',\n                    exportAs: 'matRadioGroup',\n                    providers: [\n                        MAT_RADIO_GROUP_CONTROL_VALUE_ACCESSOR,\n                        { provide: MAT_RADIO_GROUP, useExisting: MatRadioGroup },\n                    ],\n                    host: {\n                        'role': 'radiogroup',\n                        'class': 'mat-radio-group',\n                    },\n                }]\n        }], propDecorators: { _radios: [{\n                type: ContentChildren,\n                args: [forwardRef(() => MatRadioButton), { descendants: true }]\n            }] } });\n// Boilerplate for applying mixins to MatRadioButton.\n/** @docs-private */\nclass MatRadioButtonBase {\n    constructor(_elementRef) {\n        this._elementRef = _elementRef;\n    }\n}\nconst _MatRadioButtonMixinBase = mixinDisableRipple(mixinTabIndex(MatRadioButtonBase));\n/**\n * Base class with all of the `MatRadioButton` functionality.\n * @docs-private\n */\nclass _MatRadioButtonBase extends _MatRadioButtonMixinBase {\n    constructor(radioGroup, elementRef, _changeDetector, _focusMonitor, _radioDispatcher, animationMode, _providerOverride, tabIndex) {\n        super(elementRef);\n        this._changeDetector = _changeDetector;\n        this._focusMonitor = _focusMonitor;\n        this._radioDispatcher = _radioDispatcher;\n        this._providerOverride = _providerOverride;\n        this._uniqueId = `mat-radio-${++nextUniqueId}`;\n        /** The unique ID for the radio button. */\n        this.id = this._uniqueId;\n        /**\n         * Event emitted when the checked state of this radio button changes.\n         * Change events are only emitted when the value changes due to user interaction with\n         * the radio button (the same behavior as `<input type-\"radio\">`).\n         */\n        this.change = new EventEmitter();\n        /** Whether this radio is checked. */\n        this._checked = false;\n        /** Value assigned to this radio. */\n        this._value = null;\n        /** Unregister function for _radioDispatcher */\n        this._removeUniqueSelectionListener = () => { };\n        // Assertions. Ideally these should be stripped out by the compiler.\n        // TODO(jelbourn): Assert that there's no name binding AND a parent radio group.\n        this.radioGroup = radioGroup;\n        this._noopAnimations = animationMode === 'NoopAnimations';\n        if (tabIndex) {\n            this.tabIndex = coerceNumberProperty(tabIndex, 0);\n        }\n        this._removeUniqueSelectionListener = _radioDispatcher.listen((id, name) => {\n            if (id !== this.id && name === this.name) {\n                this.checked = false;\n            }\n        });\n    }\n    /** Whether this radio button is checked. */\n    get checked() {\n        return this._checked;\n    }\n    set checked(value) {\n        const newCheckedState = coerceBooleanProperty(value);\n        if (this._checked !== newCheckedState) {\n            this._checked = newCheckedState;\n            if (newCheckedState && this.radioGroup && this.radioGroup.value !== this.value) {\n                this.radioGroup.selected = this;\n            }\n            else if (!newCheckedState && this.radioGroup && this.radioGroup.value === this.value) {\n                // When unchecking the selected radio button, update the selected radio\n                // property on the group.\n                this.radioGroup.selected = null;\n            }\n            if (newCheckedState) {\n                // Notify all radio buttons with the same name to un-check.\n                this._radioDispatcher.notify(this.id, this.name);\n            }\n            this._changeDetector.markForCheck();\n        }\n    }\n    /** The value of this radio button. */\n    get value() {\n        return this._value;\n    }\n    set value(value) {\n        if (this._value !== value) {\n            this._value = value;\n            if (this.radioGroup !== null) {\n                if (!this.checked) {\n                    // Update checked when the value changed to match the radio group's value\n                    this.checked = this.radioGroup.value === value;\n                }\n                if (this.checked) {\n                    this.radioGroup.selected = this;\n                }\n            }\n        }\n    }\n    /** Whether the label should appear after or before the radio button. Defaults to 'after' */\n    get labelPosition() {\n        return this._labelPosition || (this.radioGroup && this.radioGroup.labelPosition) || 'after';\n    }\n    set labelPosition(value) {\n        this._labelPosition = value;\n    }\n    /** Whether the radio button is disabled. */\n    get disabled() {\n        return this._disabled || (this.radioGroup !== null && this.radioGroup.disabled);\n    }\n    set disabled(value) {\n        this._setDisabled(coerceBooleanProperty(value));\n    }\n    /** Whether the radio button is required. */\n    get required() {\n        return this._required || (this.radioGroup && this.radioGroup.required);\n    }\n    set required(value) {\n        this._required = coerceBooleanProperty(value);\n    }\n    /** Theme color of the radio button. */\n    get color() {\n        // As per Material design specifications the selection control radio should use the accent color\n        // palette by default. https://material.io/guidelines/components/selection-controls.html\n        return (this._color ||\n            (this.radioGroup && this.radioGroup.color) ||\n            (this._providerOverride && this._providerOverride.color) ||\n            'accent');\n    }\n    set color(newValue) {\n        this._color = newValue;\n    }\n    /** ID of the native input element inside `<mat-radio-button>` */\n    get inputId() {\n        return `${this.id || this._uniqueId}-input`;\n    }\n    /** Focuses the radio button. */\n    focus(options, origin) {\n        if (origin) {\n            this._focusMonitor.focusVia(this._inputElement, origin, options);\n        }\n        else {\n            this._inputElement.nativeElement.focus(options);\n        }\n    }\n    /**\n     * Marks the radio button as needing checking for change detection.\n     * This method is exposed because the parent radio group will directly\n     * update bound properties of the radio button.\n     */\n    _markForCheck() {\n        // When group value changes, the button will not be notified. Use `markForCheck` to explicit\n        // update radio button's status\n        this._changeDetector.markForCheck();\n    }\n    ngOnInit() {\n        if (this.radioGroup) {\n            // If the radio is inside a radio group, determine if it should be checked\n            this.checked = this.radioGroup.value === this._value;\n            if (this.checked) {\n                this.radioGroup.selected = this;\n            }\n            // Copy name from parent radio group\n            this.name = this.radioGroup.name;\n        }\n    }\n    ngDoCheck() {\n        this._updateTabIndex();\n    }\n    ngAfterViewInit() {\n        this._updateTabIndex();\n        this._focusMonitor.monitor(this._elementRef, true).subscribe(focusOrigin => {\n            if (!focusOrigin && this.radioGroup) {\n                this.radioGroup._touch();\n            }\n        });\n    }\n    ngOnDestroy() {\n        this._focusMonitor.stopMonitoring(this._elementRef);\n        this._removeUniqueSelectionListener();\n    }\n    /** Dispatch change event with current value. */\n    _emitChangeEvent() {\n        this.change.emit(new MatRadioChange(this, this._value));\n    }\n    _isRippleDisabled() {\n        return this.disableRipple || this.disabled;\n    }\n    _onInputClick(event) {\n        // We have to stop propagation for click events on the visual hidden input element.\n        // By default, when a user clicks on a label element, a generated click event will be\n        // dispatched on the associated input element. Since we are using a label element as our\n        // root container, the click event on the `radio-button` will be executed twice.\n        // The real click event will bubble up, and the generated click event also tries to bubble up.\n        // This will lead to multiple click events.\n        // Preventing bubbling for the second event will solve that issue.\n        event.stopPropagation();\n    }\n    /** Triggered when the radio button receives an interaction from the user. */\n    _onInputInteraction(event) {\n        // We always have to stop propagation on the change event.\n        // Otherwise the change event, from the input element, will bubble up and\n        // emit its event object to the `change` output.\n        event.stopPropagation();\n        if (!this.checked && !this.disabled) {\n            const groupValueChanged = this.radioGroup && this.value !== this.radioGroup.value;\n            this.checked = true;\n            this._emitChangeEvent();\n            if (this.radioGroup) {\n                this.radioGroup._controlValueAccessorChangeFn(this.value);\n                if (groupValueChanged) {\n                    this.radioGroup._emitChangeEvent();\n                }\n            }\n        }\n    }\n    /** Sets the disabled state and marks for check if a change occurred. */\n    _setDisabled(value) {\n        if (this._disabled !== value) {\n            this._disabled = value;\n            this._changeDetector.markForCheck();\n        }\n    }\n    /** Gets the tabindex for the underlying input element. */\n    _updateTabIndex() {\n        const group = this.radioGroup;\n        let value;\n        // Implement a roving tabindex if the button is inside a group. For most cases this isn't\n        // necessary, because the browser handles the tab order for inputs inside a group automatically,\n        // but we need an explicitly higher tabindex for the selected button in order for things like\n        // the focus trap to pick it up correctly.\n        if (!group || !group.selected || this.disabled) {\n            value = this.tabIndex;\n        }\n        else {\n            value = group.selected === this ? this.tabIndex : -1;\n        }\n        if (value !== this._previousTabIndex) {\n            // We have to set the tabindex directly on the DOM node, because it depends on\n            // the selected state which is prone to \"changed after checked errors\".\n            const input = this._inputElement?.nativeElement;\n            if (input) {\n                input.setAttribute('tabindex', value + '');\n                this._previousTabIndex = value;\n            }\n        }\n    }\n}\n_MatRadioButtonBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatRadioButtonBase, deps: \"invalid\", target: i0.ɵɵFactoryTarget.Directive });\n_MatRadioButtonBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: _MatRadioButtonBase, inputs: { id: \"id\", name: \"name\", ariaLabel: [\"aria-label\", \"ariaLabel\"], ariaLabelledby: [\"aria-labelledby\", \"ariaLabelledby\"], ariaDescribedby: [\"aria-describedby\", \"ariaDescribedby\"], checked: \"checked\", value: \"value\", labelPosition: \"labelPosition\", disabled: \"disabled\", required: \"required\", color: \"color\" }, outputs: { change: \"change\" }, viewQueries: [{ propertyName: \"_inputElement\", first: true, predicate: [\"input\"], descendants: true }], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatRadioButtonBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: _MatRadioGroupBase }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i1.FocusMonitor }, { type: i2.UniqueSelectionDispatcher }, { type: undefined }, { type: undefined }, { type: undefined }]; }, propDecorators: { id: [{\n                type: Input\n            }], name: [{\n                type: Input\n            }], ariaLabel: [{\n                type: Input,\n                args: ['aria-label']\n            }], ariaLabelledby: [{\n                type: Input,\n                args: ['aria-labelledby']\n            }], ariaDescribedby: [{\n                type: Input,\n                args: ['aria-describedby']\n            }], checked: [{\n                type: Input\n            }], value: [{\n                type: Input\n            }], labelPosition: [{\n                type: Input\n            }], disabled: [{\n                type: Input\n            }], required: [{\n                type: Input\n            }], color: [{\n                type: Input\n            }], change: [{\n                type: Output\n            }], _inputElement: [{\n                type: ViewChild,\n                args: ['input']\n            }] } });\n/**\n * A Material design radio-button. Typically placed inside of `<mat-radio-group>` elements.\n */\nclass MatRadioButton extends _MatRadioButtonBase {\n    constructor(radioGroup, elementRef, changeDetector, focusMonitor, radioDispatcher, animationMode, providerOverride, tabIndex) {\n        super(radioGroup, elementRef, changeDetector, focusMonitor, radioDispatcher, animationMode, providerOverride, tabIndex);\n    }\n}\nMatRadioButton.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRadioButton, deps: [{ token: MAT_RADIO_GROUP, optional: true }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i1.FocusMonitor }, { token: i2.UniqueSelectionDispatcher }, { token: ANIMATION_MODULE_TYPE, optional: true }, { token: MAT_RADIO_DEFAULT_OPTIONS, optional: true }, { token: 'tabindex', attribute: true }], target: i0.ɵɵFactoryTarget.Component });\nMatRadioButton.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatRadioButton, selector: \"mat-radio-button\", inputs: { disableRipple: \"disableRipple\", tabIndex: \"tabIndex\" }, host: { listeners: { \"focus\": \"_inputElement.nativeElement.focus()\" }, properties: { \"class.mat-radio-checked\": \"checked\", \"class.mat-radio-disabled\": \"disabled\", \"class._mat-animation-noopable\": \"_noopAnimations\", \"class.mat-primary\": \"color === \\\"primary\\\"\", \"class.mat-accent\": \"color === \\\"accent\\\"\", \"class.mat-warn\": \"color === \\\"warn\\\"\", \"attr.tabindex\": \"null\", \"attr.id\": \"id\", \"attr.aria-label\": \"null\", \"attr.aria-labelledby\": \"null\", \"attr.aria-describedby\": \"null\" }, classAttribute: \"mat-radio-button\" }, exportAs: [\"matRadioButton\"], usesInheritance: true, ngImport: i0, template: \"<!-- TODO(jelbourn): render the radio on either side of the content -->\\n<!-- TODO(mtlin): Evaluate trade-offs of using native radio vs. cost of additional bindings. -->\\n<label [attr.for]=\\\"inputId\\\" class=\\\"mat-radio-label\\\" #label>\\n  <!-- The actual 'radio' part of the control. -->\\n  <span class=\\\"mat-radio-container\\\">\\n    <span class=\\\"mat-radio-outer-circle\\\"></span>\\n    <span class=\\\"mat-radio-inner-circle\\\"></span>\\n    <input #input class=\\\"mat-radio-input\\\" type=\\\"radio\\\"\\n        [id]=\\\"inputId\\\"\\n        [checked]=\\\"checked\\\"\\n        [disabled]=\\\"disabled\\\"\\n        [attr.name]=\\\"name\\\"\\n        [attr.value]=\\\"value\\\"\\n        [required]=\\\"required\\\"\\n        [attr.aria-label]=\\\"ariaLabel\\\"\\n        [attr.aria-labelledby]=\\\"ariaLabelledby\\\"\\n        [attr.aria-describedby]=\\\"ariaDescribedby\\\"\\n        (change)=\\\"_onInputInteraction($event)\\\"\\n        (click)=\\\"_onInputClick($event)\\\">\\n\\n    <!-- The ripple comes after the input so that we can target it with a CSS\\n         sibling selector when the input is focused. -->\\n    <span mat-ripple class=\\\"mat-radio-ripple mat-focus-indicator\\\"\\n         [matRippleTrigger]=\\\"label\\\"\\n         [matRippleDisabled]=\\\"_isRippleDisabled()\\\"\\n         [matRippleCentered]=\\\"true\\\"\\n         [matRippleRadius]=\\\"20\\\"\\n         [matRippleAnimation]=\\\"{enterDuration: _noopAnimations ? 0 : 150}\\\">\\n\\n      <span class=\\\"mat-ripple-element mat-radio-persistent-ripple\\\"></span>\\n    </span>\\n  </span>\\n\\n  <!-- The label content for radio control. -->\\n  <span class=\\\"mat-radio-label-content\\\" [class.mat-radio-label-before]=\\\"labelPosition == 'before'\\\">\\n    <!-- Add an invisible span so JAWS can read the label -->\\n    <span style=\\\"display:none\\\">&nbsp;</span>\\n    <ng-content></ng-content>\\n  </span>\\n</label>\\n\", styles: [\".mat-radio-button{display:inline-block;-webkit-tap-highlight-color:transparent;outline:0}.mat-radio-label{-webkit-user-select:none;user-select:none;cursor:pointer;display:inline-flex;align-items:center;white-space:nowrap;vertical-align:middle;width:100%}.mat-radio-container{box-sizing:border-box;display:inline-block;position:relative;width:20px;height:20px;flex-shrink:0}.mat-radio-outer-circle{box-sizing:border-box;display:block;height:20px;left:0;position:absolute;top:0;transition:border-color ease 280ms;width:20px;border-width:2px;border-style:solid;border-radius:50%}._mat-animation-noopable .mat-radio-outer-circle{transition:none}.mat-radio-inner-circle{border-radius:50%;box-sizing:border-box;display:block;height:20px;left:0;position:absolute;top:0;opacity:0;transition:transform ease 280ms,background-color ease 280ms,opacity linear 1ms 280ms;width:20px;transform:scale(0.001);-webkit-print-color-adjust:exact;color-adjust:exact}.mat-radio-checked .mat-radio-inner-circle{transform:scale(0.5);opacity:1;transition:transform ease 280ms,background-color ease 280ms}.cdk-high-contrast-active .mat-radio-checked .mat-radio-inner-circle{border:solid 10px}._mat-animation-noopable .mat-radio-inner-circle{transition:none}.mat-radio-label-content{-webkit-user-select:auto;user-select:auto;display:inline-block;order:0;line-height:inherit;padding-left:8px;padding-right:0}[dir=rtl] .mat-radio-label-content{padding-right:8px;padding-left:0}.mat-radio-label-content.mat-radio-label-before{order:-1;padding-left:0;padding-right:8px}[dir=rtl] .mat-radio-label-content.mat-radio-label-before{padding-right:0;padding-left:8px}.mat-radio-disabled,.mat-radio-disabled .mat-radio-label{cursor:default}.mat-radio-button .mat-radio-ripple{position:absolute;left:calc(50% - 20px);top:calc(50% - 20px);height:40px;width:40px;z-index:1;pointer-events:none}.mat-radio-button .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple){opacity:.16}.mat-radio-persistent-ripple{width:100%;height:100%;transform:none;top:0;left:0}.mat-radio-container:hover .mat-radio-persistent-ripple{opacity:.04}.mat-radio-button:not(.mat-radio-disabled).cdk-keyboard-focused .mat-radio-persistent-ripple,.mat-radio-button:not(.mat-radio-disabled).cdk-program-focused .mat-radio-persistent-ripple{opacity:.12}.mat-radio-persistent-ripple,.mat-radio-disabled .mat-radio-container:hover .mat-radio-persistent-ripple{opacity:0}@media(hover: none){.mat-radio-container:hover .mat-radio-persistent-ripple{display:none}}.mat-radio-input{opacity:0;position:absolute;top:0;left:0;margin:0;width:100%;height:100%;cursor:inherit;z-index:-1}.cdk-high-contrast-active .mat-radio-button:not(.mat-radio-disabled).cdk-keyboard-focused .mat-radio-ripple,.cdk-high-contrast-active .mat-radio-button:not(.mat-radio-disabled).cdk-program-focused .mat-radio-ripple{outline:solid 3px}.cdk-high-contrast-active .mat-radio-disabled{opacity:.5}\\n\"], directives: [{ type: i3.MatRipple, selector: \"[mat-ripple], [matRipple]\", inputs: [\"matRippleColor\", \"matRippleUnbounded\", \"matRippleCentered\", \"matRippleRadius\", \"matRippleAnimation\", \"matRippleDisabled\", \"matRippleTrigger\"], exportAs: [\"matRipple\"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRadioButton, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-radio-button', inputs: ['disableRipple', 'tabIndex'], encapsulation: ViewEncapsulation.None, exportAs: 'matRadioButton', host: {\n                        'class': 'mat-radio-button',\n                        '[class.mat-radio-checked]': 'checked',\n                        '[class.mat-radio-disabled]': 'disabled',\n                        '[class._mat-animation-noopable]': '_noopAnimations',\n                        '[class.mat-primary]': 'color === \"primary\"',\n                        '[class.mat-accent]': 'color === \"accent\"',\n                        '[class.mat-warn]': 'color === \"warn\"',\n                        // Needs to be removed since it causes some a11y issues (see #21266).\n                        '[attr.tabindex]': 'null',\n                        '[attr.id]': 'id',\n                        '[attr.aria-label]': 'null',\n                        '[attr.aria-labelledby]': 'null',\n                        '[attr.aria-describedby]': 'null',\n                        // Note: under normal conditions focus shouldn't land on this element, however it may be\n                        // programmatically set, for example inside of a focus trap, in this case we want to forward\n                        // the focus to the native element.\n                        '(focus)': '_inputElement.nativeElement.focus()',\n                    }, changeDetection: ChangeDetectionStrategy.OnPush, template: \"<!-- TODO(jelbourn): render the radio on either side of the content -->\\n<!-- TODO(mtlin): Evaluate trade-offs of using native radio vs. cost of additional bindings. -->\\n<label [attr.for]=\\\"inputId\\\" class=\\\"mat-radio-label\\\" #label>\\n  <!-- The actual 'radio' part of the control. -->\\n  <span class=\\\"mat-radio-container\\\">\\n    <span class=\\\"mat-radio-outer-circle\\\"></span>\\n    <span class=\\\"mat-radio-inner-circle\\\"></span>\\n    <input #input class=\\\"mat-radio-input\\\" type=\\\"radio\\\"\\n        [id]=\\\"inputId\\\"\\n        [checked]=\\\"checked\\\"\\n        [disabled]=\\\"disabled\\\"\\n        [attr.name]=\\\"name\\\"\\n        [attr.value]=\\\"value\\\"\\n        [required]=\\\"required\\\"\\n        [attr.aria-label]=\\\"ariaLabel\\\"\\n        [attr.aria-labelledby]=\\\"ariaLabelledby\\\"\\n        [attr.aria-describedby]=\\\"ariaDescribedby\\\"\\n        (change)=\\\"_onInputInteraction($event)\\\"\\n        (click)=\\\"_onInputClick($event)\\\">\\n\\n    <!-- The ripple comes after the input so that we can target it with a CSS\\n         sibling selector when the input is focused. -->\\n    <span mat-ripple class=\\\"mat-radio-ripple mat-focus-indicator\\\"\\n         [matRippleTrigger]=\\\"label\\\"\\n         [matRippleDisabled]=\\\"_isRippleDisabled()\\\"\\n         [matRippleCentered]=\\\"true\\\"\\n         [matRippleRadius]=\\\"20\\\"\\n         [matRippleAnimation]=\\\"{enterDuration: _noopAnimations ? 0 : 150}\\\">\\n\\n      <span class=\\\"mat-ripple-element mat-radio-persistent-ripple\\\"></span>\\n    </span>\\n  </span>\\n\\n  <!-- The label content for radio control. -->\\n  <span class=\\\"mat-radio-label-content\\\" [class.mat-radio-label-before]=\\\"labelPosition == 'before'\\\">\\n    <!-- Add an invisible span so JAWS can read the label -->\\n    <span style=\\\"display:none\\\">&nbsp;</span>\\n    <ng-content></ng-content>\\n  </span>\\n</label>\\n\", styles: [\".mat-radio-button{display:inline-block;-webkit-tap-highlight-color:transparent;outline:0}.mat-radio-label{-webkit-user-select:none;user-select:none;cursor:pointer;display:inline-flex;align-items:center;white-space:nowrap;vertical-align:middle;width:100%}.mat-radio-container{box-sizing:border-box;display:inline-block;position:relative;width:20px;height:20px;flex-shrink:0}.mat-radio-outer-circle{box-sizing:border-box;display:block;height:20px;left:0;position:absolute;top:0;transition:border-color ease 280ms;width:20px;border-width:2px;border-style:solid;border-radius:50%}._mat-animation-noopable .mat-radio-outer-circle{transition:none}.mat-radio-inner-circle{border-radius:50%;box-sizing:border-box;display:block;height:20px;left:0;position:absolute;top:0;opacity:0;transition:transform ease 280ms,background-color ease 280ms,opacity linear 1ms 280ms;width:20px;transform:scale(0.001);-webkit-print-color-adjust:exact;color-adjust:exact}.mat-radio-checked .mat-radio-inner-circle{transform:scale(0.5);opacity:1;transition:transform ease 280ms,background-color ease 280ms}.cdk-high-contrast-active .mat-radio-checked .mat-radio-inner-circle{border:solid 10px}._mat-animation-noopable .mat-radio-inner-circle{transition:none}.mat-radio-label-content{-webkit-user-select:auto;user-select:auto;display:inline-block;order:0;line-height:inherit;padding-left:8px;padding-right:0}[dir=rtl] .mat-radio-label-content{padding-right:8px;padding-left:0}.mat-radio-label-content.mat-radio-label-before{order:-1;padding-left:0;padding-right:8px}[dir=rtl] .mat-radio-label-content.mat-radio-label-before{padding-right:0;padding-left:8px}.mat-radio-disabled,.mat-radio-disabled .mat-radio-label{cursor:default}.mat-radio-button .mat-radio-ripple{position:absolute;left:calc(50% - 20px);top:calc(50% - 20px);height:40px;width:40px;z-index:1;pointer-events:none}.mat-radio-button .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple){opacity:.16}.mat-radio-persistent-ripple{width:100%;height:100%;transform:none;top:0;left:0}.mat-radio-container:hover .mat-radio-persistent-ripple{opacity:.04}.mat-radio-button:not(.mat-radio-disabled).cdk-keyboard-focused .mat-radio-persistent-ripple,.mat-radio-button:not(.mat-radio-disabled).cdk-program-focused .mat-radio-persistent-ripple{opacity:.12}.mat-radio-persistent-ripple,.mat-radio-disabled .mat-radio-container:hover .mat-radio-persistent-ripple{opacity:0}@media(hover: none){.mat-radio-container:hover .mat-radio-persistent-ripple{display:none}}.mat-radio-input{opacity:0;position:absolute;top:0;left:0;margin:0;width:100%;height:100%;cursor:inherit;z-index:-1}.cdk-high-contrast-active .mat-radio-button:not(.mat-radio-disabled).cdk-keyboard-focused .mat-radio-ripple,.cdk-high-contrast-active .mat-radio-button:not(.mat-radio-disabled).cdk-program-focused .mat-radio-ripple{outline:solid 3px}.cdk-high-contrast-active .mat-radio-disabled{opacity:.5}\\n\"] }]\n        }], ctorParameters: function () { return [{ type: MatRadioGroup, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_RADIO_GROUP]\n                }] }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i1.FocusMonitor }, { type: i2.UniqueSelectionDispatcher }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [ANIMATION_MODULE_TYPE]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_RADIO_DEFAULT_OPTIONS]\n                }] }, { type: undefined, decorators: [{\n                    type: Attribute,\n                    args: ['tabindex']\n                }] }]; } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatRadioModule {\n}\nMatRadioModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRadioModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatRadioModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRadioModule, declarations: [MatRadioGroup, MatRadioButton], imports: [MatRippleModule, MatCommonModule], exports: [MatRadioGroup, MatRadioButton, MatCommonModule] });\nMatRadioModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRadioModule, imports: [[MatRippleModule, MatCommonModule], MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRadioModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [MatRippleModule, MatCommonModule],\n                    exports: [MatRadioGroup, MatRadioButton, MatCommonModule],\n                    declarations: [MatRadioGroup, MatRadioButton],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_RADIO_DEFAULT_OPTIONS, MAT_RADIO_DEFAULT_OPTIONS_FACTORY, MAT_RADIO_GROUP, MAT_RADIO_GROUP_CONTROL_VALUE_ACCESSOR, MatRadioButton, MatRadioChange, MatRadioGroup, MatRadioModule, _MatRadioButtonBase, _MatRadioGroupBase };\n","import * as i7 from '@angular/cdk/overlay';\nimport { Overlay, CdkConnectedOverlay, OverlayModule } from '@angular/cdk/overlay';\nimport * as i8 from '@angular/common';\nimport { CommonModule } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { InjectionToken, Directive, EventEmitter, Optional, Inject, Self, Attribute, ViewChild, Input, Output, Component, ViewEncapsulation, ChangeDetectionStrategy, ContentChildren, ContentChild, NgModule } from '@angular/core';\nimport * as i2 from '@angular/material/core';\nimport { mixinDisableRipple, mixinTabIndex, mixinDisabled, mixinErrorState, _countGroupLabelsBeforeOption, _getOptionScrollPosition, MAT_OPTION_PARENT_COMPONENT, MatOption, MAT_OPTGROUP, MatOptionModule, MatCommonModule } from '@angular/material/core';\nimport * as i6 from '@angular/material/form-field';\nimport { MAT_FORM_FIELD, MatFormFieldControl, MatFormFieldModule } from '@angular/material/form-field';\nimport * as i1 from '@angular/cdk/scrolling';\nimport { CdkScrollableModule } from '@angular/cdk/scrolling';\nimport * as i5 from '@angular/cdk/a11y';\nimport { ActiveDescendantKeyManager } from '@angular/cdk/a11y';\nimport * as i3 from '@angular/cdk/bidi';\nimport { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';\nimport { SelectionModel } from '@angular/cdk/collections';\nimport { DOWN_ARROW, UP_ARROW, LEFT_ARROW, RIGHT_ARROW, ENTER, SPACE, hasModifierKey, A } from '@angular/cdk/keycodes';\nimport * as i4 from '@angular/forms';\nimport { Validators } from '@angular/forms';\nimport { Subject, defer, merge } from 'rxjs';\nimport { startWith, switchMap, take, filter, map, distinctUntilChanged, takeUntil } from 'rxjs/operators';\nimport { trigger, transition, query, animateChild, state, style, animate } from '@angular/animations';\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * The following are all the animations for the mat-select component, with each\n * const containing the metadata for one animation.\n *\n * The values below match the implementation of the AngularJS Material mat-select animation.\n * @docs-private\n */\nconst matSelectAnimations = {\n    /**\n     * This animation ensures the select's overlay panel animation (transformPanel) is called when\n     * closing the select.\n     * This is needed due to https://github.com/angular/angular/issues/23302\n     */\n    transformPanelWrap: trigger('transformPanelWrap', [\n        transition('* => void', query('@transformPanel', [animateChild()], { optional: true })),\n    ]),\n    /**\n     * This animation transforms the select's overlay panel on and off the page.\n     *\n     * When the panel is attached to the DOM, it expands its width by the amount of padding, scales it\n     * up to 100% on the Y axis, fades in its border, and translates slightly up and to the\n     * side to ensure the option text correctly overlaps the trigger text.\n     *\n     * When the panel is removed from the DOM, it simply fades out linearly.\n     */\n    transformPanel: trigger('transformPanel', [\n        state('void', style({\n            transform: 'scaleY(0.8)',\n            minWidth: '100%',\n            opacity: 0,\n        })),\n        state('showing', style({\n            opacity: 1,\n            minWidth: 'calc(100% + 32px)',\n            transform: 'scaleY(1)',\n        })),\n        state('showing-multiple', style({\n            opacity: 1,\n            minWidth: 'calc(100% + 64px)',\n            transform: 'scaleY(1)',\n        })),\n        transition('void => *', animate('120ms cubic-bezier(0, 0, 0.2, 1)')),\n        transition('* => void', animate('100ms 25ms linear', style({ opacity: 0 }))),\n    ]),\n};\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Returns an exception to be thrown when attempting to change a select's `multiple` option\n * after initialization.\n * @docs-private\n */\nfunction getMatSelectDynamicMultipleError() {\n    return Error('Cannot change `multiple` mode of select after initialization.');\n}\n/**\n * Returns an exception to be thrown when attempting to assign a non-array value to a select\n * in `multiple` mode. Note that `undefined` and `null` are still valid values to allow for\n * resetting the value.\n * @docs-private\n */\nfunction getMatSelectNonArrayValueError() {\n    return Error('Value must be an array in multiple-selection mode.');\n}\n/**\n * Returns an exception to be thrown when assigning a non-function value to the comparator\n * used to determine if a value corresponds to an option. Note that whether the function\n * actually takes two values and returns a boolean is not checked.\n */\nfunction getMatSelectNonFunctionValueError() {\n    return Error('`compareWith` must be a function.');\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 */\nlet nextUniqueId = 0;\n/**\n * The following style constants are necessary to save here in order\n * to properly calculate the alignment of the selected option over\n * the trigger element.\n */\n/** The max height of the select's overlay panel. */\nconst SELECT_PANEL_MAX_HEIGHT = 256;\n/** The panel's padding on the x-axis. */\nconst SELECT_PANEL_PADDING_X = 16;\n/** The panel's x axis padding if it is indented (e.g. there is an option group). */\nconst SELECT_PANEL_INDENT_PADDING_X = SELECT_PANEL_PADDING_X * 2;\n/** The height of the select items in `em` units. */\nconst SELECT_ITEM_HEIGHT_EM = 3;\n// TODO(josephperrott): Revert to a constant after 2018 spec updates are fully merged.\n/**\n * Distance between the panel edge and the option text in\n * multi-selection mode.\n *\n * Calculated as:\n * (SELECT_PANEL_PADDING_X * 1.5) + 16 = 40\n * The padding is multiplied by 1.5 because the checkbox's margin is half the padding.\n * The checkbox width is 16px.\n */\nconst SELECT_MULTIPLE_PANEL_PADDING_X = SELECT_PANEL_PADDING_X * 1.5 + 16;\n/**\n * The select panel will only \"fit\" inside the viewport if it is positioned at\n * this value or more away from the viewport boundary.\n */\nconst SELECT_PANEL_VIEWPORT_PADDING = 8;\n/** Injection token that determines the scroll handling while a select is open. */\nconst MAT_SELECT_SCROLL_STRATEGY = new InjectionToken('mat-select-scroll-strategy');\n/** @docs-private */\nfunction MAT_SELECT_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {\n    return () => overlay.scrollStrategies.reposition();\n}\n/** Injection token that can be used to provide the default options the select module. */\nconst MAT_SELECT_CONFIG = new InjectionToken('MAT_SELECT_CONFIG');\n/** @docs-private */\nconst MAT_SELECT_SCROLL_STRATEGY_PROVIDER = {\n    provide: MAT_SELECT_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: MAT_SELECT_SCROLL_STRATEGY_PROVIDER_FACTORY,\n};\n/** Change event object that is emitted when the select value has changed. */\nclass MatSelectChange {\n    constructor(\n    /** Reference to the select that emitted the change event. */\n    source, \n    /** Current value of the select that emitted the event. */\n    value) {\n        this.source = source;\n        this.value = value;\n    }\n}\n// Boilerplate for applying mixins to MatSelect.\n/** @docs-private */\nconst _MatSelectMixinBase = mixinDisableRipple(mixinTabIndex(mixinDisabled(mixinErrorState(class {\n    constructor(_elementRef, _defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl) {\n        this._elementRef = _elementRef;\n        this._defaultErrorStateMatcher = _defaultErrorStateMatcher;\n        this._parentForm = _parentForm;\n        this._parentFormGroup = _parentFormGroup;\n        this.ngControl = ngControl;\n    }\n}))));\n/**\n * Injection token that can be used to reference instances of `MatSelectTrigger`. It serves as\n * alternative token to the actual `MatSelectTrigger` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */\nconst MAT_SELECT_TRIGGER = new InjectionToken('MatSelectTrigger');\n/**\n * Allows the user to customize the trigger that is displayed when the select has a value.\n */\nclass MatSelectTrigger {\n}\nMatSelectTrigger.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSelectTrigger, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatSelectTrigger.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatSelectTrigger, selector: \"mat-select-trigger\", providers: [{ provide: MAT_SELECT_TRIGGER, useExisting: MatSelectTrigger }], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSelectTrigger, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-select-trigger',\n                    providers: [{ provide: MAT_SELECT_TRIGGER, useExisting: MatSelectTrigger }],\n                }]\n        }] });\n/** Base class with all of the `MatSelect` functionality. */\nclass _MatSelectBase extends _MatSelectMixinBase {\n    constructor(_viewportRuler, _changeDetectorRef, _ngZone, _defaultErrorStateMatcher, elementRef, _dir, _parentForm, _parentFormGroup, _parentFormField, ngControl, tabIndex, scrollStrategyFactory, _liveAnnouncer, _defaultOptions) {\n        super(elementRef, _defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl);\n        this._viewportRuler = _viewportRuler;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._ngZone = _ngZone;\n        this._dir = _dir;\n        this._parentFormField = _parentFormField;\n        this._liveAnnouncer = _liveAnnouncer;\n        this._defaultOptions = _defaultOptions;\n        /** Whether or not the overlay panel is open. */\n        this._panelOpen = false;\n        /** Comparison function to specify which option is displayed. Defaults to object equality. */\n        this._compareWith = (o1, o2) => o1 === o2;\n        /** Unique id for this input. */\n        this._uid = `mat-select-${nextUniqueId++}`;\n        /** Current `ariar-labelledby` value for the select trigger. */\n        this._triggerAriaLabelledBy = null;\n        /** Emits whenever the component is destroyed. */\n        this._destroy = new Subject();\n        /** `View -> model callback called when value changes` */\n        this._onChange = () => { };\n        /** `View -> model callback called when select has been touched` */\n        this._onTouched = () => { };\n        /** ID for the DOM node containing the select's value. */\n        this._valueId = `mat-select-value-${nextUniqueId++}`;\n        /** Emits when the panel element is finished transforming in. */\n        this._panelDoneAnimatingStream = new Subject();\n        this._overlayPanelClass = this._defaultOptions?.overlayPanelClass || '';\n        this._focused = false;\n        /** A name for this control that can be used by `mat-form-field`. */\n        this.controlType = 'mat-select';\n        this._multiple = false;\n        this._disableOptionCentering = this._defaultOptions?.disableOptionCentering ?? false;\n        /** Aria label of the select. */\n        this.ariaLabel = '';\n        /** Combined stream of all of the child options' change events. */\n        this.optionSelectionChanges = defer(() => {\n            const options = this.options;\n            if (options) {\n                return options.changes.pipe(startWith(options), switchMap(() => merge(...options.map(option => option.onSelectionChange))));\n            }\n            return this._ngZone.onStable.pipe(take(1), switchMap(() => this.optionSelectionChanges));\n        });\n        /** Event emitted when the select panel has been toggled. */\n        this.openedChange = new EventEmitter();\n        /** Event emitted when the select has been opened. */\n        this._openedStream = this.openedChange.pipe(filter(o => o), map(() => { }));\n        /** Event emitted when the select has been closed. */\n        this._closedStream = this.openedChange.pipe(filter(o => !o), map(() => { }));\n        /** Event emitted when the selected value has been changed by the user. */\n        this.selectionChange = new EventEmitter();\n        /**\n         * Event that emits whenever the raw value of the select changes. This is here primarily\n         * to facilitate the two-way binding for the `value` input.\n         * @docs-private\n         */\n        this.valueChange = new EventEmitter();\n        if (this.ngControl) {\n            // Note: we provide the value accessor through here, instead of\n            // the `providers` to avoid running into a circular import.\n            this.ngControl.valueAccessor = this;\n        }\n        // Note that we only want to set this when the defaults pass it in, otherwise it should\n        // stay as `undefined` so that it falls back to the default in the key manager.\n        if (_defaultOptions?.typeaheadDebounceInterval != null) {\n            this._typeaheadDebounceInterval = _defaultOptions.typeaheadDebounceInterval;\n        }\n        this._scrollStrategyFactory = scrollStrategyFactory;\n        this._scrollStrategy = this._scrollStrategyFactory();\n        this.tabIndex = parseInt(tabIndex) || 0;\n        // Force setter to be called in case id was not specified.\n        this.id = this.id;\n    }\n    /** Whether the select is focused. */\n    get focused() {\n        return this._focused || this._panelOpen;\n    }\n    /** Placeholder to be shown if no value has been selected. */\n    get placeholder() {\n        return this._placeholder;\n    }\n    set placeholder(value) {\n        this._placeholder = value;\n        this.stateChanges.next();\n    }\n    /** Whether the component is required. */\n    get required() {\n        return this._required ?? this.ngControl?.control?.hasValidator(Validators.required) ?? false;\n    }\n    set required(value) {\n        this._required = coerceBooleanProperty(value);\n        this.stateChanges.next();\n    }\n    /** Whether the user should be allowed to select multiple options. */\n    get multiple() {\n        return this._multiple;\n    }\n    set multiple(value) {\n        if (this._selectionModel && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getMatSelectDynamicMultipleError();\n        }\n        this._multiple = coerceBooleanProperty(value);\n    }\n    /** Whether to center the active option over the trigger. */\n    get disableOptionCentering() {\n        return this._disableOptionCentering;\n    }\n    set disableOptionCentering(value) {\n        this._disableOptionCentering = coerceBooleanProperty(value);\n    }\n    /**\n     * Function to compare the option values with the selected values. The first argument\n     * is a value from an option. The second is a value from the selection. A boolean\n     * should be returned.\n     */\n    get compareWith() {\n        return this._compareWith;\n    }\n    set compareWith(fn) {\n        if (typeof fn !== 'function' && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getMatSelectNonFunctionValueError();\n        }\n        this._compareWith = fn;\n        if (this._selectionModel) {\n            // A different comparator means the selection could change.\n            this._initializeSelection();\n        }\n    }\n    /** Value of the select control. */\n    get value() {\n        return this._value;\n    }\n    set value(newValue) {\n        const hasAssigned = this._assignValue(newValue);\n        if (hasAssigned) {\n            this._onChange(newValue);\n        }\n    }\n    /** Time to wait in milliseconds after the last keystroke before moving focus to an item. */\n    get typeaheadDebounceInterval() {\n        return this._typeaheadDebounceInterval;\n    }\n    set typeaheadDebounceInterval(value) {\n        this._typeaheadDebounceInterval = coerceNumberProperty(value);\n    }\n    /** Unique id of the element. */\n    get id() {\n        return this._id;\n    }\n    set id(value) {\n        this._id = value || this._uid;\n        this.stateChanges.next();\n    }\n    ngOnInit() {\n        this._selectionModel = new SelectionModel(this.multiple);\n        this.stateChanges.next();\n        // We need `distinctUntilChanged` here, because some browsers will\n        // fire the animation end event twice for the same animation. See:\n        // https://github.com/angular/angular/issues/24084\n        this._panelDoneAnimatingStream\n            .pipe(distinctUntilChanged(), takeUntil(this._destroy))\n            .subscribe(() => this._panelDoneAnimating(this.panelOpen));\n    }\n    ngAfterContentInit() {\n        this._initKeyManager();\n        this._selectionModel.changed.pipe(takeUntil(this._destroy)).subscribe(event => {\n            event.added.forEach(option => option.select());\n            event.removed.forEach(option => option.deselect());\n        });\n        this.options.changes.pipe(startWith(null), takeUntil(this._destroy)).subscribe(() => {\n            this._resetOptions();\n            this._initializeSelection();\n        });\n    }\n    ngDoCheck() {\n        const newAriaLabelledby = this._getTriggerAriaLabelledby();\n        const ngControl = this.ngControl;\n        // We have to manage setting the `aria-labelledby` ourselves, because part of its value\n        // is computed as a result of a content query which can cause this binding to trigger a\n        // \"changed after checked\" error.\n        if (newAriaLabelledby !== this._triggerAriaLabelledBy) {\n            const element = this._elementRef.nativeElement;\n            this._triggerAriaLabelledBy = newAriaLabelledby;\n            if (newAriaLabelledby) {\n                element.setAttribute('aria-labelledby', newAriaLabelledby);\n            }\n            else {\n                element.removeAttribute('aria-labelledby');\n            }\n        }\n        if (ngControl) {\n            // The disabled state might go out of sync if the form group is swapped out. See #17860.\n            if (this._previousControl !== ngControl.control) {\n                if (this._previousControl !== undefined &&\n                    ngControl.disabled !== null &&\n                    ngControl.disabled !== this.disabled) {\n                    this.disabled = ngControl.disabled;\n                }\n                this._previousControl = ngControl.control;\n            }\n            this.updateErrorState();\n        }\n    }\n    ngOnChanges(changes) {\n        // Updating the disabled state is handled by `mixinDisabled`, but we need to additionally let\n        // the parent form field know to run change detection when the disabled state changes.\n        if (changes['disabled']) {\n            this.stateChanges.next();\n        }\n        if (changes['typeaheadDebounceInterval'] && this._keyManager) {\n            this._keyManager.withTypeAhead(this._typeaheadDebounceInterval);\n        }\n    }\n    ngOnDestroy() {\n        this._destroy.next();\n        this._destroy.complete();\n        this.stateChanges.complete();\n    }\n    /** Toggles the overlay panel open or closed. */\n    toggle() {\n        this.panelOpen ? this.close() : this.open();\n    }\n    /** Opens the overlay panel. */\n    open() {\n        if (this._canOpen()) {\n            this._panelOpen = true;\n            this._keyManager.withHorizontalOrientation(null);\n            this._highlightCorrectOption();\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n    /** Closes the overlay panel and focuses the host element. */\n    close() {\n        if (this._panelOpen) {\n            this._panelOpen = false;\n            this._keyManager.withHorizontalOrientation(this._isRtl() ? 'rtl' : 'ltr');\n            this._changeDetectorRef.markForCheck();\n            this._onTouched();\n        }\n    }\n    /**\n     * Sets the select's value. Part of the ControlValueAccessor interface\n     * required to integrate with Angular's core forms API.\n     *\n     * @param value New value to be written to the model.\n     */\n    writeValue(value) {\n        this._assignValue(value);\n    }\n    /**\n     * Saves a callback function to be invoked when the select's value\n     * changes from user input. Part of the ControlValueAccessor interface\n     * required to integrate with Angular's core forms API.\n     *\n     * @param fn Callback to be triggered when the value changes.\n     */\n    registerOnChange(fn) {\n        this._onChange = fn;\n    }\n    /**\n     * Saves a callback function to be invoked when the select is blurred\n     * by the user. Part of the ControlValueAccessor interface required\n     * to integrate with Angular's core forms API.\n     *\n     * @param fn Callback to be triggered when the component has been touched.\n     */\n    registerOnTouched(fn) {\n        this._onTouched = fn;\n    }\n    /**\n     * Disables the select. Part of the ControlValueAccessor interface required\n     * to integrate with Angular's core forms API.\n     *\n     * @param isDisabled Sets whether the component is disabled.\n     */\n    setDisabledState(isDisabled) {\n        this.disabled = isDisabled;\n        this._changeDetectorRef.markForCheck();\n        this.stateChanges.next();\n    }\n    /** Whether or not the overlay panel is open. */\n    get panelOpen() {\n        return this._panelOpen;\n    }\n    /** The currently selected option. */\n    get selected() {\n        return this.multiple ? this._selectionModel?.selected || [] : this._selectionModel?.selected[0];\n    }\n    /** The value displayed in the trigger. */\n    get triggerValue() {\n        if (this.empty) {\n            return '';\n        }\n        if (this._multiple) {\n            const selectedOptions = this._selectionModel.selected.map(option => option.viewValue);\n            if (this._isRtl()) {\n                selectedOptions.reverse();\n            }\n            // TODO(crisbeto): delimiter should be configurable for proper localization.\n            return selectedOptions.join(', ');\n        }\n        return this._selectionModel.selected[0].viewValue;\n    }\n    /** Whether the element is in RTL mode. */\n    _isRtl() {\n        return this._dir ? this._dir.value === 'rtl' : false;\n    }\n    /** Handles all keydown events on the select. */\n    _handleKeydown(event) {\n        if (!this.disabled) {\n            this.panelOpen ? this._handleOpenKeydown(event) : this._handleClosedKeydown(event);\n        }\n    }\n    /** Handles keyboard events while the select is closed. */\n    _handleClosedKeydown(event) {\n        const keyCode = event.keyCode;\n        const isArrowKey = keyCode === DOWN_ARROW ||\n            keyCode === UP_ARROW ||\n            keyCode === LEFT_ARROW ||\n            keyCode === RIGHT_ARROW;\n        const isOpenKey = keyCode === ENTER || keyCode === SPACE;\n        const manager = this._keyManager;\n        // Open the select on ALT + arrow key to match the native <select>\n        if ((!manager.isTyping() && isOpenKey && !hasModifierKey(event)) ||\n            ((this.multiple || event.altKey) && isArrowKey)) {\n            event.preventDefault(); // prevents the page from scrolling down when pressing space\n            this.open();\n        }\n        else if (!this.multiple) {\n            const previouslySelectedOption = this.selected;\n            manager.onKeydown(event);\n            const selectedOption = this.selected;\n            // Since the value has changed, we need to announce it ourselves.\n            if (selectedOption && previouslySelectedOption !== selectedOption) {\n                // We set a duration on the live announcement, because we want the live element to be\n                // cleared after a while so that users can't navigate to it using the arrow keys.\n                this._liveAnnouncer.announce(selectedOption.viewValue, 10000);\n            }\n        }\n    }\n    /** Handles keyboard events when the selected is open. */\n    _handleOpenKeydown(event) {\n        const manager = this._keyManager;\n        const keyCode = event.keyCode;\n        const isArrowKey = keyCode === DOWN_ARROW || keyCode === UP_ARROW;\n        const isTyping = manager.isTyping();\n        if (isArrowKey && event.altKey) {\n            // Close the select on ALT + arrow key to match the native <select>\n            event.preventDefault();\n            this.close();\n            // Don't do anything in this case if the user is typing,\n            // because the typing sequence can include the space key.\n        }\n        else if (!isTyping &&\n            (keyCode === ENTER || keyCode === SPACE) &&\n            manager.activeItem &&\n            !hasModifierKey(event)) {\n            event.preventDefault();\n            manager.activeItem._selectViaInteraction();\n        }\n        else if (!isTyping && this._multiple && keyCode === A && event.ctrlKey) {\n            event.preventDefault();\n            const hasDeselectedOptions = this.options.some(opt => !opt.disabled && !opt.selected);\n            this.options.forEach(option => {\n                if (!option.disabled) {\n                    hasDeselectedOptions ? option.select() : option.deselect();\n                }\n            });\n        }\n        else {\n            const previouslyFocusedIndex = manager.activeItemIndex;\n            manager.onKeydown(event);\n            if (this._multiple &&\n                isArrowKey &&\n                event.shiftKey &&\n                manager.activeItem &&\n                manager.activeItemIndex !== previouslyFocusedIndex) {\n                manager.activeItem._selectViaInteraction();\n            }\n        }\n    }\n    _onFocus() {\n        if (!this.disabled) {\n            this._focused = true;\n            this.stateChanges.next();\n        }\n    }\n    /**\n     * Calls the touched callback only if the panel is closed. Otherwise, the trigger will\n     * \"blur\" to the panel when it opens, causing a false positive.\n     */\n    _onBlur() {\n        this._focused = false;\n        if (!this.disabled && !this.panelOpen) {\n            this._onTouched();\n            this._changeDetectorRef.markForCheck();\n            this.stateChanges.next();\n        }\n    }\n    /**\n     * Callback that is invoked when the overlay panel has been attached.\n     */\n    _onAttached() {\n        this._overlayDir.positionChange.pipe(take(1)).subscribe(() => {\n            this._changeDetectorRef.detectChanges();\n            this._positioningSettled();\n        });\n    }\n    /** Returns the theme to be used on the panel. */\n    _getPanelTheme() {\n        return this._parentFormField ? `mat-${this._parentFormField.color}` : '';\n    }\n    /** Whether the select has a value. */\n    get empty() {\n        return !this._selectionModel || this._selectionModel.isEmpty();\n    }\n    _initializeSelection() {\n        // Defer setting the value in order to avoid the \"Expression\n        // has changed after it was checked\" errors from Angular.\n        Promise.resolve().then(() => {\n            if (this.ngControl) {\n                this._value = this.ngControl.value;\n            }\n            this._setSelectionByValue(this._value);\n            this.stateChanges.next();\n        });\n    }\n    /**\n     * Sets the selected option based on a value. If no option can be\n     * found with the designated value, the select trigger is cleared.\n     */\n    _setSelectionByValue(value) {\n        this._selectionModel.selected.forEach(option => option.setInactiveStyles());\n        this._selectionModel.clear();\n        if (this.multiple && value) {\n            if (!Array.isArray(value) && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                throw getMatSelectNonArrayValueError();\n            }\n            value.forEach((currentValue) => this._selectOptionByValue(currentValue));\n            this._sortValues();\n        }\n        else {\n            const correspondingOption = this._selectOptionByValue(value);\n            // Shift focus to the active item. Note that we shouldn't do this in multiple\n            // mode, because we don't know what option the user interacted with last.\n            if (correspondingOption) {\n                this._keyManager.updateActiveItem(correspondingOption);\n            }\n            else if (!this.panelOpen) {\n                // Otherwise reset the highlighted option. Note that we only want to do this while\n                // closed, because doing it while open can shift the user's focus unnecessarily.\n                this._keyManager.updateActiveItem(-1);\n            }\n        }\n        this._changeDetectorRef.markForCheck();\n    }\n    /**\n     * Finds and selects and option based on its value.\n     * @returns Option that has the corresponding value.\n     */\n    _selectOptionByValue(value) {\n        const correspondingOption = this.options.find((option) => {\n            // Skip options that are already in the model. This allows us to handle cases\n            // where the same primitive value is selected multiple times.\n            if (this._selectionModel.isSelected(option)) {\n                return false;\n            }\n            try {\n                // Treat null as a special reset value.\n                return option.value != null && this._compareWith(option.value, value);\n            }\n            catch (error) {\n                if (typeof ngDevMode === 'undefined' || ngDevMode) {\n                    // Notify developers of errors in their comparator.\n                    console.warn(error);\n                }\n                return false;\n            }\n        });\n        if (correspondingOption) {\n            this._selectionModel.select(correspondingOption);\n        }\n        return correspondingOption;\n    }\n    /** Assigns a specific value to the select. Returns whether the value has changed. */\n    _assignValue(newValue) {\n        // Always re-assign an array, because it might have been mutated.\n        if (newValue !== this._value || (this._multiple && Array.isArray(newValue))) {\n            if (this.options) {\n                this._setSelectionByValue(newValue);\n            }\n            this._value = newValue;\n            return true;\n        }\n        return false;\n    }\n    /** Sets up a key manager to listen to keyboard events on the overlay panel. */\n    _initKeyManager() {\n        this._keyManager = new ActiveDescendantKeyManager(this.options)\n            .withTypeAhead(this._typeaheadDebounceInterval)\n            .withVerticalOrientation()\n            .withHorizontalOrientation(this._isRtl() ? 'rtl' : 'ltr')\n            .withHomeAndEnd()\n            .withAllowedModifierKeys(['shiftKey']);\n        this._keyManager.tabOut.pipe(takeUntil(this._destroy)).subscribe(() => {\n            if (this.panelOpen) {\n                // Select the active item when tabbing away. This is consistent with how the native\n                // select behaves. Note that we only want to do this in single selection mode.\n                if (!this.multiple && this._keyManager.activeItem) {\n                    this._keyManager.activeItem._selectViaInteraction();\n                }\n                // Restore focus to the trigger before closing. Ensures that the focus\n                // position won't be lost if the user got focus into the overlay.\n                this.focus();\n                this.close();\n            }\n        });\n        this._keyManager.change.pipe(takeUntil(this._destroy)).subscribe(() => {\n            if (this._panelOpen && this.panel) {\n                this._scrollOptionIntoView(this._keyManager.activeItemIndex || 0);\n            }\n            else if (!this._panelOpen && !this.multiple && this._keyManager.activeItem) {\n                this._keyManager.activeItem._selectViaInteraction();\n            }\n        });\n    }\n    /** Drops current option subscriptions and IDs and resets from scratch. */\n    _resetOptions() {\n        const changedOrDestroyed = merge(this.options.changes, this._destroy);\n        this.optionSelectionChanges.pipe(takeUntil(changedOrDestroyed)).subscribe(event => {\n            this._onSelect(event.source, event.isUserInput);\n            if (event.isUserInput && !this.multiple && this._panelOpen) {\n                this.close();\n                this.focus();\n            }\n        });\n        // Listen to changes in the internal state of the options and react accordingly.\n        // Handles cases like the labels of the selected options changing.\n        merge(...this.options.map(option => option._stateChanges))\n            .pipe(takeUntil(changedOrDestroyed))\n            .subscribe(() => {\n            this._changeDetectorRef.markForCheck();\n            this.stateChanges.next();\n        });\n    }\n    /** Invoked when an option is clicked. */\n    _onSelect(option, isUserInput) {\n        const wasSelected = this._selectionModel.isSelected(option);\n        if (option.value == null && !this._multiple) {\n            option.deselect();\n            this._selectionModel.clear();\n            if (this.value != null) {\n                this._propagateChanges(option.value);\n            }\n        }\n        else {\n            if (wasSelected !== option.selected) {\n                option.selected\n                    ? this._selectionModel.select(option)\n                    : this._selectionModel.deselect(option);\n            }\n            if (isUserInput) {\n                this._keyManager.setActiveItem(option);\n            }\n            if (this.multiple) {\n                this._sortValues();\n                if (isUserInput) {\n                    // In case the user selected the option with their mouse, we\n                    // want to restore focus back to the trigger, in order to\n                    // prevent the select keyboard controls from clashing with\n                    // the ones from `mat-option`.\n                    this.focus();\n                }\n            }\n        }\n        if (wasSelected !== this._selectionModel.isSelected(option)) {\n            this._propagateChanges();\n        }\n        this.stateChanges.next();\n    }\n    /** Sorts the selected values in the selected based on their order in the panel. */\n    _sortValues() {\n        if (this.multiple) {\n            const options = this.options.toArray();\n            this._selectionModel.sort((a, b) => {\n                return this.sortComparator\n                    ? this.sortComparator(a, b, options)\n                    : options.indexOf(a) - options.indexOf(b);\n            });\n            this.stateChanges.next();\n        }\n    }\n    /** Emits change event to set the model value. */\n    _propagateChanges(fallbackValue) {\n        let valueToEmit = null;\n        if (this.multiple) {\n            valueToEmit = this.selected.map(option => option.value);\n        }\n        else {\n            valueToEmit = this.selected ? this.selected.value : fallbackValue;\n        }\n        this._value = valueToEmit;\n        this.valueChange.emit(valueToEmit);\n        this._onChange(valueToEmit);\n        this.selectionChange.emit(this._getChangeEvent(valueToEmit));\n        this._changeDetectorRef.markForCheck();\n    }\n    /**\n     * Highlights the selected item. If no option is selected, it will highlight\n     * the first item instead.\n     */\n    _highlightCorrectOption() {\n        if (this._keyManager) {\n            if (this.empty) {\n                this._keyManager.setFirstItemActive();\n            }\n            else {\n                this._keyManager.setActiveItem(this._selectionModel.selected[0]);\n            }\n        }\n    }\n    /** Whether the panel is allowed to open. */\n    _canOpen() {\n        return !this._panelOpen && !this.disabled && this.options?.length > 0;\n    }\n    /** Focuses the select element. */\n    focus(options) {\n        this._elementRef.nativeElement.focus(options);\n    }\n    /** Gets the aria-labelledby for the select panel. */\n    _getPanelAriaLabelledby() {\n        if (this.ariaLabel) {\n            return null;\n        }\n        const labelId = this._parentFormField?.getLabelId();\n        const labelExpression = labelId ? labelId + ' ' : '';\n        return this.ariaLabelledby ? labelExpression + this.ariaLabelledby : labelId;\n    }\n    /** Determines the `aria-activedescendant` to be set on the host. */\n    _getAriaActiveDescendant() {\n        if (this.panelOpen && this._keyManager && this._keyManager.activeItem) {\n            return this._keyManager.activeItem.id;\n        }\n        return null;\n    }\n    /** Gets the aria-labelledby of the select component trigger. */\n    _getTriggerAriaLabelledby() {\n        if (this.ariaLabel) {\n            return null;\n        }\n        const labelId = this._parentFormField?.getLabelId();\n        let value = (labelId ? labelId + ' ' : '') + this._valueId;\n        if (this.ariaLabelledby) {\n            value += ' ' + this.ariaLabelledby;\n        }\n        return value;\n    }\n    /** Called when the overlay panel is done animating. */\n    _panelDoneAnimating(isOpen) {\n        this.openedChange.emit(isOpen);\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    setDescribedByIds(ids) {\n        this._ariaDescribedby = ids.join(' ');\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    onContainerClick() {\n        this.focus();\n        this.open();\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get shouldLabelFloat() {\n        return this._panelOpen || !this.empty || (this._focused && !!this._placeholder);\n    }\n}\n_MatSelectBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatSelectBase, deps: [{ token: i1.ViewportRuler }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }, { token: i2.ErrorStateMatcher }, { token: i0.ElementRef }, { token: i3.Directionality, optional: true }, { token: i4.NgForm, optional: true }, { token: i4.FormGroupDirective, optional: true }, { token: MAT_FORM_FIELD, optional: true }, { token: i4.NgControl, optional: true, self: true }, { token: 'tabindex', attribute: true }, { token: MAT_SELECT_SCROLL_STRATEGY }, { token: i5.LiveAnnouncer }, { token: MAT_SELECT_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\n_MatSelectBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: _MatSelectBase, inputs: { panelClass: \"panelClass\", placeholder: \"placeholder\", required: \"required\", multiple: \"multiple\", disableOptionCentering: \"disableOptionCentering\", compareWith: \"compareWith\", value: \"value\", ariaLabel: [\"aria-label\", \"ariaLabel\"], ariaLabelledby: [\"aria-labelledby\", \"ariaLabelledby\"], errorStateMatcher: \"errorStateMatcher\", typeaheadDebounceInterval: \"typeaheadDebounceInterval\", sortComparator: \"sortComparator\", id: \"id\" }, outputs: { openedChange: \"openedChange\", _openedStream: \"opened\", _closedStream: \"closed\", selectionChange: \"selectionChange\", valueChange: \"valueChange\" }, viewQueries: [{ propertyName: \"trigger\", first: true, predicate: [\"trigger\"], descendants: true }, { propertyName: \"panel\", first: true, predicate: [\"panel\"], descendants: true }, { propertyName: \"_overlayDir\", first: true, predicate: CdkConnectedOverlay, descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatSelectBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i1.ViewportRuler }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }, { type: i2.ErrorStateMatcher }, { type: i0.ElementRef }, { type: i3.Directionality, decorators: [{\n                    type: Optional\n                }] }, { type: i4.NgForm, decorators: [{\n                    type: Optional\n                }] }, { type: i4.FormGroupDirective, decorators: [{\n                    type: Optional\n                }] }, { type: i6.MatFormField, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_FORM_FIELD]\n                }] }, { type: i4.NgControl, decorators: [{\n                    type: Self\n                }, {\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Attribute,\n                    args: ['tabindex']\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_SELECT_SCROLL_STRATEGY]\n                }] }, { type: i5.LiveAnnouncer }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_SELECT_CONFIG]\n                }] }]; }, propDecorators: { trigger: [{\n                type: ViewChild,\n                args: ['trigger']\n            }], panel: [{\n                type: ViewChild,\n                args: ['panel']\n            }], _overlayDir: [{\n                type: ViewChild,\n                args: [CdkConnectedOverlay]\n            }], panelClass: [{\n                type: Input\n            }], placeholder: [{\n                type: Input\n            }], required: [{\n                type: Input\n            }], multiple: [{\n                type: Input\n            }], disableOptionCentering: [{\n                type: Input\n            }], compareWith: [{\n                type: Input\n            }], value: [{\n                type: Input\n            }], ariaLabel: [{\n                type: Input,\n                args: ['aria-label']\n            }], ariaLabelledby: [{\n                type: Input,\n                args: ['aria-labelledby']\n            }], errorStateMatcher: [{\n                type: Input\n            }], typeaheadDebounceInterval: [{\n                type: Input\n            }], sortComparator: [{\n                type: Input\n            }], id: [{\n                type: Input\n            }], openedChange: [{\n                type: Output\n            }], _openedStream: [{\n                type: Output,\n                args: ['opened']\n            }], _closedStream: [{\n                type: Output,\n                args: ['closed']\n            }], selectionChange: [{\n                type: Output\n            }], valueChange: [{\n                type: Output\n            }] } });\nclass MatSelect extends _MatSelectBase {\n    constructor() {\n        super(...arguments);\n        /** The scroll position of the overlay panel, calculated to center the selected option. */\n        this._scrollTop = 0;\n        /** The cached font-size of the trigger element. */\n        this._triggerFontSize = 0;\n        /** The value of the select panel's transform-origin property. */\n        this._transformOrigin = 'top';\n        /**\n         * The y-offset of the overlay panel in relation to the trigger's top start corner.\n         * This must be adjusted to align the selected option text over the trigger text.\n         * when the panel opens. Will change based on the y-position of the selected option.\n         */\n        this._offsetY = 0;\n        this._positions = [\n            {\n                originX: 'start',\n                originY: 'top',\n                overlayX: 'start',\n                overlayY: 'top',\n            },\n            {\n                originX: 'start',\n                originY: 'bottom',\n                overlayX: 'start',\n                overlayY: 'bottom',\n            },\n        ];\n    }\n    /**\n     * Calculates the scroll position of the select's overlay panel.\n     *\n     * Attempts to center the selected option in the panel. If the option is\n     * too high or too low in the panel to be scrolled to the center, it clamps the\n     * scroll position to the min or max scroll positions respectively.\n     */\n    _calculateOverlayScroll(selectedIndex, scrollBuffer, maxScroll) {\n        const itemHeight = this._getItemHeight();\n        const optionOffsetFromScrollTop = itemHeight * selectedIndex;\n        const halfOptionHeight = itemHeight / 2;\n        // Starts at the optionOffsetFromScrollTop, which scrolls the option to the top of the\n        // scroll container, then subtracts the scroll buffer to scroll the option down to\n        // the center of the overlay panel. Half the option height must be re-added to the\n        // scrollTop so the option is centered based on its middle, not its top edge.\n        const optimalScrollPosition = optionOffsetFromScrollTop - scrollBuffer + halfOptionHeight;\n        return Math.min(Math.max(0, optimalScrollPosition), maxScroll);\n    }\n    ngOnInit() {\n        super.ngOnInit();\n        this._viewportRuler\n            .change()\n            .pipe(takeUntil(this._destroy))\n            .subscribe(() => {\n            if (this.panelOpen) {\n                this._triggerRect = this.trigger.nativeElement.getBoundingClientRect();\n                this._changeDetectorRef.markForCheck();\n            }\n        });\n    }\n    open() {\n        if (super._canOpen()) {\n            super.open();\n            this._triggerRect = this.trigger.nativeElement.getBoundingClientRect();\n            // Note: The computed font-size will be a string pixel value (e.g. \"16px\").\n            // `parseInt` ignores the trailing 'px' and converts this to a number.\n            this._triggerFontSize = parseInt(getComputedStyle(this.trigger.nativeElement).fontSize || '0');\n            this._calculateOverlayPosition();\n            // Set the font size on the panel element once it exists.\n            this._ngZone.onStable.pipe(take(1)).subscribe(() => {\n                if (this._triggerFontSize &&\n                    this._overlayDir.overlayRef &&\n                    this._overlayDir.overlayRef.overlayElement) {\n                    this._overlayDir.overlayRef.overlayElement.style.fontSize = `${this._triggerFontSize}px`;\n                }\n            });\n        }\n    }\n    /** Scrolls the active option into view. */\n    _scrollOptionIntoView(index) {\n        const labelCount = _countGroupLabelsBeforeOption(index, this.options, this.optionGroups);\n        const itemHeight = this._getItemHeight();\n        if (index === 0 && labelCount === 1) {\n            // If we've got one group label before the option and we're at the top option,\n            // scroll the list to the top. This is better UX than scrolling the list to the\n            // top of the option, because it allows the user to read the top group's label.\n            this.panel.nativeElement.scrollTop = 0;\n        }\n        else {\n            this.panel.nativeElement.scrollTop = _getOptionScrollPosition((index + labelCount) * itemHeight, itemHeight, this.panel.nativeElement.scrollTop, SELECT_PANEL_MAX_HEIGHT);\n        }\n    }\n    _positioningSettled() {\n        this._calculateOverlayOffsetX();\n        this.panel.nativeElement.scrollTop = this._scrollTop;\n    }\n    _panelDoneAnimating(isOpen) {\n        if (this.panelOpen) {\n            this._scrollTop = 0;\n        }\n        else {\n            this._overlayDir.offsetX = 0;\n            this._changeDetectorRef.markForCheck();\n        }\n        super._panelDoneAnimating(isOpen);\n    }\n    _getChangeEvent(value) {\n        return new MatSelectChange(this, value);\n    }\n    /**\n     * Sets the x-offset of the overlay panel in relation to the trigger's top start corner.\n     * This must be adjusted to align the selected option text over the trigger text when\n     * the panel opens. Will change based on LTR or RTL text direction. Note that the offset\n     * can't be calculated until the panel has been attached, because we need to know the\n     * content width in order to constrain the panel within the viewport.\n     */\n    _calculateOverlayOffsetX() {\n        const overlayRect = this._overlayDir.overlayRef.overlayElement.getBoundingClientRect();\n        const viewportSize = this._viewportRuler.getViewportSize();\n        const isRtl = this._isRtl();\n        const paddingWidth = this.multiple\n            ? SELECT_MULTIPLE_PANEL_PADDING_X + SELECT_PANEL_PADDING_X\n            : SELECT_PANEL_PADDING_X * 2;\n        let offsetX;\n        // Adjust the offset, depending on the option padding.\n        if (this.multiple) {\n            offsetX = SELECT_MULTIPLE_PANEL_PADDING_X;\n        }\n        else if (this.disableOptionCentering) {\n            offsetX = SELECT_PANEL_PADDING_X;\n        }\n        else {\n            let selected = this._selectionModel.selected[0] || this.options.first;\n            offsetX = selected && selected.group ? SELECT_PANEL_INDENT_PADDING_X : SELECT_PANEL_PADDING_X;\n        }\n        // Invert the offset in LTR.\n        if (!isRtl) {\n            offsetX *= -1;\n        }\n        // Determine how much the select overflows on each side.\n        const leftOverflow = 0 - (overlayRect.left + offsetX - (isRtl ? paddingWidth : 0));\n        const rightOverflow = overlayRect.right + offsetX - viewportSize.width + (isRtl ? 0 : paddingWidth);\n        // If the element overflows on either side, reduce the offset to allow it to fit.\n        if (leftOverflow > 0) {\n            offsetX += leftOverflow + SELECT_PANEL_VIEWPORT_PADDING;\n        }\n        else if (rightOverflow > 0) {\n            offsetX -= rightOverflow + SELECT_PANEL_VIEWPORT_PADDING;\n        }\n        // Set the offset directly in order to avoid having to go through change detection and\n        // potentially triggering \"changed after it was checked\" errors. Round the value to avoid\n        // blurry content in some browsers.\n        this._overlayDir.offsetX = Math.round(offsetX);\n        this._overlayDir.overlayRef.updatePosition();\n    }\n    /**\n     * Calculates the y-offset of the select's overlay panel in relation to the\n     * top start corner of the trigger. It has to be adjusted in order for the\n     * selected option to be aligned over the trigger when the panel opens.\n     */\n    _calculateOverlayOffsetY(selectedIndex, scrollBuffer, maxScroll) {\n        const itemHeight = this._getItemHeight();\n        const optionHeightAdjustment = (itemHeight - this._triggerRect.height) / 2;\n        const maxOptionsDisplayed = Math.floor(SELECT_PANEL_MAX_HEIGHT / itemHeight);\n        let optionOffsetFromPanelTop;\n        // Disable offset if requested by user by returning 0 as value to offset\n        if (this.disableOptionCentering) {\n            return 0;\n        }\n        if (this._scrollTop === 0) {\n            optionOffsetFromPanelTop = selectedIndex * itemHeight;\n        }\n        else if (this._scrollTop === maxScroll) {\n            const firstDisplayedIndex = this._getItemCount() - maxOptionsDisplayed;\n            const selectedDisplayIndex = selectedIndex - firstDisplayedIndex;\n            // The first item is partially out of the viewport. Therefore we need to calculate what\n            // portion of it is shown in the viewport and account for it in our offset.\n            let partialItemHeight = itemHeight - ((this._getItemCount() * itemHeight - SELECT_PANEL_MAX_HEIGHT) % itemHeight);\n            // Because the panel height is longer than the height of the options alone,\n            // there is always extra padding at the top or bottom of the panel. When\n            // scrolled to the very bottom, this padding is at the top of the panel and\n            // must be added to the offset.\n            optionOffsetFromPanelTop = selectedDisplayIndex * itemHeight + partialItemHeight;\n        }\n        else {\n            // If the option was scrolled to the middle of the panel using a scroll buffer,\n            // its offset will be the scroll buffer minus the half height that was added to\n            // center it.\n            optionOffsetFromPanelTop = scrollBuffer - itemHeight / 2;\n        }\n        // The final offset is the option's offset from the top, adjusted for the height difference,\n        // multiplied by -1 to ensure that the overlay moves in the correct direction up the page.\n        // The value is rounded to prevent some browsers from blurring the content.\n        return Math.round(optionOffsetFromPanelTop * -1 - optionHeightAdjustment);\n    }\n    /**\n     * Checks that the attempted overlay position will fit within the viewport.\n     * If it will not fit, tries to adjust the scroll position and the associated\n     * y-offset so the panel can open fully on-screen. If it still won't fit,\n     * sets the offset back to 0 to allow the fallback position to take over.\n     */\n    _checkOverlayWithinViewport(maxScroll) {\n        const itemHeight = this._getItemHeight();\n        const viewportSize = this._viewportRuler.getViewportSize();\n        const topSpaceAvailable = this._triggerRect.top - SELECT_PANEL_VIEWPORT_PADDING;\n        const bottomSpaceAvailable = viewportSize.height - this._triggerRect.bottom - SELECT_PANEL_VIEWPORT_PADDING;\n        const panelHeightTop = Math.abs(this._offsetY);\n        const totalPanelHeight = Math.min(this._getItemCount() * itemHeight, SELECT_PANEL_MAX_HEIGHT);\n        const panelHeightBottom = totalPanelHeight - panelHeightTop - this._triggerRect.height;\n        if (panelHeightBottom > bottomSpaceAvailable) {\n            this._adjustPanelUp(panelHeightBottom, bottomSpaceAvailable);\n        }\n        else if (panelHeightTop > topSpaceAvailable) {\n            this._adjustPanelDown(panelHeightTop, topSpaceAvailable, maxScroll);\n        }\n        else {\n            this._transformOrigin = this._getOriginBasedOnOption();\n        }\n    }\n    /** Adjusts the overlay panel up to fit in the viewport. */\n    _adjustPanelUp(panelHeightBottom, bottomSpaceAvailable) {\n        // Browsers ignore fractional scroll offsets, so we need to round.\n        const distanceBelowViewport = Math.round(panelHeightBottom - bottomSpaceAvailable);\n        // Scrolls the panel up by the distance it was extending past the boundary, then\n        // adjusts the offset by that amount to move the panel up into the viewport.\n        this._scrollTop -= distanceBelowViewport;\n        this._offsetY -= distanceBelowViewport;\n        this._transformOrigin = this._getOriginBasedOnOption();\n        // If the panel is scrolled to the very top, it won't be able to fit the panel\n        // by scrolling, so set the offset to 0 to allow the fallback position to take\n        // effect.\n        if (this._scrollTop <= 0) {\n            this._scrollTop = 0;\n            this._offsetY = 0;\n            this._transformOrigin = `50% bottom 0px`;\n        }\n    }\n    /** Adjusts the overlay panel down to fit in the viewport. */\n    _adjustPanelDown(panelHeightTop, topSpaceAvailable, maxScroll) {\n        // Browsers ignore fractional scroll offsets, so we need to round.\n        const distanceAboveViewport = Math.round(panelHeightTop - topSpaceAvailable);\n        // Scrolls the panel down by the distance it was extending past the boundary, then\n        // adjusts the offset by that amount to move the panel down into the viewport.\n        this._scrollTop += distanceAboveViewport;\n        this._offsetY += distanceAboveViewport;\n        this._transformOrigin = this._getOriginBasedOnOption();\n        // If the panel is scrolled to the very bottom, it won't be able to fit the\n        // panel by scrolling, so set the offset to 0 to allow the fallback position\n        // to take effect.\n        if (this._scrollTop >= maxScroll) {\n            this._scrollTop = maxScroll;\n            this._offsetY = 0;\n            this._transformOrigin = `50% top 0px`;\n            return;\n        }\n    }\n    /** Calculates the scroll position and x- and y-offsets of the overlay panel. */\n    _calculateOverlayPosition() {\n        const itemHeight = this._getItemHeight();\n        const items = this._getItemCount();\n        const panelHeight = Math.min(items * itemHeight, SELECT_PANEL_MAX_HEIGHT);\n        const scrollContainerHeight = items * itemHeight;\n        // The farthest the panel can be scrolled before it hits the bottom\n        const maxScroll = scrollContainerHeight - panelHeight;\n        // If no value is selected we open the popup to the first item.\n        let selectedOptionOffset;\n        if (this.empty) {\n            selectedOptionOffset = 0;\n        }\n        else {\n            selectedOptionOffset = Math.max(this.options.toArray().indexOf(this._selectionModel.selected[0]), 0);\n        }\n        selectedOptionOffset += _countGroupLabelsBeforeOption(selectedOptionOffset, this.options, this.optionGroups);\n        // We must maintain a scroll buffer so the selected option will be scrolled to the\n        // center of the overlay panel rather than the top.\n        const scrollBuffer = panelHeight / 2;\n        this._scrollTop = this._calculateOverlayScroll(selectedOptionOffset, scrollBuffer, maxScroll);\n        this._offsetY = this._calculateOverlayOffsetY(selectedOptionOffset, scrollBuffer, maxScroll);\n        this._checkOverlayWithinViewport(maxScroll);\n    }\n    /** Sets the transform origin point based on the selected option. */\n    _getOriginBasedOnOption() {\n        const itemHeight = this._getItemHeight();\n        const optionHeightAdjustment = (itemHeight - this._triggerRect.height) / 2;\n        const originY = Math.abs(this._offsetY) - optionHeightAdjustment + itemHeight / 2;\n        return `50% ${originY}px 0px`;\n    }\n    /** Calculates the height of the select's options. */\n    _getItemHeight() {\n        return this._triggerFontSize * SELECT_ITEM_HEIGHT_EM;\n    }\n    /** Calculates the amount of items in the select. This includes options and group labels. */\n    _getItemCount() {\n        return this.options.length + this.optionGroups.length;\n    }\n}\nMatSelect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSelect, deps: null, target: i0.ɵɵFactoryTarget.Component });\nMatSelect.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatSelect, selector: \"mat-select\", inputs: { disabled: \"disabled\", disableRipple: \"disableRipple\", tabIndex: \"tabIndex\" }, host: { attributes: { \"role\": \"combobox\", \"aria-autocomplete\": \"none\", \"aria-haspopup\": \"true\" }, listeners: { \"keydown\": \"_handleKeydown($event)\", \"focus\": \"_onFocus()\", \"blur\": \"_onBlur()\" }, properties: { \"attr.id\": \"id\", \"attr.tabindex\": \"tabIndex\", \"attr.aria-controls\": \"panelOpen ? id + \\\"-panel\\\" : null\", \"attr.aria-expanded\": \"panelOpen\", \"attr.aria-label\": \"ariaLabel || null\", \"attr.aria-required\": \"required.toString()\", \"attr.aria-disabled\": \"disabled.toString()\", \"attr.aria-invalid\": \"errorState\", \"attr.aria-describedby\": \"_ariaDescribedby || null\", \"attr.aria-activedescendant\": \"_getAriaActiveDescendant()\", \"class.mat-select-disabled\": \"disabled\", \"class.mat-select-invalid\": \"errorState\", \"class.mat-select-required\": \"required\", \"class.mat-select-empty\": \"empty\", \"class.mat-select-multiple\": \"multiple\" }, classAttribute: \"mat-select\" }, providers: [\n        { provide: MatFormFieldControl, useExisting: MatSelect },\n        { provide: MAT_OPTION_PARENT_COMPONENT, useExisting: MatSelect },\n    ], queries: [{ propertyName: \"customTrigger\", first: true, predicate: MAT_SELECT_TRIGGER, descendants: true }, { propertyName: \"options\", predicate: MatOption, descendants: true }, { propertyName: \"optionGroups\", predicate: MAT_OPTGROUP, descendants: true }], exportAs: [\"matSelect\"], usesInheritance: true, ngImport: i0, template: \"<!--\\n Note that the select trigger element specifies `aria-owns` pointing to the listbox overlay.\\n While aria-owns is not required for the ARIA 1.2 `role=\\\"combobox\\\"` interaction pattern,\\n it fixes an issue with VoiceOver when the select appears inside of an `aria-model=\\\"true\\\"`\\n element (e.g. a dialog). Without this `aria-owns`, the `aria-modal` on a dialog prevents\\n VoiceOver from \\\"seeing\\\" the select's listbox overlay for aria-activedescendant.\\n Using `aria-owns` re-parents the select overlay so that it works again.\\n See https://github.com/angular/components/issues/20694\\n-->\\n<div cdk-overlay-origin\\n     [attr.aria-owns]=\\\"panelOpen ? id + '-panel' : null\\\"\\n     class=\\\"mat-select-trigger\\\"\\n     (click)=\\\"toggle()\\\"\\n     #origin=\\\"cdkOverlayOrigin\\\"\\n     #trigger>\\n  <div class=\\\"mat-select-value\\\" [ngSwitch]=\\\"empty\\\" [attr.id]=\\\"_valueId\\\">\\n    <span class=\\\"mat-select-placeholder mat-select-min-line\\\" *ngSwitchCase=\\\"true\\\">{{placeholder}}</span>\\n    <span class=\\\"mat-select-value-text\\\" *ngSwitchCase=\\\"false\\\" [ngSwitch]=\\\"!!customTrigger\\\">\\n      <span class=\\\"mat-select-min-line\\\" *ngSwitchDefault>{{triggerValue}}</span>\\n      <ng-content select=\\\"mat-select-trigger\\\" *ngSwitchCase=\\\"true\\\"></ng-content>\\n    </span>\\n  </div>\\n\\n  <div class=\\\"mat-select-arrow-wrapper\\\"><div class=\\\"mat-select-arrow\\\"></div></div>\\n</div>\\n\\n<ng-template\\n  cdk-connected-overlay\\n  cdkConnectedOverlayLockPosition\\n  cdkConnectedOverlayHasBackdrop\\n  cdkConnectedOverlayBackdropClass=\\\"cdk-overlay-transparent-backdrop\\\"\\n  [cdkConnectedOverlayPanelClass]=\\\"_overlayPanelClass\\\"\\n  [cdkConnectedOverlayScrollStrategy]=\\\"_scrollStrategy\\\"\\n  [cdkConnectedOverlayOrigin]=\\\"origin\\\"\\n  [cdkConnectedOverlayOpen]=\\\"panelOpen\\\"\\n  [cdkConnectedOverlayPositions]=\\\"_positions\\\"\\n  [cdkConnectedOverlayMinWidth]=\\\"_triggerRect?.width!\\\"\\n  [cdkConnectedOverlayOffsetY]=\\\"_offsetY\\\"\\n  (backdropClick)=\\\"close()\\\"\\n  (attach)=\\\"_onAttached()\\\"\\n  (detach)=\\\"close()\\\">\\n  <div class=\\\"mat-select-panel-wrap\\\" [@transformPanelWrap]>\\n    <div\\n      #panel\\n      role=\\\"listbox\\\"\\n      tabindex=\\\"-1\\\"\\n      class=\\\"mat-select-panel {{ _getPanelTheme() }}\\\"\\n      [attr.id]=\\\"id + '-panel'\\\"\\n      [attr.aria-multiselectable]=\\\"multiple\\\"\\n      [attr.aria-label]=\\\"ariaLabel || null\\\"\\n      [attr.aria-labelledby]=\\\"_getPanelAriaLabelledby()\\\"\\n      [ngClass]=\\\"panelClass\\\"\\n      [@transformPanel]=\\\"multiple ? 'showing-multiple' : 'showing'\\\"\\n      (@transformPanel.done)=\\\"_panelDoneAnimatingStream.next($event.toState)\\\"\\n      [style.transformOrigin]=\\\"_transformOrigin\\\"\\n      [style.font-size.px]=\\\"_triggerFontSize\\\"\\n      (keydown)=\\\"_handleKeydown($event)\\\">\\n      <ng-content></ng-content>\\n    </div>\\n  </div>\\n</ng-template>\\n\", styles: [\".mat-select{display:inline-block;width:100%;outline:none}.mat-select-trigger{display:inline-flex;align-items:center;cursor:pointer;position:relative;box-sizing:border-box;width:100%}.mat-select-disabled .mat-select-trigger{-webkit-user-select:none;user-select:none;cursor:default}.mat-select-value{width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.mat-select-value-text{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.mat-select-arrow-wrapper{height:16px;flex-shrink:0;display:inline-flex;align-items:center}.mat-form-field-appearance-fill .mat-select-arrow-wrapper{transform:translateY(-50%)}.mat-form-field-appearance-outline .mat-select-arrow-wrapper{transform:translateY(-25%)}.mat-form-field-appearance-standard.mat-form-field-has-label .mat-select:not(.mat-select-empty) .mat-select-arrow-wrapper{transform:translateY(-50%)}.mat-form-field-appearance-standard .mat-select.mat-select-empty .mat-select-arrow-wrapper{transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}._mat-animation-noopable.mat-form-field-appearance-standard .mat-select.mat-select-empty .mat-select-arrow-wrapper{transition:none}.mat-select-arrow{width:0;height:0;border-left:5px solid transparent;border-right:5px solid transparent;border-top:5px solid;margin:0 4px}.mat-form-field.mat-focused .mat-select-arrow{transform:translateX(0)}.mat-select-panel-wrap{flex-basis:100%}.mat-select-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;padding-top:0;padding-bottom:0;max-height:256px;min-width:100%;border-radius:4px;outline:0}.cdk-high-contrast-active .mat-select-panel{outline:solid 1px}.mat-select-panel .mat-optgroup-label,.mat-select-panel .mat-option{font-size:inherit;line-height:3em;height:3em}.mat-form-field-type-mat-select:not(.mat-form-field-disabled) .mat-form-field-flex{cursor:pointer}.mat-form-field-type-mat-select .mat-form-field-label{width:calc(100% - 18px)}.mat-select-placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}._mat-animation-noopable .mat-select-placeholder{transition:none}.mat-form-field-hide-placeholder .mat-select-placeholder{color:transparent;-webkit-text-fill-color:transparent;transition:none;display:block}.mat-select-min-line:empty::before{content:\\\" \\\";white-space:pre;width:1px;display:inline-block;visibility:hidden}\\n\"], directives: [{ type: i7.CdkOverlayOrigin, selector: \"[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]\", exportAs: [\"cdkOverlayOrigin\"] }, { type: i8.NgSwitch, selector: \"[ngSwitch]\", inputs: [\"ngSwitch\"] }, { type: i8.NgSwitchCase, selector: \"[ngSwitchCase]\", inputs: [\"ngSwitchCase\"] }, { type: i8.NgSwitchDefault, selector: \"[ngSwitchDefault]\" }, { type: i7.CdkConnectedOverlay, selector: \"[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]\", inputs: [\"cdkConnectedOverlayOrigin\", \"cdkConnectedOverlayPositions\", \"cdkConnectedOverlayPositionStrategy\", \"cdkConnectedOverlayOffsetX\", \"cdkConnectedOverlayOffsetY\", \"cdkConnectedOverlayWidth\", \"cdkConnectedOverlayHeight\", \"cdkConnectedOverlayMinWidth\", \"cdkConnectedOverlayMinHeight\", \"cdkConnectedOverlayBackdropClass\", \"cdkConnectedOverlayPanelClass\", \"cdkConnectedOverlayViewportMargin\", \"cdkConnectedOverlayScrollStrategy\", \"cdkConnectedOverlayOpen\", \"cdkConnectedOverlayDisableClose\", \"cdkConnectedOverlayTransformOriginOn\", \"cdkConnectedOverlayHasBackdrop\", \"cdkConnectedOverlayLockPosition\", \"cdkConnectedOverlayFlexibleDimensions\", \"cdkConnectedOverlayGrowAfterOpen\", \"cdkConnectedOverlayPush\"], outputs: [\"backdropClick\", \"positionChange\", \"attach\", \"detach\", \"overlayKeydown\", \"overlayOutsideClick\"], exportAs: [\"cdkConnectedOverlay\"] }, { type: i8.NgClass, selector: \"[ngClass]\", inputs: [\"class\", \"ngClass\"] }], animations: [matSelectAnimations.transformPanelWrap, matSelectAnimations.transformPanel], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSelect, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-select', exportAs: 'matSelect', inputs: ['disabled', 'disableRipple', 'tabIndex'], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, host: {\n                        'role': 'combobox',\n                        'aria-autocomplete': 'none',\n                        // TODO(crisbeto): the value for aria-haspopup should be `listbox`, but currently it's difficult\n                        // to sync into Google, because of an outdated automated a11y check which flags it as an invalid\n                        // value. At some point we should try to switch it back to being `listbox`.\n                        'aria-haspopup': 'true',\n                        'class': 'mat-select',\n                        '[attr.id]': 'id',\n                        '[attr.tabindex]': 'tabIndex',\n                        '[attr.aria-controls]': 'panelOpen ? id + \"-panel\" : null',\n                        '[attr.aria-expanded]': 'panelOpen',\n                        '[attr.aria-label]': 'ariaLabel || null',\n                        '[attr.aria-required]': 'required.toString()',\n                        '[attr.aria-disabled]': 'disabled.toString()',\n                        '[attr.aria-invalid]': 'errorState',\n                        '[attr.aria-describedby]': '_ariaDescribedby || null',\n                        '[attr.aria-activedescendant]': '_getAriaActiveDescendant()',\n                        '[class.mat-select-disabled]': 'disabled',\n                        '[class.mat-select-invalid]': 'errorState',\n                        '[class.mat-select-required]': 'required',\n                        '[class.mat-select-empty]': 'empty',\n                        '[class.mat-select-multiple]': 'multiple',\n                        '(keydown)': '_handleKeydown($event)',\n                        '(focus)': '_onFocus()',\n                        '(blur)': '_onBlur()',\n                    }, animations: [matSelectAnimations.transformPanelWrap, matSelectAnimations.transformPanel], providers: [\n                        { provide: MatFormFieldControl, useExisting: MatSelect },\n                        { provide: MAT_OPTION_PARENT_COMPONENT, useExisting: MatSelect },\n                    ], template: \"<!--\\n Note that the select trigger element specifies `aria-owns` pointing to the listbox overlay.\\n While aria-owns is not required for the ARIA 1.2 `role=\\\"combobox\\\"` interaction pattern,\\n it fixes an issue with VoiceOver when the select appears inside of an `aria-model=\\\"true\\\"`\\n element (e.g. a dialog). Without this `aria-owns`, the `aria-modal` on a dialog prevents\\n VoiceOver from \\\"seeing\\\" the select's listbox overlay for aria-activedescendant.\\n Using `aria-owns` re-parents the select overlay so that it works again.\\n See https://github.com/angular/components/issues/20694\\n-->\\n<div cdk-overlay-origin\\n     [attr.aria-owns]=\\\"panelOpen ? id + '-panel' : null\\\"\\n     class=\\\"mat-select-trigger\\\"\\n     (click)=\\\"toggle()\\\"\\n     #origin=\\\"cdkOverlayOrigin\\\"\\n     #trigger>\\n  <div class=\\\"mat-select-value\\\" [ngSwitch]=\\\"empty\\\" [attr.id]=\\\"_valueId\\\">\\n    <span class=\\\"mat-select-placeholder mat-select-min-line\\\" *ngSwitchCase=\\\"true\\\">{{placeholder}}</span>\\n    <span class=\\\"mat-select-value-text\\\" *ngSwitchCase=\\\"false\\\" [ngSwitch]=\\\"!!customTrigger\\\">\\n      <span class=\\\"mat-select-min-line\\\" *ngSwitchDefault>{{triggerValue}}</span>\\n      <ng-content select=\\\"mat-select-trigger\\\" *ngSwitchCase=\\\"true\\\"></ng-content>\\n    </span>\\n  </div>\\n\\n  <div class=\\\"mat-select-arrow-wrapper\\\"><div class=\\\"mat-select-arrow\\\"></div></div>\\n</div>\\n\\n<ng-template\\n  cdk-connected-overlay\\n  cdkConnectedOverlayLockPosition\\n  cdkConnectedOverlayHasBackdrop\\n  cdkConnectedOverlayBackdropClass=\\\"cdk-overlay-transparent-backdrop\\\"\\n  [cdkConnectedOverlayPanelClass]=\\\"_overlayPanelClass\\\"\\n  [cdkConnectedOverlayScrollStrategy]=\\\"_scrollStrategy\\\"\\n  [cdkConnectedOverlayOrigin]=\\\"origin\\\"\\n  [cdkConnectedOverlayOpen]=\\\"panelOpen\\\"\\n  [cdkConnectedOverlayPositions]=\\\"_positions\\\"\\n  [cdkConnectedOverlayMinWidth]=\\\"_triggerRect?.width!\\\"\\n  [cdkConnectedOverlayOffsetY]=\\\"_offsetY\\\"\\n  (backdropClick)=\\\"close()\\\"\\n  (attach)=\\\"_onAttached()\\\"\\n  (detach)=\\\"close()\\\">\\n  <div class=\\\"mat-select-panel-wrap\\\" [@transformPanelWrap]>\\n    <div\\n      #panel\\n      role=\\\"listbox\\\"\\n      tabindex=\\\"-1\\\"\\n      class=\\\"mat-select-panel {{ _getPanelTheme() }}\\\"\\n      [attr.id]=\\\"id + '-panel'\\\"\\n      [attr.aria-multiselectable]=\\\"multiple\\\"\\n      [attr.aria-label]=\\\"ariaLabel || null\\\"\\n      [attr.aria-labelledby]=\\\"_getPanelAriaLabelledby()\\\"\\n      [ngClass]=\\\"panelClass\\\"\\n      [@transformPanel]=\\\"multiple ? 'showing-multiple' : 'showing'\\\"\\n      (@transformPanel.done)=\\\"_panelDoneAnimatingStream.next($event.toState)\\\"\\n      [style.transformOrigin]=\\\"_transformOrigin\\\"\\n      [style.font-size.px]=\\\"_triggerFontSize\\\"\\n      (keydown)=\\\"_handleKeydown($event)\\\">\\n      <ng-content></ng-content>\\n    </div>\\n  </div>\\n</ng-template>\\n\", styles: [\".mat-select{display:inline-block;width:100%;outline:none}.mat-select-trigger{display:inline-flex;align-items:center;cursor:pointer;position:relative;box-sizing:border-box;width:100%}.mat-select-disabled .mat-select-trigger{-webkit-user-select:none;user-select:none;cursor:default}.mat-select-value{width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.mat-select-value-text{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.mat-select-arrow-wrapper{height:16px;flex-shrink:0;display:inline-flex;align-items:center}.mat-form-field-appearance-fill .mat-select-arrow-wrapper{transform:translateY(-50%)}.mat-form-field-appearance-outline .mat-select-arrow-wrapper{transform:translateY(-25%)}.mat-form-field-appearance-standard.mat-form-field-has-label .mat-select:not(.mat-select-empty) .mat-select-arrow-wrapper{transform:translateY(-50%)}.mat-form-field-appearance-standard .mat-select.mat-select-empty .mat-select-arrow-wrapper{transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}._mat-animation-noopable.mat-form-field-appearance-standard .mat-select.mat-select-empty .mat-select-arrow-wrapper{transition:none}.mat-select-arrow{width:0;height:0;border-left:5px solid transparent;border-right:5px solid transparent;border-top:5px solid;margin:0 4px}.mat-form-field.mat-focused .mat-select-arrow{transform:translateX(0)}.mat-select-panel-wrap{flex-basis:100%}.mat-select-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;padding-top:0;padding-bottom:0;max-height:256px;min-width:100%;border-radius:4px;outline:0}.cdk-high-contrast-active .mat-select-panel{outline:solid 1px}.mat-select-panel .mat-optgroup-label,.mat-select-panel .mat-option{font-size:inherit;line-height:3em;height:3em}.mat-form-field-type-mat-select:not(.mat-form-field-disabled) .mat-form-field-flex{cursor:pointer}.mat-form-field-type-mat-select .mat-form-field-label{width:calc(100% - 18px)}.mat-select-placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}._mat-animation-noopable .mat-select-placeholder{transition:none}.mat-form-field-hide-placeholder .mat-select-placeholder{color:transparent;-webkit-text-fill-color:transparent;transition:none;display:block}.mat-select-min-line:empty::before{content:\\\" \\\";white-space:pre;width:1px;display:inline-block;visibility:hidden}\\n\"] }]\n        }], propDecorators: { options: [{\n                type: ContentChildren,\n                args: [MatOption, { descendants: true }]\n            }], optionGroups: [{\n                type: ContentChildren,\n                args: [MAT_OPTGROUP, { descendants: true }]\n            }], customTrigger: [{\n                type: ContentChild,\n                args: [MAT_SELECT_TRIGGER]\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatSelectModule {\n}\nMatSelectModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSelectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatSelectModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSelectModule, declarations: [MatSelect, MatSelectTrigger], imports: [CommonModule, OverlayModule, MatOptionModule, MatCommonModule], exports: [CdkScrollableModule,\n        MatFormFieldModule,\n        MatSelect,\n        MatSelectTrigger,\n        MatOptionModule,\n        MatCommonModule] });\nMatSelectModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSelectModule, providers: [MAT_SELECT_SCROLL_STRATEGY_PROVIDER], imports: [[CommonModule, OverlayModule, MatOptionModule, MatCommonModule], CdkScrollableModule,\n        MatFormFieldModule,\n        MatOptionModule,\n        MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSelectModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [CommonModule, OverlayModule, MatOptionModule, MatCommonModule],\n                    exports: [\n                        CdkScrollableModule,\n                        MatFormFieldModule,\n                        MatSelect,\n                        MatSelectTrigger,\n                        MatOptionModule,\n                        MatCommonModule,\n                    ],\n                    declarations: [MatSelect, MatSelectTrigger],\n                    providers: [MAT_SELECT_SCROLL_STRATEGY_PROVIDER],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_SELECT_CONFIG, MAT_SELECT_SCROLL_STRATEGY, MAT_SELECT_SCROLL_STRATEGY_PROVIDER, MAT_SELECT_SCROLL_STRATEGY_PROVIDER_FACTORY, MAT_SELECT_TRIGGER, MatSelect, MatSelectChange, MatSelectModule, MatSelectTrigger, _MatSelectBase, matSelectAnimations };\n","import * as i1 from '@angular/cdk/bidi';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { _VIEW_REPEATER_STRATEGY, _RecycleViewRepeaterStrategy, isDataSource, _DisposeViewRepeaterStrategy } from '@angular/cdk/collections';\nexport { DataSource } from '@angular/cdk/collections';\nimport * as i2 from '@angular/cdk/platform';\nimport * as i3 from '@angular/cdk/scrolling';\nimport { ScrollingModule } from '@angular/cdk/scrolling';\nimport { DOCUMENT } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { InjectionToken, Directive, Inject, Optional, Input, ContentChild, Injectable, Component, ChangeDetectionStrategy, ViewEncapsulation, EmbeddedViewRef, EventEmitter, NgZone, Attribute, SkipSelf, Output, ViewChild, ContentChildren, NgModule } from '@angular/core';\nimport { Subject, from, BehaviorSubject, isObservable, of } from 'rxjs';\nimport { takeUntil, take } from 'rxjs/operators';\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 * Mixin to provide a directive with a function that checks if the sticky input has been\n * changed since the last time the function was called. Essentially adds a dirty-check to the\n * sticky value.\n * @docs-private\n */\nfunction mixinHasStickyInput(base) {\n    return class extends base {\n        constructor(...args) {\n            super(...args);\n            this._sticky = false;\n            /** Whether the sticky input has changed since it was last checked. */\n            this._hasStickyChanged = false;\n        }\n        /** Whether sticky positioning should be applied. */\n        get sticky() {\n            return this._sticky;\n        }\n        set sticky(v) {\n            const prevValue = this._sticky;\n            this._sticky = coerceBooleanProperty(v);\n            this._hasStickyChanged = prevValue !== this._sticky;\n        }\n        /** Whether the sticky value has changed since this was last called. */\n        hasStickyChanged() {\n            const hasStickyChanged = this._hasStickyChanged;\n            this._hasStickyChanged = false;\n            return hasStickyChanged;\n        }\n        /** Resets the dirty check for cases where the sticky state has been used without checking. */\n        resetStickyChanged() {\n            this._hasStickyChanged = false;\n        }\n    };\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Used to provide a table to some of the sub-components without causing a circular dependency.\n * @docs-private\n */\nconst CDK_TABLE = new InjectionToken('CDK_TABLE');\n/** Injection token that can be used to specify the text column options. */\nconst TEXT_COLUMN_OPTIONS = new InjectionToken('text-column-options');\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 * Cell definition for a CDK table.\n * Captures the template of a column's data row cell as well as cell-specific properties.\n */\nclass CdkCellDef {\n    constructor(/** @docs-private */ template) {\n        this.template = template;\n    }\n}\nCdkCellDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkCellDef, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });\nCdkCellDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkCellDef, selector: \"[cdkCellDef]\", ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkCellDef, decorators: [{\n            type: Directive,\n            args: [{ selector: '[cdkCellDef]' }]\n        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });\n/**\n * Header cell definition for a CDK table.\n * Captures the template of a column's header cell and as well as cell-specific properties.\n */\nclass CdkHeaderCellDef {\n    constructor(/** @docs-private */ template) {\n        this.template = template;\n    }\n}\nCdkHeaderCellDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkHeaderCellDef, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });\nCdkHeaderCellDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkHeaderCellDef, selector: \"[cdkHeaderCellDef]\", ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkHeaderCellDef, decorators: [{\n            type: Directive,\n            args: [{ selector: '[cdkHeaderCellDef]' }]\n        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });\n/**\n * Footer cell definition for a CDK table.\n * Captures the template of a column's footer cell and as well as cell-specific properties.\n */\nclass CdkFooterCellDef {\n    constructor(/** @docs-private */ template) {\n        this.template = template;\n    }\n}\nCdkFooterCellDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkFooterCellDef, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });\nCdkFooterCellDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkFooterCellDef, selector: \"[cdkFooterCellDef]\", ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkFooterCellDef, decorators: [{\n            type: Directive,\n            args: [{ selector: '[cdkFooterCellDef]' }]\n        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });\n// Boilerplate for applying mixins to CdkColumnDef.\n/** @docs-private */\nclass CdkColumnDefBase {\n}\nconst _CdkColumnDefBase = mixinHasStickyInput(CdkColumnDefBase);\n/**\n * Column definition for the CDK table.\n * Defines a set of cells available for a table column.\n */\nclass CdkColumnDef extends _CdkColumnDefBase {\n    constructor(_table) {\n        super();\n        this._table = _table;\n        this._stickyEnd = false;\n    }\n    /** Unique name for this column. */\n    get name() {\n        return this._name;\n    }\n    set name(name) {\n        this._setNameInput(name);\n    }\n    /**\n     * Whether this column should be sticky positioned on the end of the row. Should make sure\n     * that it mimics the `CanStick` mixin such that `_hasStickyChanged` is set to true if the value\n     * has been changed.\n     */\n    get stickyEnd() {\n        return this._stickyEnd;\n    }\n    set stickyEnd(v) {\n        const prevValue = this._stickyEnd;\n        this._stickyEnd = coerceBooleanProperty(v);\n        this._hasStickyChanged = prevValue !== this._stickyEnd;\n    }\n    /**\n     * Overridable method that sets the css classes that will be added to every cell in this\n     * column.\n     * In the future, columnCssClassName will change from type string[] to string and this\n     * will set a single string value.\n     * @docs-private\n     */\n    _updateColumnCssClassName() {\n        this._columnCssClassName = [`cdk-column-${this.cssClassFriendlyName}`];\n    }\n    /**\n     * This has been extracted to a util because of TS 4 and VE.\n     * View Engine doesn't support property rename inheritance.\n     * TS 4.0 doesn't allow properties to override accessors or vice-versa.\n     * @docs-private\n     */\n    _setNameInput(value) {\n        // If the directive is set without a name (updated programmatically), then this setter will\n        // trigger with an empty string and should not overwrite the programmatically set value.\n        if (value) {\n            this._name = value;\n            this.cssClassFriendlyName = value.replace(/[^a-z0-9_-]/gi, '-');\n            this._updateColumnCssClassName();\n        }\n    }\n}\nCdkColumnDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkColumnDef, deps: [{ token: CDK_TABLE, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nCdkColumnDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkColumnDef, selector: \"[cdkColumnDef]\", inputs: { sticky: \"sticky\", name: [\"cdkColumnDef\", \"name\"], stickyEnd: \"stickyEnd\" }, providers: [{ provide: 'MAT_SORT_HEADER_COLUMN_DEF', useExisting: CdkColumnDef }], queries: [{ propertyName: \"cell\", first: true, predicate: CdkCellDef, descendants: true }, { propertyName: \"headerCell\", first: true, predicate: CdkHeaderCellDef, descendants: true }, { propertyName: \"footerCell\", first: true, predicate: CdkFooterCellDef, descendants: true }], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkColumnDef, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdkColumnDef]',\n                    inputs: ['sticky'],\n                    providers: [{ provide: 'MAT_SORT_HEADER_COLUMN_DEF', useExisting: CdkColumnDef }],\n                }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [CDK_TABLE]\n                }, {\n                    type: Optional\n                }] }]; }, propDecorators: { name: [{\n                type: Input,\n                args: ['cdkColumnDef']\n            }], stickyEnd: [{\n                type: Input,\n                args: ['stickyEnd']\n            }], cell: [{\n                type: ContentChild,\n                args: [CdkCellDef]\n            }], headerCell: [{\n                type: ContentChild,\n                args: [CdkHeaderCellDef]\n            }], footerCell: [{\n                type: ContentChild,\n                args: [CdkFooterCellDef]\n            }] } });\n/** Base class for the cells. Adds a CSS classname that identifies the column it renders in. */\nclass BaseCdkCell {\n    constructor(columnDef, elementRef) {\n        elementRef.nativeElement.classList.add(...columnDef._columnCssClassName);\n    }\n}\n/** Header cell template container that adds the right classes and role. */\nclass CdkHeaderCell extends BaseCdkCell {\n    constructor(columnDef, elementRef) {\n        super(columnDef, elementRef);\n    }\n}\nCdkHeaderCell.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkHeaderCell, deps: [{ token: CdkColumnDef }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });\nCdkHeaderCell.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkHeaderCell, selector: \"cdk-header-cell, th[cdk-header-cell]\", host: { attributes: { \"role\": \"columnheader\" }, classAttribute: \"cdk-header-cell\" }, usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkHeaderCell, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'cdk-header-cell, th[cdk-header-cell]',\n                    host: {\n                        'class': 'cdk-header-cell',\n                        'role': 'columnheader',\n                    },\n                }]\n        }], ctorParameters: function () { return [{ type: CdkColumnDef }, { type: i0.ElementRef }]; } });\n/** Footer cell template container that adds the right classes and role. */\nclass CdkFooterCell extends BaseCdkCell {\n    constructor(columnDef, elementRef) {\n        super(columnDef, elementRef);\n        if (columnDef._table?._elementRef.nativeElement.nodeType === 1) {\n            const tableRole = columnDef._table._elementRef.nativeElement.getAttribute('role');\n            const role = tableRole === 'grid' || tableRole === 'treegrid' ? 'gridcell' : 'cell';\n            elementRef.nativeElement.setAttribute('role', role);\n        }\n    }\n}\nCdkFooterCell.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkFooterCell, deps: [{ token: CdkColumnDef }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });\nCdkFooterCell.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkFooterCell, selector: \"cdk-footer-cell, td[cdk-footer-cell]\", host: { classAttribute: \"cdk-footer-cell\" }, usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkFooterCell, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'cdk-footer-cell, td[cdk-footer-cell]',\n                    host: {\n                        'class': 'cdk-footer-cell',\n                    },\n                }]\n        }], ctorParameters: function () { return [{ type: CdkColumnDef }, { type: i0.ElementRef }]; } });\n/** Cell template container that adds the right classes and role. */\nclass CdkCell extends BaseCdkCell {\n    constructor(columnDef, elementRef) {\n        super(columnDef, elementRef);\n        if (columnDef._table?._elementRef.nativeElement.nodeType === 1) {\n            const tableRole = columnDef._table._elementRef.nativeElement.getAttribute('role');\n            const role = tableRole === 'grid' || tableRole === 'treegrid' ? 'gridcell' : 'cell';\n            elementRef.nativeElement.setAttribute('role', role);\n        }\n    }\n}\nCdkCell.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkCell, deps: [{ token: CdkColumnDef }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });\nCdkCell.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkCell, selector: \"cdk-cell, td[cdk-cell]\", host: { classAttribute: \"cdk-cell\" }, usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkCell, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'cdk-cell, td[cdk-cell]',\n                    host: {\n                        'class': 'cdk-cell',\n                    },\n                }]\n        }], ctorParameters: function () { return [{ type: CdkColumnDef }, { type: i0.ElementRef }]; } });\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 _Schedule {\n    constructor() {\n        this.tasks = [];\n        this.endTasks = [];\n    }\n}\n/** Injection token used to provide a coalesced style scheduler. */\nconst _COALESCED_STYLE_SCHEDULER = new InjectionToken('_COALESCED_STYLE_SCHEDULER');\n/**\n * Allows grouping up CSSDom mutations after the current execution context.\n * This can significantly improve performance when separate consecutive functions are\n * reading from the CSSDom and then mutating it.\n *\n * @docs-private\n */\nclass _CoalescedStyleScheduler {\n    constructor(_ngZone) {\n        this._ngZone = _ngZone;\n        this._currentSchedule = null;\n        this._destroyed = new Subject();\n    }\n    /**\n     * Schedules the specified task to run at the end of the current VM turn.\n     */\n    schedule(task) {\n        this._createScheduleIfNeeded();\n        this._currentSchedule.tasks.push(task);\n    }\n    /**\n     * Schedules the specified task to run after other scheduled tasks at the end of the current\n     * VM turn.\n     */\n    scheduleEnd(task) {\n        this._createScheduleIfNeeded();\n        this._currentSchedule.endTasks.push(task);\n    }\n    /** Prevent any further tasks from running. */\n    ngOnDestroy() {\n        this._destroyed.next();\n        this._destroyed.complete();\n    }\n    _createScheduleIfNeeded() {\n        if (this._currentSchedule) {\n            return;\n        }\n        this._currentSchedule = new _Schedule();\n        this._getScheduleObservable()\n            .pipe(takeUntil(this._destroyed))\n            .subscribe(() => {\n            while (this._currentSchedule.tasks.length || this._currentSchedule.endTasks.length) {\n                const schedule = this._currentSchedule;\n                // Capture new tasks scheduled by the current set of tasks.\n                this._currentSchedule = new _Schedule();\n                for (const task of schedule.tasks) {\n                    task();\n                }\n                for (const task of schedule.endTasks) {\n                    task();\n                }\n            }\n            this._currentSchedule = null;\n        });\n    }\n    _getScheduleObservable() {\n        // Use onStable when in the context of an ongoing change detection cycle so that we\n        // do not accidentally trigger additional cycles.\n        return this._ngZone.isStable\n            ? from(Promise.resolve(undefined))\n            : this._ngZone.onStable.pipe(take(1));\n    }\n}\n_CoalescedStyleScheduler.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _CoalescedStyleScheduler, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });\n_CoalescedStyleScheduler.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _CoalescedStyleScheduler });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _CoalescedStyleScheduler, decorators: [{\n            type: Injectable\n        }], ctorParameters: function () { return [{ type: i0.NgZone }]; } });\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 * The row template that can be used by the mat-table. Should not be used outside of the\n * material library.\n */\nconst CDK_ROW_TEMPLATE = `<ng-container cdkCellOutlet></ng-container>`;\n/**\n * Base class for the CdkHeaderRowDef and CdkRowDef that handles checking their columns inputs\n * for changes and notifying the table.\n */\nclass BaseRowDef {\n    constructor(\n    /** @docs-private */ template, _differs) {\n        this.template = template;\n        this._differs = _differs;\n    }\n    ngOnChanges(changes) {\n        // Create a new columns differ if one does not yet exist. Initialize it based on initial value\n        // of the columns property or an empty array if none is provided.\n        if (!this._columnsDiffer) {\n            const columns = (changes['columns'] && changes['columns'].currentValue) || [];\n            this._columnsDiffer = this._differs.find(columns).create();\n            this._columnsDiffer.diff(columns);\n        }\n    }\n    /**\n     * Returns the difference between the current columns and the columns from the last diff, or null\n     * if there is no difference.\n     */\n    getColumnsDiff() {\n        return this._columnsDiffer.diff(this.columns);\n    }\n    /** Gets this row def's relevant cell template from the provided column def. */\n    extractCellTemplate(column) {\n        if (this instanceof CdkHeaderRowDef) {\n            return column.headerCell.template;\n        }\n        if (this instanceof CdkFooterRowDef) {\n            return column.footerCell.template;\n        }\n        else {\n            return column.cell.template;\n        }\n    }\n}\nBaseRowDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: BaseRowDef, deps: [{ token: i0.TemplateRef }, { token: i0.IterableDiffers }], target: i0.ɵɵFactoryTarget.Directive });\nBaseRowDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: BaseRowDef, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: BaseRowDef, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.IterableDiffers }]; } });\n// Boilerplate for applying mixins to CdkHeaderRowDef.\n/** @docs-private */\nclass CdkHeaderRowDefBase extends BaseRowDef {\n}\nconst _CdkHeaderRowDefBase = mixinHasStickyInput(CdkHeaderRowDefBase);\n/**\n * Header row definition for the CDK table.\n * Captures the header row's template and other header properties such as the columns to display.\n */\nclass CdkHeaderRowDef extends _CdkHeaderRowDefBase {\n    constructor(template, _differs, _table) {\n        super(template, _differs);\n        this._table = _table;\n    }\n    // Prerender fails to recognize that ngOnChanges in a part of this class through inheritance.\n    // Explicitly define it so that the method is called as part of the Angular lifecycle.\n    ngOnChanges(changes) {\n        super.ngOnChanges(changes);\n    }\n}\nCdkHeaderRowDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkHeaderRowDef, deps: [{ token: i0.TemplateRef }, { token: i0.IterableDiffers }, { token: CDK_TABLE, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nCdkHeaderRowDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkHeaderRowDef, selector: \"[cdkHeaderRowDef]\", inputs: { columns: [\"cdkHeaderRowDef\", \"columns\"], sticky: [\"cdkHeaderRowDefSticky\", \"sticky\"] }, usesInheritance: true, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkHeaderRowDef, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdkHeaderRowDef]',\n                    inputs: ['columns: cdkHeaderRowDef', 'sticky: cdkHeaderRowDefSticky'],\n                }]\n        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.IterableDiffers }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [CDK_TABLE]\n                }, {\n                    type: Optional\n                }] }]; } });\n// Boilerplate for applying mixins to CdkFooterRowDef.\n/** @docs-private */\nclass CdkFooterRowDefBase extends BaseRowDef {\n}\nconst _CdkFooterRowDefBase = mixinHasStickyInput(CdkFooterRowDefBase);\n/**\n * Footer row definition for the CDK table.\n * Captures the footer row's template and other footer properties such as the columns to display.\n */\nclass CdkFooterRowDef extends _CdkFooterRowDefBase {\n    constructor(template, _differs, _table) {\n        super(template, _differs);\n        this._table = _table;\n    }\n    // Prerender fails to recognize that ngOnChanges in a part of this class through inheritance.\n    // Explicitly define it so that the method is called as part of the Angular lifecycle.\n    ngOnChanges(changes) {\n        super.ngOnChanges(changes);\n    }\n}\nCdkFooterRowDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkFooterRowDef, deps: [{ token: i0.TemplateRef }, { token: i0.IterableDiffers }, { token: CDK_TABLE, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nCdkFooterRowDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkFooterRowDef, selector: \"[cdkFooterRowDef]\", inputs: { columns: [\"cdkFooterRowDef\", \"columns\"], sticky: [\"cdkFooterRowDefSticky\", \"sticky\"] }, usesInheritance: true, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkFooterRowDef, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdkFooterRowDef]',\n                    inputs: ['columns: cdkFooterRowDef', 'sticky: cdkFooterRowDefSticky'],\n                }]\n        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.IterableDiffers }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [CDK_TABLE]\n                }, {\n                    type: Optional\n                }] }]; } });\n/**\n * Data row definition for the CDK table.\n * Captures the header row's template and other row properties such as the columns to display and\n * a when predicate that describes when this row should be used.\n */\nclass CdkRowDef extends BaseRowDef {\n    // TODO(andrewseguin): Add an input for providing a switch function to determine\n    //   if this template should be used.\n    constructor(template, _differs, _table) {\n        super(template, _differs);\n        this._table = _table;\n    }\n}\nCdkRowDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkRowDef, deps: [{ token: i0.TemplateRef }, { token: i0.IterableDiffers }, { token: CDK_TABLE, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nCdkRowDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkRowDef, selector: \"[cdkRowDef]\", inputs: { columns: [\"cdkRowDefColumns\", \"columns\"], when: [\"cdkRowDefWhen\", \"when\"] }, usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkRowDef, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdkRowDef]',\n                    inputs: ['columns: cdkRowDefColumns', 'when: cdkRowDefWhen'],\n                }]\n        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.IterableDiffers }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [CDK_TABLE]\n                }, {\n                    type: Optional\n                }] }]; } });\n/**\n * Outlet for rendering cells inside of a row or header row.\n * @docs-private\n */\nclass CdkCellOutlet {\n    constructor(_viewContainer) {\n        this._viewContainer = _viewContainer;\n        CdkCellOutlet.mostRecentCellOutlet = this;\n    }\n    ngOnDestroy() {\n        // If this was the last outlet being rendered in the view, remove the reference\n        // from the static property after it has been destroyed to avoid leaking memory.\n        if (CdkCellOutlet.mostRecentCellOutlet === this) {\n            CdkCellOutlet.mostRecentCellOutlet = null;\n        }\n    }\n}\n/**\n * Static property containing the latest constructed instance of this class.\n * Used by the CDK table when each CdkHeaderRow and CdkRow component is created using\n * createEmbeddedView. After one of these components are created, this property will provide\n * a handle to provide that component's cells and context. After init, the CdkCellOutlet will\n * construct the cells with the provided context.\n */\nCdkCellOutlet.mostRecentCellOutlet = null;\nCdkCellOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkCellOutlet, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });\nCdkCellOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkCellOutlet, selector: \"[cdkCellOutlet]\", ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkCellOutlet, decorators: [{\n            type: Directive,\n            args: [{ selector: '[cdkCellOutlet]' }]\n        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }]; } });\n/** Header template container that contains the cell outlet. Adds the right class and role. */\nclass CdkHeaderRow {\n}\nCdkHeaderRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkHeaderRow, deps: [], target: i0.ɵɵFactoryTarget.Component });\nCdkHeaderRow.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkHeaderRow, selector: \"cdk-header-row, tr[cdk-header-row]\", host: { attributes: { \"role\": \"row\" }, classAttribute: \"cdk-header-row\" }, ngImport: i0, template: \"<ng-container cdkCellOutlet></ng-container>\", isInline: true, directives: [{ type: CdkCellOutlet, selector: \"[cdkCellOutlet]\" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkHeaderRow, decorators: [{\n            type: Component,\n            args: [{\n                    selector: 'cdk-header-row, tr[cdk-header-row]',\n                    template: CDK_ROW_TEMPLATE,\n                    host: {\n                        'class': 'cdk-header-row',\n                        'role': 'row',\n                    },\n                    // See note on CdkTable for explanation on why this uses the default change detection strategy.\n                    // tslint:disable-next-line:validate-decorators\n                    changeDetection: ChangeDetectionStrategy.Default,\n                    encapsulation: ViewEncapsulation.None,\n                }]\n        }] });\n/** Footer template container that contains the cell outlet. Adds the right class and role. */\nclass CdkFooterRow {\n}\nCdkFooterRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkFooterRow, deps: [], target: i0.ɵɵFactoryTarget.Component });\nCdkFooterRow.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkFooterRow, selector: \"cdk-footer-row, tr[cdk-footer-row]\", host: { attributes: { \"role\": \"row\" }, classAttribute: \"cdk-footer-row\" }, ngImport: i0, template: \"<ng-container cdkCellOutlet></ng-container>\", isInline: true, directives: [{ type: CdkCellOutlet, selector: \"[cdkCellOutlet]\" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkFooterRow, decorators: [{\n            type: Component,\n            args: [{\n                    selector: 'cdk-footer-row, tr[cdk-footer-row]',\n                    template: CDK_ROW_TEMPLATE,\n                    host: {\n                        'class': 'cdk-footer-row',\n                        'role': 'row',\n                    },\n                    // See note on CdkTable for explanation on why this uses the default change detection strategy.\n                    // tslint:disable-next-line:validate-decorators\n                    changeDetection: ChangeDetectionStrategy.Default,\n                    encapsulation: ViewEncapsulation.None,\n                }]\n        }] });\n/** Data row template container that contains the cell outlet. Adds the right class and role. */\nclass CdkRow {\n}\nCdkRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkRow, deps: [], target: i0.ɵɵFactoryTarget.Component });\nCdkRow.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkRow, selector: \"cdk-row, tr[cdk-row]\", host: { attributes: { \"role\": \"row\" }, classAttribute: \"cdk-row\" }, ngImport: i0, template: \"<ng-container cdkCellOutlet></ng-container>\", isInline: true, directives: [{ type: CdkCellOutlet, selector: \"[cdkCellOutlet]\" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkRow, decorators: [{\n            type: Component,\n            args: [{\n                    selector: 'cdk-row, tr[cdk-row]',\n                    template: CDK_ROW_TEMPLATE,\n                    host: {\n                        'class': 'cdk-row',\n                        'role': 'row',\n                    },\n                    // See note on CdkTable for explanation on why this uses the default change detection strategy.\n                    // tslint:disable-next-line:validate-decorators\n                    changeDetection: ChangeDetectionStrategy.Default,\n                    encapsulation: ViewEncapsulation.None,\n                }]\n        }] });\n/** Row that can be used to display a message when no data is shown in the table. */\nclass CdkNoDataRow {\n    constructor(templateRef) {\n        this.templateRef = templateRef;\n        this._contentClassName = 'cdk-no-data-row';\n    }\n}\nCdkNoDataRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkNoDataRow, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });\nCdkNoDataRow.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkNoDataRow, selector: \"ng-template[cdkNoDataRow]\", ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkNoDataRow, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'ng-template[cdkNoDataRow]',\n                }]\n        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });\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 * List of all possible directions that can be used for sticky positioning.\n * @docs-private\n */\nconst STICKY_DIRECTIONS = ['top', 'bottom', 'left', 'right'];\n/**\n * Applies and removes sticky positioning styles to the `CdkTable` rows and columns cells.\n * @docs-private\n */\nclass StickyStyler {\n    /**\n     * @param _isNativeHtmlTable Whether the sticky logic should be based on a table\n     *     that uses the native `<table>` element.\n     * @param _stickCellCss The CSS class that will be applied to every row/cell that has\n     *     sticky positioning applied.\n     * @param direction The directionality context of the table (ltr/rtl); affects column positioning\n     *     by reversing left/right positions.\n     * @param _isBrowser Whether the table is currently being rendered on the server or the client.\n     * @param _needsPositionStickyOnElement Whether we need to specify position: sticky on cells\n     *     using inline styles. If false, it is assumed that position: sticky is included in\n     *     the component stylesheet for _stickCellCss.\n     * @param _positionListener A listener that is notified of changes to sticky rows/columns\n     *     and their dimensions.\n     */\n    constructor(_isNativeHtmlTable, _stickCellCss, direction, _coalescedStyleScheduler, _isBrowser = true, _needsPositionStickyOnElement = true, _positionListener) {\n        this._isNativeHtmlTable = _isNativeHtmlTable;\n        this._stickCellCss = _stickCellCss;\n        this.direction = direction;\n        this._coalescedStyleScheduler = _coalescedStyleScheduler;\n        this._isBrowser = _isBrowser;\n        this._needsPositionStickyOnElement = _needsPositionStickyOnElement;\n        this._positionListener = _positionListener;\n        this._cachedCellWidths = [];\n        this._borderCellCss = {\n            'top': `${_stickCellCss}-border-elem-top`,\n            'bottom': `${_stickCellCss}-border-elem-bottom`,\n            'left': `${_stickCellCss}-border-elem-left`,\n            'right': `${_stickCellCss}-border-elem-right`,\n        };\n    }\n    /**\n     * Clears the sticky positioning styles from the row and its cells by resetting the `position`\n     * style, setting the zIndex to 0, and unsetting each provided sticky direction.\n     * @param rows The list of rows that should be cleared from sticking in the provided directions\n     * @param stickyDirections The directions that should no longer be set as sticky on the rows.\n     */\n    clearStickyPositioning(rows, stickyDirections) {\n        const elementsToClear = [];\n        for (const row of rows) {\n            // If the row isn't an element (e.g. if it's an `ng-container`),\n            // it won't have inline styles or `children` so we skip it.\n            if (row.nodeType !== row.ELEMENT_NODE) {\n                continue;\n            }\n            elementsToClear.push(row);\n            for (let i = 0; i < row.children.length; i++) {\n                elementsToClear.push(row.children[i]);\n            }\n        }\n        // Coalesce with sticky row/column updates (and potentially other changes like column resize).\n        this._coalescedStyleScheduler.schedule(() => {\n            for (const element of elementsToClear) {\n                this._removeStickyStyle(element, stickyDirections);\n            }\n        });\n    }\n    /**\n     * Applies sticky left and right positions to the cells of each row according to the sticky\n     * states of the rendered column definitions.\n     * @param rows The rows that should have its set of cells stuck according to the sticky states.\n     * @param stickyStartStates A list of boolean states where each state represents whether the cell\n     *     in this index position should be stuck to the start of the row.\n     * @param stickyEndStates A list of boolean states where each state represents whether the cell\n     *     in this index position should be stuck to the end of the row.\n     * @param recalculateCellWidths Whether the sticky styler should recalculate the width of each\n     *     column cell. If `false` cached widths will be used instead.\n     */\n    updateStickyColumns(rows, stickyStartStates, stickyEndStates, recalculateCellWidths = true) {\n        if (!rows.length ||\n            !this._isBrowser ||\n            !(stickyStartStates.some(state => state) || stickyEndStates.some(state => state))) {\n            if (this._positionListener) {\n                this._positionListener.stickyColumnsUpdated({ sizes: [] });\n                this._positionListener.stickyEndColumnsUpdated({ sizes: [] });\n            }\n            return;\n        }\n        const firstRow = rows[0];\n        const numCells = firstRow.children.length;\n        const cellWidths = this._getCellWidths(firstRow, recalculateCellWidths);\n        const startPositions = this._getStickyStartColumnPositions(cellWidths, stickyStartStates);\n        const endPositions = this._getStickyEndColumnPositions(cellWidths, stickyEndStates);\n        const lastStickyStart = stickyStartStates.lastIndexOf(true);\n        const firstStickyEnd = stickyEndStates.indexOf(true);\n        // Coalesce with sticky row updates (and potentially other changes like column resize).\n        this._coalescedStyleScheduler.schedule(() => {\n            const isRtl = this.direction === 'rtl';\n            const start = isRtl ? 'right' : 'left';\n            const end = isRtl ? 'left' : 'right';\n            for (const row of rows) {\n                for (let i = 0; i < numCells; i++) {\n                    const cell = row.children[i];\n                    if (stickyStartStates[i]) {\n                        this._addStickyStyle(cell, start, startPositions[i], i === lastStickyStart);\n                    }\n                    if (stickyEndStates[i]) {\n                        this._addStickyStyle(cell, end, endPositions[i], i === firstStickyEnd);\n                    }\n                }\n            }\n            if (this._positionListener) {\n                this._positionListener.stickyColumnsUpdated({\n                    sizes: lastStickyStart === -1\n                        ? []\n                        : cellWidths\n                            .slice(0, lastStickyStart + 1)\n                            .map((width, index) => (stickyStartStates[index] ? width : null)),\n                });\n                this._positionListener.stickyEndColumnsUpdated({\n                    sizes: firstStickyEnd === -1\n                        ? []\n                        : cellWidths\n                            .slice(firstStickyEnd)\n                            .map((width, index) => (stickyEndStates[index + firstStickyEnd] ? width : null))\n                            .reverse(),\n                });\n            }\n        });\n    }\n    /**\n     * Applies sticky positioning to the row's cells if using the native table layout, and to the\n     * row itself otherwise.\n     * @param rowsToStick The list of rows that should be stuck according to their corresponding\n     *     sticky state and to the provided top or bottom position.\n     * @param stickyStates A list of boolean states where each state represents whether the row\n     *     should be stuck in the particular top or bottom position.\n     * @param position The position direction in which the row should be stuck if that row should be\n     *     sticky.\n     *\n     */\n    stickRows(rowsToStick, stickyStates, position) {\n        // Since we can't measure the rows on the server, we can't stick the rows properly.\n        if (!this._isBrowser) {\n            return;\n        }\n        // If positioning the rows to the bottom, reverse their order when evaluating the sticky\n        // position such that the last row stuck will be \"bottom: 0px\" and so on. Note that the\n        // sticky states need to be reversed as well.\n        const rows = position === 'bottom' ? rowsToStick.slice().reverse() : rowsToStick;\n        const states = position === 'bottom' ? stickyStates.slice().reverse() : stickyStates;\n        // Measure row heights all at once before adding sticky styles to reduce layout thrashing.\n        const stickyOffsets = [];\n        const stickyCellHeights = [];\n        const elementsToStick = [];\n        for (let rowIndex = 0, stickyOffset = 0; rowIndex < rows.length; rowIndex++) {\n            if (!states[rowIndex]) {\n                continue;\n            }\n            stickyOffsets[rowIndex] = stickyOffset;\n            const row = rows[rowIndex];\n            elementsToStick[rowIndex] = this._isNativeHtmlTable\n                ? Array.from(row.children)\n                : [row];\n            const height = row.getBoundingClientRect().height;\n            stickyOffset += height;\n            stickyCellHeights[rowIndex] = height;\n        }\n        const borderedRowIndex = states.lastIndexOf(true);\n        // Coalesce with other sticky row updates (top/bottom), sticky columns updates\n        // (and potentially other changes like column resize).\n        this._coalescedStyleScheduler.schedule(() => {\n            for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {\n                if (!states[rowIndex]) {\n                    continue;\n                }\n                const offset = stickyOffsets[rowIndex];\n                const isBorderedRowIndex = rowIndex === borderedRowIndex;\n                for (const element of elementsToStick[rowIndex]) {\n                    this._addStickyStyle(element, position, offset, isBorderedRowIndex);\n                }\n            }\n            if (position === 'top') {\n                this._positionListener?.stickyHeaderRowsUpdated({\n                    sizes: stickyCellHeights,\n                    offsets: stickyOffsets,\n                    elements: elementsToStick,\n                });\n            }\n            else {\n                this._positionListener?.stickyFooterRowsUpdated({\n                    sizes: stickyCellHeights,\n                    offsets: stickyOffsets,\n                    elements: elementsToStick,\n                });\n            }\n        });\n    }\n    /**\n     * When using the native table in Safari, sticky footer cells do not stick. The only way to stick\n     * footer rows is to apply sticky styling to the tfoot container. This should only be done if\n     * all footer rows are sticky. If not all footer rows are sticky, remove sticky positioning from\n     * the tfoot element.\n     */\n    updateStickyFooterContainer(tableElement, stickyStates) {\n        if (!this._isNativeHtmlTable) {\n            return;\n        }\n        const tfoot = tableElement.querySelector('tfoot');\n        // Coalesce with other sticky updates (and potentially other changes like column resize).\n        this._coalescedStyleScheduler.schedule(() => {\n            if (stickyStates.some(state => !state)) {\n                this._removeStickyStyle(tfoot, ['bottom']);\n            }\n            else {\n                this._addStickyStyle(tfoot, 'bottom', 0, false);\n            }\n        });\n    }\n    /**\n     * Removes the sticky style on the element by removing the sticky cell CSS class, re-evaluating\n     * the zIndex, removing each of the provided sticky directions, and removing the\n     * sticky position if there are no more directions.\n     */\n    _removeStickyStyle(element, stickyDirections) {\n        for (const dir of stickyDirections) {\n            element.style[dir] = '';\n            element.classList.remove(this._borderCellCss[dir]);\n        }\n        // If the element no longer has any more sticky directions, remove sticky positioning and\n        // the sticky CSS class.\n        // Short-circuit checking element.style[dir] for stickyDirections as they\n        // were already removed above.\n        const hasDirection = STICKY_DIRECTIONS.some(dir => stickyDirections.indexOf(dir) === -1 && element.style[dir]);\n        if (hasDirection) {\n            element.style.zIndex = this._getCalculatedZIndex(element);\n        }\n        else {\n            // When not hasDirection, _getCalculatedZIndex will always return ''.\n            element.style.zIndex = '';\n            if (this._needsPositionStickyOnElement) {\n                element.style.position = '';\n            }\n            element.classList.remove(this._stickCellCss);\n        }\n    }\n    /**\n     * Adds the sticky styling to the element by adding the sticky style class, changing position\n     * to be sticky (and -webkit-sticky), setting the appropriate zIndex, and adding a sticky\n     * direction and value.\n     */\n    _addStickyStyle(element, dir, dirValue, isBorderElement) {\n        element.classList.add(this._stickCellCss);\n        if (isBorderElement) {\n            element.classList.add(this._borderCellCss[dir]);\n        }\n        element.style[dir] = `${dirValue}px`;\n        element.style.zIndex = this._getCalculatedZIndex(element);\n        if (this._needsPositionStickyOnElement) {\n            element.style.cssText += 'position: -webkit-sticky; position: sticky; ';\n        }\n    }\n    /**\n     * Calculate what the z-index should be for the element, depending on what directions (top,\n     * bottom, left, right) have been set. It should be true that elements with a top direction\n     * should have the highest index since these are elements like a table header. If any of those\n     * elements are also sticky in another direction, then they should appear above other elements\n     * that are only sticky top (e.g. a sticky column on a sticky header). Bottom-sticky elements\n     * (e.g. footer rows) should then be next in the ordering such that they are below the header\n     * but above any non-sticky elements. Finally, left/right sticky elements (e.g. sticky columns)\n     * should minimally increment so that they are above non-sticky elements but below top and bottom\n     * elements.\n     */\n    _getCalculatedZIndex(element) {\n        const zIndexIncrements = {\n            top: 100,\n            bottom: 10,\n            left: 1,\n            right: 1,\n        };\n        let zIndex = 0;\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        for (const dir of STICKY_DIRECTIONS) {\n            if (element.style[dir]) {\n                zIndex += zIndexIncrements[dir];\n            }\n        }\n        return zIndex ? `${zIndex}` : '';\n    }\n    /** Gets the widths for each cell in the provided row. */\n    _getCellWidths(row, recalculateCellWidths = true) {\n        if (!recalculateCellWidths && this._cachedCellWidths.length) {\n            return this._cachedCellWidths;\n        }\n        const cellWidths = [];\n        const firstRowCells = row.children;\n        for (let i = 0; i < firstRowCells.length; i++) {\n            let cell = firstRowCells[i];\n            cellWidths.push(cell.getBoundingClientRect().width);\n        }\n        this._cachedCellWidths = cellWidths;\n        return cellWidths;\n    }\n    /**\n     * Determines the left and right positions of each sticky column cell, which will be the\n     * accumulation of all sticky column cell widths to the left and right, respectively.\n     * Non-sticky cells do not need to have a value set since their positions will not be applied.\n     */\n    _getStickyStartColumnPositions(widths, stickyStates) {\n        const positions = [];\n        let nextPosition = 0;\n        for (let i = 0; i < widths.length; i++) {\n            if (stickyStates[i]) {\n                positions[i] = nextPosition;\n                nextPosition += widths[i];\n            }\n        }\n        return positions;\n    }\n    /**\n     * Determines the left and right positions of each sticky column cell, which will be the\n     * accumulation of all sticky column cell widths to the left and right, respectively.\n     * Non-sticky cells do not need to have a value set since their positions will not be applied.\n     */\n    _getStickyEndColumnPositions(widths, stickyStates) {\n        const positions = [];\n        let nextPosition = 0;\n        for (let i = widths.length; i > 0; i--) {\n            if (stickyStates[i]) {\n                positions[i] = nextPosition;\n                nextPosition += widths[i];\n            }\n        }\n        return positions;\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Returns an error to be thrown when attempting to find an unexisting column.\n * @param id Id whose lookup failed.\n * @docs-private\n */\nfunction getTableUnknownColumnError(id) {\n    return Error(`Could not find column with id \"${id}\".`);\n}\n/**\n * Returns an error to be thrown when two column definitions have the same name.\n * @docs-private\n */\nfunction getTableDuplicateColumnNameError(name) {\n    return Error(`Duplicate column definition name provided: \"${name}\".`);\n}\n/**\n * Returns an error to be thrown when there are multiple rows that are missing a when function.\n * @docs-private\n */\nfunction getTableMultipleDefaultRowDefsError() {\n    return Error(`There can only be one default row without a when predicate function.`);\n}\n/**\n * Returns an error to be thrown when there are no matching row defs for a particular set of data.\n * @docs-private\n */\nfunction getTableMissingMatchingRowDefError(data) {\n    return Error(`Could not find a matching row definition for the` +\n        `provided row data: ${JSON.stringify(data)}`);\n}\n/**\n * Returns an error to be thrown when there is no row definitions present in the content.\n * @docs-private\n */\nfunction getTableMissingRowDefsError() {\n    return Error('Missing definitions for header, footer, and row; ' +\n        'cannot determine which columns should be rendered.');\n}\n/**\n * Returns an error to be thrown when the data source does not match the compatible types.\n * @docs-private\n */\nfunction getTableUnknownDataSourceError() {\n    return Error(`Provided data source did not match an array, Observable, or DataSource`);\n}\n/**\n * Returns an error to be thrown when the text column cannot find a parent table to inject.\n * @docs-private\n */\nfunction getTableTextColumnMissingParentTableError() {\n    return Error(`Text column could not find a parent table for registration.`);\n}\n/**\n * Returns an error to be thrown when a table text column doesn't have a name.\n * @docs-private\n */\nfunction getTableTextColumnMissingNameError() {\n    return Error(`Table text column must have a name.`);\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/** The injection token used to specify the StickyPositioningListener. */\nconst STICKY_POSITIONING_LISTENER = new InjectionToken('CDK_SPL');\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 * Enables the recycle view repeater strategy, which reduces rendering latency. Not compatible with\n * tables that animate rows.\n */\nclass CdkRecycleRows {\n}\nCdkRecycleRows.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkRecycleRows, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nCdkRecycleRows.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkRecycleRows, selector: \"cdk-table[recycleRows], table[cdk-table][recycleRows]\", providers: [{ provide: _VIEW_REPEATER_STRATEGY, useClass: _RecycleViewRepeaterStrategy }], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkRecycleRows, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'cdk-table[recycleRows], table[cdk-table][recycleRows]',\n                    providers: [{ provide: _VIEW_REPEATER_STRATEGY, useClass: _RecycleViewRepeaterStrategy }],\n                }]\n        }] });\n/**\n * Provides a handle for the table to grab the view container's ng-container to insert data rows.\n * @docs-private\n */\nclass DataRowOutlet {\n    constructor(viewContainer, elementRef) {\n        this.viewContainer = viewContainer;\n        this.elementRef = elementRef;\n    }\n}\nDataRowOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: DataRowOutlet, deps: [{ token: i0.ViewContainerRef }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });\nDataRowOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: DataRowOutlet, selector: \"[rowOutlet]\", ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: DataRowOutlet, decorators: [{\n            type: Directive,\n            args: [{ selector: '[rowOutlet]' }]\n        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.ElementRef }]; } });\n/**\n * Provides a handle for the table to grab the view container's ng-container to insert the header.\n * @docs-private\n */\nclass HeaderRowOutlet {\n    constructor(viewContainer, elementRef) {\n        this.viewContainer = viewContainer;\n        this.elementRef = elementRef;\n    }\n}\nHeaderRowOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: HeaderRowOutlet, deps: [{ token: i0.ViewContainerRef }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });\nHeaderRowOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: HeaderRowOutlet, selector: \"[headerRowOutlet]\", ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: HeaderRowOutlet, decorators: [{\n            type: Directive,\n            args: [{ selector: '[headerRowOutlet]' }]\n        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.ElementRef }]; } });\n/**\n * Provides a handle for the table to grab the view container's ng-container to insert the footer.\n * @docs-private\n */\nclass FooterRowOutlet {\n    constructor(viewContainer, elementRef) {\n        this.viewContainer = viewContainer;\n        this.elementRef = elementRef;\n    }\n}\nFooterRowOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: FooterRowOutlet, deps: [{ token: i0.ViewContainerRef }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });\nFooterRowOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: FooterRowOutlet, selector: \"[footerRowOutlet]\", ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: FooterRowOutlet, decorators: [{\n            type: Directive,\n            args: [{ selector: '[footerRowOutlet]' }]\n        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.ElementRef }]; } });\n/**\n * Provides a handle for the table to grab the view\n * container's ng-container to insert the no data row.\n * @docs-private\n */\nclass NoDataRowOutlet {\n    constructor(viewContainer, elementRef) {\n        this.viewContainer = viewContainer;\n        this.elementRef = elementRef;\n    }\n}\nNoDataRowOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: NoDataRowOutlet, deps: [{ token: i0.ViewContainerRef }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });\nNoDataRowOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: NoDataRowOutlet, selector: \"[noDataRowOutlet]\", ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: NoDataRowOutlet, decorators: [{\n            type: Directive,\n            args: [{ selector: '[noDataRowOutlet]' }]\n        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.ElementRef }]; } });\n/**\n * The table template that can be used by the mat-table. Should not be used outside of the\n * material library.\n * @docs-private\n */\nconst CDK_TABLE_TEMPLATE = \n// Note that according to MDN, the `caption` element has to be projected as the **first**\n// element in the table. See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/caption\n`\n  <ng-content select=\"caption\"></ng-content>\n  <ng-content select=\"colgroup, col\"></ng-content>\n  <ng-container headerRowOutlet></ng-container>\n  <ng-container rowOutlet></ng-container>\n  <ng-container noDataRowOutlet></ng-container>\n  <ng-container footerRowOutlet></ng-container>\n`;\n/**\n * Class used to conveniently type the embedded view ref for rows with a context.\n * @docs-private\n */\nclass RowViewRef extends EmbeddedViewRef {\n}\n/**\n * A data table that can render a header row, data rows, and a footer row.\n * Uses the dataSource input to determine the data to be rendered. The data can be provided either\n * as a data array, an Observable stream that emits the data array to render, or a DataSource with a\n * connect function that will return an Observable stream that emits the data array to render.\n */\nclass CdkTable {\n    constructor(_differs, _changeDetectorRef, _elementRef, role, _dir, _document, _platform, _viewRepeater, _coalescedStyleScheduler, _viewportRuler, \n    /**\n     * @deprecated `_stickyPositioningListener` parameter to become required.\n     * @breaking-change 13.0.0\n     */\n    _stickyPositioningListener, \n    /**\n     * @deprecated `_ngZone` parameter to become required.\n     * @breaking-change 14.0.0\n     */\n    _ngZone) {\n        this._differs = _differs;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._elementRef = _elementRef;\n        this._dir = _dir;\n        this._platform = _platform;\n        this._viewRepeater = _viewRepeater;\n        this._coalescedStyleScheduler = _coalescedStyleScheduler;\n        this._viewportRuler = _viewportRuler;\n        this._stickyPositioningListener = _stickyPositioningListener;\n        this._ngZone = _ngZone;\n        /** Subject that emits when the component has been destroyed. */\n        this._onDestroy = new Subject();\n        /**\n         * Map of all the user's defined columns (header, data, and footer cell template) identified by\n         * name. Collection populated by the column definitions gathered by `ContentChildren` as well as\n         * any custom column definitions added to `_customColumnDefs`.\n         */\n        this._columnDefsByName = new Map();\n        /**\n         * Column definitions that were defined outside of the direct content children of the table.\n         * These will be defined when, e.g., creating a wrapper around the cdkTable that has\n         * column definitions as *its* content child.\n         */\n        this._customColumnDefs = new Set();\n        /**\n         * Data row definitions that were defined outside of the direct content children of the table.\n         * These will be defined when, e.g., creating a wrapper around the cdkTable that has\n         * built-in data rows as *its* content child.\n         */\n        this._customRowDefs = new Set();\n        /**\n         * Header row definitions that were defined outside of the direct content children of the table.\n         * These will be defined when, e.g., creating a wrapper around the cdkTable that has\n         * built-in header rows as *its* content child.\n         */\n        this._customHeaderRowDefs = new Set();\n        /**\n         * Footer row definitions that were defined outside of the direct content children of the table.\n         * These will be defined when, e.g., creating a wrapper around the cdkTable that has a\n         * built-in footer row as *its* content child.\n         */\n        this._customFooterRowDefs = new Set();\n        /**\n         * Whether the header row definition has been changed. Triggers an update to the header row after\n         * content is checked. Initialized as true so that the table renders the initial set of rows.\n         */\n        this._headerRowDefChanged = true;\n        /**\n         * Whether the footer row definition has been changed. Triggers an update to the footer row after\n         * content is checked. Initialized as true so that the table renders the initial set of rows.\n         */\n        this._footerRowDefChanged = true;\n        /**\n         * Whether the sticky column styles need to be updated. Set to `true` when the visible columns\n         * change.\n         */\n        this._stickyColumnStylesNeedReset = true;\n        /**\n         * Whether the sticky styler should recalculate cell widths when applying sticky styles. If\n         * `false`, cached values will be used instead. This is only applicable to tables with\n         * {@link fixedLayout} enabled. For other tables, cell widths will always be recalculated.\n         */\n        this._forceRecalculateCellWidths = true;\n        /**\n         * Cache of the latest rendered `RenderRow` objects as a map for easy retrieval when constructing\n         * a new list of `RenderRow` objects for rendering rows. Since the new list is constructed with\n         * the cached `RenderRow` objects when possible, the row identity is preserved when the data\n         * and row template matches, which allows the `IterableDiffer` to check rows by reference\n         * and understand which rows are added/moved/removed.\n         *\n         * Implemented as a map of maps where the first key is the `data: T` object and the second is the\n         * `CdkRowDef<T>` object. With the two keys, the cache points to a `RenderRow<T>` object that\n         * contains an array of created pairs. The array is necessary to handle cases where the data\n         * array contains multiple duplicate data objects and each instantiated `RenderRow` must be\n         * stored.\n         */\n        this._cachedRenderRowsMap = new Map();\n        /**\n         * CSS class added to any row or cell that has sticky positioning applied. May be overriden by\n         * table subclasses.\n         */\n        this.stickyCssClass = 'cdk-table-sticky';\n        /**\n         * Whether to manually add positon: sticky to all sticky cell elements. Not needed if\n         * the position is set in a selector associated with the value of stickyCssClass. May be\n         * overridden by table subclasses\n         */\n        this.needsPositionStickyOnElement = true;\n        /** Whether the no data row is currently showing anything. */\n        this._isShowingNoDataRow = false;\n        this._multiTemplateDataRows = false;\n        this._fixedLayout = false;\n        /**\n         * Emits when the table completes rendering a set of data rows based on the latest data from the\n         * data source, even if the set of rows is empty.\n         */\n        this.contentChanged = new EventEmitter();\n        // TODO(andrewseguin): Remove max value as the end index\n        //   and instead calculate the view on init and scroll.\n        /**\n         * Stream containing the latest information on what rows are being displayed on screen.\n         * Can be used by the data source to as a heuristic of what data should be provided.\n         *\n         * @docs-private\n         */\n        this.viewChange = new BehaviorSubject({\n            start: 0,\n            end: Number.MAX_VALUE,\n        });\n        if (!role) {\n            this._elementRef.nativeElement.setAttribute('role', 'table');\n        }\n        this._document = _document;\n        this._isNativeHtmlTable = this._elementRef.nativeElement.nodeName === 'TABLE';\n    }\n    /**\n     * Tracking function that will be used to check the differences in data changes. Used similarly\n     * to `ngFor` `trackBy` function. Optimize row operations by identifying a row based on its data\n     * relative to the function to know if a row should be added/removed/moved.\n     * Accepts a function that takes two parameters, `index` and `item`.\n     */\n    get trackBy() {\n        return this._trackByFn;\n    }\n    set trackBy(fn) {\n        if ((typeof ngDevMode === 'undefined' || ngDevMode) && fn != null && typeof fn !== 'function') {\n            console.warn(`trackBy must be a function, but received ${JSON.stringify(fn)}.`);\n        }\n        this._trackByFn = fn;\n    }\n    /**\n     * The table's source of data, which can be provided in three ways (in order of complexity):\n     *   - Simple data array (each object represents one table row)\n     *   - Stream that emits a data array each time the array changes\n     *   - `DataSource` object that implements the connect/disconnect interface.\n     *\n     * If a data array is provided, the table must be notified when the array's objects are\n     * added, removed, or moved. This can be done by calling the `renderRows()` function which will\n     * render the diff since the last table render. If the data array reference is changed, the table\n     * will automatically trigger an update to the rows.\n     *\n     * When providing an Observable stream, the table will trigger an update automatically when the\n     * stream emits a new array of data.\n     *\n     * Finally, when providing a `DataSource` object, the table will use the Observable stream\n     * provided by the connect function and trigger updates when that stream emits new data array\n     * values. During the table's ngOnDestroy or when the data source is removed from the table, the\n     * table will call the DataSource's `disconnect` function (may be useful for cleaning up any\n     * subscriptions registered during the connect process).\n     */\n    get dataSource() {\n        return this._dataSource;\n    }\n    set dataSource(dataSource) {\n        if (this._dataSource !== dataSource) {\n            this._switchDataSource(dataSource);\n        }\n    }\n    /**\n     * Whether to allow multiple rows per data object by evaluating which rows evaluate their 'when'\n     * predicate to true. If `multiTemplateDataRows` is false, which is the default value, then each\n     * dataobject will render the first row that evaluates its when predicate to true, in the order\n     * defined in the table, or otherwise the default row which does not have a when predicate.\n     */\n    get multiTemplateDataRows() {\n        return this._multiTemplateDataRows;\n    }\n    set multiTemplateDataRows(v) {\n        this._multiTemplateDataRows = coerceBooleanProperty(v);\n        // In Ivy if this value is set via a static attribute (e.g. <table multiTemplateDataRows>),\n        // this setter will be invoked before the row outlet has been defined hence the null check.\n        if (this._rowOutlet && this._rowOutlet.viewContainer.length) {\n            this._forceRenderDataRows();\n            this.updateStickyColumnStyles();\n        }\n    }\n    /**\n     * Whether to use a fixed table layout. Enabling this option will enforce consistent column widths\n     * and optimize rendering sticky styles for native tables. No-op for flex tables.\n     */\n    get fixedLayout() {\n        return this._fixedLayout;\n    }\n    set fixedLayout(v) {\n        this._fixedLayout = coerceBooleanProperty(v);\n        // Toggling `fixedLayout` may change column widths. Sticky column styles should be recalculated.\n        this._forceRecalculateCellWidths = true;\n        this._stickyColumnStylesNeedReset = true;\n    }\n    ngOnInit() {\n        this._setupStickyStyler();\n        if (this._isNativeHtmlTable) {\n            this._applyNativeTableSections();\n        }\n        // Set up the trackBy function so that it uses the `RenderRow` as its identity by default. If\n        // the user has provided a custom trackBy, return the result of that function as evaluated\n        // with the values of the `RenderRow`'s data and index.\n        this._dataDiffer = this._differs.find([]).create((_i, dataRow) => {\n            return this.trackBy ? this.trackBy(dataRow.dataIndex, dataRow.data) : dataRow;\n        });\n        this._viewportRuler\n            .change()\n            .pipe(takeUntil(this._onDestroy))\n            .subscribe(() => {\n            this._forceRecalculateCellWidths = true;\n        });\n    }\n    ngAfterContentChecked() {\n        // Cache the row and column definitions gathered by ContentChildren and programmatic injection.\n        this._cacheRowDefs();\n        this._cacheColumnDefs();\n        // Make sure that the user has at least added header, footer, or data row def.\n        if (!this._headerRowDefs.length &&\n            !this._footerRowDefs.length &&\n            !this._rowDefs.length &&\n            (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getTableMissingRowDefsError();\n        }\n        // Render updates if the list of columns have been changed for the header, row, or footer defs.\n        const columnsChanged = this._renderUpdatedColumns();\n        const rowDefsChanged = columnsChanged || this._headerRowDefChanged || this._footerRowDefChanged;\n        // Ensure sticky column styles are reset if set to `true` elsewhere.\n        this._stickyColumnStylesNeedReset = this._stickyColumnStylesNeedReset || rowDefsChanged;\n        this._forceRecalculateCellWidths = rowDefsChanged;\n        // If the header row definition has been changed, trigger a render to the header row.\n        if (this._headerRowDefChanged) {\n            this._forceRenderHeaderRows();\n            this._headerRowDefChanged = false;\n        }\n        // If the footer row definition has been changed, trigger a render to the footer row.\n        if (this._footerRowDefChanged) {\n            this._forceRenderFooterRows();\n            this._footerRowDefChanged = false;\n        }\n        // If there is a data source and row definitions, connect to the data source unless a\n        // connection has already been made.\n        if (this.dataSource && this._rowDefs.length > 0 && !this._renderChangeSubscription) {\n            this._observeRenderChanges();\n        }\n        else if (this._stickyColumnStylesNeedReset) {\n            // In the above case, _observeRenderChanges will result in updateStickyColumnStyles being\n            // called when it row data arrives. Otherwise, we need to call it proactively.\n            this.updateStickyColumnStyles();\n        }\n        this._checkStickyStates();\n    }\n    ngOnDestroy() {\n        [\n            this._rowOutlet.viewContainer,\n            this._headerRowOutlet.viewContainer,\n            this._footerRowOutlet.viewContainer,\n            this._cachedRenderRowsMap,\n            this._customColumnDefs,\n            this._customRowDefs,\n            this._customHeaderRowDefs,\n            this._customFooterRowDefs,\n            this._columnDefsByName,\n        ].forEach(def => {\n            def.clear();\n        });\n        this._headerRowDefs = [];\n        this._footerRowDefs = [];\n        this._defaultRowDef = null;\n        this._onDestroy.next();\n        this._onDestroy.complete();\n        if (isDataSource(this.dataSource)) {\n            this.dataSource.disconnect(this);\n        }\n    }\n    /**\n     * Renders rows based on the table's latest set of data, which was either provided directly as an\n     * input or retrieved through an Observable stream (directly or from a DataSource).\n     * Checks for differences in the data since the last diff to perform only the necessary\n     * changes (add/remove/move rows).\n     *\n     * If the table's data source is a DataSource or Observable, this will be invoked automatically\n     * each time the provided Observable stream emits a new data array. Otherwise if your data is\n     * an array, this function will need to be called to render any changes.\n     */\n    renderRows() {\n        this._renderRows = this._getAllRenderRows();\n        const changes = this._dataDiffer.diff(this._renderRows);\n        if (!changes) {\n            this._updateNoDataRow();\n            this.contentChanged.next();\n            return;\n        }\n        const viewContainer = this._rowOutlet.viewContainer;\n        this._viewRepeater.applyChanges(changes, viewContainer, (record, _adjustedPreviousIndex, currentIndex) => this._getEmbeddedViewArgs(record.item, currentIndex), record => record.item.data, (change) => {\n            if (change.operation === 1 /* INSERTED */ && change.context) {\n                this._renderCellTemplateForItem(change.record.item.rowDef, change.context);\n            }\n        });\n        // Update the meta context of a row's context data (index, count, first, last, ...)\n        this._updateRowIndexContext();\n        // Update rows that did not get added/removed/moved but may have had their identity changed,\n        // e.g. if trackBy matched data on some property but the actual data reference changed.\n        changes.forEachIdentityChange((record) => {\n            const rowView = viewContainer.get(record.currentIndex);\n            rowView.context.$implicit = record.item.data;\n        });\n        this._updateNoDataRow();\n        // Allow the new row data to render before measuring it.\n        // @breaking-change 14.0.0 Remove undefined check once _ngZone is required.\n        if (this._ngZone && NgZone.isInAngularZone()) {\n            this._ngZone.onStable.pipe(take(1), takeUntil(this._onDestroy)).subscribe(() => {\n                this.updateStickyColumnStyles();\n            });\n        }\n        else {\n            this.updateStickyColumnStyles();\n        }\n        this.contentChanged.next();\n    }\n    /** Adds a column definition that was not included as part of the content children. */\n    addColumnDef(columnDef) {\n        this._customColumnDefs.add(columnDef);\n    }\n    /** Removes a column definition that was not included as part of the content children. */\n    removeColumnDef(columnDef) {\n        this._customColumnDefs.delete(columnDef);\n    }\n    /** Adds a row definition that was not included as part of the content children. */\n    addRowDef(rowDef) {\n        this._customRowDefs.add(rowDef);\n    }\n    /** Removes a row definition that was not included as part of the content children. */\n    removeRowDef(rowDef) {\n        this._customRowDefs.delete(rowDef);\n    }\n    /** Adds a header row definition that was not included as part of the content children. */\n    addHeaderRowDef(headerRowDef) {\n        this._customHeaderRowDefs.add(headerRowDef);\n        this._headerRowDefChanged = true;\n    }\n    /** Removes a header row definition that was not included as part of the content children. */\n    removeHeaderRowDef(headerRowDef) {\n        this._customHeaderRowDefs.delete(headerRowDef);\n        this._headerRowDefChanged = true;\n    }\n    /** Adds a footer row definition that was not included as part of the content children. */\n    addFooterRowDef(footerRowDef) {\n        this._customFooterRowDefs.add(footerRowDef);\n        this._footerRowDefChanged = true;\n    }\n    /** Removes a footer row definition that was not included as part of the content children. */\n    removeFooterRowDef(footerRowDef) {\n        this._customFooterRowDefs.delete(footerRowDef);\n        this._footerRowDefChanged = true;\n    }\n    /** Sets a no data row definition that was not included as a part of the content children. */\n    setNoDataRow(noDataRow) {\n        this._customNoDataRow = noDataRow;\n    }\n    /**\n     * Updates the header sticky styles. First resets all applied styles with respect to the cells\n     * sticking to the top. Then, evaluating which cells need to be stuck to the top. This is\n     * automatically called when the header row changes its displayed set of columns, or if its\n     * sticky input changes. May be called manually for cases where the cell content changes outside\n     * of these events.\n     */\n    updateStickyHeaderRowStyles() {\n        const headerRows = this._getRenderedRows(this._headerRowOutlet);\n        const tableElement = this._elementRef.nativeElement;\n        // Hide the thead element if there are no header rows. This is necessary to satisfy\n        // overzealous a11y checkers that fail because the `rowgroup` element does not contain\n        // required child `row`.\n        const thead = tableElement.querySelector('thead');\n        if (thead) {\n            thead.style.display = headerRows.length ? '' : 'none';\n        }\n        const stickyStates = this._headerRowDefs.map(def => def.sticky);\n        this._stickyStyler.clearStickyPositioning(headerRows, ['top']);\n        this._stickyStyler.stickRows(headerRows, stickyStates, 'top');\n        // Reset the dirty state of the sticky input change since it has been used.\n        this._headerRowDefs.forEach(def => def.resetStickyChanged());\n    }\n    /**\n     * Updates the footer sticky styles. First resets all applied styles with respect to the cells\n     * sticking to the bottom. Then, evaluating which cells need to be stuck to the bottom. This is\n     * automatically called when the footer row changes its displayed set of columns, or if its\n     * sticky input changes. May be called manually for cases where the cell content changes outside\n     * of these events.\n     */\n    updateStickyFooterRowStyles() {\n        const footerRows = this._getRenderedRows(this._footerRowOutlet);\n        const tableElement = this._elementRef.nativeElement;\n        // Hide the tfoot element if there are no footer rows. This is necessary to satisfy\n        // overzealous a11y checkers that fail because the `rowgroup` element does not contain\n        // required child `row`.\n        const tfoot = tableElement.querySelector('tfoot');\n        if (tfoot) {\n            tfoot.style.display = footerRows.length ? '' : 'none';\n        }\n        const stickyStates = this._footerRowDefs.map(def => def.sticky);\n        this._stickyStyler.clearStickyPositioning(footerRows, ['bottom']);\n        this._stickyStyler.stickRows(footerRows, stickyStates, 'bottom');\n        this._stickyStyler.updateStickyFooterContainer(this._elementRef.nativeElement, stickyStates);\n        // Reset the dirty state of the sticky input change since it has been used.\n        this._footerRowDefs.forEach(def => def.resetStickyChanged());\n    }\n    /**\n     * Updates the column sticky styles. First resets all applied styles with respect to the cells\n     * sticking to the left and right. Then sticky styles are added for the left and right according\n     * to the column definitions for each cell in each row. This is automatically called when\n     * the data source provides a new set of data or when a column definition changes its sticky\n     * input. May be called manually for cases where the cell content changes outside of these events.\n     */\n    updateStickyColumnStyles() {\n        const headerRows = this._getRenderedRows(this._headerRowOutlet);\n        const dataRows = this._getRenderedRows(this._rowOutlet);\n        const footerRows = this._getRenderedRows(this._footerRowOutlet);\n        // For tables not using a fixed layout, the column widths may change when new rows are rendered.\n        // In a table using a fixed layout, row content won't affect column width, so sticky styles\n        // don't need to be cleared unless either the sticky column config changes or one of the row\n        // defs change.\n        if ((this._isNativeHtmlTable && !this._fixedLayout) || this._stickyColumnStylesNeedReset) {\n            // Clear the left and right positioning from all columns in the table across all rows since\n            // sticky columns span across all table sections (header, data, footer)\n            this._stickyStyler.clearStickyPositioning([...headerRows, ...dataRows, ...footerRows], ['left', 'right']);\n            this._stickyColumnStylesNeedReset = false;\n        }\n        // Update the sticky styles for each header row depending on the def's sticky state\n        headerRows.forEach((headerRow, i) => {\n            this._addStickyColumnStyles([headerRow], this._headerRowDefs[i]);\n        });\n        // Update the sticky styles for each data row depending on its def's sticky state\n        this._rowDefs.forEach(rowDef => {\n            // Collect all the rows rendered with this row definition.\n            const rows = [];\n            for (let i = 0; i < dataRows.length; i++) {\n                if (this._renderRows[i].rowDef === rowDef) {\n                    rows.push(dataRows[i]);\n                }\n            }\n            this._addStickyColumnStyles(rows, rowDef);\n        });\n        // Update the sticky styles for each footer row depending on the def's sticky state\n        footerRows.forEach((footerRow, i) => {\n            this._addStickyColumnStyles([footerRow], this._footerRowDefs[i]);\n        });\n        // Reset the dirty state of the sticky input change since it has been used.\n        Array.from(this._columnDefsByName.values()).forEach(def => def.resetStickyChanged());\n    }\n    /**\n     * Get the list of RenderRow objects to render according to the current list of data and defined\n     * row definitions. If the previous list already contained a particular pair, it should be reused\n     * so that the differ equates their references.\n     */\n    _getAllRenderRows() {\n        const renderRows = [];\n        // Store the cache and create a new one. Any re-used RenderRow objects will be moved into the\n        // new cache while unused ones can be picked up by garbage collection.\n        const prevCachedRenderRows = this._cachedRenderRowsMap;\n        this._cachedRenderRowsMap = new Map();\n        // For each data object, get the list of rows that should be rendered, represented by the\n        // respective `RenderRow` object which is the pair of `data` and `CdkRowDef`.\n        for (let i = 0; i < this._data.length; i++) {\n            let data = this._data[i];\n            const renderRowsForData = this._getRenderRowsForData(data, i, prevCachedRenderRows.get(data));\n            if (!this._cachedRenderRowsMap.has(data)) {\n                this._cachedRenderRowsMap.set(data, new WeakMap());\n            }\n            for (let j = 0; j < renderRowsForData.length; j++) {\n                let renderRow = renderRowsForData[j];\n                const cache = this._cachedRenderRowsMap.get(renderRow.data);\n                if (cache.has(renderRow.rowDef)) {\n                    cache.get(renderRow.rowDef).push(renderRow);\n                }\n                else {\n                    cache.set(renderRow.rowDef, [renderRow]);\n                }\n                renderRows.push(renderRow);\n            }\n        }\n        return renderRows;\n    }\n    /**\n     * Gets a list of `RenderRow<T>` for the provided data object and any `CdkRowDef` objects that\n     * should be rendered for this data. Reuses the cached RenderRow objects if they match the same\n     * `(T, CdkRowDef)` pair.\n     */\n    _getRenderRowsForData(data, dataIndex, cache) {\n        const rowDefs = this._getRowDefs(data, dataIndex);\n        return rowDefs.map(rowDef => {\n            const cachedRenderRows = cache && cache.has(rowDef) ? cache.get(rowDef) : [];\n            if (cachedRenderRows.length) {\n                const dataRow = cachedRenderRows.shift();\n                dataRow.dataIndex = dataIndex;\n                return dataRow;\n            }\n            else {\n                return { data, rowDef, dataIndex };\n            }\n        });\n    }\n    /** Update the map containing the content's column definitions. */\n    _cacheColumnDefs() {\n        this._columnDefsByName.clear();\n        const columnDefs = mergeArrayAndSet(this._getOwnDefs(this._contentColumnDefs), this._customColumnDefs);\n        columnDefs.forEach(columnDef => {\n            if (this._columnDefsByName.has(columnDef.name) &&\n                (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                throw getTableDuplicateColumnNameError(columnDef.name);\n            }\n            this._columnDefsByName.set(columnDef.name, columnDef);\n        });\n    }\n    /** Update the list of all available row definitions that can be used. */\n    _cacheRowDefs() {\n        this._headerRowDefs = mergeArrayAndSet(this._getOwnDefs(this._contentHeaderRowDefs), this._customHeaderRowDefs);\n        this._footerRowDefs = mergeArrayAndSet(this._getOwnDefs(this._contentFooterRowDefs), this._customFooterRowDefs);\n        this._rowDefs = mergeArrayAndSet(this._getOwnDefs(this._contentRowDefs), this._customRowDefs);\n        // After all row definitions are determined, find the row definition to be considered default.\n        const defaultRowDefs = this._rowDefs.filter(def => !def.when);\n        if (!this.multiTemplateDataRows &&\n            defaultRowDefs.length > 1 &&\n            (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getTableMultipleDefaultRowDefsError();\n        }\n        this._defaultRowDef = defaultRowDefs[0];\n    }\n    /**\n     * Check if the header, data, or footer rows have changed what columns they want to display or\n     * whether the sticky states have changed for the header or footer. If there is a diff, then\n     * re-render that section.\n     */\n    _renderUpdatedColumns() {\n        const columnsDiffReducer = (acc, def) => acc || !!def.getColumnsDiff();\n        // Force re-render data rows if the list of column definitions have changed.\n        const dataColumnsChanged = this._rowDefs.reduce(columnsDiffReducer, false);\n        if (dataColumnsChanged) {\n            this._forceRenderDataRows();\n        }\n        // Force re-render header/footer rows if the list of column definitions have changed.\n        const headerColumnsChanged = this._headerRowDefs.reduce(columnsDiffReducer, false);\n        if (headerColumnsChanged) {\n            this._forceRenderHeaderRows();\n        }\n        const footerColumnsChanged = this._footerRowDefs.reduce(columnsDiffReducer, false);\n        if (footerColumnsChanged) {\n            this._forceRenderFooterRows();\n        }\n        return dataColumnsChanged || headerColumnsChanged || footerColumnsChanged;\n    }\n    /**\n     * Switch to the provided data source by resetting the data and unsubscribing from the current\n     * render change subscription if one exists. If the data source is null, interpret this by\n     * clearing the row outlet. Otherwise start listening for new data.\n     */\n    _switchDataSource(dataSource) {\n        this._data = [];\n        if (isDataSource(this.dataSource)) {\n            this.dataSource.disconnect(this);\n        }\n        // Stop listening for data from the previous data source.\n        if (this._renderChangeSubscription) {\n            this._renderChangeSubscription.unsubscribe();\n            this._renderChangeSubscription = null;\n        }\n        if (!dataSource) {\n            if (this._dataDiffer) {\n                this._dataDiffer.diff([]);\n            }\n            this._rowOutlet.viewContainer.clear();\n        }\n        this._dataSource = dataSource;\n    }\n    /** Set up a subscription for the data provided by the data source. */\n    _observeRenderChanges() {\n        // If no data source has been set, there is nothing to observe for changes.\n        if (!this.dataSource) {\n            return;\n        }\n        let dataStream;\n        if (isDataSource(this.dataSource)) {\n            dataStream = this.dataSource.connect(this);\n        }\n        else if (isObservable(this.dataSource)) {\n            dataStream = this.dataSource;\n        }\n        else if (Array.isArray(this.dataSource)) {\n            dataStream = of(this.dataSource);\n        }\n        if (dataStream === undefined && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getTableUnknownDataSourceError();\n        }\n        this._renderChangeSubscription = dataStream\n            .pipe(takeUntil(this._onDestroy))\n            .subscribe(data => {\n            this._data = data || [];\n            this.renderRows();\n        });\n    }\n    /**\n     * Clears any existing content in the header row outlet and creates a new embedded view\n     * in the outlet using the header row definition.\n     */\n    _forceRenderHeaderRows() {\n        // Clear the header row outlet if any content exists.\n        if (this._headerRowOutlet.viewContainer.length > 0) {\n            this._headerRowOutlet.viewContainer.clear();\n        }\n        this._headerRowDefs.forEach((def, i) => this._renderRow(this._headerRowOutlet, def, i));\n        this.updateStickyHeaderRowStyles();\n    }\n    /**\n     * Clears any existing content in the footer row outlet and creates a new embedded view\n     * in the outlet using the footer row definition.\n     */\n    _forceRenderFooterRows() {\n        // Clear the footer row outlet if any content exists.\n        if (this._footerRowOutlet.viewContainer.length > 0) {\n            this._footerRowOutlet.viewContainer.clear();\n        }\n        this._footerRowDefs.forEach((def, i) => this._renderRow(this._footerRowOutlet, def, i));\n        this.updateStickyFooterRowStyles();\n    }\n    /** Adds the sticky column styles for the rows according to the columns' stick states. */\n    _addStickyColumnStyles(rows, rowDef) {\n        const columnDefs = Array.from(rowDef.columns || []).map(columnName => {\n            const columnDef = this._columnDefsByName.get(columnName);\n            if (!columnDef && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                throw getTableUnknownColumnError(columnName);\n            }\n            return columnDef;\n        });\n        const stickyStartStates = columnDefs.map(columnDef => columnDef.sticky);\n        const stickyEndStates = columnDefs.map(columnDef => columnDef.stickyEnd);\n        this._stickyStyler.updateStickyColumns(rows, stickyStartStates, stickyEndStates, !this._fixedLayout || this._forceRecalculateCellWidths);\n    }\n    /** Gets the list of rows that have been rendered in the row outlet. */\n    _getRenderedRows(rowOutlet) {\n        const renderedRows = [];\n        for (let i = 0; i < rowOutlet.viewContainer.length; i++) {\n            const viewRef = rowOutlet.viewContainer.get(i);\n            renderedRows.push(viewRef.rootNodes[0]);\n        }\n        return renderedRows;\n    }\n    /**\n     * Get the matching row definitions that should be used for this row data. If there is only\n     * one row definition, it is returned. Otherwise, find the row definitions that has a when\n     * predicate that returns true with the data. If none return true, return the default row\n     * definition.\n     */\n    _getRowDefs(data, dataIndex) {\n        if (this._rowDefs.length == 1) {\n            return [this._rowDefs[0]];\n        }\n        let rowDefs = [];\n        if (this.multiTemplateDataRows) {\n            rowDefs = this._rowDefs.filter(def => !def.when || def.when(dataIndex, data));\n        }\n        else {\n            let rowDef = this._rowDefs.find(def => def.when && def.when(dataIndex, data)) || this._defaultRowDef;\n            if (rowDef) {\n                rowDefs.push(rowDef);\n            }\n        }\n        if (!rowDefs.length && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getTableMissingMatchingRowDefError(data);\n        }\n        return rowDefs;\n    }\n    _getEmbeddedViewArgs(renderRow, index) {\n        const rowDef = renderRow.rowDef;\n        const context = { $implicit: renderRow.data };\n        return {\n            templateRef: rowDef.template,\n            context,\n            index,\n        };\n    }\n    /**\n     * Creates a new row template in the outlet and fills it with the set of cell templates.\n     * Optionally takes a context to provide to the row and cells, as well as an optional index\n     * of where to place the new row template in the outlet.\n     */\n    _renderRow(outlet, rowDef, index, context = {}) {\n        // TODO(andrewseguin): enforce that one outlet was instantiated from createEmbeddedView\n        const view = outlet.viewContainer.createEmbeddedView(rowDef.template, context, index);\n        this._renderCellTemplateForItem(rowDef, context);\n        return view;\n    }\n    _renderCellTemplateForItem(rowDef, context) {\n        for (let cellTemplate of this._getCellTemplates(rowDef)) {\n            if (CdkCellOutlet.mostRecentCellOutlet) {\n                CdkCellOutlet.mostRecentCellOutlet._viewContainer.createEmbeddedView(cellTemplate, context);\n            }\n        }\n        this._changeDetectorRef.markForCheck();\n    }\n    /**\n     * Updates the index-related context for each row to reflect any changes in the index of the rows,\n     * e.g. first/last/even/odd.\n     */\n    _updateRowIndexContext() {\n        const viewContainer = this._rowOutlet.viewContainer;\n        for (let renderIndex = 0, count = viewContainer.length; renderIndex < count; renderIndex++) {\n            const viewRef = viewContainer.get(renderIndex);\n            const context = viewRef.context;\n            context.count = count;\n            context.first = renderIndex === 0;\n            context.last = renderIndex === count - 1;\n            context.even = renderIndex % 2 === 0;\n            context.odd = !context.even;\n            if (this.multiTemplateDataRows) {\n                context.dataIndex = this._renderRows[renderIndex].dataIndex;\n                context.renderIndex = renderIndex;\n            }\n            else {\n                context.index = this._renderRows[renderIndex].dataIndex;\n            }\n        }\n    }\n    /** Gets the column definitions for the provided row def. */\n    _getCellTemplates(rowDef) {\n        if (!rowDef || !rowDef.columns) {\n            return [];\n        }\n        return Array.from(rowDef.columns, columnId => {\n            const column = this._columnDefsByName.get(columnId);\n            if (!column && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                throw getTableUnknownColumnError(columnId);\n            }\n            return rowDef.extractCellTemplate(column);\n        });\n    }\n    /** Adds native table sections (e.g. tbody) and moves the row outlets into them. */\n    _applyNativeTableSections() {\n        const documentFragment = this._document.createDocumentFragment();\n        const sections = [\n            { tag: 'thead', outlets: [this._headerRowOutlet] },\n            { tag: 'tbody', outlets: [this._rowOutlet, this._noDataRowOutlet] },\n            { tag: 'tfoot', outlets: [this._footerRowOutlet] },\n        ];\n        for (const section of sections) {\n            const element = this._document.createElement(section.tag);\n            element.setAttribute('role', 'rowgroup');\n            for (const outlet of section.outlets) {\n                element.appendChild(outlet.elementRef.nativeElement);\n            }\n            documentFragment.appendChild(element);\n        }\n        // Use a DocumentFragment so we don't hit the DOM on each iteration.\n        this._elementRef.nativeElement.appendChild(documentFragment);\n    }\n    /**\n     * Forces a re-render of the data rows. Should be called in cases where there has been an input\n     * change that affects the evaluation of which rows should be rendered, e.g. toggling\n     * `multiTemplateDataRows` or adding/removing row definitions.\n     */\n    _forceRenderDataRows() {\n        this._dataDiffer.diff([]);\n        this._rowOutlet.viewContainer.clear();\n        this.renderRows();\n    }\n    /**\n     * Checks if there has been a change in sticky states since last check and applies the correct\n     * sticky styles. Since checking resets the \"dirty\" state, this should only be performed once\n     * during a change detection and after the inputs are settled (after content check).\n     */\n    _checkStickyStates() {\n        const stickyCheckReducer = (acc, d) => {\n            return acc || d.hasStickyChanged();\n        };\n        // Note that the check needs to occur for every definition since it notifies the definition\n        // that it can reset its dirty state. Using another operator like `some` may short-circuit\n        // remaining definitions and leave them in an unchecked state.\n        if (this._headerRowDefs.reduce(stickyCheckReducer, false)) {\n            this.updateStickyHeaderRowStyles();\n        }\n        if (this._footerRowDefs.reduce(stickyCheckReducer, false)) {\n            this.updateStickyFooterRowStyles();\n        }\n        if (Array.from(this._columnDefsByName.values()).reduce(stickyCheckReducer, false)) {\n            this._stickyColumnStylesNeedReset = true;\n            this.updateStickyColumnStyles();\n        }\n    }\n    /**\n     * Creates the sticky styler that will be used for sticky rows and columns. Listens\n     * for directionality changes and provides the latest direction to the styler. Re-applies column\n     * stickiness when directionality changes.\n     */\n    _setupStickyStyler() {\n        const direction = this._dir ? this._dir.value : 'ltr';\n        this._stickyStyler = new StickyStyler(this._isNativeHtmlTable, this.stickyCssClass, direction, this._coalescedStyleScheduler, this._platform.isBrowser, this.needsPositionStickyOnElement, this._stickyPositioningListener);\n        (this._dir ? this._dir.change : of())\n            .pipe(takeUntil(this._onDestroy))\n            .subscribe(value => {\n            this._stickyStyler.direction = value;\n            this.updateStickyColumnStyles();\n        });\n    }\n    /** Filters definitions that belong to this table from a QueryList. */\n    _getOwnDefs(items) {\n        return items.filter(item => !item._table || item._table === this);\n    }\n    /** Creates or removes the no data row, depending on whether any data is being shown. */\n    _updateNoDataRow() {\n        const noDataRow = this._customNoDataRow || this._noDataRow;\n        if (!noDataRow) {\n            return;\n        }\n        const shouldShow = this._rowOutlet.viewContainer.length === 0;\n        if (shouldShow === this._isShowingNoDataRow) {\n            return;\n        }\n        const container = this._noDataRowOutlet.viewContainer;\n        if (shouldShow) {\n            const view = container.createEmbeddedView(noDataRow.templateRef);\n            const rootNode = view.rootNodes[0];\n            // Only add the attributes if we have a single root node since it's hard\n            // to figure out which one to add it to when there are multiple.\n            if (view.rootNodes.length === 1 && rootNode?.nodeType === this._document.ELEMENT_NODE) {\n                rootNode.setAttribute('role', 'row');\n                rootNode.classList.add(noDataRow._contentClassName);\n            }\n        }\n        else {\n            container.clear();\n        }\n        this._isShowingNoDataRow = shouldShow;\n    }\n}\nCdkTable.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkTable, deps: [{ token: i0.IterableDiffers }, { token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: 'role', attribute: true }, { token: i1.Directionality, optional: true }, { token: DOCUMENT }, { token: i2.Platform }, { token: _VIEW_REPEATER_STRATEGY }, { token: _COALESCED_STYLE_SCHEDULER }, { token: i3.ViewportRuler }, { token: STICKY_POSITIONING_LISTENER, optional: true, skipSelf: true }, { token: i0.NgZone, optional: true }], target: i0.ɵɵFactoryTarget.Component });\nCdkTable.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkTable, selector: \"cdk-table, table[cdk-table]\", inputs: { trackBy: \"trackBy\", dataSource: \"dataSource\", multiTemplateDataRows: \"multiTemplateDataRows\", fixedLayout: \"fixedLayout\" }, outputs: { contentChanged: \"contentChanged\" }, host: { properties: { \"class.cdk-table-fixed-layout\": \"fixedLayout\" }, classAttribute: \"cdk-table\" }, providers: [\n        { provide: CDK_TABLE, useExisting: CdkTable },\n        { provide: _VIEW_REPEATER_STRATEGY, useClass: _DisposeViewRepeaterStrategy },\n        { provide: _COALESCED_STYLE_SCHEDULER, useClass: _CoalescedStyleScheduler },\n        // Prevent nested tables from seeing this table's StickyPositioningListener.\n        { provide: STICKY_POSITIONING_LISTENER, useValue: null },\n    ], queries: [{ propertyName: \"_noDataRow\", first: true, predicate: CdkNoDataRow, descendants: true }, { propertyName: \"_contentColumnDefs\", predicate: CdkColumnDef, descendants: true }, { propertyName: \"_contentRowDefs\", predicate: CdkRowDef, descendants: true }, { propertyName: \"_contentHeaderRowDefs\", predicate: CdkHeaderRowDef, descendants: true }, { propertyName: \"_contentFooterRowDefs\", predicate: CdkFooterRowDef, descendants: true }], viewQueries: [{ propertyName: \"_rowOutlet\", first: true, predicate: DataRowOutlet, descendants: true, static: true }, { propertyName: \"_headerRowOutlet\", first: true, predicate: HeaderRowOutlet, descendants: true, static: true }, { propertyName: \"_footerRowOutlet\", first: true, predicate: FooterRowOutlet, descendants: true, static: true }, { propertyName: \"_noDataRowOutlet\", first: true, predicate: NoDataRowOutlet, descendants: true, static: true }], exportAs: [\"cdkTable\"], ngImport: i0, template: \"\\n  <ng-content select=\\\"caption\\\"></ng-content>\\n  <ng-content select=\\\"colgroup, col\\\"></ng-content>\\n  <ng-container headerRowOutlet></ng-container>\\n  <ng-container rowOutlet></ng-container>\\n  <ng-container noDataRowOutlet></ng-container>\\n  <ng-container footerRowOutlet></ng-container>\\n\", isInline: true, styles: [\".cdk-table-fixed-layout{table-layout:fixed}\\n\"], directives: [{ type: HeaderRowOutlet, selector: \"[headerRowOutlet]\" }, { type: DataRowOutlet, selector: \"[rowOutlet]\" }, { type: NoDataRowOutlet, selector: \"[noDataRowOutlet]\" }, { type: FooterRowOutlet, selector: \"[footerRowOutlet]\" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkTable, decorators: [{\n            type: Component,\n            args: [{ selector: 'cdk-table, table[cdk-table]', exportAs: 'cdkTable', template: CDK_TABLE_TEMPLATE, host: {\n                        'class': 'cdk-table',\n                        '[class.cdk-table-fixed-layout]': 'fixedLayout',\n                    }, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.Default, providers: [\n                        { provide: CDK_TABLE, useExisting: CdkTable },\n                        { provide: _VIEW_REPEATER_STRATEGY, useClass: _DisposeViewRepeaterStrategy },\n                        { provide: _COALESCED_STYLE_SCHEDULER, useClass: _CoalescedStyleScheduler },\n                        // Prevent nested tables from seeing this table's StickyPositioningListener.\n                        { provide: STICKY_POSITIONING_LISTENER, useValue: null },\n                    ], styles: [\".cdk-table-fixed-layout{table-layout:fixed}\\n\"] }]\n        }], ctorParameters: function () { return [{ type: i0.IterableDiffers }, { type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: undefined, decorators: [{\n                    type: Attribute,\n                    args: ['role']\n                }] }, { type: i1.Directionality, decorators: [{\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: i2.Platform }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [_VIEW_REPEATER_STRATEGY]\n                }] }, { type: _CoalescedStyleScheduler, decorators: [{\n                    type: Inject,\n                    args: [_COALESCED_STYLE_SCHEDULER]\n                }] }, { type: i3.ViewportRuler }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: SkipSelf\n                }, {\n                    type: Inject,\n                    args: [STICKY_POSITIONING_LISTENER]\n                }] }, { type: i0.NgZone, decorators: [{\n                    type: Optional\n                }] }]; }, propDecorators: { trackBy: [{\n                type: Input\n            }], dataSource: [{\n                type: Input\n            }], multiTemplateDataRows: [{\n                type: Input\n            }], fixedLayout: [{\n                type: Input\n            }], contentChanged: [{\n                type: Output\n            }], _rowOutlet: [{\n                type: ViewChild,\n                args: [DataRowOutlet, { static: true }]\n            }], _headerRowOutlet: [{\n                type: ViewChild,\n                args: [HeaderRowOutlet, { static: true }]\n            }], _footerRowOutlet: [{\n                type: ViewChild,\n                args: [FooterRowOutlet, { static: true }]\n            }], _noDataRowOutlet: [{\n                type: ViewChild,\n                args: [NoDataRowOutlet, { static: true }]\n            }], _contentColumnDefs: [{\n                type: ContentChildren,\n                args: [CdkColumnDef, { descendants: true }]\n            }], _contentRowDefs: [{\n                type: ContentChildren,\n                args: [CdkRowDef, { descendants: true }]\n            }], _contentHeaderRowDefs: [{\n                type: ContentChildren,\n                args: [CdkHeaderRowDef, {\n                        descendants: true,\n                    }]\n            }], _contentFooterRowDefs: [{\n                type: ContentChildren,\n                args: [CdkFooterRowDef, {\n                        descendants: true,\n                    }]\n            }], _noDataRow: [{\n                type: ContentChild,\n                args: [CdkNoDataRow]\n            }] } });\n/** Utility function that gets a merged list of the entries in an array and values of a Set. */\nfunction mergeArrayAndSet(array, set) {\n    return array.concat(Array.from(set));\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 * Column that simply shows text content for the header and row cells. Assumes that the table\n * is using the native table implementation (`<table>`).\n *\n * By default, the name of this column will be the header text and data property accessor.\n * The header text can be overridden with the `headerText` input. Cell values can be overridden with\n * the `dataAccessor` input. Change the text justification to the start or end using the `justify`\n * input.\n */\nclass CdkTextColumn {\n    constructor(\n    // `CdkTextColumn` is always requiring a table, but we just assert it manually\n    // for better error reporting.\n    // tslint:disable-next-line: lightweight-tokens\n    _table, _options) {\n        this._table = _table;\n        this._options = _options;\n        /** Alignment of the cell values. */\n        this.justify = 'start';\n        this._options = _options || {};\n    }\n    /** Column name that should be used to reference this column. */\n    get name() {\n        return this._name;\n    }\n    set name(name) {\n        this._name = name;\n        // With Ivy, inputs can be initialized before static query results are\n        // available. In that case, we defer the synchronization until \"ngOnInit\" fires.\n        this._syncColumnDefName();\n    }\n    ngOnInit() {\n        this._syncColumnDefName();\n        if (this.headerText === undefined) {\n            this.headerText = this._createDefaultHeaderText();\n        }\n        if (!this.dataAccessor) {\n            this.dataAccessor =\n                this._options.defaultDataAccessor || ((data, name) => data[name]);\n        }\n        if (this._table) {\n            // Provide the cell and headerCell directly to the table with the static `ViewChild` query,\n            // since the columnDef will not pick up its content by the time the table finishes checking\n            // its content and initializing the rows.\n            this.columnDef.cell = this.cell;\n            this.columnDef.headerCell = this.headerCell;\n            this._table.addColumnDef(this.columnDef);\n        }\n        else if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            throw getTableTextColumnMissingParentTableError();\n        }\n    }\n    ngOnDestroy() {\n        if (this._table) {\n            this._table.removeColumnDef(this.columnDef);\n        }\n    }\n    /**\n     * Creates a default header text. Use the options' header text transformation function if one\n     * has been provided. Otherwise simply capitalize the column name.\n     */\n    _createDefaultHeaderText() {\n        const name = this.name;\n        if (!name && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getTableTextColumnMissingNameError();\n        }\n        if (this._options && this._options.defaultHeaderTextTransform) {\n            return this._options.defaultHeaderTextTransform(name);\n        }\n        return name[0].toUpperCase() + name.slice(1);\n    }\n    /** Synchronizes the column definition name with the text column name. */\n    _syncColumnDefName() {\n        if (this.columnDef) {\n            this.columnDef.name = this.name;\n        }\n    }\n}\nCdkTextColumn.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkTextColumn, deps: [{ token: CdkTable, optional: true }, { token: TEXT_COLUMN_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Component });\nCdkTextColumn.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: CdkTextColumn, selector: \"cdk-text-column\", inputs: { name: \"name\", headerText: \"headerText\", dataAccessor: \"dataAccessor\", justify: \"justify\" }, viewQueries: [{ propertyName: \"columnDef\", first: true, predicate: CdkColumnDef, descendants: true, static: true }, { propertyName: \"cell\", first: true, predicate: CdkCellDef, descendants: true, static: true }, { propertyName: \"headerCell\", first: true, predicate: CdkHeaderCellDef, descendants: true, static: true }], ngImport: i0, template: `\n    <ng-container cdkColumnDef>\n      <th cdk-header-cell *cdkHeaderCellDef [style.text-align]=\"justify\">\n        {{headerText}}\n      </th>\n      <td cdk-cell *cdkCellDef=\"let data\" [style.text-align]=\"justify\">\n        {{dataAccessor(data, name)}}\n      </td>\n    </ng-container>\n  `, isInline: true, directives: [{ type: CdkColumnDef, selector: \"[cdkColumnDef]\", inputs: [\"sticky\", \"cdkColumnDef\", \"stickyEnd\"] }, { type: CdkHeaderCellDef, selector: \"[cdkHeaderCellDef]\" }, { type: CdkHeaderCell, selector: \"cdk-header-cell, th[cdk-header-cell]\" }, { type: CdkCellDef, selector: \"[cdkCellDef]\" }, { type: CdkCell, selector: \"cdk-cell, td[cdk-cell]\" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkTextColumn, decorators: [{\n            type: Component,\n            args: [{\n                    selector: 'cdk-text-column',\n                    template: `\n    <ng-container cdkColumnDef>\n      <th cdk-header-cell *cdkHeaderCellDef [style.text-align]=\"justify\">\n        {{headerText}}\n      </th>\n      <td cdk-cell *cdkCellDef=\"let data\" [style.text-align]=\"justify\">\n        {{dataAccessor(data, name)}}\n      </td>\n    </ng-container>\n  `,\n                    encapsulation: ViewEncapsulation.None,\n                    // Change detection is intentionally not set to OnPush. This component's template will be provided\n                    // to the table to be inserted into its view. This is problematic when change detection runs since\n                    // the bindings in this template will be evaluated _after_ the table's view is evaluated, which\n                    // mean's the template in the table's view will not have the updated value (and in fact will cause\n                    // an ExpressionChangedAfterItHasBeenCheckedError).\n                    // tslint:disable-next-line:validate-decorators\n                    changeDetection: ChangeDetectionStrategy.Default,\n                }]\n        }], ctorParameters: function () { return [{ type: CdkTable, decorators: [{\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [TEXT_COLUMN_OPTIONS]\n                }] }]; }, propDecorators: { name: [{\n                type: Input\n            }], headerText: [{\n                type: Input\n            }], dataAccessor: [{\n                type: Input\n            }], justify: [{\n                type: Input\n            }], columnDef: [{\n                type: ViewChild,\n                args: [CdkColumnDef, { static: true }]\n            }], cell: [{\n                type: ViewChild,\n                args: [CdkCellDef, { static: true }]\n            }], headerCell: [{\n                type: ViewChild,\n                args: [CdkHeaderCellDef, { static: true }]\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 */\nconst EXPORTED_DECLARATIONS = [\n    CdkTable,\n    CdkRowDef,\n    CdkCellDef,\n    CdkCellOutlet,\n    CdkHeaderCellDef,\n    CdkFooterCellDef,\n    CdkColumnDef,\n    CdkCell,\n    CdkRow,\n    CdkHeaderCell,\n    CdkFooterCell,\n    CdkHeaderRow,\n    CdkHeaderRowDef,\n    CdkFooterRow,\n    CdkFooterRowDef,\n    DataRowOutlet,\n    HeaderRowOutlet,\n    FooterRowOutlet,\n    CdkTextColumn,\n    CdkNoDataRow,\n    CdkRecycleRows,\n    NoDataRowOutlet,\n];\nclass CdkTableModule {\n}\nCdkTableModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkTableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nCdkTableModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkTableModule, declarations: [CdkTable,\n        CdkRowDef,\n        CdkCellDef,\n        CdkCellOutlet,\n        CdkHeaderCellDef,\n        CdkFooterCellDef,\n        CdkColumnDef,\n        CdkCell,\n        CdkRow,\n        CdkHeaderCell,\n        CdkFooterCell,\n        CdkHeaderRow,\n        CdkHeaderRowDef,\n        CdkFooterRow,\n        CdkFooterRowDef,\n        DataRowOutlet,\n        HeaderRowOutlet,\n        FooterRowOutlet,\n        CdkTextColumn,\n        CdkNoDataRow,\n        CdkRecycleRows,\n        NoDataRowOutlet], imports: [ScrollingModule], exports: [CdkTable,\n        CdkRowDef,\n        CdkCellDef,\n        CdkCellOutlet,\n        CdkHeaderCellDef,\n        CdkFooterCellDef,\n        CdkColumnDef,\n        CdkCell,\n        CdkRow,\n        CdkHeaderCell,\n        CdkFooterCell,\n        CdkHeaderRow,\n        CdkHeaderRowDef,\n        CdkFooterRow,\n        CdkFooterRowDef,\n        DataRowOutlet,\n        HeaderRowOutlet,\n        FooterRowOutlet,\n        CdkTextColumn,\n        CdkNoDataRow,\n        CdkRecycleRows,\n        NoDataRowOutlet] });\nCdkTableModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkTableModule, imports: [[ScrollingModule]] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: CdkTableModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    exports: EXPORTED_DECLARATIONS,\n                    declarations: EXPORTED_DECLARATIONS,\n                    imports: [ScrollingModule],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { BaseCdkCell, BaseRowDef, CDK_ROW_TEMPLATE, CDK_TABLE, CDK_TABLE_TEMPLATE, CdkCell, CdkCellDef, CdkCellOutlet, CdkColumnDef, CdkFooterCell, CdkFooterCellDef, CdkFooterRow, CdkFooterRowDef, CdkHeaderCell, CdkHeaderCellDef, CdkHeaderRow, CdkHeaderRowDef, CdkNoDataRow, CdkRecycleRows, CdkRow, CdkRowDef, CdkTable, CdkTableModule, CdkTextColumn, DataRowOutlet, FooterRowOutlet, HeaderRowOutlet, NoDataRowOutlet, STICKY_DIRECTIONS, STICKY_POSITIONING_LISTENER, StickyStyler, TEXT_COLUMN_OPTIONS, _COALESCED_STYLE_SCHEDULER, _CoalescedStyleScheduler, _Schedule, mixinHasStickyInput };\n","import * as i0 from '@angular/core';\nimport { Directive, Component, ViewEncapsulation, ChangeDetectionStrategy, Input, NgModule } from '@angular/core';\nimport * as i1 from '@angular/cdk/table';\nimport { CdkTable, CDK_TABLE, _COALESCED_STYLE_SCHEDULER, _CoalescedStyleScheduler, STICKY_POSITIONING_LISTENER, CDK_TABLE_TEMPLATE, CdkCellDef, CdkHeaderCellDef, CdkFooterCellDef, CdkColumnDef, CdkHeaderCell, CdkFooterCell, CdkCell, CdkHeaderRowDef, CdkFooterRowDef, CdkRowDef, CdkHeaderRow, CDK_ROW_TEMPLATE, CdkFooterRow, CdkRow, CdkNoDataRow, CdkTextColumn, CdkTableModule, DataSource } from '@angular/cdk/table';\nimport { _VIEW_REPEATER_STRATEGY, _RecycleViewRepeaterStrategy, _DisposeViewRepeaterStrategy } from '@angular/cdk/collections';\nimport { MatCommonModule } from '@angular/material/core';\nimport { _isNumberValue } from '@angular/cdk/coercion';\nimport { BehaviorSubject, Subject, merge, of, combineLatest } from 'rxjs';\nimport { map } from 'rxjs/operators';\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 * Enables the recycle view repeater strategy, which reduces rendering latency. Not compatible with\n * tables that animate rows.\n */\nclass MatRecycleRows {\n}\nMatRecycleRows.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRecycleRows, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatRecycleRows.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatRecycleRows, selector: \"mat-table[recycleRows], table[mat-table][recycleRows]\", providers: [{ provide: _VIEW_REPEATER_STRATEGY, useClass: _RecycleViewRepeaterStrategy }], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRecycleRows, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-table[recycleRows], table[mat-table][recycleRows]',\n                    providers: [{ provide: _VIEW_REPEATER_STRATEGY, useClass: _RecycleViewRepeaterStrategy }],\n                }]\n        }] });\n/**\n * Wrapper for the CdkTable with Material design styles.\n */\nclass MatTable extends CdkTable {\n    constructor() {\n        super(...arguments);\n        /** Overrides the sticky CSS class set by the `CdkTable`. */\n        this.stickyCssClass = 'mat-table-sticky';\n        /** Overrides the need to add position: sticky on every sticky cell element in `CdkTable`. */\n        this.needsPositionStickyOnElement = false;\n    }\n}\nMatTable.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatTable, deps: null, target: i0.ɵɵFactoryTarget.Component });\nMatTable.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatTable, selector: \"mat-table, table[mat-table]\", host: { properties: { \"class.mat-table-fixed-layout\": \"fixedLayout\" }, classAttribute: \"mat-table\" }, providers: [\n        // TODO(michaeljamesparsons) Abstract the view repeater strategy to a directive API so this code\n        //  is only included in the build if used.\n        { provide: _VIEW_REPEATER_STRATEGY, useClass: _DisposeViewRepeaterStrategy },\n        { provide: CdkTable, useExisting: MatTable },\n        { provide: CDK_TABLE, useExisting: MatTable },\n        { provide: _COALESCED_STYLE_SCHEDULER, useClass: _CoalescedStyleScheduler },\n        // Prevent nested tables from seeing this table's StickyPositioningListener.\n        { provide: STICKY_POSITIONING_LISTENER, useValue: null },\n    ], exportAs: [\"matTable\"], usesInheritance: true, ngImport: i0, template: \"\\n  <ng-content select=\\\"caption\\\"></ng-content>\\n  <ng-content select=\\\"colgroup, col\\\"></ng-content>\\n  <ng-container headerRowOutlet></ng-container>\\n  <ng-container rowOutlet></ng-container>\\n  <ng-container noDataRowOutlet></ng-container>\\n  <ng-container footerRowOutlet></ng-container>\\n\", isInline: true, styles: [\"mat-table{display:block}mat-header-row{min-height:56px}mat-row,mat-footer-row{min-height:48px}mat-row,mat-header-row,mat-footer-row{display:flex;border-width:0;border-bottom-width:1px;border-style:solid;align-items:center;box-sizing:border-box}mat-cell:first-of-type,mat-header-cell:first-of-type,mat-footer-cell:first-of-type{padding-left:24px}[dir=rtl] mat-cell:first-of-type:not(:only-of-type),[dir=rtl] mat-header-cell:first-of-type:not(:only-of-type),[dir=rtl] mat-footer-cell:first-of-type:not(:only-of-type){padding-left:0;padding-right:24px}mat-cell:last-of-type,mat-header-cell:last-of-type,mat-footer-cell:last-of-type{padding-right:24px}[dir=rtl] mat-cell:last-of-type:not(:only-of-type),[dir=rtl] mat-header-cell:last-of-type:not(:only-of-type),[dir=rtl] mat-footer-cell:last-of-type:not(:only-of-type){padding-right:0;padding-left:24px}mat-cell,mat-header-cell,mat-footer-cell{flex:1;display:flex;align-items:center;overflow:hidden;word-wrap:break-word;min-height:inherit}table.mat-table{border-spacing:0}tr.mat-header-row{height:56px}tr.mat-row,tr.mat-footer-row{height:48px}th.mat-header-cell{text-align:left}[dir=rtl] th.mat-header-cell{text-align:right}th.mat-header-cell,td.mat-cell,td.mat-footer-cell{padding:0;border-bottom-width:1px;border-bottom-style:solid}th.mat-header-cell:first-of-type,td.mat-cell:first-of-type,td.mat-footer-cell:first-of-type{padding-left:24px}[dir=rtl] th.mat-header-cell:first-of-type:not(:only-of-type),[dir=rtl] td.mat-cell:first-of-type:not(:only-of-type),[dir=rtl] td.mat-footer-cell:first-of-type:not(:only-of-type){padding-left:0;padding-right:24px}th.mat-header-cell:last-of-type,td.mat-cell:last-of-type,td.mat-footer-cell:last-of-type{padding-right:24px}[dir=rtl] th.mat-header-cell:last-of-type:not(:only-of-type),[dir=rtl] td.mat-cell:last-of-type:not(:only-of-type),[dir=rtl] td.mat-footer-cell:last-of-type:not(:only-of-type){padding-right:0;padding-left:24px}.mat-table-sticky{position:sticky !important}.mat-table-fixed-layout{table-layout:fixed}\\n\"], directives: [{ type: i1.HeaderRowOutlet, selector: \"[headerRowOutlet]\" }, { type: i1.DataRowOutlet, selector: \"[rowOutlet]\" }, { type: i1.NoDataRowOutlet, selector: \"[noDataRowOutlet]\" }, { type: i1.FooterRowOutlet, selector: \"[footerRowOutlet]\" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatTable, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-table, table[mat-table]', exportAs: 'matTable', template: CDK_TABLE_TEMPLATE, host: {\n                        'class': 'mat-table',\n                        '[class.mat-table-fixed-layout]': 'fixedLayout',\n                    }, providers: [\n                        // TODO(michaeljamesparsons) Abstract the view repeater strategy to a directive API so this code\n                        //  is only included in the build if used.\n                        { provide: _VIEW_REPEATER_STRATEGY, useClass: _DisposeViewRepeaterStrategy },\n                        { provide: CdkTable, useExisting: MatTable },\n                        { provide: CDK_TABLE, useExisting: MatTable },\n                        { provide: _COALESCED_STYLE_SCHEDULER, useClass: _CoalescedStyleScheduler },\n                        // Prevent nested tables from seeing this table's StickyPositioningListener.\n                        { provide: STICKY_POSITIONING_LISTENER, useValue: null },\n                    ], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.Default, styles: [\"mat-table{display:block}mat-header-row{min-height:56px}mat-row,mat-footer-row{min-height:48px}mat-row,mat-header-row,mat-footer-row{display:flex;border-width:0;border-bottom-width:1px;border-style:solid;align-items:center;box-sizing:border-box}mat-cell:first-of-type,mat-header-cell:first-of-type,mat-footer-cell:first-of-type{padding-left:24px}[dir=rtl] mat-cell:first-of-type:not(:only-of-type),[dir=rtl] mat-header-cell:first-of-type:not(:only-of-type),[dir=rtl] mat-footer-cell:first-of-type:not(:only-of-type){padding-left:0;padding-right:24px}mat-cell:last-of-type,mat-header-cell:last-of-type,mat-footer-cell:last-of-type{padding-right:24px}[dir=rtl] mat-cell:last-of-type:not(:only-of-type),[dir=rtl] mat-header-cell:last-of-type:not(:only-of-type),[dir=rtl] mat-footer-cell:last-of-type:not(:only-of-type){padding-right:0;padding-left:24px}mat-cell,mat-header-cell,mat-footer-cell{flex:1;display:flex;align-items:center;overflow:hidden;word-wrap:break-word;min-height:inherit}table.mat-table{border-spacing:0}tr.mat-header-row{height:56px}tr.mat-row,tr.mat-footer-row{height:48px}th.mat-header-cell{text-align:left}[dir=rtl] th.mat-header-cell{text-align:right}th.mat-header-cell,td.mat-cell,td.mat-footer-cell{padding:0;border-bottom-width:1px;border-bottom-style:solid}th.mat-header-cell:first-of-type,td.mat-cell:first-of-type,td.mat-footer-cell:first-of-type{padding-left:24px}[dir=rtl] th.mat-header-cell:first-of-type:not(:only-of-type),[dir=rtl] td.mat-cell:first-of-type:not(:only-of-type),[dir=rtl] td.mat-footer-cell:first-of-type:not(:only-of-type){padding-left:0;padding-right:24px}th.mat-header-cell:last-of-type,td.mat-cell:last-of-type,td.mat-footer-cell:last-of-type{padding-right:24px}[dir=rtl] th.mat-header-cell:last-of-type:not(:only-of-type),[dir=rtl] td.mat-cell:last-of-type:not(:only-of-type),[dir=rtl] td.mat-footer-cell:last-of-type:not(:only-of-type){padding-right:0;padding-left:24px}.mat-table-sticky{position:sticky !important}.mat-table-fixed-layout{table-layout:fixed}\\n\"] }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Cell definition for the mat-table.\n * Captures the template of a column's data row cell as well as cell-specific properties.\n */\nclass MatCellDef extends CdkCellDef {\n}\nMatCellDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCellDef, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatCellDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatCellDef, selector: \"[matCellDef]\", providers: [{ provide: CdkCellDef, useExisting: MatCellDef }], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCellDef, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matCellDef]',\n                    providers: [{ provide: CdkCellDef, useExisting: MatCellDef }],\n                }]\n        }] });\n/**\n * Header cell definition for the mat-table.\n * Captures the template of a column's header cell and as well as cell-specific properties.\n */\nclass MatHeaderCellDef extends CdkHeaderCellDef {\n}\nMatHeaderCellDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatHeaderCellDef, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatHeaderCellDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatHeaderCellDef, selector: \"[matHeaderCellDef]\", providers: [{ provide: CdkHeaderCellDef, useExisting: MatHeaderCellDef }], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatHeaderCellDef, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matHeaderCellDef]',\n                    providers: [{ provide: CdkHeaderCellDef, useExisting: MatHeaderCellDef }],\n                }]\n        }] });\n/**\n * Footer cell definition for the mat-table.\n * Captures the template of a column's footer cell and as well as cell-specific properties.\n */\nclass MatFooterCellDef extends CdkFooterCellDef {\n}\nMatFooterCellDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatFooterCellDef, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatFooterCellDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatFooterCellDef, selector: \"[matFooterCellDef]\", providers: [{ provide: CdkFooterCellDef, useExisting: MatFooterCellDef }], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatFooterCellDef, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matFooterCellDef]',\n                    providers: [{ provide: CdkFooterCellDef, useExisting: MatFooterCellDef }],\n                }]\n        }] });\n/**\n * Column definition for the mat-table.\n * Defines a set of cells available for a table column.\n */\nclass MatColumnDef extends CdkColumnDef {\n    /** Unique name for this column. */\n    get name() {\n        return this._name;\n    }\n    set name(name) {\n        this._setNameInput(name);\n    }\n    /**\n     * Add \"mat-column-\" prefix in addition to \"cdk-column-\" prefix.\n     * In the future, this will only add \"mat-column-\" and columnCssClassName\n     * will change from type string[] to string.\n     * @docs-private\n     */\n    _updateColumnCssClassName() {\n        super._updateColumnCssClassName();\n        this._columnCssClassName.push(`mat-column-${this.cssClassFriendlyName}`);\n    }\n}\nMatColumnDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatColumnDef, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatColumnDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatColumnDef, selector: \"[matColumnDef]\", inputs: { sticky: \"sticky\", name: [\"matColumnDef\", \"name\"] }, providers: [\n        { provide: CdkColumnDef, useExisting: MatColumnDef },\n        { provide: 'MAT_SORT_HEADER_COLUMN_DEF', useExisting: MatColumnDef },\n    ], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatColumnDef, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matColumnDef]',\n                    inputs: ['sticky'],\n                    providers: [\n                        { provide: CdkColumnDef, useExisting: MatColumnDef },\n                        { provide: 'MAT_SORT_HEADER_COLUMN_DEF', useExisting: MatColumnDef },\n                    ],\n                }]\n        }], propDecorators: { name: [{\n                type: Input,\n                args: ['matColumnDef']\n            }] } });\n/** Header cell template container that adds the right classes and role. */\nclass MatHeaderCell extends CdkHeaderCell {\n}\nMatHeaderCell.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatHeaderCell, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatHeaderCell.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatHeaderCell, selector: \"mat-header-cell, th[mat-header-cell]\", host: { attributes: { \"role\": \"columnheader\" }, classAttribute: \"mat-header-cell\" }, usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatHeaderCell, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-header-cell, th[mat-header-cell]',\n                    host: {\n                        'class': 'mat-header-cell',\n                        'role': 'columnheader',\n                    },\n                }]\n        }] });\n/** Footer cell template container that adds the right classes and role. */\nclass MatFooterCell extends CdkFooterCell {\n}\nMatFooterCell.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatFooterCell, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatFooterCell.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatFooterCell, selector: \"mat-footer-cell, td[mat-footer-cell]\", host: { attributes: { \"role\": \"gridcell\" }, classAttribute: \"mat-footer-cell\" }, usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatFooterCell, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-footer-cell, td[mat-footer-cell]',\n                    host: {\n                        'class': 'mat-footer-cell',\n                        'role': 'gridcell',\n                    },\n                }]\n        }] });\n/** Cell template container that adds the right classes and role. */\nclass MatCell extends CdkCell {\n}\nMatCell.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCell, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatCell.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatCell, selector: \"mat-cell, td[mat-cell]\", host: { attributes: { \"role\": \"gridcell\" }, classAttribute: \"mat-cell\" }, usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatCell, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-cell, td[mat-cell]',\n                    host: {\n                        'class': 'mat-cell',\n                        'role': 'gridcell',\n                    },\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Header row definition for the mat-table.\n * Captures the header row's template and other header properties such as the columns to display.\n */\nclass MatHeaderRowDef extends CdkHeaderRowDef {\n}\nMatHeaderRowDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatHeaderRowDef, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatHeaderRowDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatHeaderRowDef, selector: \"[matHeaderRowDef]\", inputs: { columns: [\"matHeaderRowDef\", \"columns\"], sticky: [\"matHeaderRowDefSticky\", \"sticky\"] }, providers: [{ provide: CdkHeaderRowDef, useExisting: MatHeaderRowDef }], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatHeaderRowDef, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matHeaderRowDef]',\n                    providers: [{ provide: CdkHeaderRowDef, useExisting: MatHeaderRowDef }],\n                    inputs: ['columns: matHeaderRowDef', 'sticky: matHeaderRowDefSticky'],\n                }]\n        }] });\n/**\n * Footer row definition for the mat-table.\n * Captures the footer row's template and other footer properties such as the columns to display.\n */\nclass MatFooterRowDef extends CdkFooterRowDef {\n}\nMatFooterRowDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatFooterRowDef, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatFooterRowDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatFooterRowDef, selector: \"[matFooterRowDef]\", inputs: { columns: [\"matFooterRowDef\", \"columns\"], sticky: [\"matFooterRowDefSticky\", \"sticky\"] }, providers: [{ provide: CdkFooterRowDef, useExisting: MatFooterRowDef }], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatFooterRowDef, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matFooterRowDef]',\n                    providers: [{ provide: CdkFooterRowDef, useExisting: MatFooterRowDef }],\n                    inputs: ['columns: matFooterRowDef', 'sticky: matFooterRowDefSticky'],\n                }]\n        }] });\n/**\n * Data row definition for the mat-table.\n * Captures the data row's template and other properties such as the columns to display and\n * a when predicate that describes when this row should be used.\n */\nclass MatRowDef extends CdkRowDef {\n}\nMatRowDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRowDef, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatRowDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatRowDef, selector: \"[matRowDef]\", inputs: { columns: [\"matRowDefColumns\", \"columns\"], when: [\"matRowDefWhen\", \"when\"] }, providers: [{ provide: CdkRowDef, useExisting: MatRowDef }], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRowDef, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matRowDef]',\n                    providers: [{ provide: CdkRowDef, useExisting: MatRowDef }],\n                    inputs: ['columns: matRowDefColumns', 'when: matRowDefWhen'],\n                }]\n        }] });\n/** Header template container that contains the cell outlet. Adds the right class and role. */\nclass MatHeaderRow extends CdkHeaderRow {\n}\nMatHeaderRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatHeaderRow, deps: null, target: i0.ɵɵFactoryTarget.Component });\nMatHeaderRow.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatHeaderRow, selector: \"mat-header-row, tr[mat-header-row]\", host: { attributes: { \"role\": \"row\" }, classAttribute: \"mat-header-row\" }, providers: [{ provide: CdkHeaderRow, useExisting: MatHeaderRow }], exportAs: [\"matHeaderRow\"], usesInheritance: true, ngImport: i0, template: \"<ng-container cdkCellOutlet></ng-container>\", isInline: true, directives: [{ type: i1.CdkCellOutlet, selector: \"[cdkCellOutlet]\" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatHeaderRow, decorators: [{\n            type: Component,\n            args: [{\n                    selector: 'mat-header-row, tr[mat-header-row]',\n                    template: CDK_ROW_TEMPLATE,\n                    host: {\n                        'class': 'mat-header-row',\n                        'role': 'row',\n                    },\n                    // See note on CdkTable for explanation on why this uses the default change detection strategy.\n                    // tslint:disable-next-line:validate-decorators\n                    changeDetection: ChangeDetectionStrategy.Default,\n                    encapsulation: ViewEncapsulation.None,\n                    exportAs: 'matHeaderRow',\n                    providers: [{ provide: CdkHeaderRow, useExisting: MatHeaderRow }],\n                }]\n        }] });\n/** Footer template container that contains the cell outlet. Adds the right class and role. */\nclass MatFooterRow extends CdkFooterRow {\n}\nMatFooterRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatFooterRow, deps: null, target: i0.ɵɵFactoryTarget.Component });\nMatFooterRow.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatFooterRow, selector: \"mat-footer-row, tr[mat-footer-row]\", host: { attributes: { \"role\": \"row\" }, classAttribute: \"mat-footer-row\" }, providers: [{ provide: CdkFooterRow, useExisting: MatFooterRow }], exportAs: [\"matFooterRow\"], usesInheritance: true, ngImport: i0, template: \"<ng-container cdkCellOutlet></ng-container>\", isInline: true, directives: [{ type: i1.CdkCellOutlet, selector: \"[cdkCellOutlet]\" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatFooterRow, decorators: [{\n            type: Component,\n            args: [{\n                    selector: 'mat-footer-row, tr[mat-footer-row]',\n                    template: CDK_ROW_TEMPLATE,\n                    host: {\n                        'class': 'mat-footer-row',\n                        'role': 'row',\n                    },\n                    // See note on CdkTable for explanation on why this uses the default change detection strategy.\n                    // tslint:disable-next-line:validate-decorators\n                    changeDetection: ChangeDetectionStrategy.Default,\n                    encapsulation: ViewEncapsulation.None,\n                    exportAs: 'matFooterRow',\n                    providers: [{ provide: CdkFooterRow, useExisting: MatFooterRow }],\n                }]\n        }] });\n/** Data row template container that contains the cell outlet. Adds the right class and role. */\nclass MatRow extends CdkRow {\n}\nMatRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRow, deps: null, target: i0.ɵɵFactoryTarget.Component });\nMatRow.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatRow, selector: \"mat-row, tr[mat-row]\", host: { attributes: { \"role\": \"row\" }, classAttribute: \"mat-row\" }, providers: [{ provide: CdkRow, useExisting: MatRow }], exportAs: [\"matRow\"], usesInheritance: true, ngImport: i0, template: \"<ng-container cdkCellOutlet></ng-container>\", isInline: true, directives: [{ type: i1.CdkCellOutlet, selector: \"[cdkCellOutlet]\" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatRow, decorators: [{\n            type: Component,\n            args: [{\n                    selector: 'mat-row, tr[mat-row]',\n                    template: CDK_ROW_TEMPLATE,\n                    host: {\n                        'class': 'mat-row',\n                        'role': 'row',\n                    },\n                    // See note on CdkTable for explanation on why this uses the default change detection strategy.\n                    // tslint:disable-next-line:validate-decorators\n                    changeDetection: ChangeDetectionStrategy.Default,\n                    encapsulation: ViewEncapsulation.None,\n                    exportAs: 'matRow',\n                    providers: [{ provide: CdkRow, useExisting: MatRow }],\n                }]\n        }] });\n/** Row that can be used to display a message when no data is shown in the table. */\nclass MatNoDataRow extends CdkNoDataRow {\n    constructor() {\n        super(...arguments);\n        this._contentClassName = 'mat-no-data-row';\n    }\n}\nMatNoDataRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatNoDataRow, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatNoDataRow.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatNoDataRow, selector: \"ng-template[matNoDataRow]\", providers: [{ provide: CdkNoDataRow, useExisting: MatNoDataRow }], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatNoDataRow, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'ng-template[matNoDataRow]',\n                    providers: [{ provide: CdkNoDataRow, useExisting: MatNoDataRow }],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Column that simply shows text content for the header and row cells. Assumes that the table\n * is using the native table implementation (`<table>`).\n *\n * By default, the name of this column will be the header text and data property accessor.\n * The header text can be overridden with the `headerText` input. Cell values can be overridden with\n * the `dataAccessor` input. Change the text justification to the start or end using the `justify`\n * input.\n */\nclass MatTextColumn extends CdkTextColumn {\n}\nMatTextColumn.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatTextColumn, deps: null, target: i0.ɵɵFactoryTarget.Component });\nMatTextColumn.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatTextColumn, selector: \"mat-text-column\", usesInheritance: true, ngImport: i0, template: `\n    <ng-container matColumnDef>\n      <th mat-header-cell *matHeaderCellDef [style.text-align]=\"justify\">\n        {{headerText}}\n      </th>\n      <td mat-cell *matCellDef=\"let data\" [style.text-align]=\"justify\">\n        {{dataAccessor(data, name)}}\n      </td>\n    </ng-container>\n  `, isInline: true, directives: [{ type: MatColumnDef, selector: \"[matColumnDef]\", inputs: [\"sticky\", \"matColumnDef\"] }, { type: MatHeaderCellDef, selector: \"[matHeaderCellDef]\" }, { type: MatHeaderCell, selector: \"mat-header-cell, th[mat-header-cell]\" }, { type: MatCellDef, selector: \"[matCellDef]\" }, { type: MatCell, selector: \"mat-cell, td[mat-cell]\" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatTextColumn, decorators: [{\n            type: Component,\n            args: [{\n                    selector: 'mat-text-column',\n                    template: `\n    <ng-container matColumnDef>\n      <th mat-header-cell *matHeaderCellDef [style.text-align]=\"justify\">\n        {{headerText}}\n      </th>\n      <td mat-cell *matCellDef=\"let data\" [style.text-align]=\"justify\">\n        {{dataAccessor(data, name)}}\n      </td>\n    </ng-container>\n  `,\n                    encapsulation: ViewEncapsulation.None,\n                    // Change detection is intentionally not set to OnPush. This component's template will be provided\n                    // to the table to be inserted into its view. This is problematic when change detection runs since\n                    // the bindings in this template will be evaluated _after_ the table's view is evaluated, which\n                    // mean's the template in the table's view will not have the updated value (and in fact will cause\n                    // an ExpressionChangedAfterItHasBeenCheckedError).\n                    // tslint:disable-next-line:validate-decorators\n                    changeDetection: ChangeDetectionStrategy.Default,\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst EXPORTED_DECLARATIONS = [\n    // Table\n    MatTable,\n    MatRecycleRows,\n    // Template defs\n    MatHeaderCellDef,\n    MatHeaderRowDef,\n    MatColumnDef,\n    MatCellDef,\n    MatRowDef,\n    MatFooterCellDef,\n    MatFooterRowDef,\n    // Cell directives\n    MatHeaderCell,\n    MatCell,\n    MatFooterCell,\n    // Row directives\n    MatHeaderRow,\n    MatRow,\n    MatFooterRow,\n    MatNoDataRow,\n    MatTextColumn,\n];\nclass MatTableModule {\n}\nMatTableModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatTableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatTableModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatTableModule, declarations: [\n        // Table\n        MatTable,\n        MatRecycleRows,\n        // Template defs\n        MatHeaderCellDef,\n        MatHeaderRowDef,\n        MatColumnDef,\n        MatCellDef,\n        MatRowDef,\n        MatFooterCellDef,\n        MatFooterRowDef,\n        // Cell directives\n        MatHeaderCell,\n        MatCell,\n        MatFooterCell,\n        // Row directives\n        MatHeaderRow,\n        MatRow,\n        MatFooterRow,\n        MatNoDataRow,\n        MatTextColumn], imports: [CdkTableModule, MatCommonModule], exports: [MatCommonModule, \n        // Table\n        MatTable,\n        MatRecycleRows,\n        // Template defs\n        MatHeaderCellDef,\n        MatHeaderRowDef,\n        MatColumnDef,\n        MatCellDef,\n        MatRowDef,\n        MatFooterCellDef,\n        MatFooterRowDef,\n        // Cell directives\n        MatHeaderCell,\n        MatCell,\n        MatFooterCell,\n        // Row directives\n        MatHeaderRow,\n        MatRow,\n        MatFooterRow,\n        MatNoDataRow,\n        MatTextColumn] });\nMatTableModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatTableModule, imports: [[CdkTableModule, MatCommonModule], MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatTableModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [CdkTableModule, MatCommonModule],\n                    exports: [MatCommonModule, EXPORTED_DECLARATIONS],\n                    declarations: EXPORTED_DECLARATIONS,\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Corresponds to `Number.MAX_SAFE_INTEGER`. Moved out into a variable here due to\n * flaky browser support and the value not being defined in Closure's typings.\n */\nconst MAX_SAFE_INTEGER = 9007199254740991;\n/** Shared base class with MDC-based implementation. */\nclass _MatTableDataSource extends DataSource {\n    constructor(initialData = []) {\n        super();\n        /** Stream emitting render data to the table (depends on ordered data changes). */\n        this._renderData = new BehaviorSubject([]);\n        /** Stream that emits when a new filter string is set on the data source. */\n        this._filter = new BehaviorSubject('');\n        /** Used to react to internal changes of the paginator that are made by the data source itself. */\n        this._internalPageChanges = new Subject();\n        /**\n         * Subscription to the changes that should trigger an update to the table's rendered rows, such\n         * as filtering, sorting, pagination, or base data changes.\n         */\n        this._renderChangesSubscription = null;\n        /**\n         * Data accessor function that is used for accessing data properties for sorting through\n         * the default sortData function.\n         * This default function assumes that the sort header IDs (which defaults to the column name)\n         * matches the data's properties (e.g. column Xyz represents data['Xyz']).\n         * May be set to a custom function for different behavior.\n         * @param data Data object that is being accessed.\n         * @param sortHeaderId The name of the column that represents the data.\n         */\n        this.sortingDataAccessor = (data, sortHeaderId) => {\n            const value = data[sortHeaderId];\n            if (_isNumberValue(value)) {\n                const numberValue = Number(value);\n                // Numbers beyond `MAX_SAFE_INTEGER` can't be compared reliably so we\n                // leave them as strings. For more info: https://goo.gl/y5vbSg\n                return numberValue < MAX_SAFE_INTEGER ? numberValue : value;\n            }\n            return value;\n        };\n        /**\n         * Gets a sorted copy of the data array based on the state of the MatSort. Called\n         * after changes are made to the filtered data or when sort changes are emitted from MatSort.\n         * By default, the function retrieves the active sort and its direction and compares data\n         * by retrieving data using the sortingDataAccessor. May be overridden for a custom implementation\n         * of data ordering.\n         * @param data The array of data that should be sorted.\n         * @param sort The connected MatSort that holds the current sort state.\n         */\n        this.sortData = (data, sort) => {\n            const active = sort.active;\n            const direction = sort.direction;\n            if (!active || direction == '') {\n                return data;\n            }\n            return data.sort((a, b) => {\n                let valueA = this.sortingDataAccessor(a, active);\n                let valueB = this.sortingDataAccessor(b, active);\n                // If there are data in the column that can be converted to a number,\n                // it must be ensured that the rest of the data\n                // is of the same type so as not to order incorrectly.\n                const valueAType = typeof valueA;\n                const valueBType = typeof valueB;\n                if (valueAType !== valueBType) {\n                    if (valueAType === 'number') {\n                        valueA += '';\n                    }\n                    if (valueBType === 'number') {\n                        valueB += '';\n                    }\n                }\n                // If both valueA and valueB exist (truthy), then compare the two. Otherwise, check if\n                // one value exists while the other doesn't. In this case, existing value should come last.\n                // This avoids inconsistent results when comparing values to undefined/null.\n                // If neither value exists, return 0 (equal).\n                let comparatorResult = 0;\n                if (valueA != null && valueB != null) {\n                    // Check if one value is greater than the other; if equal, comparatorResult should remain 0.\n                    if (valueA > valueB) {\n                        comparatorResult = 1;\n                    }\n                    else if (valueA < valueB) {\n                        comparatorResult = -1;\n                    }\n                }\n                else if (valueA != null) {\n                    comparatorResult = 1;\n                }\n                else if (valueB != null) {\n                    comparatorResult = -1;\n                }\n                return comparatorResult * (direction == 'asc' ? 1 : -1);\n            });\n        };\n        /**\n         * Checks if a data object matches the data source's filter string. By default, each data object\n         * is converted to a string of its properties and returns true if the filter has\n         * at least one occurrence in that string. By default, the filter string has its whitespace\n         * trimmed and the match is case-insensitive. May be overridden for a custom implementation of\n         * filter matching.\n         * @param data Data object used to check against the filter.\n         * @param filter Filter string that has been set on the data source.\n         * @returns Whether the filter matches against the data\n         */\n        this.filterPredicate = (data, filter) => {\n            // Transform the data into a lowercase string of all property values.\n            const dataStr = Object.keys(data)\n                .reduce((currentTerm, key) => {\n                // Use an obscure Unicode character to delimit the words in the concatenated string.\n                // This avoids matches where the values of two columns combined will match the user's query\n                // (e.g. `Flute` and `Stop` will match `Test`). The character is intended to be something\n                // that has a very low chance of being typed in by somebody in a text field. This one in\n                // particular is \"White up-pointing triangle with dot\" from\n                // https://en.wikipedia.org/wiki/List_of_Unicode_characters\n                return currentTerm + data[key] + '◬';\n            }, '')\n                .toLowerCase();\n            // Transform the filter by converting it to lowercase and removing whitespace.\n            const transformedFilter = filter.trim().toLowerCase();\n            return dataStr.indexOf(transformedFilter) != -1;\n        };\n        this._data = new BehaviorSubject(initialData);\n        this._updateChangeSubscription();\n    }\n    /** Array of data that should be rendered by the table, where each object represents one row. */\n    get data() {\n        return this._data.value;\n    }\n    set data(data) {\n        data = Array.isArray(data) ? data : [];\n        this._data.next(data);\n        // Normally the `filteredData` is updated by the re-render\n        // subscription, but that won't happen if it's inactive.\n        if (!this._renderChangesSubscription) {\n            this._filterData(data);\n        }\n    }\n    /**\n     * Filter term that should be used to filter out objects from the data array. To override how\n     * data objects match to this filter string, provide a custom function for filterPredicate.\n     */\n    get filter() {\n        return this._filter.value;\n    }\n    set filter(filter) {\n        this._filter.next(filter);\n        // Normally the `filteredData` is updated by the re-render\n        // subscription, but that won't happen if it's inactive.\n        if (!this._renderChangesSubscription) {\n            this._filterData(this.data);\n        }\n    }\n    /**\n     * Instance of the MatSort directive used by the table to control its sorting. Sort changes\n     * emitted by the MatSort will trigger an update to the table's rendered data.\n     */\n    get sort() {\n        return this._sort;\n    }\n    set sort(sort) {\n        this._sort = sort;\n        this._updateChangeSubscription();\n    }\n    /**\n     * Instance of the MatPaginator component used by the table to control what page of the data is\n     * displayed. Page changes emitted by the MatPaginator will trigger an update to the\n     * table's rendered data.\n     *\n     * Note that the data source uses the paginator's properties to calculate which page of data\n     * should be displayed. If the paginator receives its properties as template inputs,\n     * e.g. `[pageLength]=100` or `[pageIndex]=1`, then be sure that the paginator's view has been\n     * initialized before assigning it to this data source.\n     */\n    get paginator() {\n        return this._paginator;\n    }\n    set paginator(paginator) {\n        this._paginator = paginator;\n        this._updateChangeSubscription();\n    }\n    /**\n     * Subscribe to changes that should trigger an update to the table's rendered rows. When the\n     * changes occur, process the current state of the filter, sort, and pagination along with\n     * the provided base data and send it to the table for rendering.\n     */\n    _updateChangeSubscription() {\n        // Sorting and/or pagination should be watched if MatSort and/or MatPaginator are provided.\n        // The events should emit whenever the component emits a change or initializes, or if no\n        // component is provided, a stream with just a null event should be provided.\n        // The `sortChange` and `pageChange` acts as a signal to the combineLatests below so that the\n        // pipeline can progress to the next step. Note that the value from these streams are not used,\n        // they purely act as a signal to progress in the pipeline.\n        const sortChange = this._sort\n            ? merge(this._sort.sortChange, this._sort.initialized)\n            : of(null);\n        const pageChange = this._paginator\n            ? merge(this._paginator.page, this._internalPageChanges, this._paginator.initialized)\n            : of(null);\n        const dataStream = this._data;\n        // Watch for base data or filter changes to provide a filtered set of data.\n        const filteredData = combineLatest([dataStream, this._filter]).pipe(map(([data]) => this._filterData(data)));\n        // Watch for filtered data or sort changes to provide an ordered set of data.\n        const orderedData = combineLatest([filteredData, sortChange]).pipe(map(([data]) => this._orderData(data)));\n        // Watch for ordered data or page changes to provide a paged set of data.\n        const paginatedData = combineLatest([orderedData, pageChange]).pipe(map(([data]) => this._pageData(data)));\n        // Watched for paged data changes and send the result to the table to render.\n        this._renderChangesSubscription?.unsubscribe();\n        this._renderChangesSubscription = paginatedData.subscribe(data => this._renderData.next(data));\n    }\n    /**\n     * Returns a filtered data array where each filter object contains the filter string within\n     * the result of the filterTermAccessor function. If no filter is set, returns the data array\n     * as provided.\n     */\n    _filterData(data) {\n        // If there is a filter string, filter out data that does not contain it.\n        // Each data object is converted to a string using the function defined by filterTermAccessor.\n        // May be overridden for customization.\n        this.filteredData =\n            this.filter == null || this.filter === ''\n                ? data\n                : data.filter(obj => this.filterPredicate(obj, this.filter));\n        if (this.paginator) {\n            this._updatePaginator(this.filteredData.length);\n        }\n        return this.filteredData;\n    }\n    /**\n     * Returns a sorted copy of the data if MatSort has a sort applied, otherwise just returns the\n     * data array as provided. Uses the default data accessor for data lookup, unless a\n     * sortDataAccessor function is defined.\n     */\n    _orderData(data) {\n        // If there is no active sort or direction, return the data without trying to sort.\n        if (!this.sort) {\n            return data;\n        }\n        return this.sortData(data.slice(), this.sort);\n    }\n    /**\n     * Returns a paged slice of the provided data array according to the provided MatPaginator's page\n     * index and length. If there is no paginator provided, returns the data array as provided.\n     */\n    _pageData(data) {\n        if (!this.paginator) {\n            return data;\n        }\n        const startIndex = this.paginator.pageIndex * this.paginator.pageSize;\n        return data.slice(startIndex, startIndex + this.paginator.pageSize);\n    }\n    /**\n     * Updates the paginator to reflect the length of the filtered data, and makes sure that the page\n     * index does not exceed the paginator's last page. Values are changed in a resolved promise to\n     * guard against making property changes within a round of change detection.\n     */\n    _updatePaginator(filteredDataLength) {\n        Promise.resolve().then(() => {\n            const paginator = this.paginator;\n            if (!paginator) {\n                return;\n            }\n            paginator.length = filteredDataLength;\n            // If the page index is set beyond the page, reduce it to the last page.\n            if (paginator.pageIndex > 0) {\n                const lastPageIndex = Math.ceil(paginator.length / paginator.pageSize) - 1 || 0;\n                const newPageIndex = Math.min(paginator.pageIndex, lastPageIndex);\n                if (newPageIndex !== paginator.pageIndex) {\n                    paginator.pageIndex = newPageIndex;\n                    // Since the paginator only emits after user-generated changes,\n                    // we need our own stream so we know to should re-render the data.\n                    this._internalPageChanges.next();\n                }\n            }\n        });\n    }\n    /**\n     * Used by the MatTable. Called when it connects to the data source.\n     * @docs-private\n     */\n    connect() {\n        if (!this._renderChangesSubscription) {\n            this._updateChangeSubscription();\n        }\n        return this._renderData;\n    }\n    /**\n     * Used by the MatTable. Called when it disconnects from the data source.\n     * @docs-private\n     */\n    disconnect() {\n        this._renderChangesSubscription?.unsubscribe();\n        this._renderChangesSubscription = null;\n    }\n}\n/**\n * Data source that accepts a client-side data array and includes native support of filtering,\n * sorting (using MatSort), and pagination (using MatPaginator).\n *\n * Allows for sort customization by overriding sortingDataAccessor, which defines how data\n * properties are accessed. Also allows for filter customization by overriding filterTermAccessor,\n * which defines how row data is converted to a string for filter matching.\n *\n * **Note:** This class is meant to be a simple data source to help you get started. As such\n * it isn't equipped to handle some more advanced cases like robust i18n support or server-side\n * interactions. If your app needs to support more advanced use cases, consider implementing your\n * own `DataSource`.\n */\nclass MatTableDataSource extends _MatTableDataSource {\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MatCell, MatCellDef, MatColumnDef, MatFooterCell, MatFooterCellDef, MatFooterRow, MatFooterRowDef, MatHeaderCell, MatHeaderCellDef, MatHeaderRow, MatHeaderRowDef, MatNoDataRow, MatRecycleRows, MatRow, MatRowDef, MatTable, MatTableDataSource, MatTableModule, MatTextColumn, _MatTableDataSource };\n","import * as i1 from '@angular/cdk/overlay';\nimport { Overlay, OverlayModule } from '@angular/cdk/overlay';\nimport * as i4 from '@angular/cdk/a11y';\nimport { A11yModule } from '@angular/cdk/a11y';\nimport * as i7 from '@angular/common';\nimport { DOCUMENT, CommonModule } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { InjectionToken, Directive, Inject, Input, Optional, Component, ViewEncapsulation, ChangeDetectionStrategy, ViewChild, NgModule } from '@angular/core';\nimport { MatCommonModule } from '@angular/material/core';\nimport * as i2 from '@angular/cdk/scrolling';\nimport { CdkScrollableModule } from '@angular/cdk/scrolling';\nimport * as i5 from '@angular/cdk/bidi';\nimport { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';\nimport { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';\nimport * as i6 from '@angular/cdk/layout';\nimport { Breakpoints } from '@angular/cdk/layout';\nimport * as i3 from '@angular/cdk/platform';\nimport { normalizePassiveListenerOptions } from '@angular/cdk/platform';\nimport { ComponentPortal } from '@angular/cdk/portal';\nimport { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';\nimport { Subject } from 'rxjs';\nimport { takeUntil, take } from 'rxjs/operators';\nimport { trigger, state, style, transition, animate, keyframes } from '@angular/animations';\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Time in ms to throttle repositioning after scroll events. */\nconst SCROLL_THROTTLE_MS = 20;\n/**\n * CSS class that will be attached to the overlay panel.\n * @deprecated\n * @breaking-change 13.0.0 remove this variable\n */\nconst TOOLTIP_PANEL_CLASS = 'mat-tooltip-panel';\nconst PANEL_CLASS = 'tooltip-panel';\n/** Options used to bind passive event listeners. */\nconst passiveListenerOptions = normalizePassiveListenerOptions({ passive: true });\n/**\n * Time between the user putting the pointer on a tooltip\n * trigger and the long press event being fired.\n */\nconst LONGPRESS_DELAY = 500;\n/**\n * Creates an error to be thrown if the user supplied an invalid tooltip position.\n * @docs-private\n */\nfunction getMatTooltipInvalidPositionError(position) {\n    return Error(`Tooltip position \"${position}\" is invalid.`);\n}\n/** Injection token that determines the scroll handling while a tooltip is visible. */\nconst MAT_TOOLTIP_SCROLL_STRATEGY = new InjectionToken('mat-tooltip-scroll-strategy');\n/** @docs-private */\nfunction MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY(overlay) {\n    return () => overlay.scrollStrategies.reposition({ scrollThrottle: SCROLL_THROTTLE_MS });\n}\n/** @docs-private */\nconst MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER = {\n    provide: MAT_TOOLTIP_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY,\n};\n/** Injection token to be used to override the default options for `matTooltip`. */\nconst MAT_TOOLTIP_DEFAULT_OPTIONS = new InjectionToken('mat-tooltip-default-options', {\n    providedIn: 'root',\n    factory: MAT_TOOLTIP_DEFAULT_OPTIONS_FACTORY,\n});\n/** @docs-private */\nfunction MAT_TOOLTIP_DEFAULT_OPTIONS_FACTORY() {\n    return {\n        showDelay: 0,\n        hideDelay: 0,\n        touchendHideDelay: 1500,\n    };\n}\nclass _MatTooltipBase {\n    constructor(_overlay, _elementRef, _scrollDispatcher, _viewContainerRef, _ngZone, _platform, _ariaDescriber, _focusMonitor, scrollStrategy, _dir, _defaultOptions, _document) {\n        this._overlay = _overlay;\n        this._elementRef = _elementRef;\n        this._scrollDispatcher = _scrollDispatcher;\n        this._viewContainerRef = _viewContainerRef;\n        this._ngZone = _ngZone;\n        this._platform = _platform;\n        this._ariaDescriber = _ariaDescriber;\n        this._focusMonitor = _focusMonitor;\n        this._dir = _dir;\n        this._defaultOptions = _defaultOptions;\n        this._position = 'below';\n        this._disabled = false;\n        this._viewInitialized = false;\n        this._pointerExitEventsInitialized = false;\n        this._viewportMargin = 8;\n        this._cssClassPrefix = 'mat';\n        this._showDelay = this._defaultOptions.showDelay;\n        this._hideDelay = this._defaultOptions.hideDelay;\n        /**\n         * How touch gestures should be handled by the tooltip. On touch devices the tooltip directive\n         * uses a long press gesture to show and hide, however it can conflict with the native browser\n         * gestures. To work around the conflict, Angular Material disables native gestures on the\n         * trigger, but that might not be desirable on particular elements (e.g. inputs and draggable\n         * elements). The different values for this option configure the touch event handling as follows:\n         * - `auto` - Enables touch gestures for all elements, but tries to avoid conflicts with native\n         *   browser gestures on particular elements. In particular, it allows text selection on inputs\n         *   and textareas, and preserves the native browser dragging on elements marked as `draggable`.\n         * - `on` - Enables touch gestures for all elements and disables native\n         *   browser gestures with no exceptions.\n         * - `off` - Disables touch gestures. Note that this will prevent the tooltip from\n         *   showing on touch devices.\n         */\n        this.touchGestures = 'auto';\n        this._message = '';\n        /** Manually-bound passive event listeners. */\n        this._passiveListeners = [];\n        /** Emits when the component is destroyed. */\n        this._destroyed = new Subject();\n        this._scrollStrategy = scrollStrategy;\n        this._document = _document;\n        if (_defaultOptions) {\n            if (_defaultOptions.position) {\n                this.position = _defaultOptions.position;\n            }\n            if (_defaultOptions.touchGestures) {\n                this.touchGestures = _defaultOptions.touchGestures;\n            }\n        }\n        _dir.change.pipe(takeUntil(this._destroyed)).subscribe(() => {\n            if (this._overlayRef) {\n                this._updatePosition(this._overlayRef);\n            }\n        });\n    }\n    /** Allows the user to define the position of the tooltip relative to the parent element */\n    get position() {\n        return this._position;\n    }\n    set position(value) {\n        if (value !== this._position) {\n            this._position = value;\n            if (this._overlayRef) {\n                this._updatePosition(this._overlayRef);\n                this._tooltipInstance?.show(0);\n                this._overlayRef.updatePosition();\n            }\n        }\n    }\n    /** Disables the display of the tooltip. */\n    get disabled() {\n        return this._disabled;\n    }\n    set disabled(value) {\n        this._disabled = coerceBooleanProperty(value);\n        // If tooltip is disabled, hide immediately.\n        if (this._disabled) {\n            this.hide(0);\n        }\n        else {\n            this._setupPointerEnterEventsIfNeeded();\n        }\n    }\n    /** The default delay in ms before showing the tooltip after show is called */\n    get showDelay() {\n        return this._showDelay;\n    }\n    set showDelay(value) {\n        this._showDelay = coerceNumberProperty(value);\n    }\n    /** The default delay in ms before hiding the tooltip after hide is called */\n    get hideDelay() {\n        return this._hideDelay;\n    }\n    set hideDelay(value) {\n        this._hideDelay = coerceNumberProperty(value);\n        if (this._tooltipInstance) {\n            this._tooltipInstance._mouseLeaveHideDelay = this._hideDelay;\n        }\n    }\n    /** The message to be displayed in the tooltip */\n    get message() {\n        return this._message;\n    }\n    set message(value) {\n        this._ariaDescriber.removeDescription(this._elementRef.nativeElement, this._message, 'tooltip');\n        // If the message is not a string (e.g. number), convert it to a string and trim it.\n        // Must convert with `String(value)`, not `${value}`, otherwise Closure Compiler optimises\n        // away the string-conversion: https://github.com/angular/components/issues/20684\n        this._message = value != null ? String(value).trim() : '';\n        if (!this._message && this._isTooltipVisible()) {\n            this.hide(0);\n        }\n        else {\n            this._setupPointerEnterEventsIfNeeded();\n            this._updateTooltipMessage();\n            this._ngZone.runOutsideAngular(() => {\n                // The `AriaDescriber` has some functionality that avoids adding a description if it's the\n                // same as the `aria-label` of an element, however we can't know whether the tooltip trigger\n                // has a data-bound `aria-label` or when it'll be set for the first time. We can avoid the\n                // issue by deferring the description by a tick so Angular has time to set the `aria-label`.\n                Promise.resolve().then(() => {\n                    this._ariaDescriber.describe(this._elementRef.nativeElement, this.message, 'tooltip');\n                });\n            });\n        }\n    }\n    /** Classes to be passed to the tooltip. Supports the same syntax as `ngClass`. */\n    get tooltipClass() {\n        return this._tooltipClass;\n    }\n    set tooltipClass(value) {\n        this._tooltipClass = value;\n        if (this._tooltipInstance) {\n            this._setTooltipClass(this._tooltipClass);\n        }\n    }\n    ngAfterViewInit() {\n        // This needs to happen after view init so the initial values for all inputs have been set.\n        this._viewInitialized = true;\n        this._setupPointerEnterEventsIfNeeded();\n        this._focusMonitor\n            .monitor(this._elementRef)\n            .pipe(takeUntil(this._destroyed))\n            .subscribe(origin => {\n            // Note that the focus monitor runs outside the Angular zone.\n            if (!origin) {\n                this._ngZone.run(() => this.hide(0));\n            }\n            else if (origin === 'keyboard') {\n                this._ngZone.run(() => this.show());\n            }\n        });\n    }\n    /**\n     * Dispose the tooltip when destroyed.\n     */\n    ngOnDestroy() {\n        const nativeElement = this._elementRef.nativeElement;\n        clearTimeout(this._touchstartTimeout);\n        if (this._overlayRef) {\n            this._overlayRef.dispose();\n            this._tooltipInstance = null;\n        }\n        // Clean up the event listeners set in the constructor\n        this._passiveListeners.forEach(([event, listener]) => {\n            nativeElement.removeEventListener(event, listener, passiveListenerOptions);\n        });\n        this._passiveListeners.length = 0;\n        this._destroyed.next();\n        this._destroyed.complete();\n        this._ariaDescriber.removeDescription(nativeElement, this.message, 'tooltip');\n        this._focusMonitor.stopMonitoring(nativeElement);\n    }\n    /** Shows the tooltip after the delay in ms, defaults to tooltip-delay-show or 0ms if no input */\n    show(delay = this.showDelay) {\n        if (this.disabled ||\n            !this.message ||\n            (this._isTooltipVisible() &&\n                !this._tooltipInstance._showTimeoutId &&\n                !this._tooltipInstance._hideTimeoutId)) {\n            return;\n        }\n        const overlayRef = this._createOverlay();\n        this._detach();\n        this._portal =\n            this._portal || new ComponentPortal(this._tooltipComponent, this._viewContainerRef);\n        const instance = (this._tooltipInstance = overlayRef.attach(this._portal).instance);\n        instance._triggerElement = this._elementRef.nativeElement;\n        instance._mouseLeaveHideDelay = this._hideDelay;\n        instance\n            .afterHidden()\n            .pipe(takeUntil(this._destroyed))\n            .subscribe(() => this._detach());\n        this._setTooltipClass(this._tooltipClass);\n        this._updateTooltipMessage();\n        instance.show(delay);\n    }\n    /** Hides the tooltip after the delay in ms, defaults to tooltip-delay-hide or 0ms if no input */\n    hide(delay = this.hideDelay) {\n        if (this._tooltipInstance) {\n            this._tooltipInstance.hide(delay);\n        }\n    }\n    /** Shows/hides the tooltip */\n    toggle() {\n        this._isTooltipVisible() ? this.hide() : this.show();\n    }\n    /** Returns true if the tooltip is currently visible to the user */\n    _isTooltipVisible() {\n        return !!this._tooltipInstance && this._tooltipInstance.isVisible();\n    }\n    /** Create the overlay config and position strategy */\n    _createOverlay() {\n        if (this._overlayRef) {\n            return this._overlayRef;\n        }\n        const scrollableAncestors = this._scrollDispatcher.getAncestorScrollContainers(this._elementRef);\n        // Create connected position strategy that listens for scroll events to reposition.\n        const strategy = this._overlay\n            .position()\n            .flexibleConnectedTo(this._elementRef)\n            .withTransformOriginOn(`.${this._cssClassPrefix}-tooltip`)\n            .withFlexibleDimensions(false)\n            .withViewportMargin(this._viewportMargin)\n            .withScrollableContainers(scrollableAncestors);\n        strategy.positionChanges.pipe(takeUntil(this._destroyed)).subscribe(change => {\n            this._updateCurrentPositionClass(change.connectionPair);\n            if (this._tooltipInstance) {\n                if (change.scrollableViewProperties.isOverlayClipped && this._tooltipInstance.isVisible()) {\n                    // After position changes occur and the overlay is clipped by\n                    // a parent scrollable then close the tooltip.\n                    this._ngZone.run(() => this.hide(0));\n                }\n            }\n        });\n        this._overlayRef = this._overlay.create({\n            direction: this._dir,\n            positionStrategy: strategy,\n            panelClass: `${this._cssClassPrefix}-${PANEL_CLASS}`,\n            scrollStrategy: this._scrollStrategy(),\n        });\n        this._updatePosition(this._overlayRef);\n        this._overlayRef\n            .detachments()\n            .pipe(takeUntil(this._destroyed))\n            .subscribe(() => this._detach());\n        this._overlayRef\n            .outsidePointerEvents()\n            .pipe(takeUntil(this._destroyed))\n            .subscribe(() => this._tooltipInstance?._handleBodyInteraction());\n        this._overlayRef\n            .keydownEvents()\n            .pipe(takeUntil(this._destroyed))\n            .subscribe(event => {\n            if (this._isTooltipVisible() && event.keyCode === ESCAPE && !hasModifierKey(event)) {\n                event.preventDefault();\n                event.stopPropagation();\n                this._ngZone.run(() => this.hide(0));\n            }\n        });\n        if (this._defaultOptions?.disableTooltipInteractivity) {\n            this._overlayRef.addPanelClass(`${this._cssClassPrefix}-tooltip-panel-non-interactive`);\n        }\n        return this._overlayRef;\n    }\n    /** Detaches the currently-attached tooltip. */\n    _detach() {\n        if (this._overlayRef && this._overlayRef.hasAttached()) {\n            this._overlayRef.detach();\n        }\n        this._tooltipInstance = null;\n    }\n    /** Updates the position of the current tooltip. */\n    _updatePosition(overlayRef) {\n        const position = overlayRef.getConfig().positionStrategy;\n        const origin = this._getOrigin();\n        const overlay = this._getOverlayPosition();\n        position.withPositions([\n            this._addOffset({ ...origin.main, ...overlay.main }),\n            this._addOffset({ ...origin.fallback, ...overlay.fallback }),\n        ]);\n    }\n    /** Adds the configured offset to a position. Used as a hook for child classes. */\n    _addOffset(position) {\n        return position;\n    }\n    /**\n     * Returns the origin position and a fallback position based on the user's position preference.\n     * The fallback position is the inverse of the origin (e.g. `'below' -> 'above'`).\n     */\n    _getOrigin() {\n        const isLtr = !this._dir || this._dir.value == 'ltr';\n        const position = this.position;\n        let originPosition;\n        if (position == 'above' || position == 'below') {\n            originPosition = { originX: 'center', originY: position == 'above' ? 'top' : 'bottom' };\n        }\n        else if (position == 'before' ||\n            (position == 'left' && isLtr) ||\n            (position == 'right' && !isLtr)) {\n            originPosition = { originX: 'start', originY: 'center' };\n        }\n        else if (position == 'after' ||\n            (position == 'right' && isLtr) ||\n            (position == 'left' && !isLtr)) {\n            originPosition = { originX: 'end', originY: 'center' };\n        }\n        else if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            throw getMatTooltipInvalidPositionError(position);\n        }\n        const { x, y } = this._invertPosition(originPosition.originX, originPosition.originY);\n        return {\n            main: originPosition,\n            fallback: { originX: x, originY: y },\n        };\n    }\n    /** Returns the overlay position and a fallback position based on the user's preference */\n    _getOverlayPosition() {\n        const isLtr = !this._dir || this._dir.value == 'ltr';\n        const position = this.position;\n        let overlayPosition;\n        if (position == 'above') {\n            overlayPosition = { overlayX: 'center', overlayY: 'bottom' };\n        }\n        else if (position == 'below') {\n            overlayPosition = { overlayX: 'center', overlayY: 'top' };\n        }\n        else if (position == 'before' ||\n            (position == 'left' && isLtr) ||\n            (position == 'right' && !isLtr)) {\n            overlayPosition = { overlayX: 'end', overlayY: 'center' };\n        }\n        else if (position == 'after' ||\n            (position == 'right' && isLtr) ||\n            (position == 'left' && !isLtr)) {\n            overlayPosition = { overlayX: 'start', overlayY: 'center' };\n        }\n        else if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            throw getMatTooltipInvalidPositionError(position);\n        }\n        const { x, y } = this._invertPosition(overlayPosition.overlayX, overlayPosition.overlayY);\n        return {\n            main: overlayPosition,\n            fallback: { overlayX: x, overlayY: y },\n        };\n    }\n    /** Updates the tooltip message and repositions the overlay according to the new message length */\n    _updateTooltipMessage() {\n        // Must wait for the message to be painted to the tooltip so that the overlay can properly\n        // calculate the correct positioning based on the size of the text.\n        if (this._tooltipInstance) {\n            this._tooltipInstance.message = this.message;\n            this._tooltipInstance._markForCheck();\n            this._ngZone.onMicrotaskEmpty.pipe(take(1), takeUntil(this._destroyed)).subscribe(() => {\n                if (this._tooltipInstance) {\n                    this._overlayRef.updatePosition();\n                }\n            });\n        }\n    }\n    /** Updates the tooltip class */\n    _setTooltipClass(tooltipClass) {\n        if (this._tooltipInstance) {\n            this._tooltipInstance.tooltipClass = tooltipClass;\n            this._tooltipInstance._markForCheck();\n        }\n    }\n    /** Inverts an overlay position. */\n    _invertPosition(x, y) {\n        if (this.position === 'above' || this.position === 'below') {\n            if (y === 'top') {\n                y = 'bottom';\n            }\n            else if (y === 'bottom') {\n                y = 'top';\n            }\n        }\n        else {\n            if (x === 'end') {\n                x = 'start';\n            }\n            else if (x === 'start') {\n                x = 'end';\n            }\n        }\n        return { x, y };\n    }\n    /** Updates the class on the overlay panel based on the current position of the tooltip. */\n    _updateCurrentPositionClass(connectionPair) {\n        const { overlayY, originX, originY } = connectionPair;\n        let newPosition;\n        // If the overlay is in the middle along the Y axis,\n        // it means that it's either before or after.\n        if (overlayY === 'center') {\n            // Note that since this information is used for styling, we want to\n            // resolve `start` and `end` to their real values, otherwise consumers\n            // would have to remember to do it themselves on each consumption.\n            if (this._dir && this._dir.value === 'rtl') {\n                newPosition = originX === 'end' ? 'left' : 'right';\n            }\n            else {\n                newPosition = originX === 'start' ? 'left' : 'right';\n            }\n        }\n        else {\n            newPosition = overlayY === 'bottom' && originY === 'top' ? 'above' : 'below';\n        }\n        if (newPosition !== this._currentPosition) {\n            const overlayRef = this._overlayRef;\n            if (overlayRef) {\n                const classPrefix = `${this._cssClassPrefix}-${PANEL_CLASS}-`;\n                overlayRef.removePanelClass(classPrefix + this._currentPosition);\n                overlayRef.addPanelClass(classPrefix + newPosition);\n            }\n            this._currentPosition = newPosition;\n        }\n    }\n    /** Binds the pointer events to the tooltip trigger. */\n    _setupPointerEnterEventsIfNeeded() {\n        // Optimization: Defer hooking up events if there's no message or the tooltip is disabled.\n        if (this._disabled ||\n            !this.message ||\n            !this._viewInitialized ||\n            this._passiveListeners.length) {\n            return;\n        }\n        // The mouse events shouldn't be bound on mobile devices, because they can prevent the\n        // first tap from firing its click event or can cause the tooltip to open for clicks.\n        if (this._platformSupportsMouseEvents()) {\n            this._passiveListeners.push([\n                'mouseenter',\n                () => {\n                    this._setupPointerExitEventsIfNeeded();\n                    this.show();\n                },\n            ]);\n        }\n        else if (this.touchGestures !== 'off') {\n            this._disableNativeGesturesIfNecessary();\n            this._passiveListeners.push([\n                'touchstart',\n                () => {\n                    // Note that it's important that we don't `preventDefault` here,\n                    // because it can prevent click events from firing on the element.\n                    this._setupPointerExitEventsIfNeeded();\n                    clearTimeout(this._touchstartTimeout);\n                    this._touchstartTimeout = setTimeout(() => this.show(), LONGPRESS_DELAY);\n                },\n            ]);\n        }\n        this._addListeners(this._passiveListeners);\n    }\n    _setupPointerExitEventsIfNeeded() {\n        if (this._pointerExitEventsInitialized) {\n            return;\n        }\n        this._pointerExitEventsInitialized = true;\n        const exitListeners = [];\n        if (this._platformSupportsMouseEvents()) {\n            exitListeners.push([\n                'mouseleave',\n                event => {\n                    const newTarget = event.relatedTarget;\n                    if (!newTarget || !this._overlayRef?.overlayElement.contains(newTarget)) {\n                        this.hide();\n                    }\n                },\n            ], ['wheel', event => this._wheelListener(event)]);\n        }\n        else if (this.touchGestures !== 'off') {\n            this._disableNativeGesturesIfNecessary();\n            const touchendListener = () => {\n                clearTimeout(this._touchstartTimeout);\n                this.hide(this._defaultOptions.touchendHideDelay);\n            };\n            exitListeners.push(['touchend', touchendListener], ['touchcancel', touchendListener]);\n        }\n        this._addListeners(exitListeners);\n        this._passiveListeners.push(...exitListeners);\n    }\n    _addListeners(listeners) {\n        listeners.forEach(([event, listener]) => {\n            this._elementRef.nativeElement.addEventListener(event, listener, passiveListenerOptions);\n        });\n    }\n    _platformSupportsMouseEvents() {\n        return !this._platform.IOS && !this._platform.ANDROID;\n    }\n    /** Listener for the `wheel` event on the element. */\n    _wheelListener(event) {\n        if (this._isTooltipVisible()) {\n            const elementUnderPointer = this._document.elementFromPoint(event.clientX, event.clientY);\n            const element = this._elementRef.nativeElement;\n            // On non-touch devices we depend on the `mouseleave` event to close the tooltip, but it\n            // won't fire if the user scrolls away using the wheel without moving their cursor. We\n            // work around it by finding the element under the user's cursor and closing the tooltip\n            // if it's not the trigger.\n            if (elementUnderPointer !== element && !element.contains(elementUnderPointer)) {\n                this.hide();\n            }\n        }\n    }\n    /** Disables the native browser gestures, based on how the tooltip has been configured. */\n    _disableNativeGesturesIfNecessary() {\n        const gestures = this.touchGestures;\n        if (gestures !== 'off') {\n            const element = this._elementRef.nativeElement;\n            const style = element.style;\n            // If gestures are set to `auto`, we don't disable text selection on inputs and\n            // textareas, because it prevents the user from typing into them on iOS Safari.\n            if (gestures === 'on' || (element.nodeName !== 'INPUT' && element.nodeName !== 'TEXTAREA')) {\n                style.userSelect =\n                    style.msUserSelect =\n                        style.webkitUserSelect =\n                            style.MozUserSelect =\n                                'none';\n            }\n            // If we have `auto` gestures and the element uses native HTML dragging,\n            // we don't set `-webkit-user-drag` because it prevents the native behavior.\n            if (gestures === 'on' || !element.draggable) {\n                style.webkitUserDrag = 'none';\n            }\n            style.touchAction = 'none';\n            style.webkitTapHighlightColor = 'transparent';\n        }\n    }\n}\n_MatTooltipBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatTooltipBase, deps: \"invalid\", target: i0.ɵɵFactoryTarget.Directive });\n_MatTooltipBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: _MatTooltipBase, inputs: { position: [\"matTooltipPosition\", \"position\"], disabled: [\"matTooltipDisabled\", \"disabled\"], showDelay: [\"matTooltipShowDelay\", \"showDelay\"], hideDelay: [\"matTooltipHideDelay\", \"hideDelay\"], touchGestures: [\"matTooltipTouchGestures\", \"touchGestures\"], message: [\"matTooltip\", \"message\"], tooltipClass: [\"matTooltipClass\", \"tooltipClass\"] }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _MatTooltipBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.ElementRef }, { type: i2.ScrollDispatcher }, { type: i0.ViewContainerRef }, { type: i0.NgZone }, { type: i3.Platform }, { type: i4.AriaDescriber }, { type: i4.FocusMonitor }, { type: undefined }, { type: i5.Directionality }, { type: undefined }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }]; }, propDecorators: { position: [{\n                type: Input,\n                args: ['matTooltipPosition']\n            }], disabled: [{\n                type: Input,\n                args: ['matTooltipDisabled']\n            }], showDelay: [{\n                type: Input,\n                args: ['matTooltipShowDelay']\n            }], hideDelay: [{\n                type: Input,\n                args: ['matTooltipHideDelay']\n            }], touchGestures: [{\n                type: Input,\n                args: ['matTooltipTouchGestures']\n            }], message: [{\n                type: Input,\n                args: ['matTooltip']\n            }], tooltipClass: [{\n                type: Input,\n                args: ['matTooltipClass']\n            }] } });\n/**\n * Directive that attaches a material design tooltip to the host element. Animates the showing and\n * hiding of a tooltip provided position (defaults to below the element).\n *\n * https://material.io/design/components/tooltips.html\n */\nclass MatTooltip extends _MatTooltipBase {\n    constructor(overlay, elementRef, scrollDispatcher, viewContainerRef, ngZone, platform, ariaDescriber, focusMonitor, scrollStrategy, dir, defaultOptions, _document) {\n        super(overlay, elementRef, scrollDispatcher, viewContainerRef, ngZone, platform, ariaDescriber, focusMonitor, scrollStrategy, dir, defaultOptions, _document);\n        this._tooltipComponent = TooltipComponent;\n    }\n}\nMatTooltip.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatTooltip, deps: [{ token: i1.Overlay }, { token: i0.ElementRef }, { token: i2.ScrollDispatcher }, { token: i0.ViewContainerRef }, { token: i0.NgZone }, { token: i3.Platform }, { token: i4.AriaDescriber }, { token: i4.FocusMonitor }, { token: MAT_TOOLTIP_SCROLL_STRATEGY }, { token: i5.Directionality, optional: true }, { token: MAT_TOOLTIP_DEFAULT_OPTIONS, optional: true }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive });\nMatTooltip.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatTooltip, selector: \"[matTooltip]\", host: { classAttribute: \"mat-tooltip-trigger\" }, exportAs: [\"matTooltip\"], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatTooltip, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matTooltip]',\n                    exportAs: 'matTooltip',\n                    host: {\n                        'class': 'mat-tooltip-trigger',\n                    },\n                }]\n        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.ElementRef }, { type: i2.ScrollDispatcher }, { type: i0.ViewContainerRef }, { type: i0.NgZone }, { type: i3.Platform }, { type: i4.AriaDescriber }, { type: i4.FocusMonitor }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_TOOLTIP_SCROLL_STRATEGY]\n                }] }, { type: i5.Directionality, decorators: [{\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_TOOLTIP_DEFAULT_OPTIONS]\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }]; } });\nclass _TooltipComponentBase {\n    constructor(_changeDetectorRef, animationMode) {\n        this._changeDetectorRef = _changeDetectorRef;\n        /** Property watched by the animation framework to show or hide the tooltip */\n        this._visibility = 'initial';\n        /** Whether interactions on the page should close the tooltip */\n        this._closeOnInteraction = false;\n        /** Whether the tooltip is currently visible. */\n        this._isVisible = false;\n        /** Subject for notifying that the tooltip has been hidden from the view */\n        this._onHide = new Subject();\n        this._animationsDisabled = animationMode === 'NoopAnimations';\n    }\n    /**\n     * Shows the tooltip with an animation originating from the provided origin\n     * @param delay Amount of milliseconds to the delay showing the tooltip.\n     */\n    show(delay) {\n        // Cancel the delayed hide if it is scheduled\n        clearTimeout(this._hideTimeoutId);\n        this._showTimeoutId = setTimeout(() => {\n            this._toggleVisibility(true);\n            this._showTimeoutId = undefined;\n        }, delay);\n    }\n    /**\n     * Begins the animation to hide the tooltip after the provided delay in ms.\n     * @param delay Amount of milliseconds to delay showing the tooltip.\n     */\n    hide(delay) {\n        // Cancel the delayed show if it is scheduled\n        clearTimeout(this._showTimeoutId);\n        this._hideTimeoutId = setTimeout(() => {\n            this._toggleVisibility(false);\n            this._hideTimeoutId = undefined;\n        }, delay);\n    }\n    /** Returns an observable that notifies when the tooltip has been hidden from view. */\n    afterHidden() {\n        return this._onHide;\n    }\n    /** Whether the tooltip is being displayed. */\n    isVisible() {\n        return this._isVisible;\n    }\n    ngOnDestroy() {\n        clearTimeout(this._showTimeoutId);\n        clearTimeout(this._hideTimeoutId);\n        this._onHide.complete();\n        this._triggerElement = null;\n    }\n    /**\n     * Interactions on the HTML body should close the tooltip immediately as defined in the\n     * material design spec.\n     * https://material.io/design/components/tooltips.html#behavior\n     */\n    _handleBodyInteraction() {\n        if (this._closeOnInteraction) {\n            this.hide(0);\n        }\n    }\n    /**\n     * Marks that the tooltip needs to be checked in the next change detection run.\n     * Mainly used for rendering the initial text before positioning a tooltip, which\n     * can be problematic in components with OnPush change detection.\n     */\n    _markForCheck() {\n        this._changeDetectorRef.markForCheck();\n    }\n    _handleMouseLeave({ relatedTarget }) {\n        if (!relatedTarget || !this._triggerElement.contains(relatedTarget)) {\n            this.hide(this._mouseLeaveHideDelay);\n        }\n    }\n    /**\n     * Callback for when the timeout in this.show() gets completed.\n     * This method is only needed by the mdc-tooltip, and so it is only implemented\n     * in the mdc-tooltip, not here.\n     */\n    _onShow() { }\n    /** Event listener dispatched when an animation on the tooltip finishes. */\n    _handleAnimationEnd({ animationName }) {\n        if (animationName === this._showAnimation || animationName === this._hideAnimation) {\n            this._finalizeAnimation(animationName === this._showAnimation);\n        }\n    }\n    /** Handles the cleanup after an animation has finished. */\n    _finalizeAnimation(toVisible) {\n        if (toVisible) {\n            this._closeOnInteraction = true;\n        }\n        else if (!this.isVisible()) {\n            this._onHide.next();\n        }\n    }\n    /** Toggles the visibility of the tooltip element. */\n    _toggleVisibility(isVisible) {\n        // We set the classes directly here ourselves so that toggling the tooltip state\n        // isn't bound by change detection. This allows us to hide it even if the\n        // view ref has been detached from the CD tree.\n        const tooltip = this._tooltip.nativeElement;\n        const showClass = this._showAnimation;\n        const hideClass = this._hideAnimation;\n        tooltip.classList.remove(isVisible ? hideClass : showClass);\n        tooltip.classList.add(isVisible ? showClass : hideClass);\n        this._isVisible = isVisible;\n        // It's common for internal apps to disable animations using `* { animation: none !important }`\n        // which can break the opening sequence. Try to detect such cases and work around them.\n        if (isVisible && !this._animationsDisabled && typeof getComputedStyle === 'function') {\n            const styles = getComputedStyle(tooltip);\n            // Use `getPropertyValue` to avoid issues with property renaming.\n            if (styles.getPropertyValue('animation-duration') === '0s' ||\n                styles.getPropertyValue('animation-name') === 'none') {\n                this._animationsDisabled = true;\n            }\n        }\n        if (isVisible) {\n            this._onShow();\n        }\n        if (this._animationsDisabled) {\n            tooltip.classList.add('_mat-animation-noopable');\n            this._finalizeAnimation(isVisible);\n        }\n    }\n}\n_TooltipComponentBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _TooltipComponentBase, deps: [{ token: i0.ChangeDetectorRef }, { token: ANIMATION_MODULE_TYPE, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\n_TooltipComponentBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: _TooltipComponentBase, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: _TooltipComponentBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [ANIMATION_MODULE_TYPE]\n                }] }]; } });\n/**\n * Internal component that wraps the tooltip's content.\n * @docs-private\n */\nclass TooltipComponent extends _TooltipComponentBase {\n    constructor(changeDetectorRef, _breakpointObserver, animationMode) {\n        super(changeDetectorRef, animationMode);\n        this._breakpointObserver = _breakpointObserver;\n        /** Stream that emits whether the user has a handset-sized display.  */\n        this._isHandset = this._breakpointObserver.observe(Breakpoints.Handset);\n        this._showAnimation = 'mat-tooltip-show';\n        this._hideAnimation = 'mat-tooltip-hide';\n    }\n}\nTooltipComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: TooltipComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i6.BreakpointObserver }, { token: ANIMATION_MODULE_TYPE, optional: true }], target: i0.ɵɵFactoryTarget.Component });\nTooltipComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: TooltipComponent, selector: \"mat-tooltip-component\", host: { attributes: { \"aria-hidden\": \"true\" }, listeners: { \"mouseleave\": \"_handleMouseLeave($event)\" }, properties: { \"style.zoom\": \"isVisible() ? 1 : null\" } }, viewQueries: [{ propertyName: \"_tooltip\", first: true, predicate: [\"tooltip\"], descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: \"<div #tooltip\\n     class=\\\"mat-tooltip\\\"\\n     (animationend)=\\\"_handleAnimationEnd($event)\\\"\\n     [ngClass]=\\\"tooltipClass\\\"\\n     [class.mat-tooltip-handset]=\\\"(_isHandset | async)?.matches\\\">{{message}}</div>\\n\", styles: [\".mat-tooltip{color:#fff;border-radius:4px;margin:14px;max-width:250px;padding-left:8px;padding-right:8px;overflow:hidden;text-overflow:ellipsis;transform:scale(0)}.mat-tooltip._mat-animation-noopable{animation:none;transform:scale(1)}.cdk-high-contrast-active .mat-tooltip{outline:solid 1px}.mat-tooltip-handset{margin:24px;padding-left:16px;padding-right:16px}.mat-tooltip-panel-non-interactive{pointer-events:none}@keyframes mat-tooltip-show{0%{opacity:0;transform:scale(0)}50%{opacity:.5;transform:scale(0.99)}100%{opacity:1;transform:scale(1)}}@keyframes mat-tooltip-hide{0%{opacity:1;transform:scale(1)}100%{opacity:0;transform:scale(1)}}.mat-tooltip-show{animation:mat-tooltip-show 200ms cubic-bezier(0, 0, 0.2, 1) forwards}.mat-tooltip-hide{animation:mat-tooltip-hide 100ms cubic-bezier(0, 0, 0.2, 1) forwards}\\n\"], directives: [{ type: i7.NgClass, selector: \"[ngClass]\", inputs: [\"class\", \"ngClass\"] }], pipes: { \"async\": i7.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: TooltipComponent, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-tooltip-component', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, host: {\n                        // Forces the element to have a layout in IE and Edge. This fixes issues where the element\n                        // won't be rendered if the animations are disabled or there is no web animations polyfill.\n                        '[style.zoom]': 'isVisible() ? 1 : null',\n                        '(mouseleave)': '_handleMouseLeave($event)',\n                        'aria-hidden': 'true',\n                    }, template: \"<div #tooltip\\n     class=\\\"mat-tooltip\\\"\\n     (animationend)=\\\"_handleAnimationEnd($event)\\\"\\n     [ngClass]=\\\"tooltipClass\\\"\\n     [class.mat-tooltip-handset]=\\\"(_isHandset | async)?.matches\\\">{{message}}</div>\\n\", styles: [\".mat-tooltip{color:#fff;border-radius:4px;margin:14px;max-width:250px;padding-left:8px;padding-right:8px;overflow:hidden;text-overflow:ellipsis;transform:scale(0)}.mat-tooltip._mat-animation-noopable{animation:none;transform:scale(1)}.cdk-high-contrast-active .mat-tooltip{outline:solid 1px}.mat-tooltip-handset{margin:24px;padding-left:16px;padding-right:16px}.mat-tooltip-panel-non-interactive{pointer-events:none}@keyframes mat-tooltip-show{0%{opacity:0;transform:scale(0)}50%{opacity:.5;transform:scale(0.99)}100%{opacity:1;transform:scale(1)}}@keyframes mat-tooltip-hide{0%{opacity:1;transform:scale(1)}100%{opacity:0;transform:scale(1)}}.mat-tooltip-show{animation:mat-tooltip-show 200ms cubic-bezier(0, 0, 0.2, 1) forwards}.mat-tooltip-hide{animation:mat-tooltip-hide 100ms cubic-bezier(0, 0, 0.2, 1) forwards}\\n\"] }]\n        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i6.BreakpointObserver }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [ANIMATION_MODULE_TYPE]\n                }] }]; }, propDecorators: { _tooltip: [{\n                type: ViewChild,\n                args: ['tooltip', {\n                        // Use a static query here since we interact directly with\n                        // the DOM which can happen before `ngAfterViewInit`.\n                        static: true,\n                    }]\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatTooltipModule {\n}\nMatTooltipModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatTooltipModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatTooltipModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatTooltipModule, declarations: [MatTooltip, TooltipComponent], imports: [A11yModule, CommonModule, OverlayModule, MatCommonModule], exports: [MatTooltip, TooltipComponent, MatCommonModule, CdkScrollableModule] });\nMatTooltipModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatTooltipModule, providers: [MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER], imports: [[A11yModule, CommonModule, OverlayModule, MatCommonModule], MatCommonModule, CdkScrollableModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatTooltipModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [A11yModule, CommonModule, OverlayModule, MatCommonModule],\n                    exports: [MatTooltip, TooltipComponent, MatCommonModule, CdkScrollableModule],\n                    declarations: [MatTooltip, TooltipComponent],\n                    providers: [MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Animations used by MatTooltip.\n * @docs-private\n */\nconst matTooltipAnimations = {\n    /** Animation that transitions a tooltip in and out. */\n    tooltipState: trigger('state', [\n        state('initial, void, hidden', style({ opacity: 0, transform: 'scale(0)' })),\n        state('visible', style({ transform: 'scale(1)' })),\n        transition('* => visible', animate('200ms cubic-bezier(0, 0, 0.2, 1)', keyframes([\n            style({ opacity: 0, transform: 'scale(0)', offset: 0 }),\n            style({ opacity: 0.5, transform: 'scale(0.99)', offset: 0.5 }),\n            style({ opacity: 1, transform: 'scale(1)', offset: 1 }),\n        ]))),\n        transition('* => hidden', animate('100ms cubic-bezier(0, 0, 0.2, 1)', style({ opacity: 0 }))),\n    ]),\n};\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_TOOLTIP_DEFAULT_OPTIONS, MAT_TOOLTIP_DEFAULT_OPTIONS_FACTORY, MAT_TOOLTIP_SCROLL_STRATEGY, MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY, MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER, MatTooltip, MatTooltipModule, SCROLL_THROTTLE_MS, TOOLTIP_PANEL_CLASS, TooltipComponent, _MatTooltipBase, _TooltipComponentBase, getMatTooltipInvalidPositionError, matTooltipAnimations };\n"],"x_google_ignoreList":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23]}