{"version":3,"file":"257.js","mappings":"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","names":["ID_DELIMITER","addAriaReferencedId","el","attr","id","ids","getAriaReferenceIds","some","existingId","trim","push","setAttribute","join","removeAriaReferencedId","filteredIds","filter","val","length","removeAttribute","getAttribute","match","CDK_DESCRIBEDBY_ID_PREFIX","CDK_DESCRIBEDBY_HOST_ATTRIBUTE","nextId","AriaDescriber","constructor","_document","_platform","this","_messageRegistry","Map","_messagesContainer","_id","inject","APP_ID","describe","hostElement","message","role","_canBeDescribed","key","getKey","setMessageId","set","messageElement","referenceCount","has","_createMessageElement","_isElementDescribedByMessage","_addMessageReference","removeDescription","_isElementNode","_removeMessageReference","registeredMessage","get","_deleteMessageElement","childNodes","remove","ngOnDestroy","describedElements","querySelectorAll","i","_removeCdkDescribedByReferenceIds","clear","createElement","textContent","_createMessagesContainer","appendChild","delete","containerClassName","serverContainers","messagesContainer","style","visibility","classList","add","isBrowser","body","element","originalReferenceIds","indexOf","referenceIds","messageId","trimmedMessage","ariaLabel","nodeType","ELEMENT_NODE","static","ɵfac","t","i0","DOCUMENT","i1","ɵprov","token","factory","providedIn","serviceId","ListKeyManager","_items","_activeItemIndex","_activeItem","_wrap","_letterKeyStream","Subject","_typeaheadSubscription","Subscription","EMPTY","_vertical","_allowedModifierKeys","_homeAndEnd","_pageUpAndDown","enabled","delta","_skipPredicateFn","item","disabled","_pressedLetters","tabOut","change","QueryList","_itemChangesSubscription","changes","subscribe","newItems","newIndex","toArray","skipPredicate","predicate","withWrap","shouldWrap","withVerticalOrientation","withHorizontalOrientation","direction","_horizontal","withAllowedModifierKeys","keys","withTypeAhead","debounceInterval","unsubscribe","pipe","tap","letter","debounceTime","map","inputString","items","_getItemsArray","index","getLabel","toUpperCase","setActiveItem","cancelTypeahead","withHomeAndEnd","withPageUpDown","previousActiveItem","updateActiveItem","next","onKeydown","event","keyCode","isModifierAllowed","every","modifier","TAB","DOWN_ARROW","setNextItemActive","UP_ARROW","setPreviousItemActive","RIGHT_ARROW","LEFT_ARROW","HOME","setFirstItemActive","END","setLastItemActive","PAGE_UP","targetIndex","_setActiveItemByIndex","PAGE_DOWN","itemsLength","hasModifierKey","toLocaleUpperCase","A","Z","ZERO","NINE","String","fromCharCode","preventDefault","activeItemIndex","activeItem","isTyping","_setActiveItemByDelta","itemArray","destroy","complete","_setActiveInWrapMode","_setActiveInDefaultMode","fallbackDelta","ActiveDescendantKeyManager","setInactiveStyles","super","setActiveStyles","FocusKeyManager","arguments","_origin","setFocusOrigin","origin","focus","InteractivityChecker","isDisabled","hasAttribute","isVisible","hasGeometry","offsetWidth","offsetHeight","getClientRects","getComputedStyle","isTabbable","frameElement","getFrameElement","window","getWindow","node","ownerDocument","defaultView","getTabIndexValue","nodeName","toLowerCase","tabIndexValue","WEBKIT","IOS","isPotentiallyTabbableIOS","inputType","type","FIREFOX","tabIndex","isFocusable","config","isPotentiallyFocusable","isHiddenInput","isInputElement","isNativeFormElement","isAnchorWithHref","isAnchorElement","hasValidTabIndex","ignoreVisibility","undefined","isNaN","parseInt","FocusTrap","_enabled","value","_startAnchor","_endAnchor","_toggleAnchorTabIndex","_element","_checker","_ngZone","deferAnchors","_hasAttached","startAnchorListener","focusLastTabbableElement","endAnchorListener","focusFirstTabbableElement","attachAnchors","startAnchor","endAnchor","removeEventListener","runOutsideAngular","_createAnchor","addEventListener","parentNode","insertBefore","nextSibling","focusInitialElementWhenReady","options","Promise","resolve","_executeOnStable","focusInitialElement","focusFirstTabbableElementWhenReady","focusLastTabbableElementWhenReady","_getRegionBoundary","bound","markers","_getFirstTabbableElement","_getLastTabbableElement","redirectToElement","querySelector","focusableChild","hasAttached","root","children","tabbableChild","anchor","isEnabled","toggleAnchors","fn","isStable","onStable","take","FocusTrapFactory","create","deferCaptureElements","CdkTrapFocus","focusTrap","coerceBooleanProperty","autoCapture","_autoCapture","_elementRef","_focusTrapFactory","_previouslyFocusedElement","nativeElement","ngAfterContentInit","_captureFocus","ngDoCheck","ngOnChanges","autoCaptureChange","firstChange","_getFocusedElementPierceShadowDom","ɵdir","selectors","inputs","exportAs","features","isFakeMousedownFromScreenReader","buttons","offsetX","offsetY","isFakeTouchstartFromScreenReader","touch","touches","changedTouches","identifier","radiusX","radiusY","INPUT_MODALITY_DETECTOR_OPTIONS","InjectionToken","INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS","ignoreKeys","ALT","CONTROL","MAC_META","META","SHIFT","modalityEventListenerOptions","normalizePassiveListenerOptions","passive","capture","InputModalityDetector","mostRecentModality","_modality","ngZone","document","_mostRecentTarget","BehaviorSubject","_lastTouchMs","_onKeydown","_options","_getEventTarget","_onMousedown","Date","now","_onTouchstart","modalityDetected","skip","modalityChanged","distinctUntilChanged","LIVE_ANNOUNCER_ELEMENT_TOKEN","LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY","LIVE_ANNOUNCER_DEFAULT_OPTIONS","uniqueIds","LiveAnnouncer","elementToken","_defaultOptions","_liveElement","_createLiveElement","announce","args","defaultOptions","politeness","duration","clearTimeout","_previousTimeout","_exposeAnnouncerToModals","_currentPromise","_currentResolve","setTimeout","elementClass","previousElements","getElementsByClassName","liveEl","modals","modal","ariaOwns","FOCUS_MONITOR_DEFAULT_OPTIONS","captureEventListenerOptions","FocusMonitor","_inputModalityDetector","_windowFocused","_originFromTouchInteraction","_elementInfo","_monitoredElementCount","_rootNodeFocusListenerCount","_windowFocusListener","_windowFocusTimeoutId","_stopInputModalityDetector","_rootNodeFocusAndBlurListener","target","parentElement","_onFocus","_onBlur","_detectionMode","detectionMode","monitor","checkChildren","coerceElement","of","rootNode","_getShadowRoot","_getDocument","cachedInfo","subject","info","_registerGlobalListeners","stopMonitoring","elementInfo","_setClasses","_removeGlobalListeners","focusVia","activeElement","_getClosestElementsInfo","forEach","currentElement","_originChanged","_setOrigin","_info","_getWindow","_getFocusOrigin","focusEventTarget","_shouldBeAttributedToTouch","_lastFocusOrigin","_isLastInteractionFromInputLabel","contains","toggle","isFromInteraction","_originTimeoutId","relatedTarget","Node","_emitOrigin","observers","run","rootNodeFocusListeners","takeUntil","modality","results","mostRecentTarget","labels","CdkMonitorFocus","_focusMonitor","_focusOrigin","cdkFocusChange","EventEmitter","focusOrigin","ngAfterViewInit","_monitorSubscription","emit","outputs","BLACK_ON_WHITE_CSS_CLASS","WHITE_ON_BLACK_CSS_CLASS","HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS","HighContrastModeDetector","_breakpointSubscription","BreakpointObserver","observe","_hasCheckedHighContrastMode","_applyBodyHighContrastModeCssClasses","getHighContrastMode","testElement","backgroundColor","position","documentWindow","computedStyle","computedColor","replace","bodyClasses","mode","A11yModule","highContrastModeDetector","ɵmod","ɵinj","imports","ObserversModule","DIR_DOCUMENT","DIR_DOCUMENT_FACTORY","RTL_LOCALE_PATTERN","Directionality","_resolveDirectionality","rawValue","navigator","language","test","dir","documentElement","BidiModule","coerceNumberProperty","fallbackValue","_isNumberValue","parseFloat","Number","coerceArray","Array","isArray","coerceCssPixelValue","elementOrRef","ElementRef","coerceStringArray","separator","result","sourceValues","split","sourceValue","trimmedString","ENTER","ESCAPE","SPACE","modifiers","altKey","shiftKey","ctrlKey","metaKey","mediaQueriesForWebkitCompatibility","Set","mediaQueryStyleNode","MediaMatcher","_nonce","_matchMedia","matchMedia","bind","noopMatchMedia","query","BLINK","createEmptyStyleRule","nonce","head","sheet","insertRule","e","console","error","CSP_NONCE","matches","media","addListener","removeListener","_mediaMatcher","_zone","_queries","_destroySubject","isMatched","splitQueries","mediaQuery","_registerQuery","mql","observables","observable","stateObservable","combineLatest","concat","breakpointStates","response","breakpoints","output","Observable","observer","handler","startWith","queries","reduce","a1","a2","MutationObserverFactory","callback","MutationObserver","providers","hasV8BreakIterator","Intl","v8BreakIterator","supportedInputTypes","Platform","_platformId","isPlatformBrowser","EDGE","userAgent","TRIDENT","chrome","CSS","ANDROID","SAFARI","PLATFORM_ID","candidateInputTypes","getSupportedInputTypes","featureTestInput","supportsPassiveEvents","rtlScrollAxisType","scrollBehaviorSupported","shadowDomIsSupported","supportsPassiveEventListeners","Object","defineProperty","supportsScrollBehavior","Element","scrollToFunction","prototype","scrollTo","toString","getRtlScrollAxisType","scrollContainer","containerStyle","width","overflow","pointerEvents","content","contentStyle","height","scrollLeft","_supportsShadowDom","createShadowRoot","attachShadow","getRootNode","ShadowRoot","shadowRoot","newActiveElement","composedPath","_isTestEnvironment","__karma__","jasmine","jest","Mocha","_c2","MatOption_mat_pseudo_checkbox_0_Template","rf","ctx","ctx_r0","selected","MatOption_mat_pseudo_checkbox_5_Template","ctx_r2","MatOption_span_6_Template","ctx_r3","group","label","_c3","_c4","MATERIAL_SANITY_CHECKS","MATERIAL_SANITY_CHECKS_FACTORY","MatCommonModule","_sanityChecks","_hasDoneGlobalChecks","_checkIsEnabled","name","mixinDisabled","base","_disabled","mixinColor","defaultColor","color","_color","colorPalette","mixinDisableRipple","disableRipple","_disableRipple","mixinTabIndex","defaultTabIndex","_tabIndex","mixinErrorState","updateErrorState","oldState","errorState","newState","errorStateMatcher","_defaultErrorStateMatcher","isErrorState","ngControl","control","_parentFormGroup","_parentForm","stateChanges","MAT_DATE_LOCALE","MAT_DATE_LOCALE_FACTORY","LOCALE_ID","DateAdapter","_localeChanges","localeChanges","getValidDateOrNull","obj","isDateInstance","isValid","deserialize","invalid","setLocale","locale","compareDate","first","second","getYear","getMonth","getDate","sameDate","firstValid","secondValid","clampDate","date","min","max","MAT_DATE_FORMATS","ISO_8601_REGEX","range","valueFunction","valuesArray","NativeDateAdapter","matDateLocale","useUtcForDisplay","getFullYear","getDayOfWeek","getDay","getMonthNames","dtf","DateTimeFormat","month","timeZone","_format","getDateNames","day","getDayOfWeekNames","weekday","getYearName","year","getFirstDayOfWeek","getNumDaysInMonth","_createDateWithOverflow","clone","getTime","createDate","today","parse","parseFormat","format","displayFormat","Error","addCalendarYears","years","addCalendarMonths","months","newDate","addCalendarDays","days","toIso8601","getUTCFullYear","_2digit","getUTCMonth","getUTCDate","NaN","d","setFullYear","setHours","n","slice","setUTCFullYear","setUTCHours","getHours","getMinutes","getSeconds","getMilliseconds","i1$1","MAT_NATIVE_DATE_FORMATS","dateInput","display","monthYearLabel","dateA11yLabel","monthYearA11yLabel","NativeDateModule","provide","useClass","MatNativeDateModule","useValue","ErrorStateMatcher","form","touched","submitted","RippleRef","_renderer","_animationForciblyDisabledThroughCss","state","fadeOut","fadeOutRipple","passiveCapturingEventOptions$1","RippleEventManager","_events","_delegateEventHandler","handlers","handleEvent","addHandler","handlersForEvent","handlersForElement","removeHandler","size","defaultRippleAnimationConfig","enterDuration","exitDuration","passiveCapturingEventOptions","pointerDownEvents","pointerUpEvents","RippleRenderer","_eventManager","_target","elementOrElementRef","_isPointerDown","_activeRipples","_pointerUpEventsRegistered","_containerElement","fadeInRipple","x","y","containerRect","_containerRect","getBoundingClientRect","animationConfig","animation","centered","left","top","radius","distanceToFurthestCorner","rect","distX","Math","abs","right","distY","bottom","sqrt","ripple","transitionDuration","computedStyles","userTransitionDuration","animationForciblyDisabledThroughCss","transitionProperty","rippleRef","transform","persistent","_mostRecentTransientRipple","eventListeners","onTransitionEnd","_finishRippleTransition","onTransitionCancel","_destroyRipple","rippleEl","opacity","fadeOutAll","_getActiveRipples","fadeOutAllNonPersistent","setupTriggerEvents","_triggerElement","_removeTriggerEvents","_onTouchStart","_onPointerUp","_startFadeOutTransition","isMostRecentTransientRipple","isFakeMousedown","isSyntheticEvent","_lastTouchStartEvent","rippleDisabled","clientX","clientY","rippleConfig","terminateOnPointerUp","from","trigger","MAT_RIPPLE_GLOBAL_OPTIONS","MatRipple","_setupTriggerEventsIfEnabled","_trigger","platform","globalOptions","_animationMode","_isInitialized","_globalOptions","_rippleRenderer","ngOnInit","launch","configOrX","ANIMATION_MODULE_TYPE","hostAttrs","hostVars","hostBindings","unbounded","MatRippleModule","MatPseudoCheckbox","appearance","ɵcmp","decls","vars","template","styles","encapsulation","changeDetection","MatPseudoCheckboxModule","MAT_OPTION_PARENT_COMPONENT","MAT_OPTGROUP","_uniqueIdCounter","MatOptionSelectionChange","source","isUserInput","_MatOptionBase","multiple","_parent","_selected","hideSingleSelectionIndicator","_changeDetectorRef","_active","_mostRecentViewValue","onSelectionChange","_stateChanges","active","viewValue","_text","select","emitEvent","markForCheck","_emitSelectionChangeEvent","deselect","_getHostElement","_handleKeydown","_selectViaInteraction","_getTabIndex","ngAfterViewChecked","viewQuery","_t","MatOption","changeDetectorRef","parent","$event","ngContentSelectors","consts","_inert","dependencies","i3","_countGroupLabelsBeforeOption","optionIndex","optionGroups","optionsArray","groups","groupCounter","_getOptionScrollPosition","optionOffset","optionHeight","currentScrollPosition","panelHeight","MatOptionModule","CommonModule","eventListenerOptions","rippleInteractionEvents","matRippleUninitialized","matRippleClassName","matRippleCentered","matRippleDisabled","MatRippleLoader","optional","ANIMATION_MODULE_TYPE$1","_globalRippleOptions","NgZone","_onInteraction","HTMLElement","closest","createRipple","configureRipple","host","className","getRipple","matRipple","setDisabled","append","attachRipple"],"sourceRoot":"webpack:///","sources":["./node_modules/@angular/cdk/fesm2022/a11y.mjs","./node_modules/@angular/cdk/fesm2022/bidi.mjs","./node_modules/@angular/cdk/fesm2022/coercion.mjs","./node_modules/@angular/cdk/fesm2022/keycodes.mjs","./node_modules/@angular/cdk/fesm2022/layout.mjs","./node_modules/@angular/cdk/fesm2022/observers.mjs","./node_modules/@angular/cdk/fesm2022/platform.mjs","./node_modules/@angular/material/fesm2022/core.mjs"],"sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { inject, APP_ID, Injectable, Inject, QueryList, Directive, Input, InjectionToken, Optional, EventEmitter, Output, NgModule } from '@angular/core';\nimport * as i1 from '@angular/cdk/platform';\nimport { _getFocusedElementPierceShadowDom, normalizePassiveListenerOptions, _getEventTarget, _getShadowRoot } from '@angular/cdk/platform';\nimport { Subject, Subscription, BehaviorSubject, of } from 'rxjs';\nimport { hasModifierKey, A, Z, ZERO, NINE, PAGE_DOWN, PAGE_UP, END, HOME, LEFT_ARROW, RIGHT_ARROW, UP_ARROW, DOWN_ARROW, TAB, ALT, CONTROL, MAC_META, META, SHIFT } from '@angular/cdk/keycodes';\nimport { tap, debounceTime, filter, map, take, skip, distinctUntilChanged, takeUntil } from 'rxjs/operators';\nimport { coerceBooleanProperty, coerceElement } from '@angular/cdk/coercion';\nimport * as i1$1 from '@angular/cdk/observers';\nimport { ObserversModule } from '@angular/cdk/observers';\nimport { BreakpointObserver } from '@angular/cdk/layout';\n\n/** IDs are delimited by an empty space, as per the spec. */\nconst ID_DELIMITER = ' ';\n/**\n * Adds the given ID to the specified ARIA attribute on an element.\n * Used for attributes such as aria-labelledby, aria-owns, etc.\n */\nfunction addAriaReferencedId(el, attr, id) {\n    const ids = getAriaReferenceIds(el, attr);\n    if (ids.some(existingId => existingId.trim() == id.trim())) {\n        return;\n    }\n    ids.push(id.trim());\n    el.setAttribute(attr, ids.join(ID_DELIMITER));\n}\n/**\n * Removes the given ID from the specified ARIA attribute on an element.\n * Used for attributes such as aria-labelledby, aria-owns, etc.\n */\nfunction removeAriaReferencedId(el, attr, id) {\n    const ids = getAriaReferenceIds(el, attr);\n    const filteredIds = ids.filter(val => val != id.trim());\n    if (filteredIds.length) {\n        el.setAttribute(attr, filteredIds.join(ID_DELIMITER));\n    }\n    else {\n        el.removeAttribute(attr);\n    }\n}\n/**\n * Gets the list of IDs referenced by the given ARIA attribute on an element.\n * Used for attributes such as aria-labelledby, aria-owns, etc.\n */\nfunction getAriaReferenceIds(el, attr) {\n    // Get string array of all individual ids (whitespace delimited) in the attribute value\n    return (el.getAttribute(attr) || '').match(/\\S+/g) || [];\n}\n\n/**\n * ID used for the body container where all messages are appended.\n * @deprecated No longer being used. To be removed.\n * @breaking-change 14.0.0\n */\nconst MESSAGES_CONTAINER_ID = 'cdk-describedby-message-container';\n/**\n * ID prefix used for each created message element.\n * @deprecated To be turned into a private variable.\n * @breaking-change 14.0.0\n */\nconst CDK_DESCRIBEDBY_ID_PREFIX = 'cdk-describedby-message';\n/**\n * Attribute given to each host element that is described by a message element.\n * @deprecated To be turned into a private variable.\n * @breaking-change 14.0.0\n */\nconst CDK_DESCRIBEDBY_HOST_ATTRIBUTE = 'cdk-describedby-host';\n/** Global incremental identifier for each registered message element. */\nlet nextId = 0;\n/**\n * Utility that creates visually hidden elements with a message content. Useful for elements that\n * want to use aria-describedby to further describe themselves without adding additional visual\n * content.\n */\nclass AriaDescriber {\n    constructor(_document, \n    /**\n     * @deprecated To be turned into a required parameter.\n     * @breaking-change 14.0.0\n     */\n    _platform) {\n        this._platform = _platform;\n        /** Map of all registered message elements that have been placed into the document. */\n        this._messageRegistry = new Map();\n        /** Container for all registered messages. */\n        this._messagesContainer = null;\n        /** Unique ID for the service. */\n        this._id = `${nextId++}`;\n        this._document = _document;\n        this._id = inject(APP_ID) + '-' + nextId++;\n    }\n    describe(hostElement, message, role) {\n        if (!this._canBeDescribed(hostElement, message)) {\n            return;\n        }\n        const key = getKey(message, role);\n        if (typeof message !== 'string') {\n            // We need to ensure that the element has an ID.\n            setMessageId(message, this._id);\n            this._messageRegistry.set(key, { messageElement: message, referenceCount: 0 });\n        }\n        else if (!this._messageRegistry.has(key)) {\n            this._createMessageElement(message, role);\n        }\n        if (!this._isElementDescribedByMessage(hostElement, key)) {\n            this._addMessageReference(hostElement, key);\n        }\n    }\n    removeDescription(hostElement, message, role) {\n        if (!message || !this._isElementNode(hostElement)) {\n            return;\n        }\n        const key = getKey(message, role);\n        if (this._isElementDescribedByMessage(hostElement, key)) {\n            this._removeMessageReference(hostElement, key);\n        }\n        // If the message is a string, it means that it's one that we created for the\n        // consumer so we can remove it safely, otherwise we should leave it in place.\n        if (typeof message === 'string') {\n            const registeredMessage = this._messageRegistry.get(key);\n            if (registeredMessage && registeredMessage.referenceCount === 0) {\n                this._deleteMessageElement(key);\n            }\n        }\n        if (this._messagesContainer?.childNodes.length === 0) {\n            this._messagesContainer.remove();\n            this._messagesContainer = null;\n        }\n    }\n    /** Unregisters all created message elements and removes the message container. */\n    ngOnDestroy() {\n        const describedElements = this._document.querySelectorAll(`[${CDK_DESCRIBEDBY_HOST_ATTRIBUTE}=\"${this._id}\"]`);\n        for (let i = 0; i < describedElements.length; i++) {\n            this._removeCdkDescribedByReferenceIds(describedElements[i]);\n            describedElements[i].removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);\n        }\n        this._messagesContainer?.remove();\n        this._messagesContainer = null;\n        this._messageRegistry.clear();\n    }\n    /**\n     * Creates a new element in the visually hidden message container element with the message\n     * as its content and adds it to the message registry.\n     */\n    _createMessageElement(message, role) {\n        const messageElement = this._document.createElement('div');\n        setMessageId(messageElement, this._id);\n        messageElement.textContent = message;\n        if (role) {\n            messageElement.setAttribute('role', role);\n        }\n        this._createMessagesContainer();\n        this._messagesContainer.appendChild(messageElement);\n        this._messageRegistry.set(getKey(message, role), { messageElement, referenceCount: 0 });\n    }\n    /** Deletes the message element from the global messages container. */\n    _deleteMessageElement(key) {\n        this._messageRegistry.get(key)?.messageElement?.remove();\n        this._messageRegistry.delete(key);\n    }\n    /** Creates the global container for all aria-describedby messages. */\n    _createMessagesContainer() {\n        if (this._messagesContainer) {\n            return;\n        }\n        const containerClassName = 'cdk-describedby-message-container';\n        const serverContainers = this._document.querySelectorAll(`.${containerClassName}[platform=\"server\"]`);\n        for (let i = 0; i < serverContainers.length; i++) {\n            // When going from the server to the client, we may end up in a situation where there's\n            // already a container on the page, but we don't have a reference to it. Clear the\n            // old container so we don't get duplicates. Doing this, instead of emptying the previous\n            // container, should be slightly faster.\n            serverContainers[i].remove();\n        }\n        const messagesContainer = this._document.createElement('div');\n        // We add `visibility: hidden` in order to prevent text in this container from\n        // being searchable by the browser's Ctrl + F functionality.\n        // Screen-readers will still read the description for elements with aria-describedby even\n        // when the description element is not visible.\n        messagesContainer.style.visibility = 'hidden';\n        // Even though we use `visibility: hidden`, we still apply `cdk-visually-hidden` so that\n        // the description element doesn't impact page layout.\n        messagesContainer.classList.add(containerClassName);\n        messagesContainer.classList.add('cdk-visually-hidden');\n        // @breaking-change 14.0.0 Remove null check for `_platform`.\n        if (this._platform && !this._platform.isBrowser) {\n            messagesContainer.setAttribute('platform', 'server');\n        }\n        this._document.body.appendChild(messagesContainer);\n        this._messagesContainer = messagesContainer;\n    }\n    /** Removes all cdk-describedby messages that are hosted through the element. */\n    _removeCdkDescribedByReferenceIds(element) {\n        // Remove all aria-describedby reference IDs that are prefixed by CDK_DESCRIBEDBY_ID_PREFIX\n        const originalReferenceIds = getAriaReferenceIds(element, 'aria-describedby').filter(id => id.indexOf(CDK_DESCRIBEDBY_ID_PREFIX) != 0);\n        element.setAttribute('aria-describedby', originalReferenceIds.join(' '));\n    }\n    /**\n     * Adds a message reference to the element using aria-describedby and increments the registered\n     * message's reference count.\n     */\n    _addMessageReference(element, key) {\n        const registeredMessage = this._messageRegistry.get(key);\n        // Add the aria-describedby reference and set the\n        // describedby_host attribute to mark the element.\n        addAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);\n        element.setAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE, this._id);\n        registeredMessage.referenceCount++;\n    }\n    /**\n     * Removes a message reference from the element using aria-describedby\n     * and decrements the registered message's reference count.\n     */\n    _removeMessageReference(element, key) {\n        const registeredMessage = this._messageRegistry.get(key);\n        registeredMessage.referenceCount--;\n        removeAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);\n        element.removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);\n    }\n    /** Returns true if the element has been described by the provided message ID. */\n    _isElementDescribedByMessage(element, key) {\n        const referenceIds = getAriaReferenceIds(element, 'aria-describedby');\n        const registeredMessage = this._messageRegistry.get(key);\n        const messageId = registeredMessage && registeredMessage.messageElement.id;\n        return !!messageId && referenceIds.indexOf(messageId) != -1;\n    }\n    /** Determines whether a message can be described on a particular element. */\n    _canBeDescribed(element, message) {\n        if (!this._isElementNode(element)) {\n            return false;\n        }\n        if (message && typeof message === 'object') {\n            // We'd have to make some assumptions about the description element's text, if the consumer\n            // passed in an element. Assume that if an element is passed in, the consumer has verified\n            // that it can be used as a description.\n            return true;\n        }\n        const trimmedMessage = message == null ? '' : `${message}`.trim();\n        const ariaLabel = element.getAttribute('aria-label');\n        // We shouldn't set descriptions if they're exactly the same as the `aria-label` of the\n        // element, because screen readers will end up reading out the same text twice in a row.\n        return trimmedMessage ? !ariaLabel || ariaLabel.trim() !== trimmedMessage : false;\n    }\n    /** Checks whether a node is an Element node. */\n    _isElementNode(element) {\n        return element.nodeType === this._document.ELEMENT_NODE;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: AriaDescriber, deps: [{ token: DOCUMENT }, { token: i1.Platform }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: AriaDescriber, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: AriaDescriber, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: i1.Platform }]; } });\n/** Gets a key that can be used to look messages up in the registry. */\nfunction getKey(message, role) {\n    return typeof message === 'string' ? `${role || ''}/${message}` : message;\n}\n/** Assigns a unique ID to an element, if it doesn't have one already. */\nfunction setMessageId(element, serviceId) {\n    if (!element.id) {\n        element.id = `${CDK_DESCRIBEDBY_ID_PREFIX}-${serviceId}-${nextId++}`;\n    }\n}\n\n/**\n * This class manages keyboard events for selectable lists. If you pass it a query list\n * of items, it will set the active item correctly when arrow events occur.\n */\nclass ListKeyManager {\n    constructor(_items) {\n        this._items = _items;\n        this._activeItemIndex = -1;\n        this._activeItem = null;\n        this._wrap = false;\n        this._letterKeyStream = new Subject();\n        this._typeaheadSubscription = Subscription.EMPTY;\n        this._vertical = true;\n        this._allowedModifierKeys = [];\n        this._homeAndEnd = false;\n        this._pageUpAndDown = { enabled: false, delta: 10 };\n        /**\n         * Predicate function that can be used to check whether an item should be skipped\n         * by the key manager. By default, disabled items are skipped.\n         */\n        this._skipPredicateFn = (item) => item.disabled;\n        // Buffer for the letters that the user has pressed when the typeahead option is turned on.\n        this._pressedLetters = [];\n        /**\n         * Stream that emits any time the TAB key is pressed, so components can react\n         * when focus is shifted off of the list.\n         */\n        this.tabOut = new Subject();\n        /** Stream that emits whenever the active item of the list manager changes. */\n        this.change = new Subject();\n        // We allow for the items to be an array because, in some cases, the consumer may\n        // not have access to a QueryList of the items they want to manage (e.g. when the\n        // items aren't being collected via `ViewChildren` or `ContentChildren`).\n        if (_items instanceof QueryList) {\n            this._itemChangesSubscription = _items.changes.subscribe((newItems) => {\n                if (this._activeItem) {\n                    const itemArray = newItems.toArray();\n                    const newIndex = itemArray.indexOf(this._activeItem);\n                    if (newIndex > -1 && newIndex !== this._activeItemIndex) {\n                        this._activeItemIndex = newIndex;\n                    }\n                }\n            });\n        }\n    }\n    /**\n     * Sets the predicate function that determines which items should be skipped by the\n     * list key manager.\n     * @param predicate Function that determines whether the given item should be skipped.\n     */\n    skipPredicate(predicate) {\n        this._skipPredicateFn = predicate;\n        return this;\n    }\n    /**\n     * Configures wrapping mode, which determines whether the active item will wrap to\n     * the other end of list when there are no more items in the given direction.\n     * @param shouldWrap Whether the list should wrap when reaching the end.\n     */\n    withWrap(shouldWrap = true) {\n        this._wrap = shouldWrap;\n        return this;\n    }\n    /**\n     * Configures whether the key manager should be able to move the selection vertically.\n     * @param enabled Whether vertical selection should be enabled.\n     */\n    withVerticalOrientation(enabled = true) {\n        this._vertical = enabled;\n        return this;\n    }\n    /**\n     * Configures the key manager to move the selection horizontally.\n     * Passing in `null` will disable horizontal movement.\n     * @param direction Direction in which the selection can be moved.\n     */\n    withHorizontalOrientation(direction) {\n        this._horizontal = direction;\n        return this;\n    }\n    /**\n     * Modifier keys which are allowed to be held down and whose default actions will be prevented\n     * as the user is pressing the arrow keys. Defaults to not allowing any modifier keys.\n     */\n    withAllowedModifierKeys(keys) {\n        this._allowedModifierKeys = keys;\n        return this;\n    }\n    /**\n     * Turns on typeahead mode which allows users to set the active item by typing.\n     * @param debounceInterval Time to wait after the last keystroke before setting the active item.\n     */\n    withTypeAhead(debounceInterval = 200) {\n        if ((typeof ngDevMode === 'undefined' || ngDevMode) &&\n            this._items.length &&\n            this._items.some(item => typeof item.getLabel !== 'function')) {\n            throw Error('ListKeyManager items in typeahead mode must implement the `getLabel` method.');\n        }\n        this._typeaheadSubscription.unsubscribe();\n        // Debounce the presses of non-navigational keys, collect the ones that correspond to letters\n        // and convert those letters back into a string. Afterwards find the first item that starts\n        // with that string and select it.\n        this._typeaheadSubscription = this._letterKeyStream\n            .pipe(tap(letter => this._pressedLetters.push(letter)), debounceTime(debounceInterval), filter(() => this._pressedLetters.length > 0), map(() => this._pressedLetters.join('')))\n            .subscribe(inputString => {\n            const items = this._getItemsArray();\n            // Start at 1 because we want to start searching at the item immediately\n            // following the current active item.\n            for (let i = 1; i < items.length + 1; i++) {\n                const index = (this._activeItemIndex + i) % items.length;\n                const item = items[index];\n                if (!this._skipPredicateFn(item) &&\n                    item.getLabel().toUpperCase().trim().indexOf(inputString) === 0) {\n                    this.setActiveItem(index);\n                    break;\n                }\n            }\n            this._pressedLetters = [];\n        });\n        return this;\n    }\n    /** Cancels the current typeahead sequence. */\n    cancelTypeahead() {\n        this._pressedLetters = [];\n        return this;\n    }\n    /**\n     * Configures the key manager to activate the first and last items\n     * respectively when the Home or End key is pressed.\n     * @param enabled Whether pressing the Home or End key activates the first/last item.\n     */\n    withHomeAndEnd(enabled = true) {\n        this._homeAndEnd = enabled;\n        return this;\n    }\n    /**\n     * Configures the key manager to activate every 10th, configured or first/last element in up/down direction\n     * respectively when the Page-Up or Page-Down key is pressed.\n     * @param enabled Whether pressing the Page-Up or Page-Down key activates the first/last item.\n     * @param delta Whether pressing the Home or End key activates the first/last item.\n     */\n    withPageUpDown(enabled = true, delta = 10) {\n        this._pageUpAndDown = { enabled, delta };\n        return this;\n    }\n    setActiveItem(item) {\n        const previousActiveItem = this._activeItem;\n        this.updateActiveItem(item);\n        if (this._activeItem !== previousActiveItem) {\n            this.change.next(this._activeItemIndex);\n        }\n    }\n    /**\n     * Sets the active item depending on the key event passed in.\n     * @param event Keyboard event to be used for determining which element should be active.\n     */\n    onKeydown(event) {\n        const keyCode = event.keyCode;\n        const modifiers = ['altKey', 'ctrlKey', 'metaKey', 'shiftKey'];\n        const isModifierAllowed = modifiers.every(modifier => {\n            return !event[modifier] || this._allowedModifierKeys.indexOf(modifier) > -1;\n        });\n        switch (keyCode) {\n            case TAB:\n                this.tabOut.next();\n                return;\n            case DOWN_ARROW:\n                if (this._vertical && isModifierAllowed) {\n                    this.setNextItemActive();\n                    break;\n                }\n                else {\n                    return;\n                }\n            case UP_ARROW:\n                if (this._vertical && isModifierAllowed) {\n                    this.setPreviousItemActive();\n                    break;\n                }\n                else {\n                    return;\n                }\n            case RIGHT_ARROW:\n                if (this._horizontal && isModifierAllowed) {\n                    this._horizontal === 'rtl' ? this.setPreviousItemActive() : this.setNextItemActive();\n                    break;\n                }\n                else {\n                    return;\n                }\n            case LEFT_ARROW:\n                if (this._horizontal && isModifierAllowed) {\n                    this._horizontal === 'rtl' ? this.setNextItemActive() : this.setPreviousItemActive();\n                    break;\n                }\n                else {\n                    return;\n                }\n            case HOME:\n                if (this._homeAndEnd && isModifierAllowed) {\n                    this.setFirstItemActive();\n                    break;\n                }\n                else {\n                    return;\n                }\n            case END:\n                if (this._homeAndEnd && isModifierAllowed) {\n                    this.setLastItemActive();\n                    break;\n                }\n                else {\n                    return;\n                }\n            case PAGE_UP:\n                if (this._pageUpAndDown.enabled && isModifierAllowed) {\n                    const targetIndex = this._activeItemIndex - this._pageUpAndDown.delta;\n                    this._setActiveItemByIndex(targetIndex > 0 ? targetIndex : 0, 1);\n                    break;\n                }\n                else {\n                    return;\n                }\n            case PAGE_DOWN:\n                if (this._pageUpAndDown.enabled && isModifierAllowed) {\n                    const targetIndex = this._activeItemIndex + this._pageUpAndDown.delta;\n                    const itemsLength = this._getItemsArray().length;\n                    this._setActiveItemByIndex(targetIndex < itemsLength ? targetIndex : itemsLength - 1, -1);\n                    break;\n                }\n                else {\n                    return;\n                }\n            default:\n                if (isModifierAllowed || hasModifierKey(event, 'shiftKey')) {\n                    // Attempt to use the `event.key` which also maps it to the user's keyboard language,\n                    // otherwise fall back to resolving alphanumeric characters via the keyCode.\n                    if (event.key && event.key.length === 1) {\n                        this._letterKeyStream.next(event.key.toLocaleUpperCase());\n                    }\n                    else if ((keyCode >= A && keyCode <= Z) || (keyCode >= ZERO && keyCode <= NINE)) {\n                        this._letterKeyStream.next(String.fromCharCode(keyCode));\n                    }\n                }\n                // Note that we return here, in order to avoid preventing\n                // the default action of non-navigational keys.\n                return;\n        }\n        this._pressedLetters = [];\n        event.preventDefault();\n    }\n    /** Index of the currently active item. */\n    get activeItemIndex() {\n        return this._activeItemIndex;\n    }\n    /** The active item. */\n    get activeItem() {\n        return this._activeItem;\n    }\n    /** Gets whether the user is currently typing into the manager using the typeahead feature. */\n    isTyping() {\n        return this._pressedLetters.length > 0;\n    }\n    /** Sets the active item to the first enabled item in the list. */\n    setFirstItemActive() {\n        this._setActiveItemByIndex(0, 1);\n    }\n    /** Sets the active item to the last enabled item in the list. */\n    setLastItemActive() {\n        this._setActiveItemByIndex(this._items.length - 1, -1);\n    }\n    /** Sets the active item to the next enabled item in the list. */\n    setNextItemActive() {\n        this._activeItemIndex < 0 ? this.setFirstItemActive() : this._setActiveItemByDelta(1);\n    }\n    /** Sets the active item to a previous enabled item in the list. */\n    setPreviousItemActive() {\n        this._activeItemIndex < 0 && this._wrap\n            ? this.setLastItemActive()\n            : this._setActiveItemByDelta(-1);\n    }\n    updateActiveItem(item) {\n        const itemArray = this._getItemsArray();\n        const index = typeof item === 'number' ? item : itemArray.indexOf(item);\n        const activeItem = itemArray[index];\n        // Explicitly check for `null` and `undefined` because other falsy values are valid.\n        this._activeItem = activeItem == null ? null : activeItem;\n        this._activeItemIndex = index;\n    }\n    /** Cleans up the key manager. */\n    destroy() {\n        this._typeaheadSubscription.unsubscribe();\n        this._itemChangesSubscription?.unsubscribe();\n        this._letterKeyStream.complete();\n        this.tabOut.complete();\n        this.change.complete();\n        this._pressedLetters = [];\n    }\n    /**\n     * This method sets the active item, given a list of items and the delta between the\n     * currently active item and the new active item. It will calculate differently\n     * depending on whether wrap mode is turned on.\n     */\n    _setActiveItemByDelta(delta) {\n        this._wrap ? this._setActiveInWrapMode(delta) : this._setActiveInDefaultMode(delta);\n    }\n    /**\n     * Sets the active item properly given \"wrap\" mode. In other words, it will continue to move\n     * down the list until it finds an item that is not disabled, and it will wrap if it\n     * encounters either end of the list.\n     */\n    _setActiveInWrapMode(delta) {\n        const items = this._getItemsArray();\n        for (let i = 1; i <= items.length; i++) {\n            const index = (this._activeItemIndex + delta * i + items.length) % items.length;\n            const item = items[index];\n            if (!this._skipPredicateFn(item)) {\n                this.setActiveItem(index);\n                return;\n            }\n        }\n    }\n    /**\n     * Sets the active item properly given the default mode. In other words, it will\n     * continue to move down the list until it finds an item that is not disabled. If\n     * it encounters either end of the list, it will stop and not wrap.\n     */\n    _setActiveInDefaultMode(delta) {\n        this._setActiveItemByIndex(this._activeItemIndex + delta, delta);\n    }\n    /**\n     * Sets the active item to the first enabled item starting at the index specified. If the\n     * item is disabled, it will move in the fallbackDelta direction until it either\n     * finds an enabled item or encounters the end of the list.\n     */\n    _setActiveItemByIndex(index, fallbackDelta) {\n        const items = this._getItemsArray();\n        if (!items[index]) {\n            return;\n        }\n        while (this._skipPredicateFn(items[index])) {\n            index += fallbackDelta;\n            if (!items[index]) {\n                return;\n            }\n        }\n        this.setActiveItem(index);\n    }\n    /** Returns the items as an array. */\n    _getItemsArray() {\n        return this._items instanceof QueryList ? this._items.toArray() : this._items;\n    }\n}\n\nclass ActiveDescendantKeyManager extends ListKeyManager {\n    setActiveItem(index) {\n        if (this.activeItem) {\n            this.activeItem.setInactiveStyles();\n        }\n        super.setActiveItem(index);\n        if (this.activeItem) {\n            this.activeItem.setActiveStyles();\n        }\n    }\n}\n\nclass FocusKeyManager extends ListKeyManager {\n    constructor() {\n        super(...arguments);\n        this._origin = 'program';\n    }\n    /**\n     * Sets the focus origin that will be passed in to the items for any subsequent `focus` calls.\n     * @param origin Focus origin to be used when focusing items.\n     */\n    setFocusOrigin(origin) {\n        this._origin = origin;\n        return this;\n    }\n    setActiveItem(item) {\n        super.setActiveItem(item);\n        if (this.activeItem) {\n            this.activeItem.focus(this._origin);\n        }\n    }\n}\n\n/**\n * Configuration for the isFocusable method.\n */\nclass IsFocusableConfig {\n    constructor() {\n        /**\n         * Whether to count an element as focusable even if it is not currently visible.\n         */\n        this.ignoreVisibility = false;\n    }\n}\n// The InteractivityChecker leans heavily on the ally.js accessibility utilities.\n// Methods like `isTabbable` are only covering specific edge-cases for the browsers which are\n// supported.\n/**\n * Utility for checking the interactivity of an element, such as whether it is focusable or\n * tabbable.\n */\nclass InteractivityChecker {\n    constructor(_platform) {\n        this._platform = _platform;\n    }\n    /**\n     * Gets whether an element is disabled.\n     *\n     * @param element Element to be checked.\n     * @returns Whether the element is disabled.\n     */\n    isDisabled(element) {\n        // This does not capture some cases, such as a non-form control with a disabled attribute or\n        // a form control inside of a disabled form, but should capture the most common cases.\n        return element.hasAttribute('disabled');\n    }\n    /**\n     * Gets whether an element is visible for the purposes of interactivity.\n     *\n     * This will capture states like `display: none` and `visibility: hidden`, but not things like\n     * being clipped by an `overflow: hidden` parent or being outside the viewport.\n     *\n     * @returns Whether the element is visible.\n     */\n    isVisible(element) {\n        return hasGeometry(element) && getComputedStyle(element).visibility === 'visible';\n    }\n    /**\n     * Gets whether an element can be reached via Tab key.\n     * Assumes that the element has already been checked with isFocusable.\n     *\n     * @param element Element to be checked.\n     * @returns Whether the element is tabbable.\n     */\n    isTabbable(element) {\n        // Nothing is tabbable on the server 😎\n        if (!this._platform.isBrowser) {\n            return false;\n        }\n        const frameElement = getFrameElement(getWindow(element));\n        if (frameElement) {\n            // Frame elements inherit their tabindex onto all child elements.\n            if (getTabIndexValue(frameElement) === -1) {\n                return false;\n            }\n            // Browsers disable tabbing to an element inside of an invisible frame.\n            if (!this.isVisible(frameElement)) {\n                return false;\n            }\n        }\n        let nodeName = element.nodeName.toLowerCase();\n        let tabIndexValue = getTabIndexValue(element);\n        if (element.hasAttribute('contenteditable')) {\n            return tabIndexValue !== -1;\n        }\n        if (nodeName === 'iframe' || nodeName === 'object') {\n            // The frame or object's content may be tabbable depending on the content, but it's\n            // not possibly to reliably detect the content of the frames. We always consider such\n            // elements as non-tabbable.\n            return false;\n        }\n        // In iOS, the browser only considers some specific elements as tabbable.\n        if (this._platform.WEBKIT && this._platform.IOS && !isPotentiallyTabbableIOS(element)) {\n            return false;\n        }\n        if (nodeName === 'audio') {\n            // Audio elements without controls enabled are never tabbable, regardless\n            // of the tabindex attribute explicitly being set.\n            if (!element.hasAttribute('controls')) {\n                return false;\n            }\n            // Audio elements with controls are by default tabbable unless the\n            // tabindex attribute is set to `-1` explicitly.\n            return tabIndexValue !== -1;\n        }\n        if (nodeName === 'video') {\n            // For all video elements, if the tabindex attribute is set to `-1`, the video\n            // is not tabbable. Note: We cannot rely on the default `HTMLElement.tabIndex`\n            // property as that one is set to `-1` in Chrome, Edge and Safari v13.1. The\n            // tabindex attribute is the source of truth here.\n            if (tabIndexValue === -1) {\n                return false;\n            }\n            // If the tabindex is explicitly set, and not `-1` (as per check before), the\n            // video element is always tabbable (regardless of whether it has controls or not).\n            if (tabIndexValue !== null) {\n                return true;\n            }\n            // Otherwise (when no explicit tabindex is set), a video is only tabbable if it\n            // has controls enabled. Firefox is special as videos are always tabbable regardless\n            // of whether there are controls or not.\n            return this._platform.FIREFOX || element.hasAttribute('controls');\n        }\n        return element.tabIndex >= 0;\n    }\n    /**\n     * Gets whether an element can be focused by the user.\n     *\n     * @param element Element to be checked.\n     * @param config The config object with options to customize this method's behavior\n     * @returns Whether the element is focusable.\n     */\n    isFocusable(element, config) {\n        // Perform checks in order of left to most expensive.\n        // Again, naive approach that does not capture many edge cases and browser quirks.\n        return (isPotentiallyFocusable(element) &&\n            !this.isDisabled(element) &&\n            (config?.ignoreVisibility || this.isVisible(element)));\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: InteractivityChecker, deps: [{ token: i1.Platform }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: InteractivityChecker, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: InteractivityChecker, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: i1.Platform }]; } });\n/**\n * Returns the frame element from a window object. Since browsers like MS Edge throw errors if\n * the frameElement property is being accessed from a different host address, this property\n * should be accessed carefully.\n */\nfunction getFrameElement(window) {\n    try {\n        return window.frameElement;\n    }\n    catch {\n        return null;\n    }\n}\n/** Checks whether the specified element has any geometry / rectangles. */\nfunction hasGeometry(element) {\n    // Use logic from jQuery to check for an invisible element.\n    // See https://github.com/jquery/jquery/blob/master/src/css/hiddenVisibleSelectors.js#L12\n    return !!(element.offsetWidth ||\n        element.offsetHeight ||\n        (typeof element.getClientRects === 'function' && element.getClientRects().length));\n}\n/** Gets whether an element's  */\nfunction isNativeFormElement(element) {\n    let nodeName = element.nodeName.toLowerCase();\n    return (nodeName === 'input' ||\n        nodeName === 'select' ||\n        nodeName === 'button' ||\n        nodeName === 'textarea');\n}\n/** Gets whether an element is an `<input type=\"hidden\">`. */\nfunction isHiddenInput(element) {\n    return isInputElement(element) && element.type == 'hidden';\n}\n/** Gets whether an element is an anchor that has an href attribute. */\nfunction isAnchorWithHref(element) {\n    return isAnchorElement(element) && element.hasAttribute('href');\n}\n/** Gets whether an element is an input element. */\nfunction isInputElement(element) {\n    return element.nodeName.toLowerCase() == 'input';\n}\n/** Gets whether an element is an anchor element. */\nfunction isAnchorElement(element) {\n    return element.nodeName.toLowerCase() == 'a';\n}\n/** Gets whether an element has a valid tabindex. */\nfunction hasValidTabIndex(element) {\n    if (!element.hasAttribute('tabindex') || element.tabIndex === undefined) {\n        return false;\n    }\n    let tabIndex = element.getAttribute('tabindex');\n    return !!(tabIndex && !isNaN(parseInt(tabIndex, 10)));\n}\n/**\n * Returns the parsed tabindex from the element attributes instead of returning the\n * evaluated tabindex from the browsers defaults.\n */\nfunction getTabIndexValue(element) {\n    if (!hasValidTabIndex(element)) {\n        return null;\n    }\n    // See browser issue in Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054\n    const tabIndex = parseInt(element.getAttribute('tabindex') || '', 10);\n    return isNaN(tabIndex) ? -1 : tabIndex;\n}\n/** Checks whether the specified element is potentially tabbable on iOS */\nfunction isPotentiallyTabbableIOS(element) {\n    let nodeName = element.nodeName.toLowerCase();\n    let inputType = nodeName === 'input' && element.type;\n    return (inputType === 'text' ||\n        inputType === 'password' ||\n        nodeName === 'select' ||\n        nodeName === 'textarea');\n}\n/**\n * Gets whether an element is potentially focusable without taking current visible/disabled state\n * into account.\n */\nfunction isPotentiallyFocusable(element) {\n    // Inputs are potentially focusable *unless* they're type=\"hidden\".\n    if (isHiddenInput(element)) {\n        return false;\n    }\n    return (isNativeFormElement(element) ||\n        isAnchorWithHref(element) ||\n        element.hasAttribute('contenteditable') ||\n        hasValidTabIndex(element));\n}\n/** Gets the parent window of a DOM node with regards of being inside of an iframe. */\nfunction getWindow(node) {\n    // ownerDocument is null if `node` itself *is* a document.\n    return (node.ownerDocument && node.ownerDocument.defaultView) || window;\n}\n\n/**\n * Class that allows for trapping focus within a DOM element.\n *\n * This class currently uses a relatively simple approach to focus trapping.\n * It assumes that the tab order is the same as DOM order, which is not necessarily true.\n * Things like `tabIndex > 0`, flex `order`, and shadow roots can cause the two to be misaligned.\n *\n * @deprecated Use `ConfigurableFocusTrap` instead.\n * @breaking-change 11.0.0\n */\nclass FocusTrap {\n    /** Whether the focus trap is active. */\n    get enabled() {\n        return this._enabled;\n    }\n    set enabled(value) {\n        this._enabled = value;\n        if (this._startAnchor && this._endAnchor) {\n            this._toggleAnchorTabIndex(value, this._startAnchor);\n            this._toggleAnchorTabIndex(value, this._endAnchor);\n        }\n    }\n    constructor(_element, _checker, _ngZone, _document, deferAnchors = false) {\n        this._element = _element;\n        this._checker = _checker;\n        this._ngZone = _ngZone;\n        this._document = _document;\n        this._hasAttached = false;\n        // Event listeners for the anchors. Need to be regular functions so that we can unbind them later.\n        this.startAnchorListener = () => this.focusLastTabbableElement();\n        this.endAnchorListener = () => this.focusFirstTabbableElement();\n        this._enabled = true;\n        if (!deferAnchors) {\n            this.attachAnchors();\n        }\n    }\n    /** Destroys the focus trap by cleaning up the anchors. */\n    destroy() {\n        const startAnchor = this._startAnchor;\n        const endAnchor = this._endAnchor;\n        if (startAnchor) {\n            startAnchor.removeEventListener('focus', this.startAnchorListener);\n            startAnchor.remove();\n        }\n        if (endAnchor) {\n            endAnchor.removeEventListener('focus', this.endAnchorListener);\n            endAnchor.remove();\n        }\n        this._startAnchor = this._endAnchor = null;\n        this._hasAttached = false;\n    }\n    /**\n     * Inserts the anchors into the DOM. This is usually done automatically\n     * in the constructor, but can be deferred for cases like directives with `*ngIf`.\n     * @returns Whether the focus trap managed to attach successfully. This may not be the case\n     * if the target element isn't currently in the DOM.\n     */\n    attachAnchors() {\n        // If we're not on the browser, there can be no focus to trap.\n        if (this._hasAttached) {\n            return true;\n        }\n        this._ngZone.runOutsideAngular(() => {\n            if (!this._startAnchor) {\n                this._startAnchor = this._createAnchor();\n                this._startAnchor.addEventListener('focus', this.startAnchorListener);\n            }\n            if (!this._endAnchor) {\n                this._endAnchor = this._createAnchor();\n                this._endAnchor.addEventListener('focus', this.endAnchorListener);\n            }\n        });\n        if (this._element.parentNode) {\n            this._element.parentNode.insertBefore(this._startAnchor, this._element);\n            this._element.parentNode.insertBefore(this._endAnchor, this._element.nextSibling);\n            this._hasAttached = true;\n        }\n        return this._hasAttached;\n    }\n    /**\n     * Waits for the zone to stabilize, then focuses the first tabbable element.\n     * @returns Returns a promise that resolves with a boolean, depending\n     * on whether focus was moved successfully.\n     */\n    focusInitialElementWhenReady(options) {\n        return new Promise(resolve => {\n            this._executeOnStable(() => resolve(this.focusInitialElement(options)));\n        });\n    }\n    /**\n     * Waits for the zone to stabilize, then focuses\n     * the first tabbable element within the focus trap region.\n     * @returns Returns a promise that resolves with a boolean, depending\n     * on whether focus was moved successfully.\n     */\n    focusFirstTabbableElementWhenReady(options) {\n        return new Promise(resolve => {\n            this._executeOnStable(() => resolve(this.focusFirstTabbableElement(options)));\n        });\n    }\n    /**\n     * Waits for the zone to stabilize, then focuses\n     * the last tabbable element within the focus trap region.\n     * @returns Returns a promise that resolves with a boolean, depending\n     * on whether focus was moved successfully.\n     */\n    focusLastTabbableElementWhenReady(options) {\n        return new Promise(resolve => {\n            this._executeOnStable(() => resolve(this.focusLastTabbableElement(options)));\n        });\n    }\n    /**\n     * Get the specified boundary element of the trapped region.\n     * @param bound The boundary to get (start or end of trapped region).\n     * @returns The boundary element.\n     */\n    _getRegionBoundary(bound) {\n        // Contains the deprecated version of selector, for temporary backwards comparability.\n        const markers = this._element.querySelectorAll(`[cdk-focus-region-${bound}], ` + `[cdkFocusRegion${bound}], ` + `[cdk-focus-${bound}]`);\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            for (let i = 0; i < markers.length; i++) {\n                // @breaking-change 8.0.0\n                if (markers[i].hasAttribute(`cdk-focus-${bound}`)) {\n                    console.warn(`Found use of deprecated attribute 'cdk-focus-${bound}', ` +\n                        `use 'cdkFocusRegion${bound}' instead. The deprecated ` +\n                        `attribute will be removed in 8.0.0.`, markers[i]);\n                }\n                else if (markers[i].hasAttribute(`cdk-focus-region-${bound}`)) {\n                    console.warn(`Found use of deprecated attribute 'cdk-focus-region-${bound}', ` +\n                        `use 'cdkFocusRegion${bound}' instead. The deprecated attribute ` +\n                        `will be removed in 8.0.0.`, markers[i]);\n                }\n            }\n        }\n        if (bound == 'start') {\n            return markers.length ? markers[0] : this._getFirstTabbableElement(this._element);\n        }\n        return markers.length\n            ? markers[markers.length - 1]\n            : this._getLastTabbableElement(this._element);\n    }\n    /**\n     * Focuses the element that should be focused when the focus trap is initialized.\n     * @returns Whether focus was moved successfully.\n     */\n    focusInitialElement(options) {\n        // Contains the deprecated version of selector, for temporary backwards comparability.\n        const redirectToElement = this._element.querySelector(`[cdk-focus-initial], ` + `[cdkFocusInitial]`);\n        if (redirectToElement) {\n            // @breaking-change 8.0.0\n            if ((typeof ngDevMode === 'undefined' || ngDevMode) &&\n                redirectToElement.hasAttribute(`cdk-focus-initial`)) {\n                console.warn(`Found use of deprecated attribute 'cdk-focus-initial', ` +\n                    `use 'cdkFocusInitial' instead. The deprecated attribute ` +\n                    `will be removed in 8.0.0`, redirectToElement);\n            }\n            // Warn the consumer if the element they've pointed to\n            // isn't focusable, when not in production mode.\n            if ((typeof ngDevMode === 'undefined' || ngDevMode) &&\n                !this._checker.isFocusable(redirectToElement)) {\n                console.warn(`Element matching '[cdkFocusInitial]' is not focusable.`, redirectToElement);\n            }\n            if (!this._checker.isFocusable(redirectToElement)) {\n                const focusableChild = this._getFirstTabbableElement(redirectToElement);\n                focusableChild?.focus(options);\n                return !!focusableChild;\n            }\n            redirectToElement.focus(options);\n            return true;\n        }\n        return this.focusFirstTabbableElement(options);\n    }\n    /**\n     * Focuses the first tabbable element within the focus trap region.\n     * @returns Whether focus was moved successfully.\n     */\n    focusFirstTabbableElement(options) {\n        const redirectToElement = this._getRegionBoundary('start');\n        if (redirectToElement) {\n            redirectToElement.focus(options);\n        }\n        return !!redirectToElement;\n    }\n    /**\n     * Focuses the last tabbable element within the focus trap region.\n     * @returns Whether focus was moved successfully.\n     */\n    focusLastTabbableElement(options) {\n        const redirectToElement = this._getRegionBoundary('end');\n        if (redirectToElement) {\n            redirectToElement.focus(options);\n        }\n        return !!redirectToElement;\n    }\n    /**\n     * Checks whether the focus trap has successfully been attached.\n     */\n    hasAttached() {\n        return this._hasAttached;\n    }\n    /** Get the first tabbable element from a DOM subtree (inclusive). */\n    _getFirstTabbableElement(root) {\n        if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {\n            return root;\n        }\n        const children = root.children;\n        for (let i = 0; i < children.length; i++) {\n            const tabbableChild = children[i].nodeType === this._document.ELEMENT_NODE\n                ? this._getFirstTabbableElement(children[i])\n                : null;\n            if (tabbableChild) {\n                return tabbableChild;\n            }\n        }\n        return null;\n    }\n    /** Get the last tabbable element from a DOM subtree (inclusive). */\n    _getLastTabbableElement(root) {\n        if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {\n            return root;\n        }\n        // Iterate in reverse DOM order.\n        const children = root.children;\n        for (let i = children.length - 1; i >= 0; i--) {\n            const tabbableChild = children[i].nodeType === this._document.ELEMENT_NODE\n                ? this._getLastTabbableElement(children[i])\n                : null;\n            if (tabbableChild) {\n                return tabbableChild;\n            }\n        }\n        return null;\n    }\n    /** Creates an anchor element. */\n    _createAnchor() {\n        const anchor = this._document.createElement('div');\n        this._toggleAnchorTabIndex(this._enabled, anchor);\n        anchor.classList.add('cdk-visually-hidden');\n        anchor.classList.add('cdk-focus-trap-anchor');\n        anchor.setAttribute('aria-hidden', 'true');\n        return anchor;\n    }\n    /**\n     * Toggles the `tabindex` of an anchor, based on the enabled state of the focus trap.\n     * @param isEnabled Whether the focus trap is enabled.\n     * @param anchor Anchor on which to toggle the tabindex.\n     */\n    _toggleAnchorTabIndex(isEnabled, anchor) {\n        // Remove the tabindex completely, rather than setting it to -1, because if the\n        // element has a tabindex, the user might still hit it when navigating with the arrow keys.\n        isEnabled ? anchor.setAttribute('tabindex', '0') : anchor.removeAttribute('tabindex');\n    }\n    /**\n     * Toggles the`tabindex` of both anchors to either trap Tab focus or allow it to escape.\n     * @param enabled: Whether the anchors should trap Tab.\n     */\n    toggleAnchors(enabled) {\n        if (this._startAnchor && this._endAnchor) {\n            this._toggleAnchorTabIndex(enabled, this._startAnchor);\n            this._toggleAnchorTabIndex(enabled, this._endAnchor);\n        }\n    }\n    /** Executes a function when the zone is stable. */\n    _executeOnStable(fn) {\n        if (this._ngZone.isStable) {\n            fn();\n        }\n        else {\n            this._ngZone.onStable.pipe(take(1)).subscribe(fn);\n        }\n    }\n}\n/**\n * Factory that allows easy instantiation of focus traps.\n * @deprecated Use `ConfigurableFocusTrapFactory` instead.\n * @breaking-change 11.0.0\n */\nclass FocusTrapFactory {\n    constructor(_checker, _ngZone, _document) {\n        this._checker = _checker;\n        this._ngZone = _ngZone;\n        this._document = _document;\n    }\n    /**\n     * Creates a focus-trapped region around the given element.\n     * @param element The element around which focus will be trapped.\n     * @param deferCaptureElements Defers the creation of focus-capturing elements to be done\n     *     manually by the user.\n     * @returns The created focus trap instance.\n     */\n    create(element, deferCaptureElements = false) {\n        return new FocusTrap(element, this._checker, this._ngZone, this._document, deferCaptureElements);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: FocusTrapFactory, deps: [{ token: InteractivityChecker }, { token: i0.NgZone }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: FocusTrapFactory, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: FocusTrapFactory, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: InteractivityChecker }, { type: i0.NgZone }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }]; } });\n/** Directive for trapping focus within a region. */\nclass CdkTrapFocus {\n    /** Whether the focus trap is active. */\n    get enabled() {\n        return this.focusTrap.enabled;\n    }\n    set enabled(value) {\n        this.focusTrap.enabled = coerceBooleanProperty(value);\n    }\n    /**\n     * Whether the directive should automatically move focus into the trapped region upon\n     * initialization and return focus to the previous activeElement upon destruction.\n     */\n    get autoCapture() {\n        return this._autoCapture;\n    }\n    set autoCapture(value) {\n        this._autoCapture = coerceBooleanProperty(value);\n    }\n    constructor(_elementRef, _focusTrapFactory, \n    /**\n     * @deprecated No longer being used. To be removed.\n     * @breaking-change 13.0.0\n     */\n    _document) {\n        this._elementRef = _elementRef;\n        this._focusTrapFactory = _focusTrapFactory;\n        /** Previously focused element to restore focus to upon destroy when using autoCapture. */\n        this._previouslyFocusedElement = null;\n        this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);\n    }\n    ngOnDestroy() {\n        this.focusTrap.destroy();\n        // If we stored a previously focused element when using autoCapture, return focus to that\n        // element now that the trapped region is being destroyed.\n        if (this._previouslyFocusedElement) {\n            this._previouslyFocusedElement.focus();\n            this._previouslyFocusedElement = null;\n        }\n    }\n    ngAfterContentInit() {\n        this.focusTrap.attachAnchors();\n        if (this.autoCapture) {\n            this._captureFocus();\n        }\n    }\n    ngDoCheck() {\n        if (!this.focusTrap.hasAttached()) {\n            this.focusTrap.attachAnchors();\n        }\n    }\n    ngOnChanges(changes) {\n        const autoCaptureChange = changes['autoCapture'];\n        if (autoCaptureChange &&\n            !autoCaptureChange.firstChange &&\n            this.autoCapture &&\n            this.focusTrap.hasAttached()) {\n            this._captureFocus();\n        }\n    }\n    _captureFocus() {\n        this._previouslyFocusedElement = _getFocusedElementPierceShadowDom();\n        this.focusTrap.focusInitialElementWhenReady();\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkTrapFocus, deps: [{ token: i0.ElementRef }, { token: FocusTrapFactory }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: CdkTrapFocus, selector: \"[cdkTrapFocus]\", inputs: { enabled: [\"cdkTrapFocus\", \"enabled\"], autoCapture: [\"cdkTrapFocusAutoCapture\", \"autoCapture\"] }, exportAs: [\"cdkTrapFocus\"], usesOnChanges: true, ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkTrapFocus, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdkTrapFocus]',\n                    exportAs: 'cdkTrapFocus',\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: FocusTrapFactory }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }]; }, propDecorators: { enabled: [{\n                type: Input,\n                args: ['cdkTrapFocus']\n            }], autoCapture: [{\n                type: Input,\n                args: ['cdkTrapFocusAutoCapture']\n            }] } });\n\n/**\n * Class that allows for trapping focus within a DOM element.\n *\n * This class uses a strategy pattern that determines how it traps focus.\n * See FocusTrapInertStrategy.\n */\nclass ConfigurableFocusTrap extends FocusTrap {\n    /** Whether the FocusTrap is enabled. */\n    get enabled() {\n        return this._enabled;\n    }\n    set enabled(value) {\n        this._enabled = value;\n        if (this._enabled) {\n            this._focusTrapManager.register(this);\n        }\n        else {\n            this._focusTrapManager.deregister(this);\n        }\n    }\n    constructor(_element, _checker, _ngZone, _document, _focusTrapManager, _inertStrategy, config) {\n        super(_element, _checker, _ngZone, _document, config.defer);\n        this._focusTrapManager = _focusTrapManager;\n        this._inertStrategy = _inertStrategy;\n        this._focusTrapManager.register(this);\n    }\n    /** Notifies the FocusTrapManager that this FocusTrap will be destroyed. */\n    destroy() {\n        this._focusTrapManager.deregister(this);\n        super.destroy();\n    }\n    /** @docs-private Implemented as part of ManagedFocusTrap. */\n    _enable() {\n        this._inertStrategy.preventFocus(this);\n        this.toggleAnchors(true);\n    }\n    /** @docs-private Implemented as part of ManagedFocusTrap. */\n    _disable() {\n        this._inertStrategy.allowFocus(this);\n        this.toggleAnchors(false);\n    }\n}\n\n/** The injection token used to specify the inert strategy. */\nconst FOCUS_TRAP_INERT_STRATEGY = new InjectionToken('FOCUS_TRAP_INERT_STRATEGY');\n\n/**\n * Lightweight FocusTrapInertStrategy that adds a document focus event\n * listener to redirect focus back inside the FocusTrap.\n */\nclass EventListenerFocusTrapInertStrategy {\n    constructor() {\n        /** Focus event handler. */\n        this._listener = null;\n    }\n    /** Adds a document event listener that keeps focus inside the FocusTrap. */\n    preventFocus(focusTrap) {\n        // Ensure there's only one listener per document\n        if (this._listener) {\n            focusTrap._document.removeEventListener('focus', this._listener, true);\n        }\n        this._listener = (e) => this._trapFocus(focusTrap, e);\n        focusTrap._ngZone.runOutsideAngular(() => {\n            focusTrap._document.addEventListener('focus', this._listener, true);\n        });\n    }\n    /** Removes the event listener added in preventFocus. */\n    allowFocus(focusTrap) {\n        if (!this._listener) {\n            return;\n        }\n        focusTrap._document.removeEventListener('focus', this._listener, true);\n        this._listener = null;\n    }\n    /**\n     * Refocuses the first element in the FocusTrap if the focus event target was outside\n     * the FocusTrap.\n     *\n     * This is an event listener callback. The event listener is added in runOutsideAngular,\n     * so all this code runs outside Angular as well.\n     */\n    _trapFocus(focusTrap, event) {\n        const target = event.target;\n        const focusTrapRoot = focusTrap._element;\n        // Don't refocus if target was in an overlay, because the overlay might be associated\n        // with an element inside the FocusTrap, ex. mat-select.\n        if (target && !focusTrapRoot.contains(target) && !target.closest?.('div.cdk-overlay-pane')) {\n            // Some legacy FocusTrap usages have logic that focuses some element on the page\n            // just before FocusTrap is destroyed. For backwards compatibility, wait\n            // to be sure FocusTrap is still enabled before refocusing.\n            setTimeout(() => {\n                // Check whether focus wasn't put back into the focus trap while the timeout was pending.\n                if (focusTrap.enabled && !focusTrapRoot.contains(focusTrap._document.activeElement)) {\n                    focusTrap.focusFirstTabbableElement();\n                }\n            });\n        }\n    }\n}\n\n/** Injectable that ensures only the most recently enabled FocusTrap is active. */\nclass FocusTrapManager {\n    constructor() {\n        // A stack of the FocusTraps on the page. Only the FocusTrap at the\n        // top of the stack is active.\n        this._focusTrapStack = [];\n    }\n    /**\n     * Disables the FocusTrap at the top of the stack, and then pushes\n     * the new FocusTrap onto the stack.\n     */\n    register(focusTrap) {\n        // Dedupe focusTraps that register multiple times.\n        this._focusTrapStack = this._focusTrapStack.filter(ft => ft !== focusTrap);\n        let stack = this._focusTrapStack;\n        if (stack.length) {\n            stack[stack.length - 1]._disable();\n        }\n        stack.push(focusTrap);\n        focusTrap._enable();\n    }\n    /**\n     * Removes the FocusTrap from the stack, and activates the\n     * FocusTrap that is the new top of the stack.\n     */\n    deregister(focusTrap) {\n        focusTrap._disable();\n        const stack = this._focusTrapStack;\n        const i = stack.indexOf(focusTrap);\n        if (i !== -1) {\n            stack.splice(i, 1);\n            if (stack.length) {\n                stack[stack.length - 1]._enable();\n            }\n        }\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: FocusTrapManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: FocusTrapManager, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: FocusTrapManager, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }] });\n\n/** Factory that allows easy instantiation of configurable focus traps. */\nclass ConfigurableFocusTrapFactory {\n    constructor(_checker, _ngZone, _focusTrapManager, _document, _inertStrategy) {\n        this._checker = _checker;\n        this._ngZone = _ngZone;\n        this._focusTrapManager = _focusTrapManager;\n        this._document = _document;\n        // TODO split up the strategies into different modules, similar to DateAdapter.\n        this._inertStrategy = _inertStrategy || new EventListenerFocusTrapInertStrategy();\n    }\n    create(element, config = { defer: false }) {\n        let configObject;\n        if (typeof config === 'boolean') {\n            configObject = { defer: config };\n        }\n        else {\n            configObject = config;\n        }\n        return new ConfigurableFocusTrap(element, this._checker, this._ngZone, this._document, this._focusTrapManager, this._inertStrategy, configObject);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ConfigurableFocusTrapFactory, deps: [{ token: InteractivityChecker }, { token: i0.NgZone }, { token: FocusTrapManager }, { token: DOCUMENT }, { token: FOCUS_TRAP_INERT_STRATEGY, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ConfigurableFocusTrapFactory, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ConfigurableFocusTrapFactory, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: InteractivityChecker }, { type: i0.NgZone }, { type: FocusTrapManager }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [FOCUS_TRAP_INERT_STRATEGY]\n                }] }]; } });\n\n/** Gets whether an event could be a faked `mousedown` event dispatched by a screen reader. */\nfunction isFakeMousedownFromScreenReader(event) {\n    // Some screen readers will dispatch a fake `mousedown` event when pressing enter or space on\n    // a clickable element. We can distinguish these events when both `offsetX` and `offsetY` are\n    // zero or `event.buttons` is zero, depending on the browser:\n    // - `event.buttons` works on Firefox, but fails on Chrome.\n    // - `offsetX` and `offsetY` work on Chrome, but fail on Firefox.\n    // Note that there's an edge case where the user could click the 0x0 spot of the\n    // screen themselves, but that is unlikely to contain interactive elements.\n    return event.buttons === 0 || (event.offsetX === 0 && event.offsetY === 0);\n}\n/** Gets whether an event could be a faked `touchstart` event dispatched by a screen reader. */\nfunction isFakeTouchstartFromScreenReader(event) {\n    const touch = (event.touches && event.touches[0]) || (event.changedTouches && event.changedTouches[0]);\n    // A fake `touchstart` can be distinguished from a real one by looking at the `identifier`\n    // which is typically >= 0 on a real device versus -1 from a screen reader. Just to be safe,\n    // we can also look at `radiusX` and `radiusY`. This behavior was observed against a Windows 10\n    // device with a touch screen running NVDA v2020.4 and Firefox 85 or Chrome 88.\n    return (!!touch &&\n        touch.identifier === -1 &&\n        (touch.radiusX == null || touch.radiusX === 1) &&\n        (touch.radiusY == null || touch.radiusY === 1));\n}\n\n/**\n * Injectable options for the InputModalityDetector. These are shallowly merged with the default\n * options.\n */\nconst INPUT_MODALITY_DETECTOR_OPTIONS = new InjectionToken('cdk-input-modality-detector-options');\n/**\n * Default options for the InputModalityDetector.\n *\n * Modifier keys are ignored by default (i.e. when pressed won't cause the service to detect\n * keyboard input modality) for two reasons:\n *\n * 1. Modifier keys are commonly used with mouse to perform actions such as 'right click' or 'open\n *    in new tab', and are thus less representative of actual keyboard interaction.\n * 2. VoiceOver triggers some keyboard events when linearly navigating with Control + Option (but\n *    confusingly not with Caps Lock). Thus, to have parity with other screen readers, we ignore\n *    these keys so as to not update the input modality.\n *\n * Note that we do not by default ignore the right Meta key on Safari because it has the same key\n * code as the ContextMenu key on other browsers. When we switch to using event.key, we can\n * distinguish between the two.\n */\nconst INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS = {\n    ignoreKeys: [ALT, CONTROL, MAC_META, META, SHIFT],\n};\n/**\n * The amount of time needed to pass after a touchstart event in order for a subsequent mousedown\n * event to be attributed as mouse and not touch.\n *\n * This is the value used by AngularJS Material. Through trial and error (on iPhone 6S) they found\n * that a value of around 650ms seems appropriate.\n */\nconst TOUCH_BUFFER_MS = 650;\n/**\n * Event listener options that enable capturing and also mark the listener as passive if the browser\n * supports it.\n */\nconst modalityEventListenerOptions = normalizePassiveListenerOptions({\n    passive: true,\n    capture: true,\n});\n/**\n * Service that detects the user's input modality.\n *\n * This service does not update the input modality when a user navigates with a screen reader\n * (e.g. linear navigation with VoiceOver, object navigation / browse mode with NVDA, virtual PC\n * cursor mode with JAWS). This is in part due to technical limitations (i.e. keyboard events do not\n * fire as expected in these modes) but is also arguably the correct behavior. Navigating with a\n * screen reader is akin to visually scanning a page, and should not be interpreted as actual user\n * input interaction.\n *\n * When a user is not navigating but *interacting* with a screen reader, this service attempts to\n * update the input modality to keyboard, but in general this service's behavior is largely\n * undefined.\n */\nclass InputModalityDetector {\n    /** The most recently detected input modality. */\n    get mostRecentModality() {\n        return this._modality.value;\n    }\n    constructor(_platform, ngZone, document, options) {\n        this._platform = _platform;\n        /**\n         * The most recently detected input modality event target. Is null if no input modality has been\n         * detected or if the associated event target is null for some unknown reason.\n         */\n        this._mostRecentTarget = null;\n        /** The underlying BehaviorSubject that emits whenever an input modality is detected. */\n        this._modality = new BehaviorSubject(null);\n        /**\n         * The timestamp of the last touch input modality. Used to determine whether mousedown events\n         * should be attributed to mouse or touch.\n         */\n        this._lastTouchMs = 0;\n        /**\n         * Handles keydown events. Must be an arrow function in order to preserve the context when it gets\n         * bound.\n         */\n        this._onKeydown = (event) => {\n            // If this is one of the keys we should ignore, then ignore it and don't update the input\n            // modality to keyboard.\n            if (this._options?.ignoreKeys?.some(keyCode => keyCode === event.keyCode)) {\n                return;\n            }\n            this._modality.next('keyboard');\n            this._mostRecentTarget = _getEventTarget(event);\n        };\n        /**\n         * Handles mousedown events. Must be an arrow function in order to preserve the context when it\n         * gets bound.\n         */\n        this._onMousedown = (event) => {\n            // Touches trigger both touch and mouse events, so we need to distinguish between mouse events\n            // that were triggered via mouse vs touch. To do so, check if the mouse event occurs closely\n            // after the previous touch event.\n            if (Date.now() - this._lastTouchMs < TOUCH_BUFFER_MS) {\n                return;\n            }\n            // Fake mousedown events are fired by some screen readers when controls are activated by the\n            // screen reader. Attribute them to keyboard input modality.\n            this._modality.next(isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse');\n            this._mostRecentTarget = _getEventTarget(event);\n        };\n        /**\n         * Handles touchstart events. Must be an arrow function in order to preserve the context when it\n         * gets bound.\n         */\n        this._onTouchstart = (event) => {\n            // Same scenario as mentioned in _onMousedown, but on touch screen devices, fake touchstart\n            // events are fired. Again, attribute to keyboard input modality.\n            if (isFakeTouchstartFromScreenReader(event)) {\n                this._modality.next('keyboard');\n                return;\n            }\n            // Store the timestamp of this touch event, as it's used to distinguish between mouse events\n            // triggered via mouse vs touch.\n            this._lastTouchMs = Date.now();\n            this._modality.next('touch');\n            this._mostRecentTarget = _getEventTarget(event);\n        };\n        this._options = {\n            ...INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS,\n            ...options,\n        };\n        // Skip the first emission as it's null.\n        this.modalityDetected = this._modality.pipe(skip(1));\n        this.modalityChanged = this.modalityDetected.pipe(distinctUntilChanged());\n        // If we're not in a browser, this service should do nothing, as there's no relevant input\n        // modality to detect.\n        if (_platform.isBrowser) {\n            ngZone.runOutsideAngular(() => {\n                document.addEventListener('keydown', this._onKeydown, modalityEventListenerOptions);\n                document.addEventListener('mousedown', this._onMousedown, modalityEventListenerOptions);\n                document.addEventListener('touchstart', this._onTouchstart, modalityEventListenerOptions);\n            });\n        }\n    }\n    ngOnDestroy() {\n        this._modality.complete();\n        if (this._platform.isBrowser) {\n            document.removeEventListener('keydown', this._onKeydown, modalityEventListenerOptions);\n            document.removeEventListener('mousedown', this._onMousedown, modalityEventListenerOptions);\n            document.removeEventListener('touchstart', this._onTouchstart, modalityEventListenerOptions);\n        }\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: InputModalityDetector, deps: [{ token: i1.Platform }, { token: i0.NgZone }, { token: DOCUMENT }, { token: INPUT_MODALITY_DETECTOR_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: InputModalityDetector, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: InputModalityDetector, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: i1.Platform }, { type: i0.NgZone }, { type: Document, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [INPUT_MODALITY_DETECTOR_OPTIONS]\n                }] }]; } });\n\nconst LIVE_ANNOUNCER_ELEMENT_TOKEN = new InjectionToken('liveAnnouncerElement', {\n    providedIn: 'root',\n    factory: LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY,\n});\n/** @docs-private */\nfunction LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY() {\n    return null;\n}\n/** Injection token that can be used to configure the default options for the LiveAnnouncer. */\nconst LIVE_ANNOUNCER_DEFAULT_OPTIONS = new InjectionToken('LIVE_ANNOUNCER_DEFAULT_OPTIONS');\n\nlet uniqueIds = 0;\nclass LiveAnnouncer {\n    constructor(elementToken, _ngZone, _document, _defaultOptions) {\n        this._ngZone = _ngZone;\n        this._defaultOptions = _defaultOptions;\n        // We inject the live element and document as `any` because the constructor signature cannot\n        // reference browser globals (HTMLElement, Document) on non-browser environments, since having\n        // a class decorator causes TypeScript to preserve the constructor signature types.\n        this._document = _document;\n        this._liveElement = elementToken || this._createLiveElement();\n    }\n    announce(message, ...args) {\n        const defaultOptions = this._defaultOptions;\n        let politeness;\n        let duration;\n        if (args.length === 1 && typeof args[0] === 'number') {\n            duration = args[0];\n        }\n        else {\n            [politeness, duration] = args;\n        }\n        this.clear();\n        clearTimeout(this._previousTimeout);\n        if (!politeness) {\n            politeness =\n                defaultOptions && defaultOptions.politeness ? defaultOptions.politeness : 'polite';\n        }\n        if (duration == null && defaultOptions) {\n            duration = defaultOptions.duration;\n        }\n        // TODO: ensure changing the politeness works on all environments we support.\n        this._liveElement.setAttribute('aria-live', politeness);\n        if (this._liveElement.id) {\n            this._exposeAnnouncerToModals(this._liveElement.id);\n        }\n        // This 100ms timeout is necessary for some browser + screen-reader combinations:\n        // - Both JAWS and NVDA over IE11 will not announce anything without a non-zero timeout.\n        // - With Chrome and IE11 with NVDA or JAWS, a repeated (identical) message won't be read a\n        //   second time without clearing and then using a non-zero delay.\n        // (using JAWS 17 at time of this writing).\n        return this._ngZone.runOutsideAngular(() => {\n            if (!this._currentPromise) {\n                this._currentPromise = new Promise(resolve => (this._currentResolve = resolve));\n            }\n            clearTimeout(this._previousTimeout);\n            this._previousTimeout = setTimeout(() => {\n                this._liveElement.textContent = message;\n                if (typeof duration === 'number') {\n                    this._previousTimeout = setTimeout(() => this.clear(), duration);\n                }\n                this._currentResolve();\n                this._currentPromise = this._currentResolve = undefined;\n            }, 100);\n            return this._currentPromise;\n        });\n    }\n    /**\n     * Clears the current text from the announcer element. Can be used to prevent\n     * screen readers from reading the text out again while the user is going\n     * through the page landmarks.\n     */\n    clear() {\n        if (this._liveElement) {\n            this._liveElement.textContent = '';\n        }\n    }\n    ngOnDestroy() {\n        clearTimeout(this._previousTimeout);\n        this._liveElement?.remove();\n        this._liveElement = null;\n        this._currentResolve?.();\n        this._currentPromise = this._currentResolve = undefined;\n    }\n    _createLiveElement() {\n        const elementClass = 'cdk-live-announcer-element';\n        const previousElements = this._document.getElementsByClassName(elementClass);\n        const liveEl = this._document.createElement('div');\n        // Remove any old containers. This can happen when coming in from a server-side-rendered page.\n        for (let i = 0; i < previousElements.length; i++) {\n            previousElements[i].remove();\n        }\n        liveEl.classList.add(elementClass);\n        liveEl.classList.add('cdk-visually-hidden');\n        liveEl.setAttribute('aria-atomic', 'true');\n        liveEl.setAttribute('aria-live', 'polite');\n        liveEl.id = `cdk-live-announcer-${uniqueIds++}`;\n        this._document.body.appendChild(liveEl);\n        return liveEl;\n    }\n    /**\n     * Some browsers won't expose the accessibility node of the live announcer element if there is an\n     * `aria-modal` and the live announcer is outside of it. This method works around the issue by\n     * pointing the `aria-owns` of all modals to the live announcer element.\n     */\n    _exposeAnnouncerToModals(id) {\n        // TODO(http://github.com/angular/components/issues/26853): consider de-duplicating this with\n        // the `SnakBarContainer` and other usages.\n        //\n        // Note that the selector here is limited to CDK overlays at the moment in order to reduce the\n        // section of the DOM we need to look through. This should cover all the cases we support, but\n        // the selector can be expanded if it turns out to be too narrow.\n        const modals = this._document.querySelectorAll('body > .cdk-overlay-container [aria-modal=\"true\"]');\n        for (let i = 0; i < modals.length; i++) {\n            const modal = modals[i];\n            const ariaOwns = modal.getAttribute('aria-owns');\n            if (!ariaOwns) {\n                modal.setAttribute('aria-owns', id);\n            }\n            else if (ariaOwns.indexOf(id) === -1) {\n                modal.setAttribute('aria-owns', ariaOwns + ' ' + id);\n            }\n        }\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: LiveAnnouncer, deps: [{ token: LIVE_ANNOUNCER_ELEMENT_TOKEN, optional: true }, { token: i0.NgZone }, { token: DOCUMENT }, { token: LIVE_ANNOUNCER_DEFAULT_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: LiveAnnouncer, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: LiveAnnouncer, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [LIVE_ANNOUNCER_ELEMENT_TOKEN]\n                }] }, { type: i0.NgZone }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [LIVE_ANNOUNCER_DEFAULT_OPTIONS]\n                }] }]; } });\n/**\n * A directive that works similarly to aria-live, but uses the LiveAnnouncer to ensure compatibility\n * with a wider range of browsers and screen readers.\n */\nclass CdkAriaLive {\n    /** The aria-live politeness level to use when announcing messages. */\n    get politeness() {\n        return this._politeness;\n    }\n    set politeness(value) {\n        this._politeness = value === 'off' || value === 'assertive' ? value : 'polite';\n        if (this._politeness === 'off') {\n            if (this._subscription) {\n                this._subscription.unsubscribe();\n                this._subscription = null;\n            }\n        }\n        else if (!this._subscription) {\n            this._subscription = this._ngZone.runOutsideAngular(() => {\n                return this._contentObserver.observe(this._elementRef).subscribe(() => {\n                    // Note that we use textContent here, rather than innerText, in order to avoid a reflow.\n                    const elementText = this._elementRef.nativeElement.textContent;\n                    // The `MutationObserver` fires also for attribute\n                    // changes which we don't want to announce.\n                    if (elementText !== this._previousAnnouncedText) {\n                        this._liveAnnouncer.announce(elementText, this._politeness, this.duration);\n                        this._previousAnnouncedText = elementText;\n                    }\n                });\n            });\n        }\n    }\n    constructor(_elementRef, _liveAnnouncer, _contentObserver, _ngZone) {\n        this._elementRef = _elementRef;\n        this._liveAnnouncer = _liveAnnouncer;\n        this._contentObserver = _contentObserver;\n        this._ngZone = _ngZone;\n        this._politeness = 'polite';\n    }\n    ngOnDestroy() {\n        if (this._subscription) {\n            this._subscription.unsubscribe();\n        }\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkAriaLive, deps: [{ token: i0.ElementRef }, { token: LiveAnnouncer }, { token: i1$1.ContentObserver }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: CdkAriaLive, selector: \"[cdkAriaLive]\", inputs: { politeness: [\"cdkAriaLive\", \"politeness\"], duration: [\"cdkAriaLiveDuration\", \"duration\"] }, exportAs: [\"cdkAriaLive\"], ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkAriaLive, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdkAriaLive]',\n                    exportAs: 'cdkAriaLive',\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: LiveAnnouncer }, { type: i1$1.ContentObserver }, { type: i0.NgZone }]; }, propDecorators: { politeness: [{\n                type: Input,\n                args: ['cdkAriaLive']\n            }], duration: [{\n                type: Input,\n                args: ['cdkAriaLiveDuration']\n            }] } });\n\n/** InjectionToken for FocusMonitorOptions. */\nconst FOCUS_MONITOR_DEFAULT_OPTIONS = new InjectionToken('cdk-focus-monitor-default-options');\n/**\n * Event listener options that enable capturing and also\n * mark the listener as passive if the browser supports it.\n */\nconst captureEventListenerOptions = normalizePassiveListenerOptions({\n    passive: true,\n    capture: true,\n});\n/** Monitors mouse and keyboard events to determine the cause of focus events. */\nclass FocusMonitor {\n    constructor(_ngZone, _platform, _inputModalityDetector, \n    /** @breaking-change 11.0.0 make document required */\n    document, options) {\n        this._ngZone = _ngZone;\n        this._platform = _platform;\n        this._inputModalityDetector = _inputModalityDetector;\n        /** The focus origin that the next focus event is a result of. */\n        this._origin = null;\n        /** Whether the window has just been focused. */\n        this._windowFocused = false;\n        /**\n         * Whether the origin was determined via a touch interaction. Necessary as properly attributing\n         * focus events to touch interactions requires special logic.\n         */\n        this._originFromTouchInteraction = false;\n        /** Map of elements being monitored to their info. */\n        this._elementInfo = new Map();\n        /** The number of elements currently being monitored. */\n        this._monitoredElementCount = 0;\n        /**\n         * Keeps track of the root nodes to which we've currently bound a focus/blur handler,\n         * as well as the number of monitored elements that they contain. We have to treat focus/blur\n         * handlers differently from the rest of the events, because the browser won't emit events\n         * to the document when focus moves inside of a shadow root.\n         */\n        this._rootNodeFocusListenerCount = new Map();\n        /**\n         * Event listener for `focus` events on the window.\n         * Needs to be an arrow function in order to preserve the context when it gets bound.\n         */\n        this._windowFocusListener = () => {\n            // Make a note of when the window regains focus, so we can\n            // restore the origin info for the focused element.\n            this._windowFocused = true;\n            this._windowFocusTimeoutId = window.setTimeout(() => (this._windowFocused = false));\n        };\n        /** Subject for stopping our InputModalityDetector subscription. */\n        this._stopInputModalityDetector = new Subject();\n        /**\n         * Event listener for `focus` and 'blur' events on the document.\n         * Needs to be an arrow function in order to preserve the context when it gets bound.\n         */\n        this._rootNodeFocusAndBlurListener = (event) => {\n            const target = _getEventTarget(event);\n            // We need to walk up the ancestor chain in order to support `checkChildren`.\n            for (let element = target; element; element = element.parentElement) {\n                if (event.type === 'focus') {\n                    this._onFocus(event, element);\n                }\n                else {\n                    this._onBlur(event, element);\n                }\n            }\n        };\n        this._document = document;\n        this._detectionMode = options?.detectionMode || 0 /* FocusMonitorDetectionMode.IMMEDIATE */;\n    }\n    monitor(element, checkChildren = false) {\n        const nativeElement = coerceElement(element);\n        // Do nothing if we're not on the browser platform or the passed in node isn't an element.\n        if (!this._platform.isBrowser || nativeElement.nodeType !== 1) {\n            // Note: we don't want the observable to emit at all so we don't pass any parameters.\n            return of();\n        }\n        // If the element is inside the shadow DOM, we need to bind our focus/blur listeners to\n        // the shadow root, rather than the `document`, because the browser won't emit focus events\n        // to the `document`, if focus is moving within the same shadow root.\n        const rootNode = _getShadowRoot(nativeElement) || this._getDocument();\n        const cachedInfo = this._elementInfo.get(nativeElement);\n        // Check if we're already monitoring this element.\n        if (cachedInfo) {\n            if (checkChildren) {\n                // TODO(COMP-318): this can be problematic, because it'll turn all non-checkChildren\n                // observers into ones that behave as if `checkChildren` was turned on. We need a more\n                // robust solution.\n                cachedInfo.checkChildren = true;\n            }\n            return cachedInfo.subject;\n        }\n        // Create monitored element info.\n        const info = {\n            checkChildren: checkChildren,\n            subject: new Subject(),\n            rootNode,\n        };\n        this._elementInfo.set(nativeElement, info);\n        this._registerGlobalListeners(info);\n        return info.subject;\n    }\n    stopMonitoring(element) {\n        const nativeElement = coerceElement(element);\n        const elementInfo = this._elementInfo.get(nativeElement);\n        if (elementInfo) {\n            elementInfo.subject.complete();\n            this._setClasses(nativeElement);\n            this._elementInfo.delete(nativeElement);\n            this._removeGlobalListeners(elementInfo);\n        }\n    }\n    focusVia(element, origin, options) {\n        const nativeElement = coerceElement(element);\n        const focusedElement = this._getDocument().activeElement;\n        // If the element is focused already, calling `focus` again won't trigger the event listener\n        // which means that the focus classes won't be updated. If that's the case, update the classes\n        // directly without waiting for an event.\n        if (nativeElement === focusedElement) {\n            this._getClosestElementsInfo(nativeElement).forEach(([currentElement, info]) => this._originChanged(currentElement, origin, info));\n        }\n        else {\n            this._setOrigin(origin);\n            // `focus` isn't available on the server\n            if (typeof nativeElement.focus === 'function') {\n                nativeElement.focus(options);\n            }\n        }\n    }\n    ngOnDestroy() {\n        this._elementInfo.forEach((_info, element) => this.stopMonitoring(element));\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    _getFocusOrigin(focusEventTarget) {\n        if (this._origin) {\n            // If the origin was realized via a touch interaction, we need to perform additional checks\n            // to determine whether the focus origin should be attributed to touch or program.\n            if (this._originFromTouchInteraction) {\n                return this._shouldBeAttributedToTouch(focusEventTarget) ? 'touch' : 'program';\n            }\n            else {\n                return this._origin;\n            }\n        }\n        // If the window has just regained focus, we can restore the most recent origin from before the\n        // window blurred. Otherwise, we've reached the point where we can't identify the source of the\n        // focus. This typically means one of two things happened:\n        //\n        // 1) The element was programmatically focused, or\n        // 2) The element was focused via screen reader navigation (which generally doesn't fire\n        //    events).\n        //\n        // Because we can't distinguish between these two cases, we default to setting `program`.\n        if (this._windowFocused && this._lastFocusOrigin) {\n            return this._lastFocusOrigin;\n        }\n        // If the interaction is coming from an input label, we consider it a mouse interactions.\n        // This is a special case where focus moves on `click`, rather than `mousedown` which breaks\n        // our detection, because all our assumptions are for `mousedown`. We need to handle this\n        // special case, because it's very common for checkboxes and radio buttons.\n        if (focusEventTarget && this._isLastInteractionFromInputLabel(focusEventTarget)) {\n            return 'mouse';\n        }\n        return 'program';\n    }\n    /**\n     * Returns whether the focus event should be attributed to touch. Recall that in IMMEDIATE mode, a\n     * touch origin isn't immediately reset at the next tick (see _setOrigin). This means that when we\n     * handle a focus event following a touch interaction, we need to determine whether (1) the focus\n     * event was directly caused by the touch interaction or (2) the focus event was caused by a\n     * subsequent programmatic focus call triggered by the touch interaction.\n     * @param focusEventTarget The target of the focus event under examination.\n     */\n    _shouldBeAttributedToTouch(focusEventTarget) {\n        // Please note that this check is not perfect. Consider the following edge case:\n        //\n        // <div #parent tabindex=\"0\">\n        //   <div #child tabindex=\"0\" (click)=\"#parent.focus()\"></div>\n        // </div>\n        //\n        // Suppose there is a FocusMonitor in IMMEDIATE mode attached to #parent. When the user touches\n        // #child, #parent is programmatically focused. This code will attribute the focus to touch\n        // instead of program. This is a relatively minor edge-case that can be worked around by using\n        // focusVia(parent, 'program') to focus #parent.\n        return (this._detectionMode === 1 /* FocusMonitorDetectionMode.EVENTUAL */ ||\n            !!focusEventTarget?.contains(this._inputModalityDetector._mostRecentTarget));\n    }\n    /**\n     * Sets the focus classes on the element based on the given focus origin.\n     * @param element The element to update the classes on.\n     * @param origin The focus origin.\n     */\n    _setClasses(element, origin) {\n        element.classList.toggle('cdk-focused', !!origin);\n        element.classList.toggle('cdk-touch-focused', origin === 'touch');\n        element.classList.toggle('cdk-keyboard-focused', origin === 'keyboard');\n        element.classList.toggle('cdk-mouse-focused', origin === 'mouse');\n        element.classList.toggle('cdk-program-focused', origin === 'program');\n    }\n    /**\n     * Updates the focus origin. If we're using immediate detection mode, we schedule an async\n     * function to clear the origin at the end of a timeout. The duration of the timeout depends on\n     * the origin being set.\n     * @param origin The origin to set.\n     * @param isFromInteraction Whether we are setting the origin from an interaction event.\n     */\n    _setOrigin(origin, isFromInteraction = false) {\n        this._ngZone.runOutsideAngular(() => {\n            this._origin = origin;\n            this._originFromTouchInteraction = origin === 'touch' && isFromInteraction;\n            // If we're in IMMEDIATE mode, reset the origin at the next tick (or in `TOUCH_BUFFER_MS` ms\n            // for a touch event). We reset the origin at the next tick because Firefox focuses one tick\n            // after the interaction event. We wait `TOUCH_BUFFER_MS` ms before resetting the origin for\n            // a touch event because when a touch event is fired, the associated focus event isn't yet in\n            // the event queue. Before doing so, clear any pending timeouts.\n            if (this._detectionMode === 0 /* FocusMonitorDetectionMode.IMMEDIATE */) {\n                clearTimeout(this._originTimeoutId);\n                const ms = this._originFromTouchInteraction ? TOUCH_BUFFER_MS : 1;\n                this._originTimeoutId = setTimeout(() => (this._origin = null), ms);\n            }\n        });\n    }\n    /**\n     * Handles focus events on a registered element.\n     * @param event The focus event.\n     * @param element The monitored element.\n     */\n    _onFocus(event, element) {\n        // NOTE(mmalerba): We currently set the classes based on the focus origin of the most recent\n        // focus event affecting the monitored element. If we want to use the origin of the first event\n        // instead we should check for the cdk-focused class here and return if the element already has\n        // it. (This only matters for elements that have includesChildren = true).\n        // If we are not counting child-element-focus as focused, make sure that the event target is the\n        // monitored element itself.\n        const elementInfo = this._elementInfo.get(element);\n        const focusEventTarget = _getEventTarget(event);\n        if (!elementInfo || (!elementInfo.checkChildren && element !== focusEventTarget)) {\n            return;\n        }\n        this._originChanged(element, this._getFocusOrigin(focusEventTarget), elementInfo);\n    }\n    /**\n     * Handles blur events on a registered element.\n     * @param event The blur event.\n     * @param element The monitored element.\n     */\n    _onBlur(event, element) {\n        // If we are counting child-element-focus as focused, make sure that we aren't just blurring in\n        // order to focus another child of the monitored element.\n        const elementInfo = this._elementInfo.get(element);\n        if (!elementInfo ||\n            (elementInfo.checkChildren &&\n                event.relatedTarget instanceof Node &&\n                element.contains(event.relatedTarget))) {\n            return;\n        }\n        this._setClasses(element);\n        this._emitOrigin(elementInfo, null);\n    }\n    _emitOrigin(info, origin) {\n        if (info.subject.observers.length) {\n            this._ngZone.run(() => info.subject.next(origin));\n        }\n    }\n    _registerGlobalListeners(elementInfo) {\n        if (!this._platform.isBrowser) {\n            return;\n        }\n        const rootNode = elementInfo.rootNode;\n        const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode) || 0;\n        if (!rootNodeFocusListeners) {\n            this._ngZone.runOutsideAngular(() => {\n                rootNode.addEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);\n                rootNode.addEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);\n            });\n        }\n        this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners + 1);\n        // Register global listeners when first element is monitored.\n        if (++this._monitoredElementCount === 1) {\n            // Note: we listen to events in the capture phase so we\n            // can detect them even if the user stops propagation.\n            this._ngZone.runOutsideAngular(() => {\n                const window = this._getWindow();\n                window.addEventListener('focus', this._windowFocusListener);\n            });\n            // The InputModalityDetector is also just a collection of global listeners.\n            this._inputModalityDetector.modalityDetected\n                .pipe(takeUntil(this._stopInputModalityDetector))\n                .subscribe(modality => {\n                this._setOrigin(modality, true /* isFromInteraction */);\n            });\n        }\n    }\n    _removeGlobalListeners(elementInfo) {\n        const rootNode = elementInfo.rootNode;\n        if (this._rootNodeFocusListenerCount.has(rootNode)) {\n            const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode);\n            if (rootNodeFocusListeners > 1) {\n                this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners - 1);\n            }\n            else {\n                rootNode.removeEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);\n                rootNode.removeEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);\n                this._rootNodeFocusListenerCount.delete(rootNode);\n            }\n        }\n        // Unregister global listeners when last element is unmonitored.\n        if (!--this._monitoredElementCount) {\n            const window = this._getWindow();\n            window.removeEventListener('focus', this._windowFocusListener);\n            // Equivalently, stop our InputModalityDetector subscription.\n            this._stopInputModalityDetector.next();\n            // Clear timeouts for all potentially pending timeouts to prevent the leaks.\n            clearTimeout(this._windowFocusTimeoutId);\n            clearTimeout(this._originTimeoutId);\n        }\n    }\n    /** Updates all the state on an element once its focus origin has changed. */\n    _originChanged(element, origin, elementInfo) {\n        this._setClasses(element, origin);\n        this._emitOrigin(elementInfo, origin);\n        this._lastFocusOrigin = origin;\n    }\n    /**\n     * Collects the `MonitoredElementInfo` of a particular element and\n     * all of its ancestors that have enabled `checkChildren`.\n     * @param element Element from which to start the search.\n     */\n    _getClosestElementsInfo(element) {\n        const results = [];\n        this._elementInfo.forEach((info, currentElement) => {\n            if (currentElement === element || (info.checkChildren && currentElement.contains(element))) {\n                results.push([currentElement, info]);\n            }\n        });\n        return results;\n    }\n    /**\n     * Returns whether an interaction is likely to have come from the user clicking the `label` of\n     * an `input` or `textarea` in order to focus it.\n     * @param focusEventTarget Target currently receiving focus.\n     */\n    _isLastInteractionFromInputLabel(focusEventTarget) {\n        const { _mostRecentTarget: mostRecentTarget, mostRecentModality } = this._inputModalityDetector;\n        // If the last interaction used the mouse on an element contained by one of the labels\n        // of an `input`/`textarea` that is currently focused, it is very likely that the\n        // user redirected focus using the label.\n        if (mostRecentModality !== 'mouse' ||\n            !mostRecentTarget ||\n            mostRecentTarget === focusEventTarget ||\n            (focusEventTarget.nodeName !== 'INPUT' && focusEventTarget.nodeName !== 'TEXTAREA') ||\n            focusEventTarget.disabled) {\n            return false;\n        }\n        const labels = focusEventTarget.labels;\n        if (labels) {\n            for (let i = 0; i < labels.length; i++) {\n                if (labels[i].contains(mostRecentTarget)) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: FocusMonitor, deps: [{ token: i0.NgZone }, { token: i1.Platform }, { token: InputModalityDetector }, { token: DOCUMENT, optional: true }, { token: FOCUS_MONITOR_DEFAULT_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: FocusMonitor, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: FocusMonitor, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i1.Platform }, { type: InputModalityDetector }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [FOCUS_MONITOR_DEFAULT_OPTIONS]\n                }] }]; } });\n/**\n * Directive that determines how a particular element was focused (via keyboard, mouse, touch, or\n * programmatically) and adds corresponding classes to the element.\n *\n * There are two variants of this directive:\n * 1) cdkMonitorElementFocus: does not consider an element to be focused if one of its children is\n *    focused.\n * 2) cdkMonitorSubtreeFocus: considers an element focused if it or any of its children are focused.\n */\nclass CdkMonitorFocus {\n    constructor(_elementRef, _focusMonitor) {\n        this._elementRef = _elementRef;\n        this._focusMonitor = _focusMonitor;\n        this._focusOrigin = null;\n        this.cdkFocusChange = new EventEmitter();\n    }\n    get focusOrigin() {\n        return this._focusOrigin;\n    }\n    ngAfterViewInit() {\n        const element = this._elementRef.nativeElement;\n        this._monitorSubscription = this._focusMonitor\n            .monitor(element, element.nodeType === 1 && element.hasAttribute('cdkMonitorSubtreeFocus'))\n            .subscribe(origin => {\n            this._focusOrigin = origin;\n            this.cdkFocusChange.emit(origin);\n        });\n    }\n    ngOnDestroy() {\n        this._focusMonitor.stopMonitoring(this._elementRef);\n        if (this._monitorSubscription) {\n            this._monitorSubscription.unsubscribe();\n        }\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkMonitorFocus, deps: [{ token: i0.ElementRef }, { token: FocusMonitor }], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: CdkMonitorFocus, selector: \"[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]\", outputs: { cdkFocusChange: \"cdkFocusChange\" }, exportAs: [\"cdkMonitorFocus\"], ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkMonitorFocus, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]',\n                    exportAs: 'cdkMonitorFocus',\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: FocusMonitor }]; }, propDecorators: { cdkFocusChange: [{\n                type: Output\n            }] } });\n\n/** CSS class applied to the document body when in black-on-white high-contrast mode. */\nconst BLACK_ON_WHITE_CSS_CLASS = 'cdk-high-contrast-black-on-white';\n/** CSS class applied to the document body when in white-on-black high-contrast mode. */\nconst WHITE_ON_BLACK_CSS_CLASS = 'cdk-high-contrast-white-on-black';\n/** CSS class applied to the document body when in high-contrast mode. */\nconst HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS = 'cdk-high-contrast-active';\n/**\n * Service to determine whether the browser is currently in a high-contrast-mode environment.\n *\n * Microsoft Windows supports an accessibility feature called \"High Contrast Mode\". This mode\n * changes the appearance of all applications, including web applications, to dramatically increase\n * contrast.\n *\n * IE, Edge, and Firefox currently support this mode. Chrome does not support Windows High Contrast\n * Mode. This service does not detect high-contrast mode as added by the Chrome \"High Contrast\"\n * browser extension.\n */\nclass HighContrastModeDetector {\n    constructor(_platform, document) {\n        this._platform = _platform;\n        this._document = document;\n        this._breakpointSubscription = inject(BreakpointObserver)\n            .observe('(forced-colors: active)')\n            .subscribe(() => {\n            if (this._hasCheckedHighContrastMode) {\n                this._hasCheckedHighContrastMode = false;\n                this._applyBodyHighContrastModeCssClasses();\n            }\n        });\n    }\n    /** Gets the current high-contrast-mode for the page. */\n    getHighContrastMode() {\n        if (!this._platform.isBrowser) {\n            return 0 /* HighContrastMode.NONE */;\n        }\n        // Create a test element with an arbitrary background-color that is neither black nor\n        // white; high-contrast mode will coerce the color to either black or white. Also ensure that\n        // appending the test element to the DOM does not affect layout by absolutely positioning it\n        const testElement = this._document.createElement('div');\n        testElement.style.backgroundColor = 'rgb(1,2,3)';\n        testElement.style.position = 'absolute';\n        this._document.body.appendChild(testElement);\n        // Get the computed style for the background color, collapsing spaces to normalize between\n        // browsers. Once we get this color, we no longer need the test element. Access the `window`\n        // via the document so we can fake it in tests. Note that we have extra null checks, because\n        // this logic will likely run during app bootstrap and throwing can break the entire app.\n        const documentWindow = this._document.defaultView || window;\n        const computedStyle = documentWindow && documentWindow.getComputedStyle\n            ? documentWindow.getComputedStyle(testElement)\n            : null;\n        const computedColor = ((computedStyle && computedStyle.backgroundColor) || '').replace(/ /g, '');\n        testElement.remove();\n        switch (computedColor) {\n            // Pre Windows 11 dark theme.\n            case 'rgb(0,0,0)':\n            // Windows 11 dark themes.\n            case 'rgb(45,50,54)':\n            case 'rgb(32,32,32)':\n                return 2 /* HighContrastMode.WHITE_ON_BLACK */;\n            // Pre Windows 11 light theme.\n            case 'rgb(255,255,255)':\n            // Windows 11 light theme.\n            case 'rgb(255,250,239)':\n                return 1 /* HighContrastMode.BLACK_ON_WHITE */;\n        }\n        return 0 /* HighContrastMode.NONE */;\n    }\n    ngOnDestroy() {\n        this._breakpointSubscription.unsubscribe();\n    }\n    /** Applies CSS classes indicating high-contrast mode to document body (browser-only). */\n    _applyBodyHighContrastModeCssClasses() {\n        if (!this._hasCheckedHighContrastMode && this._platform.isBrowser && this._document.body) {\n            const bodyClasses = this._document.body.classList;\n            bodyClasses.remove(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS, BLACK_ON_WHITE_CSS_CLASS, WHITE_ON_BLACK_CSS_CLASS);\n            this._hasCheckedHighContrastMode = true;\n            const mode = this.getHighContrastMode();\n            if (mode === 1 /* HighContrastMode.BLACK_ON_WHITE */) {\n                bodyClasses.add(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS, BLACK_ON_WHITE_CSS_CLASS);\n            }\n            else if (mode === 2 /* HighContrastMode.WHITE_ON_BLACK */) {\n                bodyClasses.add(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS, WHITE_ON_BLACK_CSS_CLASS);\n            }\n        }\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: HighContrastModeDetector, deps: [{ token: i1.Platform }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: HighContrastModeDetector, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: HighContrastModeDetector, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: i1.Platform }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }]; } });\n\nclass A11yModule {\n    constructor(highContrastModeDetector) {\n        highContrastModeDetector._applyBodyHighContrastModeCssClasses();\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: A11yModule, deps: [{ token: HighContrastModeDetector }], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: A11yModule, declarations: [CdkAriaLive, CdkTrapFocus, CdkMonitorFocus], imports: [ObserversModule], exports: [CdkAriaLive, CdkTrapFocus, CdkMonitorFocus] }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: A11yModule, imports: [ObserversModule] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: A11yModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [ObserversModule],\n                    declarations: [CdkAriaLive, CdkTrapFocus, CdkMonitorFocus],\n                    exports: [CdkAriaLive, CdkTrapFocus, CdkMonitorFocus],\n                }]\n        }], ctorParameters: function () { return [{ type: HighContrastModeDetector }]; } });\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { A11yModule, ActiveDescendantKeyManager, AriaDescriber, CDK_DESCRIBEDBY_HOST_ATTRIBUTE, CDK_DESCRIBEDBY_ID_PREFIX, CdkAriaLive, CdkMonitorFocus, CdkTrapFocus, ConfigurableFocusTrap, ConfigurableFocusTrapFactory, EventListenerFocusTrapInertStrategy, FOCUS_MONITOR_DEFAULT_OPTIONS, FOCUS_TRAP_INERT_STRATEGY, FocusKeyManager, FocusMonitor, FocusTrap, FocusTrapFactory, HighContrastModeDetector, INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS, INPUT_MODALITY_DETECTOR_OPTIONS, InputModalityDetector, InteractivityChecker, IsFocusableConfig, LIVE_ANNOUNCER_DEFAULT_OPTIONS, LIVE_ANNOUNCER_ELEMENT_TOKEN, LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY, ListKeyManager, LiveAnnouncer, MESSAGES_CONTAINER_ID, addAriaReferencedId, getAriaReferenceIds, isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader, removeAriaReferencedId };\n","import * as i0 from '@angular/core';\nimport { InjectionToken, inject, EventEmitter, Injectable, Optional, Inject, Directive, Output, Input, NgModule } from '@angular/core';\nimport { DOCUMENT } from '@angular/common';\n\n/**\n * Injection token used to inject the document into Directionality.\n * This is used so that the value can be faked in tests.\n *\n * We can't use the real document in tests because changing the real `dir` causes geometry-based\n * tests in Safari to fail.\n *\n * We also can't re-provide the DOCUMENT token from platform-browser because the unit tests\n * themselves use things like `querySelector` in test code.\n *\n * This token is defined in a separate file from Directionality as a workaround for\n * https://github.com/angular/angular/issues/22559\n *\n * @docs-private\n */\nconst DIR_DOCUMENT = new InjectionToken('cdk-dir-doc', {\n    providedIn: 'root',\n    factory: DIR_DOCUMENT_FACTORY,\n});\n/** @docs-private */\nfunction DIR_DOCUMENT_FACTORY() {\n    return inject(DOCUMENT);\n}\n\n/** Regex that matches locales with an RTL script. Taken from `goog.i18n.bidi.isRtlLanguage`. */\nconst RTL_LOCALE_PATTERN = /^(ar|ckb|dv|he|iw|fa|nqo|ps|sd|ug|ur|yi|.*[-_](Adlm|Arab|Hebr|Nkoo|Rohg|Thaa))(?!.*[-_](Latn|Cyrl)($|-|_))($|-|_)/i;\n/** Resolves a string value to a specific direction. */\nfunction _resolveDirectionality(rawValue) {\n    const value = rawValue?.toLowerCase() || '';\n    if (value === 'auto' && typeof navigator !== 'undefined' && navigator?.language) {\n        return RTL_LOCALE_PATTERN.test(navigator.language) ? 'rtl' : 'ltr';\n    }\n    return value === 'rtl' ? 'rtl' : 'ltr';\n}\n/**\n * The directionality (LTR / RTL) context for the application (or a subtree of it).\n * Exposes the current direction and a stream of direction changes.\n */\nclass Directionality {\n    constructor(_document) {\n        /** The current 'ltr' or 'rtl' value. */\n        this.value = 'ltr';\n        /** Stream that emits whenever the 'ltr' / 'rtl' state changes. */\n        this.change = new EventEmitter();\n        if (_document) {\n            const bodyDir = _document.body ? _document.body.dir : null;\n            const htmlDir = _document.documentElement ? _document.documentElement.dir : null;\n            this.value = _resolveDirectionality(bodyDir || htmlDir || 'ltr');\n        }\n    }\n    ngOnDestroy() {\n        this.change.complete();\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: Directionality, deps: [{ token: DIR_DOCUMENT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: Directionality, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: Directionality, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [DIR_DOCUMENT]\n                }] }]; } });\n\n/**\n * Directive to listen for changes of direction of part of the DOM.\n *\n * Provides itself as Directionality such that descendant directives only need to ever inject\n * Directionality to get the closest direction.\n */\nclass Dir {\n    constructor() {\n        /** Normalized direction that accounts for invalid/unsupported values. */\n        this._dir = 'ltr';\n        /** Whether the `value` has been set to its initial value. */\n        this._isInitialized = false;\n        /** Event emitted when the direction changes. */\n        this.change = new EventEmitter();\n    }\n    /** @docs-private */\n    get dir() {\n        return this._dir;\n    }\n    set dir(value) {\n        const previousValue = this._dir;\n        // Note: `_resolveDirectionality` resolves the language based on the browser's language,\n        // whereas the browser does it based on the content of the element. Since doing so based\n        // on the content can be expensive, for now we're doing the simpler matching.\n        this._dir = _resolveDirectionality(value);\n        this._rawDir = value;\n        if (previousValue !== this._dir && this._isInitialized) {\n            this.change.emit(this._dir);\n        }\n    }\n    /** Current layout direction of the element. */\n    get value() {\n        return this.dir;\n    }\n    /** Initialize once default value has been set. */\n    ngAfterContentInit() {\n        this._isInitialized = true;\n    }\n    ngOnDestroy() {\n        this.change.complete();\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: Dir, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: Dir, selector: \"[dir]\", inputs: { dir: \"dir\" }, outputs: { change: \"dirChange\" }, host: { properties: { \"attr.dir\": \"_rawDir\" } }, providers: [{ provide: Directionality, useExisting: Dir }], exportAs: [\"dir\"], ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: Dir, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[dir]',\n                    providers: [{ provide: Directionality, useExisting: Dir }],\n                    host: { '[attr.dir]': '_rawDir' },\n                    exportAs: 'dir',\n                }]\n        }], propDecorators: { change: [{\n                type: Output,\n                args: ['dirChange']\n            }], dir: [{\n                type: Input\n            }] } });\n\nclass BidiModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: BidiModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: BidiModule, declarations: [Dir], exports: [Dir] }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: BidiModule }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: BidiModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    exports: [Dir],\n                    declarations: [Dir],\n                }]\n        }] });\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { BidiModule, DIR_DOCUMENT, Dir, Directionality };\n","import { ElementRef } from '@angular/core';\n\n/** Coerces a data-bound value (typically a string) to a boolean. */\nfunction coerceBooleanProperty(value) {\n    return value != null && `${value}` !== 'false';\n}\n\nfunction coerceNumberProperty(value, fallbackValue = 0) {\n    return _isNumberValue(value) ? Number(value) : fallbackValue;\n}\n/**\n * Whether the provided value is considered a number.\n * @docs-private\n */\nfunction _isNumberValue(value) {\n    // parseFloat(value) handles most of the cases we're interested in (it treats null, empty string,\n    // and other non-number values as NaN, where Number just uses 0) but it considers the string\n    // '123hello' to be a valid number. Therefore we also check if Number(value) is NaN.\n    return !isNaN(parseFloat(value)) && !isNaN(Number(value));\n}\n\nfunction coerceArray(value) {\n    return Array.isArray(value) ? value : [value];\n}\n\n/** Coerces a value to a CSS pixel value. */\nfunction coerceCssPixelValue(value) {\n    if (value == null) {\n        return '';\n    }\n    return typeof value === 'string' ? value : `${value}px`;\n}\n\n/**\n * Coerces an ElementRef or an Element into an element.\n * Useful for APIs that can accept either a ref or the native element itself.\n */\nfunction coerceElement(elementOrRef) {\n    return elementOrRef instanceof ElementRef ? elementOrRef.nativeElement : elementOrRef;\n}\n\n/**\n * Coerces a value to an array of trimmed non-empty strings.\n * Any input that is not an array, `null` or `undefined` will be turned into a string\n * via `toString()` and subsequently split with the given separator.\n * `null` and `undefined` will result in an empty array.\n * This results in the following outcomes:\n * - `null` -&gt; `[]`\n * - `[null]` -&gt; `[\"null\"]`\n * - `[\"a\", \"b \", \" \"]` -&gt; `[\"a\", \"b\"]`\n * - `[1, [2, 3]]` -&gt; `[\"1\", \"2,3\"]`\n * - `[{ a: 0 }]` -&gt; `[\"[object Object]\"]`\n * - `{ a: 0 }` -&gt; `[\"[object\", \"Object]\"]`\n *\n * Useful for defining CSS classes or table columns.\n * @param value the value to coerce into an array of strings\n * @param separator split-separator if value isn't an array\n */\nfunction coerceStringArray(value, separator = /\\s+/) {\n    const result = [];\n    if (value != null) {\n        const sourceValues = Array.isArray(value) ? value : `${value}`.split(separator);\n        for (const sourceValue of sourceValues) {\n            const trimmedString = `${sourceValue}`.trim();\n            if (trimmedString) {\n                result.push(trimmedString);\n            }\n        }\n    }\n    return result;\n}\n\nexport { _isNumberValue, coerceArray, coerceBooleanProperty, coerceCssPixelValue, coerceElement, coerceNumberProperty, coerceStringArray };\n","const MAC_ENTER = 3;\nconst BACKSPACE = 8;\nconst TAB = 9;\nconst NUM_CENTER = 12;\nconst ENTER = 13;\nconst SHIFT = 16;\nconst CONTROL = 17;\nconst ALT = 18;\nconst PAUSE = 19;\nconst CAPS_LOCK = 20;\nconst ESCAPE = 27;\nconst SPACE = 32;\nconst PAGE_UP = 33;\nconst PAGE_DOWN = 34;\nconst END = 35;\nconst HOME = 36;\nconst LEFT_ARROW = 37;\nconst UP_ARROW = 38;\nconst RIGHT_ARROW = 39;\nconst DOWN_ARROW = 40;\nconst PLUS_SIGN = 43;\nconst PRINT_SCREEN = 44;\nconst INSERT = 45;\nconst DELETE = 46;\nconst ZERO = 48;\nconst ONE = 49;\nconst TWO = 50;\nconst THREE = 51;\nconst FOUR = 52;\nconst FIVE = 53;\nconst SIX = 54;\nconst SEVEN = 55;\nconst EIGHT = 56;\nconst NINE = 57;\nconst FF_SEMICOLON = 59; // Firefox (Gecko) fires this for semicolon instead of 186\nconst FF_EQUALS = 61; // Firefox (Gecko) fires this for equals instead of 187\nconst QUESTION_MARK = 63;\nconst AT_SIGN = 64;\nconst A = 65;\nconst B = 66;\nconst C = 67;\nconst D = 68;\nconst E = 69;\nconst F = 70;\nconst G = 71;\nconst H = 72;\nconst I = 73;\nconst J = 74;\nconst K = 75;\nconst L = 76;\nconst M = 77;\nconst N = 78;\nconst O = 79;\nconst P = 80;\nconst Q = 81;\nconst R = 82;\nconst S = 83;\nconst T = 84;\nconst U = 85;\nconst V = 86;\nconst W = 87;\nconst X = 88;\nconst Y = 89;\nconst Z = 90;\nconst META = 91; // WIN_KEY_LEFT\nconst MAC_WK_CMD_LEFT = 91;\nconst MAC_WK_CMD_RIGHT = 93;\nconst CONTEXT_MENU = 93;\nconst NUMPAD_ZERO = 96;\nconst NUMPAD_ONE = 97;\nconst NUMPAD_TWO = 98;\nconst NUMPAD_THREE = 99;\nconst NUMPAD_FOUR = 100;\nconst NUMPAD_FIVE = 101;\nconst NUMPAD_SIX = 102;\nconst NUMPAD_SEVEN = 103;\nconst NUMPAD_EIGHT = 104;\nconst NUMPAD_NINE = 105;\nconst NUMPAD_MULTIPLY = 106;\nconst NUMPAD_PLUS = 107;\nconst NUMPAD_MINUS = 109;\nconst NUMPAD_PERIOD = 110;\nconst NUMPAD_DIVIDE = 111;\nconst F1 = 112;\nconst F2 = 113;\nconst F3 = 114;\nconst F4 = 115;\nconst F5 = 116;\nconst F6 = 117;\nconst F7 = 118;\nconst F8 = 119;\nconst F9 = 120;\nconst F10 = 121;\nconst F11 = 122;\nconst F12 = 123;\nconst NUM_LOCK = 144;\nconst SCROLL_LOCK = 145;\nconst FIRST_MEDIA = 166;\nconst FF_MINUS = 173;\nconst MUTE = 173; // Firefox (Gecko) fires 181 for MUTE\nconst VOLUME_DOWN = 174; // Firefox (Gecko) fires 182 for VOLUME_DOWN\nconst VOLUME_UP = 175; // Firefox (Gecko) fires 183 for VOLUME_UP\nconst FF_MUTE = 181;\nconst FF_VOLUME_DOWN = 182;\nconst LAST_MEDIA = 183;\nconst FF_VOLUME_UP = 183;\nconst SEMICOLON = 186; // Firefox (Gecko) fires 59 for SEMICOLON\nconst EQUALS = 187; // Firefox (Gecko) fires 61 for EQUALS\nconst COMMA = 188;\nconst DASH = 189; // Firefox (Gecko) fires 173 for DASH/MINUS\nconst PERIOD = 190;\nconst SLASH = 191;\nconst APOSTROPHE = 192;\nconst TILDE = 192;\nconst OPEN_SQUARE_BRACKET = 219;\nconst BACKSLASH = 220;\nconst CLOSE_SQUARE_BRACKET = 221;\nconst SINGLE_QUOTE = 222;\nconst MAC_META = 224;\n\n/**\n * Checks whether a modifier key is pressed.\n * @param event Event to be checked.\n */\nfunction hasModifierKey(event, ...modifiers) {\n    if (modifiers.length) {\n        return modifiers.some(modifier => event[modifier]);\n    }\n    return event.altKey || event.shiftKey || event.ctrlKey || event.metaKey;\n}\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { A, ALT, APOSTROPHE, AT_SIGN, B, BACKSLASH, BACKSPACE, C, CAPS_LOCK, CLOSE_SQUARE_BRACKET, COMMA, CONTEXT_MENU, CONTROL, D, DASH, DELETE, DOWN_ARROW, E, EIGHT, END, ENTER, EQUALS, ESCAPE, F, F1, F10, F11, F12, F2, F3, F4, F5, F6, F7, F8, F9, FF_EQUALS, FF_MINUS, FF_MUTE, FF_SEMICOLON, FF_VOLUME_DOWN, FF_VOLUME_UP, FIRST_MEDIA, FIVE, FOUR, G, H, HOME, I, INSERT, J, K, L, LAST_MEDIA, LEFT_ARROW, M, MAC_ENTER, MAC_META, MAC_WK_CMD_LEFT, MAC_WK_CMD_RIGHT, META, MUTE, N, NINE, NUMPAD_DIVIDE, NUMPAD_EIGHT, NUMPAD_FIVE, NUMPAD_FOUR, NUMPAD_MINUS, NUMPAD_MULTIPLY, NUMPAD_NINE, NUMPAD_ONE, NUMPAD_PERIOD, NUMPAD_PLUS, NUMPAD_SEVEN, NUMPAD_SIX, NUMPAD_THREE, NUMPAD_TWO, NUMPAD_ZERO, NUM_CENTER, NUM_LOCK, O, ONE, OPEN_SQUARE_BRACKET, P, PAGE_DOWN, PAGE_UP, PAUSE, PERIOD, PLUS_SIGN, PRINT_SCREEN, Q, QUESTION_MARK, R, RIGHT_ARROW, S, SCROLL_LOCK, SEMICOLON, SEVEN, SHIFT, SINGLE_QUOTE, SIX, SLASH, SPACE, T, TAB, THREE, TILDE, TWO, U, UP_ARROW, V, VOLUME_DOWN, VOLUME_UP, W, X, Y, Z, ZERO, hasModifierKey };\n","import * as i0 from '@angular/core';\nimport { NgModule, CSP_NONCE, Injectable, Optional, Inject } from '@angular/core';\nimport { coerceArray } from '@angular/cdk/coercion';\nimport { Subject, combineLatest, concat, Observable } from 'rxjs';\nimport { take, skip, debounceTime, map, startWith, takeUntil } from 'rxjs/operators';\nimport * as i1 from '@angular/cdk/platform';\n\nclass LayoutModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: LayoutModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: LayoutModule }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: LayoutModule }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: LayoutModule, decorators: [{\n            type: NgModule,\n            args: [{}]\n        }] });\n\n/** Global registry for all dynamically-created, injected media queries. */\nconst mediaQueriesForWebkitCompatibility = new Set();\n/** Style tag that holds all of the dynamically-created media queries. */\nlet mediaQueryStyleNode;\n/** A utility for calling matchMedia queries. */\nclass MediaMatcher {\n    constructor(_platform, _nonce) {\n        this._platform = _platform;\n        this._nonce = _nonce;\n        this._matchMedia =\n            this._platform.isBrowser && window.matchMedia\n                ? // matchMedia is bound to the window scope intentionally as it is an illegal invocation to\n                    // call it from a different scope.\n                    window.matchMedia.bind(window)\n                : noopMatchMedia;\n    }\n    /**\n     * Evaluates the given media query and returns the native MediaQueryList from which results\n     * can be retrieved.\n     * Confirms the layout engine will trigger for the selector query provided and returns the\n     * MediaQueryList for the query provided.\n     */\n    matchMedia(query) {\n        if (this._platform.WEBKIT || this._platform.BLINK) {\n            createEmptyStyleRule(query, this._nonce);\n        }\n        return this._matchMedia(query);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MediaMatcher, deps: [{ token: i1.Platform }, { token: CSP_NONCE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MediaMatcher, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MediaMatcher, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: i1.Platform }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [CSP_NONCE]\n                }] }]; } });\n/**\n * Creates an empty stylesheet that is used to work around browser inconsistencies related to\n * `matchMedia`. At the time of writing, it handles the following cases:\n * 1. On WebKit browsers, a media query has to have at least one rule in order for `matchMedia`\n * to fire. We work around it by declaring a dummy stylesheet with a `@media` declaration.\n * 2. In some cases Blink browsers will stop firing the `matchMedia` listener if none of the rules\n * inside the `@media` match existing elements on the page. We work around it by having one rule\n * targeting the `body`. See https://github.com/angular/components/issues/23546.\n */\nfunction createEmptyStyleRule(query, nonce) {\n    if (mediaQueriesForWebkitCompatibility.has(query)) {\n        return;\n    }\n    try {\n        if (!mediaQueryStyleNode) {\n            mediaQueryStyleNode = document.createElement('style');\n            if (nonce) {\n                mediaQueryStyleNode.nonce = nonce;\n            }\n            mediaQueryStyleNode.setAttribute('type', 'text/css');\n            document.head.appendChild(mediaQueryStyleNode);\n        }\n        if (mediaQueryStyleNode.sheet) {\n            mediaQueryStyleNode.sheet.insertRule(`@media ${query} {body{ }}`, 0);\n            mediaQueriesForWebkitCompatibility.add(query);\n        }\n    }\n    catch (e) {\n        console.error(e);\n    }\n}\n/** No-op matchMedia replacement for non-browser platforms. */\nfunction noopMatchMedia(query) {\n    // Use `as any` here to avoid adding additional necessary properties for\n    // the noop matcher.\n    return {\n        matches: query === 'all' || query === '',\n        media: query,\n        addListener: () => { },\n        removeListener: () => { },\n    };\n}\n\n/** Utility for checking the matching state of @media queries. */\nclass BreakpointObserver {\n    constructor(_mediaMatcher, _zone) {\n        this._mediaMatcher = _mediaMatcher;\n        this._zone = _zone;\n        /**  A map of all media queries currently being listened for. */\n        this._queries = new Map();\n        /** A subject for all other observables to takeUntil based on. */\n        this._destroySubject = new Subject();\n    }\n    /** Completes the active subject, signalling to all other observables to complete. */\n    ngOnDestroy() {\n        this._destroySubject.next();\n        this._destroySubject.complete();\n    }\n    /**\n     * Whether one or more media queries match the current viewport size.\n     * @param value One or more media queries to check.\n     * @returns Whether any of the media queries match.\n     */\n    isMatched(value) {\n        const queries = splitQueries(coerceArray(value));\n        return queries.some(mediaQuery => this._registerQuery(mediaQuery).mql.matches);\n    }\n    /**\n     * Gets an observable of results for the given queries that will emit new results for any changes\n     * in matching of the given queries.\n     * @param value One or more media queries to check.\n     * @returns A stream of matches for the given queries.\n     */\n    observe(value) {\n        const queries = splitQueries(coerceArray(value));\n        const observables = queries.map(query => this._registerQuery(query).observable);\n        let stateObservable = combineLatest(observables);\n        // Emit the first state immediately, and then debounce the subsequent emissions.\n        stateObservable = concat(stateObservable.pipe(take(1)), stateObservable.pipe(skip(1), debounceTime(0)));\n        return stateObservable.pipe(map(breakpointStates => {\n            const response = {\n                matches: false,\n                breakpoints: {},\n            };\n            breakpointStates.forEach(({ matches, query }) => {\n                response.matches = response.matches || matches;\n                response.breakpoints[query] = matches;\n            });\n            return response;\n        }));\n    }\n    /** Registers a specific query to be listened for. */\n    _registerQuery(query) {\n        // Only set up a new MediaQueryList if it is not already being listened for.\n        if (this._queries.has(query)) {\n            return this._queries.get(query);\n        }\n        const mql = this._mediaMatcher.matchMedia(query);\n        // Create callback for match changes and add it is as a listener.\n        const queryObservable = new Observable((observer) => {\n            // Listener callback methods are wrapped to be placed back in ngZone. Callbacks must be placed\n            // back into the zone because matchMedia is only included in Zone.js by loading the\n            // webapis-media-query.js file alongside the zone.js file.  Additionally, some browsers do not\n            // have MediaQueryList inherit from EventTarget, which causes inconsistencies in how Zone.js\n            // patches it.\n            const handler = (e) => this._zone.run(() => observer.next(e));\n            mql.addListener(handler);\n            return () => {\n                mql.removeListener(handler);\n            };\n        }).pipe(startWith(mql), map(({ matches }) => ({ query, matches })), takeUntil(this._destroySubject));\n        // Add the MediaQueryList to the set of queries.\n        const output = { observable: queryObservable, mql };\n        this._queries.set(query, output);\n        return output;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: BreakpointObserver, deps: [{ token: MediaMatcher }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: BreakpointObserver, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: BreakpointObserver, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: MediaMatcher }, { type: i0.NgZone }]; } });\n/**\n * Split each query string into separate query strings if two queries are provided as comma\n * separated.\n */\nfunction splitQueries(queries) {\n    return queries\n        .map(query => query.split(','))\n        .reduce((a1, a2) => a1.concat(a2))\n        .map(query => query.trim());\n}\n\n// PascalCase is being used as Breakpoints is used like an enum.\n// tslint:disable-next-line:variable-name\nconst Breakpoints = {\n    XSmall: '(max-width: 599.98px)',\n    Small: '(min-width: 600px) and (max-width: 959.98px)',\n    Medium: '(min-width: 960px) and (max-width: 1279.98px)',\n    Large: '(min-width: 1280px) and (max-width: 1919.98px)',\n    XLarge: '(min-width: 1920px)',\n    Handset: '(max-width: 599.98px) and (orientation: portrait), ' +\n        '(max-width: 959.98px) and (orientation: landscape)',\n    Tablet: '(min-width: 600px) and (max-width: 839.98px) and (orientation: portrait), ' +\n        '(min-width: 960px) and (max-width: 1279.98px) and (orientation: landscape)',\n    Web: '(min-width: 840px) and (orientation: portrait), ' +\n        '(min-width: 1280px) and (orientation: landscape)',\n    HandsetPortrait: '(max-width: 599.98px) and (orientation: portrait)',\n    TabletPortrait: '(min-width: 600px) and (max-width: 839.98px) and (orientation: portrait)',\n    WebPortrait: '(min-width: 840px) and (orientation: portrait)',\n    HandsetLandscape: '(max-width: 959.98px) and (orientation: landscape)',\n    TabletLandscape: '(min-width: 960px) and (max-width: 1279.98px) and (orientation: landscape)',\n    WebLandscape: '(min-width: 1280px) and (orientation: landscape)',\n};\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { BreakpointObserver, Breakpoints, LayoutModule, MediaMatcher };\n","import { coerceElement, coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';\nimport * as i0 from '@angular/core';\nimport { Injectable, EventEmitter, Directive, Output, Input, NgModule } from '@angular/core';\nimport { Observable, Subject } from 'rxjs';\nimport { debounceTime } from 'rxjs/operators';\n\n/**\n * Factory that creates a new MutationObserver and allows us to stub it out in unit tests.\n * @docs-private\n */\nclass MutationObserverFactory {\n    create(callback) {\n        return typeof MutationObserver === 'undefined' ? null : new MutationObserver(callback);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MutationObserverFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MutationObserverFactory, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MutationObserverFactory, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }] });\n/** An injectable service that allows watching elements for changes to their content. */\nclass ContentObserver {\n    constructor(_mutationObserverFactory) {\n        this._mutationObserverFactory = _mutationObserverFactory;\n        /** Keeps track of the existing MutationObservers so they can be reused. */\n        this._observedElements = new Map();\n    }\n    ngOnDestroy() {\n        this._observedElements.forEach((_, element) => this._cleanupObserver(element));\n    }\n    observe(elementOrRef) {\n        const element = coerceElement(elementOrRef);\n        return new Observable((observer) => {\n            const stream = this._observeElement(element);\n            const subscription = stream.subscribe(observer);\n            return () => {\n                subscription.unsubscribe();\n                this._unobserveElement(element);\n            };\n        });\n    }\n    /**\n     * Observes the given element by using the existing MutationObserver if available, or creating a\n     * new one if not.\n     */\n    _observeElement(element) {\n        if (!this._observedElements.has(element)) {\n            const stream = new Subject();\n            const observer = this._mutationObserverFactory.create(mutations => stream.next(mutations));\n            if (observer) {\n                observer.observe(element, {\n                    characterData: true,\n                    childList: true,\n                    subtree: true,\n                });\n            }\n            this._observedElements.set(element, { observer, stream, count: 1 });\n        }\n        else {\n            this._observedElements.get(element).count++;\n        }\n        return this._observedElements.get(element).stream;\n    }\n    /**\n     * Un-observes the given element and cleans up the underlying MutationObserver if nobody else is\n     * observing this element.\n     */\n    _unobserveElement(element) {\n        if (this._observedElements.has(element)) {\n            this._observedElements.get(element).count--;\n            if (!this._observedElements.get(element).count) {\n                this._cleanupObserver(element);\n            }\n        }\n    }\n    /** Clean up the underlying MutationObserver for the specified element. */\n    _cleanupObserver(element) {\n        if (this._observedElements.has(element)) {\n            const { observer, stream } = this._observedElements.get(element);\n            if (observer) {\n                observer.disconnect();\n            }\n            stream.complete();\n            this._observedElements.delete(element);\n        }\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ContentObserver, deps: [{ token: MutationObserverFactory }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ContentObserver, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ContentObserver, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: MutationObserverFactory }]; } });\n/**\n * Directive that triggers a callback whenever the content of\n * its associated element has changed.\n */\nclass CdkObserveContent {\n    /**\n     * Whether observing content is disabled. This option can be used\n     * to disconnect the underlying MutationObserver until it is needed.\n     */\n    get disabled() {\n        return this._disabled;\n    }\n    set disabled(value) {\n        this._disabled = coerceBooleanProperty(value);\n        this._disabled ? this._unsubscribe() : this._subscribe();\n    }\n    /** Debounce interval for emitting the changes. */\n    get debounce() {\n        return this._debounce;\n    }\n    set debounce(value) {\n        this._debounce = coerceNumberProperty(value);\n        this._subscribe();\n    }\n    constructor(_contentObserver, _elementRef, _ngZone) {\n        this._contentObserver = _contentObserver;\n        this._elementRef = _elementRef;\n        this._ngZone = _ngZone;\n        /** Event emitted for each change in the element's content. */\n        this.event = new EventEmitter();\n        this._disabled = false;\n        this._currentSubscription = null;\n    }\n    ngAfterContentInit() {\n        if (!this._currentSubscription && !this.disabled) {\n            this._subscribe();\n        }\n    }\n    ngOnDestroy() {\n        this._unsubscribe();\n    }\n    _subscribe() {\n        this._unsubscribe();\n        const stream = this._contentObserver.observe(this._elementRef);\n        // TODO(mmalerba): We shouldn't be emitting on this @Output() outside the zone.\n        // Consider brining it back inside the zone next time we're making breaking changes.\n        // Bringing it back inside can cause things like infinite change detection loops and changed\n        // after checked errors if people's code isn't handling it properly.\n        this._ngZone.runOutsideAngular(() => {\n            this._currentSubscription = (this.debounce ? stream.pipe(debounceTime(this.debounce)) : stream).subscribe(this.event);\n        });\n    }\n    _unsubscribe() {\n        this._currentSubscription?.unsubscribe();\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkObserveContent, deps: [{ token: ContentObserver }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: CdkObserveContent, selector: \"[cdkObserveContent]\", inputs: { disabled: [\"cdkObserveContentDisabled\", \"disabled\"], debounce: \"debounce\" }, outputs: { event: \"cdkObserveContent\" }, exportAs: [\"cdkObserveContent\"], ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkObserveContent, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdkObserveContent]',\n                    exportAs: 'cdkObserveContent',\n                }]\n        }], ctorParameters: function () { return [{ type: ContentObserver }, { type: i0.ElementRef }, { type: i0.NgZone }]; }, propDecorators: { event: [{\n                type: Output,\n                args: ['cdkObserveContent']\n            }], disabled: [{\n                type: Input,\n                args: ['cdkObserveContentDisabled']\n            }], debounce: [{\n                type: Input\n            }] } });\nclass ObserversModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ObserversModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: ObserversModule, declarations: [CdkObserveContent], exports: [CdkObserveContent] }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ObserversModule, providers: [MutationObserverFactory] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ObserversModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    exports: [CdkObserveContent],\n                    declarations: [CdkObserveContent],\n                    providers: [MutationObserverFactory],\n                }]\n        }] });\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { CdkObserveContent, ContentObserver, MutationObserverFactory, ObserversModule };\n","import * as i0 from '@angular/core';\nimport { PLATFORM_ID, Injectable, Inject, NgModule } from '@angular/core';\nimport { isPlatformBrowser } from '@angular/common';\n\n// Whether the current platform supports the V8 Break Iterator. The V8 check\n// is necessary to detect all Blink based browsers.\nlet hasV8BreakIterator;\n// We need a try/catch around the reference to `Intl`, because accessing it in some cases can\n// cause IE to throw. These cases are tied to particular versions of Windows and can happen if\n// the consumer is providing a polyfilled `Map`. See:\n// https://github.com/Microsoft/ChakraCore/issues/3189\n// https://github.com/angular/components/issues/15687\ntry {\n    hasV8BreakIterator = typeof Intl !== 'undefined' && Intl.v8BreakIterator;\n}\ncatch {\n    hasV8BreakIterator = false;\n}\n/**\n * Service to detect the current platform by comparing the userAgent strings and\n * checking browser-specific global properties.\n */\nclass Platform {\n    constructor(_platformId) {\n        this._platformId = _platformId;\n        // We want to use the Angular platform check because if the Document is shimmed\n        // without the navigator, the following checks will fail. This is preferred because\n        // sometimes the Document may be shimmed without the user's knowledge or intention\n        /** Whether the Angular application is being rendered in the browser. */\n        this.isBrowser = this._platformId\n            ? isPlatformBrowser(this._platformId)\n            : typeof document === 'object' && !!document;\n        /** Whether the current browser is Microsoft Edge. */\n        this.EDGE = this.isBrowser && /(edge)/i.test(navigator.userAgent);\n        /** Whether the current rendering engine is Microsoft Trident. */\n        this.TRIDENT = this.isBrowser && /(msie|trident)/i.test(navigator.userAgent);\n        // EdgeHTML and Trident mock Blink specific things and need to be excluded from this check.\n        /** Whether the current rendering engine is Blink. */\n        this.BLINK = this.isBrowser &&\n            !!(window.chrome || hasV8BreakIterator) &&\n            typeof CSS !== 'undefined' &&\n            !this.EDGE &&\n            !this.TRIDENT;\n        // Webkit is part of the userAgent in EdgeHTML, Blink and Trident. Therefore we need to\n        // ensure that Webkit runs standalone and is not used as another engine's base.\n        /** Whether the current rendering engine is WebKit. */\n        this.WEBKIT = this.isBrowser &&\n            /AppleWebKit/i.test(navigator.userAgent) &&\n            !this.BLINK &&\n            !this.EDGE &&\n            !this.TRIDENT;\n        /** Whether the current platform is Apple iOS. */\n        this.IOS = this.isBrowser && /iPad|iPhone|iPod/.test(navigator.userAgent) && !('MSStream' in window);\n        // It's difficult to detect the plain Gecko engine, because most of the browsers identify\n        // them self as Gecko-like browsers and modify the userAgent's according to that.\n        // Since we only cover one explicit Firefox case, we can simply check for Firefox\n        // instead of having an unstable check for Gecko.\n        /** Whether the current browser is Firefox. */\n        this.FIREFOX = this.isBrowser && /(firefox|minefield)/i.test(navigator.userAgent);\n        /** Whether the current platform is Android. */\n        // Trident on mobile adds the android platform to the userAgent to trick detections.\n        this.ANDROID = this.isBrowser && /android/i.test(navigator.userAgent) && !this.TRIDENT;\n        // Safari browsers will include the Safari keyword in their userAgent. Some browsers may fake\n        // this and just place the Safari keyword in the userAgent. To be more safe about Safari every\n        // Safari browser should also use Webkit as its layout engine.\n        /** Whether the current browser is Safari. */\n        this.SAFARI = this.isBrowser && /safari/i.test(navigator.userAgent) && this.WEBKIT;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: Platform, deps: [{ token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: Platform, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: Platform, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: Object, decorators: [{\n                    type: Inject,\n                    args: [PLATFORM_ID]\n                }] }]; } });\n\nclass PlatformModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: PlatformModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: PlatformModule }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: PlatformModule }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: PlatformModule, decorators: [{\n            type: NgModule,\n            args: [{}]\n        }] });\n\n/** Cached result Set of input types support by the current browser. */\nlet supportedInputTypes;\n/** Types of `<input>` that *might* be supported. */\nconst candidateInputTypes = [\n    // `color` must come first. Chrome 56 shows a warning if we change the type to `color` after\n    // first changing it to something else:\n    // The specified value \"\" does not conform to the required format.\n    // The format is \"#rrggbb\" where rr, gg, bb are two-digit hexadecimal numbers.\n    'color',\n    'button',\n    'checkbox',\n    'date',\n    'datetime-local',\n    'email',\n    'file',\n    'hidden',\n    'image',\n    'month',\n    'number',\n    'password',\n    'radio',\n    'range',\n    'reset',\n    'search',\n    'submit',\n    'tel',\n    'text',\n    'time',\n    'url',\n    'week',\n];\n/** @returns The input types supported by this browser. */\nfunction getSupportedInputTypes() {\n    // Result is cached.\n    if (supportedInputTypes) {\n        return supportedInputTypes;\n    }\n    // We can't check if an input type is not supported until we're on the browser, so say that\n    // everything is supported when not on the browser. We don't use `Platform` here since it's\n    // just a helper function and can't inject it.\n    if (typeof document !== 'object' || !document) {\n        supportedInputTypes = new Set(candidateInputTypes);\n        return supportedInputTypes;\n    }\n    let featureTestInput = document.createElement('input');\n    supportedInputTypes = new Set(candidateInputTypes.filter(value => {\n        featureTestInput.setAttribute('type', value);\n        return featureTestInput.type === value;\n    }));\n    return supportedInputTypes;\n}\n\n/** Cached result of whether the user's browser supports passive event listeners. */\nlet supportsPassiveEvents;\n/**\n * Checks whether the user's browser supports passive event listeners.\n * See: https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md\n */\nfunction supportsPassiveEventListeners() {\n    if (supportsPassiveEvents == null && typeof window !== 'undefined') {\n        try {\n            window.addEventListener('test', null, Object.defineProperty({}, 'passive', {\n                get: () => (supportsPassiveEvents = true),\n            }));\n        }\n        finally {\n            supportsPassiveEvents = supportsPassiveEvents || false;\n        }\n    }\n    return supportsPassiveEvents;\n}\n/**\n * Normalizes an `AddEventListener` object to something that can be passed\n * to `addEventListener` on any browser, no matter whether it supports the\n * `options` parameter.\n * @param options Object to be normalized.\n */\nfunction normalizePassiveListenerOptions(options) {\n    return supportsPassiveEventListeners() ? options : !!options.capture;\n}\n\n/** Cached result of the way the browser handles the horizontal scroll axis in RTL mode. */\nlet rtlScrollAxisType;\n/** Cached result of the check that indicates whether the browser supports scroll behaviors. */\nlet scrollBehaviorSupported;\n/** Check whether the browser supports scroll behaviors. */\nfunction supportsScrollBehavior() {\n    if (scrollBehaviorSupported == null) {\n        // If we're not in the browser, it can't be supported. Also check for `Element`, because\n        // some projects stub out the global `document` during SSR which can throw us off.\n        if (typeof document !== 'object' || !document || typeof Element !== 'function' || !Element) {\n            scrollBehaviorSupported = false;\n            return scrollBehaviorSupported;\n        }\n        // If the element can have a `scrollBehavior` style, we can be sure that it's supported.\n        if ('scrollBehavior' in document.documentElement.style) {\n            scrollBehaviorSupported = true;\n        }\n        else {\n            // At this point we have 3 possibilities: `scrollTo` isn't supported at all, it's\n            // supported but it doesn't handle scroll behavior, or it has been polyfilled.\n            const scrollToFunction = Element.prototype.scrollTo;\n            if (scrollToFunction) {\n                // We can detect if the function has been polyfilled by calling `toString` on it. Native\n                // functions are obfuscated using `[native code]`, whereas if it was overwritten we'd get\n                // the actual function source. Via https://davidwalsh.name/detect-native-function. Consider\n                // polyfilled functions as supporting scroll behavior.\n                scrollBehaviorSupported = !/\\{\\s*\\[native code\\]\\s*\\}/.test(scrollToFunction.toString());\n            }\n            else {\n                scrollBehaviorSupported = false;\n            }\n        }\n    }\n    return scrollBehaviorSupported;\n}\n/**\n * Checks the type of RTL scroll axis used by this browser. As of time of writing, Chrome is NORMAL,\n * Firefox & Safari are NEGATED, and IE & Edge are INVERTED.\n */\nfunction getRtlScrollAxisType() {\n    // We can't check unless we're on the browser. Just assume 'normal' if we're not.\n    if (typeof document !== 'object' || !document) {\n        return 0 /* RtlScrollAxisType.NORMAL */;\n    }\n    if (rtlScrollAxisType == null) {\n        // Create a 1px wide scrolling container and a 2px wide content element.\n        const scrollContainer = document.createElement('div');\n        const containerStyle = scrollContainer.style;\n        scrollContainer.dir = 'rtl';\n        containerStyle.width = '1px';\n        containerStyle.overflow = 'auto';\n        containerStyle.visibility = 'hidden';\n        containerStyle.pointerEvents = 'none';\n        containerStyle.position = 'absolute';\n        const content = document.createElement('div');\n        const contentStyle = content.style;\n        contentStyle.width = '2px';\n        contentStyle.height = '1px';\n        scrollContainer.appendChild(content);\n        document.body.appendChild(scrollContainer);\n        rtlScrollAxisType = 0 /* RtlScrollAxisType.NORMAL */;\n        // The viewport starts scrolled all the way to the right in RTL mode. If we are in a NORMAL\n        // browser this would mean that the scrollLeft should be 1. If it's zero instead we know we're\n        // dealing with one of the other two types of browsers.\n        if (scrollContainer.scrollLeft === 0) {\n            // In a NEGATED browser the scrollLeft is always somewhere in [-maxScrollAmount, 0]. For an\n            // INVERTED browser it is always somewhere in [0, maxScrollAmount]. We can determine which by\n            // setting to the scrollLeft to 1. This is past the max for a NEGATED browser, so it will\n            // return 0 when we read it again.\n            scrollContainer.scrollLeft = 1;\n            rtlScrollAxisType =\n                scrollContainer.scrollLeft === 0 ? 1 /* RtlScrollAxisType.NEGATED */ : 2 /* RtlScrollAxisType.INVERTED */;\n        }\n        scrollContainer.remove();\n    }\n    return rtlScrollAxisType;\n}\n\nlet shadowDomIsSupported;\n/** Checks whether the user's browser support Shadow DOM. */\nfunction _supportsShadowDom() {\n    if (shadowDomIsSupported == null) {\n        const head = typeof document !== 'undefined' ? document.head : null;\n        shadowDomIsSupported = !!(head && (head.createShadowRoot || head.attachShadow));\n    }\n    return shadowDomIsSupported;\n}\n/** Gets the shadow root of an element, if supported and the element is inside the Shadow DOM. */\nfunction _getShadowRoot(element) {\n    if (_supportsShadowDom()) {\n        const rootNode = element.getRootNode ? element.getRootNode() : null;\n        // Note that this should be caught by `_supportsShadowDom`, but some\n        // teams have been able to hit this code path on unsupported browsers.\n        if (typeof ShadowRoot !== 'undefined' && ShadowRoot && rootNode instanceof ShadowRoot) {\n            return rootNode;\n        }\n    }\n    return null;\n}\n/**\n * Gets the currently-focused element on the page while\n * also piercing through Shadow DOM boundaries.\n */\nfunction _getFocusedElementPierceShadowDom() {\n    let activeElement = typeof document !== 'undefined' && document\n        ? document.activeElement\n        : null;\n    while (activeElement && activeElement.shadowRoot) {\n        const newActiveElement = activeElement.shadowRoot.activeElement;\n        if (newActiveElement === activeElement) {\n            break;\n        }\n        else {\n            activeElement = newActiveElement;\n        }\n    }\n    return activeElement;\n}\n/** Gets the target of an event while accounting for Shadow DOM. */\nfunction _getEventTarget(event) {\n    // If an event is bound outside the Shadow DOM, the `event.target` will\n    // point to the shadow root so we have to use `composedPath` instead.\n    return (event.composedPath ? event.composedPath()[0] : event.target);\n}\n\n/** Gets whether the code is currently running in a test environment. */\nfunction _isTestEnvironment() {\n    // We can't use `declare const` because it causes conflicts inside Google with the real typings\n    // for these symbols and we can't read them off the global object, because they don't appear to\n    // be attached there for some runners like Jest.\n    // (see: https://github.com/angular/components/issues/23365#issuecomment-938146643)\n    return (\n    // @ts-ignore\n    (typeof __karma__ !== 'undefined' && !!__karma__) ||\n        // @ts-ignore\n        (typeof jasmine !== 'undefined' && !!jasmine) ||\n        // @ts-ignore\n        (typeof jest !== 'undefined' && !!jest) ||\n        // @ts-ignore\n        (typeof Mocha !== 'undefined' && !!Mocha));\n}\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { Platform, PlatformModule, _getEventTarget, _getFocusedElementPierceShadowDom, _getShadowRoot, _isTestEnvironment, _supportsShadowDom, getRtlScrollAxisType, getSupportedInputTypes, normalizePassiveListenerOptions, supportsPassiveEventListeners, supportsScrollBehavior };\n","import * as i0 from '@angular/core';\nimport { Version, InjectionToken, inject, NgModule, Optional, Inject, LOCALE_ID, Injectable, Directive, Input, Component, ViewEncapsulation, ChangeDetectionStrategy, EventEmitter, Output, ViewChild, ANIMATION_MODULE_TYPE as ANIMATION_MODULE_TYPE$1, NgZone, ElementRef } from '@angular/core';\nimport * as i1 from '@angular/cdk/a11y';\nimport { isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader } from '@angular/cdk/a11y';\nimport { BidiModule } from '@angular/cdk/bidi';\nimport { VERSION as VERSION$1 } from '@angular/cdk';\nimport * as i3 from '@angular/common';\nimport { DOCUMENT, CommonModule } from '@angular/common';\nimport * as i1$1 from '@angular/cdk/platform';\nimport { Platform, _isTestEnvironment, normalizePassiveListenerOptions, _getEventTarget } from '@angular/cdk/platform';\nimport { coerceBooleanProperty, coerceNumberProperty, coerceElement } from '@angular/cdk/coercion';\nimport { Observable, Subject } from 'rxjs';\nimport { startWith } from 'rxjs/operators';\nimport { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';\nimport { ENTER, SPACE, hasModifierKey } from '@angular/cdk/keycodes';\n\n/** Current version of Angular Material. */\nconst VERSION = new Version('16.2.11');\n\n/** @docs-private */\nclass AnimationCurves {\n    static { this.STANDARD_CURVE = 'cubic-bezier(0.4,0.0,0.2,1)'; }\n    static { this.DECELERATION_CURVE = 'cubic-bezier(0.0,0.0,0.2,1)'; }\n    static { this.ACCELERATION_CURVE = 'cubic-bezier(0.4,0.0,1,1)'; }\n    static { this.SHARP_CURVE = 'cubic-bezier(0.4,0.0,0.6,1)'; }\n}\n/** @docs-private */\nclass AnimationDurations {\n    static { this.COMPLEX = '375ms'; }\n    static { this.ENTERING = '225ms'; }\n    static { this.EXITING = '195ms'; }\n}\n\n/** @docs-private */\nfunction MATERIAL_SANITY_CHECKS_FACTORY() {\n    return true;\n}\n/** Injection token that configures whether the Material sanity checks are enabled. */\nconst MATERIAL_SANITY_CHECKS = new InjectionToken('mat-sanity-checks', {\n    providedIn: 'root',\n    factory: MATERIAL_SANITY_CHECKS_FACTORY,\n});\n/**\n * Module that captures anything that should be loaded and/or run for *all* Angular Material\n * components. This includes Bidi, etc.\n *\n * This module should be imported to each top-level component module (e.g., MatTabsModule).\n */\nclass MatCommonModule {\n    constructor(highContrastModeDetector, _sanityChecks, _document) {\n        this._sanityChecks = _sanityChecks;\n        this._document = _document;\n        /** Whether we've done the global sanity checks (e.g. a theme is loaded, there is a doctype). */\n        this._hasDoneGlobalChecks = false;\n        // While A11yModule also does this, we repeat it here to avoid importing A11yModule\n        // in MatCommonModule.\n        highContrastModeDetector._applyBodyHighContrastModeCssClasses();\n        if (!this._hasDoneGlobalChecks) {\n            this._hasDoneGlobalChecks = true;\n            if (typeof ngDevMode === 'undefined' || ngDevMode) {\n                // Inject in here so the reference to `Platform` can be removed in production mode.\n                const platform = inject(Platform, { optional: true });\n                if (this._checkIsEnabled('doctype')) {\n                    _checkDoctypeIsDefined(this._document);\n                }\n                if (this._checkIsEnabled('theme')) {\n                    _checkThemeIsPresent(this._document, !!platform?.isBrowser);\n                }\n                if (this._checkIsEnabled('version')) {\n                    _checkCdkVersionMatch();\n                }\n            }\n        }\n    }\n    /** Gets whether a specific sanity check is enabled. */\n    _checkIsEnabled(name) {\n        if (_isTestEnvironment()) {\n            return false;\n        }\n        if (typeof this._sanityChecks === 'boolean') {\n            return this._sanityChecks;\n        }\n        return !!this._sanityChecks[name];\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatCommonModule, deps: [{ token: i1.HighContrastModeDetector }, { token: MATERIAL_SANITY_CHECKS, optional: true }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: MatCommonModule, imports: [BidiModule], exports: [BidiModule] }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatCommonModule, imports: [BidiModule, BidiModule] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatCommonModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [BidiModule],\n                    exports: [BidiModule],\n                }]\n        }], ctorParameters: function () { return [{ type: i1.HighContrastModeDetector }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MATERIAL_SANITY_CHECKS]\n                }] }, { type: Document, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }]; } });\n/** Checks that the page has a doctype. */\nfunction _checkDoctypeIsDefined(doc) {\n    if (!doc.doctype) {\n        console.warn('Current document does not have a doctype. This may cause ' +\n            'some Angular Material components not to behave as expected.');\n    }\n}\n/** Checks that a theme has been included. */\nfunction _checkThemeIsPresent(doc, isBrowser) {\n    // We need to assert that the `body` is defined, because these checks run very early\n    // and the `body` won't be defined if the consumer put their scripts in the `head`.\n    if (!doc.body || !isBrowser) {\n        return;\n    }\n    const testElement = doc.createElement('div');\n    testElement.classList.add('mat-theme-loaded-marker');\n    doc.body.appendChild(testElement);\n    const computedStyle = getComputedStyle(testElement);\n    // In some situations the computed style of the test element can be null. For example in\n    // Firefox, the computed style is null if an application is running inside of a hidden iframe.\n    // See: https://bugzilla.mozilla.org/show_bug.cgi?id=548397\n    if (computedStyle && computedStyle.display !== 'none') {\n        console.warn('Could not find Angular Material core theme. Most Material ' +\n            'components may not work as expected. For more info refer ' +\n            'to the theming guide: https://material.angular.io/guide/theming');\n    }\n    testElement.remove();\n}\n/** Checks whether the Material version matches the CDK version. */\nfunction _checkCdkVersionMatch() {\n    if (VERSION.full !== VERSION$1.full) {\n        console.warn('The Angular Material version (' +\n            VERSION.full +\n            ') does not match ' +\n            'the Angular CDK version (' +\n            VERSION$1.full +\n            ').\\n' +\n            'Please ensure the versions of these two packages exactly match.');\n    }\n}\n\nfunction mixinDisabled(base) {\n    return class extends base {\n        get disabled() {\n            return this._disabled;\n        }\n        set disabled(value) {\n            this._disabled = coerceBooleanProperty(value);\n        }\n        constructor(...args) {\n            super(...args);\n            this._disabled = false;\n        }\n    };\n}\n\nfunction mixinColor(base, defaultColor) {\n    return class extends base {\n        get color() {\n            return this._color;\n        }\n        set color(value) {\n            const colorPalette = value || this.defaultColor;\n            if (colorPalette !== this._color) {\n                if (this._color) {\n                    this._elementRef.nativeElement.classList.remove(`mat-${this._color}`);\n                }\n                if (colorPalette) {\n                    this._elementRef.nativeElement.classList.add(`mat-${colorPalette}`);\n                }\n                this._color = colorPalette;\n            }\n        }\n        constructor(...args) {\n            super(...args);\n            this.defaultColor = defaultColor;\n            // Set the default color that can be specified from the mixin.\n            this.color = defaultColor;\n        }\n    };\n}\n\nfunction mixinDisableRipple(base) {\n    return class extends base {\n        /** Whether the ripple effect is disabled or not. */\n        get disableRipple() {\n            return this._disableRipple;\n        }\n        set disableRipple(value) {\n            this._disableRipple = coerceBooleanProperty(value);\n        }\n        constructor(...args) {\n            super(...args);\n            this._disableRipple = false;\n        }\n    };\n}\n\nfunction mixinTabIndex(base, defaultTabIndex = 0) {\n    return class extends base {\n        get tabIndex() {\n            return this.disabled ? -1 : this._tabIndex;\n        }\n        set tabIndex(value) {\n            // If the specified tabIndex value is null or undefined, fall back to the default value.\n            this._tabIndex = value != null ? coerceNumberProperty(value) : this.defaultTabIndex;\n        }\n        constructor(...args) {\n            super(...args);\n            this._tabIndex = defaultTabIndex;\n            this.defaultTabIndex = defaultTabIndex;\n        }\n    };\n}\n\nfunction mixinErrorState(base) {\n    return class extends base {\n        /** Updates the error state based on the provided error state matcher. */\n        updateErrorState() {\n            const oldState = this.errorState;\n            const parent = this._parentFormGroup || this._parentForm;\n            const matcher = this.errorStateMatcher || this._defaultErrorStateMatcher;\n            const control = this.ngControl ? this.ngControl.control : null;\n            const newState = matcher.isErrorState(control, parent);\n            if (newState !== oldState) {\n                this.errorState = newState;\n                this.stateChanges.next();\n            }\n        }\n        constructor(...args) {\n            super(...args);\n            /** Whether the component is in an error state. */\n            this.errorState = false;\n        }\n    };\n}\n\n/** Mixin to augment a directive with an initialized property that will emits when ngOnInit ends. */\nfunction mixinInitialized(base) {\n    return class extends base {\n        constructor(...args) {\n            super(...args);\n            /** Whether this directive has been marked as initialized. */\n            this._isInitialized = false;\n            /**\n             * List of subscribers that subscribed before the directive was initialized. Should be notified\n             * during _markInitialized. Set to null after pending subscribers are notified, and should\n             * not expect to be populated after.\n             */\n            this._pendingSubscribers = [];\n            /**\n             * Observable stream that emits when the directive initializes. If already initialized, the\n             * subscriber is stored to be notified once _markInitialized is called.\n             */\n            this.initialized = new Observable(subscriber => {\n                // If initialized, immediately notify the subscriber. Otherwise store the subscriber to notify\n                // when _markInitialized is called.\n                if (this._isInitialized) {\n                    this._notifySubscriber(subscriber);\n                }\n                else {\n                    this._pendingSubscribers.push(subscriber);\n                }\n            });\n        }\n        /**\n         * Marks the state as initialized and notifies pending subscribers. Should be called at the end\n         * of ngOnInit.\n         * @docs-private\n         */\n        _markInitialized() {\n            if (this._isInitialized && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                throw Error('This directive has already been marked as initialized and ' +\n                    'should not be called twice.');\n            }\n            this._isInitialized = true;\n            this._pendingSubscribers.forEach(this._notifySubscriber);\n            this._pendingSubscribers = null;\n        }\n        /** Emits and completes the subscriber stream (should only emit once). */\n        _notifySubscriber(subscriber) {\n            subscriber.next();\n            subscriber.complete();\n        }\n    };\n}\n\n/** InjectionToken for datepicker that can be used to override default locale code. */\nconst MAT_DATE_LOCALE = new InjectionToken('MAT_DATE_LOCALE', {\n    providedIn: 'root',\n    factory: MAT_DATE_LOCALE_FACTORY,\n});\n/** @docs-private */\nfunction MAT_DATE_LOCALE_FACTORY() {\n    return inject(LOCALE_ID);\n}\n/** Adapts type `D` to be usable as a date by cdk-based components that work with dates. */\nclass DateAdapter {\n    constructor() {\n        this._localeChanges = new Subject();\n        /** A stream that emits when the locale changes. */\n        this.localeChanges = this._localeChanges;\n    }\n    /**\n     * Given a potential date object, returns that same date object if it is\n     * a valid date, or `null` if it's not a valid date.\n     * @param obj The object to check.\n     * @returns A date or `null`.\n     */\n    getValidDateOrNull(obj) {\n        return this.isDateInstance(obj) && this.isValid(obj) ? obj : null;\n    }\n    /**\n     * Attempts to deserialize a value to a valid date object. This is different from parsing in that\n     * deserialize should only accept non-ambiguous, locale-independent formats (e.g. a ISO 8601\n     * string). The default implementation does not allow any deserialization, it simply checks that\n     * the given value is already a valid date object or null. The `<mat-datepicker>` will call this\n     * method on all of its `@Input()` properties that accept dates. It is therefore possible to\n     * support passing values from your backend directly to these properties by overriding this method\n     * to also deserialize the format used by your backend.\n     * @param value The value to be deserialized into a date object.\n     * @returns The deserialized date object, either a valid date, null if the value can be\n     *     deserialized into a null date (e.g. the empty string), or an invalid date.\n     */\n    deserialize(value) {\n        if (value == null || (this.isDateInstance(value) && this.isValid(value))) {\n            return value;\n        }\n        return this.invalid();\n    }\n    /**\n     * Sets the locale used for all dates.\n     * @param locale The new locale.\n     */\n    setLocale(locale) {\n        this.locale = locale;\n        this._localeChanges.next();\n    }\n    /**\n     * Compares two dates.\n     * @param first The first date to compare.\n     * @param second The second date to compare.\n     * @returns 0 if the dates are equal, a number less than 0 if the first date is earlier,\n     *     a number greater than 0 if the first date is later.\n     */\n    compareDate(first, second) {\n        return (this.getYear(first) - this.getYear(second) ||\n            this.getMonth(first) - this.getMonth(second) ||\n            this.getDate(first) - this.getDate(second));\n    }\n    /**\n     * Checks if two dates are equal.\n     * @param first The first date to check.\n     * @param second The second date to check.\n     * @returns Whether the two dates are equal.\n     *     Null dates are considered equal to other null dates.\n     */\n    sameDate(first, second) {\n        if (first && second) {\n            let firstValid = this.isValid(first);\n            let secondValid = this.isValid(second);\n            if (firstValid && secondValid) {\n                return !this.compareDate(first, second);\n            }\n            return firstValid == secondValid;\n        }\n        return first == second;\n    }\n    /**\n     * Clamp the given date between min and max dates.\n     * @param date The date to clamp.\n     * @param min The minimum value to allow. If null or omitted no min is enforced.\n     * @param max The maximum value to allow. If null or omitted no max is enforced.\n     * @returns `min` if `date` is less than `min`, `max` if date is greater than `max`,\n     *     otherwise `date`.\n     */\n    clampDate(date, min, max) {\n        if (min && this.compareDate(date, min) < 0) {\n            return min;\n        }\n        if (max && this.compareDate(date, max) > 0) {\n            return max;\n        }\n        return date;\n    }\n}\n\nconst MAT_DATE_FORMATS = new InjectionToken('mat-date-formats');\n\n/**\n * Matches strings that have the form of a valid RFC 3339 string\n * (https://tools.ietf.org/html/rfc3339). Note that the string may not actually be a valid date\n * because the regex will match strings an with out of bounds month, date, etc.\n */\nconst ISO_8601_REGEX = /^\\d{4}-\\d{2}-\\d{2}(?:T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|(?:(?:\\+|-)\\d{2}:\\d{2}))?)?$/;\n/** Creates an array and fills it with values. */\nfunction range(length, valueFunction) {\n    const valuesArray = Array(length);\n    for (let i = 0; i < length; i++) {\n        valuesArray[i] = valueFunction(i);\n    }\n    return valuesArray;\n}\n/** Adapts the native JS Date for use with cdk-based components that work with dates. */\nclass NativeDateAdapter extends DateAdapter {\n    constructor(matDateLocale, \n    /**\n     * @deprecated No longer being used. To be removed.\n     * @breaking-change 14.0.0\n     */\n    _platform) {\n        super();\n        /**\n         * @deprecated No longer being used. To be removed.\n         * @breaking-change 14.0.0\n         */\n        this.useUtcForDisplay = false;\n        super.setLocale(matDateLocale);\n    }\n    getYear(date) {\n        return date.getFullYear();\n    }\n    getMonth(date) {\n        return date.getMonth();\n    }\n    getDate(date) {\n        return date.getDate();\n    }\n    getDayOfWeek(date) {\n        return date.getDay();\n    }\n    getMonthNames(style) {\n        const dtf = new Intl.DateTimeFormat(this.locale, { month: style, timeZone: 'utc' });\n        return range(12, i => this._format(dtf, new Date(2017, i, 1)));\n    }\n    getDateNames() {\n        const dtf = new Intl.DateTimeFormat(this.locale, { day: 'numeric', timeZone: 'utc' });\n        return range(31, i => this._format(dtf, new Date(2017, 0, i + 1)));\n    }\n    getDayOfWeekNames(style) {\n        const dtf = new Intl.DateTimeFormat(this.locale, { weekday: style, timeZone: 'utc' });\n        return range(7, i => this._format(dtf, new Date(2017, 0, i + 1)));\n    }\n    getYearName(date) {\n        const dtf = new Intl.DateTimeFormat(this.locale, { year: 'numeric', timeZone: 'utc' });\n        return this._format(dtf, date);\n    }\n    getFirstDayOfWeek() {\n        // We can't tell using native JS Date what the first day of the week is, we default to Sunday.\n        return 0;\n    }\n    getNumDaysInMonth(date) {\n        return this.getDate(this._createDateWithOverflow(this.getYear(date), this.getMonth(date) + 1, 0));\n    }\n    clone(date) {\n        return new Date(date.getTime());\n    }\n    createDate(year, month, date) {\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            // Check for invalid month and date (except upper bound on date which we have to check after\n            // creating the Date).\n            if (month < 0 || month > 11) {\n                throw Error(`Invalid month index \"${month}\". Month index has to be between 0 and 11.`);\n            }\n            if (date < 1) {\n                throw Error(`Invalid date \"${date}\". Date has to be greater than 0.`);\n            }\n        }\n        let result = this._createDateWithOverflow(year, month, date);\n        // Check that the date wasn't above the upper bound for the month, causing the month to overflow\n        if (result.getMonth() != month && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw Error(`Invalid date \"${date}\" for month with index \"${month}\".`);\n        }\n        return result;\n    }\n    today() {\n        return new Date();\n    }\n    parse(value, parseFormat) {\n        // We have no way using the native JS Date to set the parse format or locale, so we ignore these\n        // parameters.\n        if (typeof value == 'number') {\n            return new Date(value);\n        }\n        return value ? new Date(Date.parse(value)) : null;\n    }\n    format(date, displayFormat) {\n        if (!this.isValid(date)) {\n            throw Error('NativeDateAdapter: Cannot format invalid date.');\n        }\n        const dtf = new Intl.DateTimeFormat(this.locale, { ...displayFormat, timeZone: 'utc' });\n        return this._format(dtf, date);\n    }\n    addCalendarYears(date, years) {\n        return this.addCalendarMonths(date, years * 12);\n    }\n    addCalendarMonths(date, months) {\n        let newDate = this._createDateWithOverflow(this.getYear(date), this.getMonth(date) + months, this.getDate(date));\n        // It's possible to wind up in the wrong month if the original month has more days than the new\n        // month. In this case we want to go to the last day of the desired month.\n        // Note: the additional + 12 % 12 ensures we end up with a positive number, since JS % doesn't\n        // guarantee this.\n        if (this.getMonth(newDate) != (((this.getMonth(date) + months) % 12) + 12) % 12) {\n            newDate = this._createDateWithOverflow(this.getYear(newDate), this.getMonth(newDate), 0);\n        }\n        return newDate;\n    }\n    addCalendarDays(date, days) {\n        return this._createDateWithOverflow(this.getYear(date), this.getMonth(date), this.getDate(date) + days);\n    }\n    toIso8601(date) {\n        return [\n            date.getUTCFullYear(),\n            this._2digit(date.getUTCMonth() + 1),\n            this._2digit(date.getUTCDate()),\n        ].join('-');\n    }\n    /**\n     * Returns the given value if given a valid Date or null. Deserializes valid ISO 8601 strings\n     * (https://www.ietf.org/rfc/rfc3339.txt) into valid Dates and empty string into null. Returns an\n     * invalid date for all other values.\n     */\n    deserialize(value) {\n        if (typeof value === 'string') {\n            if (!value) {\n                return null;\n            }\n            // The `Date` constructor accepts formats other than ISO 8601, so we need to make sure the\n            // string is the right format first.\n            if (ISO_8601_REGEX.test(value)) {\n                let date = new Date(value);\n                if (this.isValid(date)) {\n                    return date;\n                }\n            }\n        }\n        return super.deserialize(value);\n    }\n    isDateInstance(obj) {\n        return obj instanceof Date;\n    }\n    isValid(date) {\n        return !isNaN(date.getTime());\n    }\n    invalid() {\n        return new Date(NaN);\n    }\n    /** Creates a date but allows the month and date to overflow. */\n    _createDateWithOverflow(year, month, date) {\n        // Passing the year to the constructor causes year numbers <100 to be converted to 19xx.\n        // To work around this we use `setFullYear` and `setHours` instead.\n        const d = new Date();\n        d.setFullYear(year, month, date);\n        d.setHours(0, 0, 0, 0);\n        return d;\n    }\n    /**\n     * Pads a number to make it two digits.\n     * @param n The number to pad.\n     * @returns The padded number.\n     */\n    _2digit(n) {\n        return ('00' + n).slice(-2);\n    }\n    /**\n     * When converting Date object to string, javascript built-in functions may return wrong\n     * results because it applies its internal DST rules. The DST rules around the world change\n     * very frequently, and the current valid rule is not always valid in previous years though.\n     * We work around this problem building a new Date object which has its internal UTC\n     * representation with the local date and time.\n     * @param dtf Intl.DateTimeFormat object, containing the desired string format. It must have\n     *    timeZone set to 'utc' to work fine.\n     * @param date Date from which we want to get the string representation according to dtf\n     * @returns A Date object with its UTC representation based on the passed in date info\n     */\n    _format(dtf, date) {\n        // Passing the year to the constructor causes year numbers <100 to be converted to 19xx.\n        // To work around this we use `setUTCFullYear` and `setUTCHours` instead.\n        const d = new Date();\n        d.setUTCFullYear(date.getFullYear(), date.getMonth(), date.getDate());\n        d.setUTCHours(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());\n        return dtf.format(d);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: NativeDateAdapter, deps: [{ token: MAT_DATE_LOCALE, optional: true }, { token: i1$1.Platform }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: NativeDateAdapter }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: NativeDateAdapter, decorators: [{\n            type: Injectable\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_DATE_LOCALE]\n                }] }, { type: i1$1.Platform }]; } });\n\nconst MAT_NATIVE_DATE_FORMATS = {\n    parse: {\n        dateInput: null,\n    },\n    display: {\n        dateInput: { year: 'numeric', month: 'numeric', day: 'numeric' },\n        monthYearLabel: { year: 'numeric', month: 'short' },\n        dateA11yLabel: { year: 'numeric', month: 'long', day: 'numeric' },\n        monthYearA11yLabel: { year: 'numeric', month: 'long' },\n    },\n};\n\nclass NativeDateModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: NativeDateModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: NativeDateModule }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: NativeDateModule, providers: [{ provide: DateAdapter, useClass: NativeDateAdapter }] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: NativeDateModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    providers: [{ provide: DateAdapter, useClass: NativeDateAdapter }],\n                }]\n        }] });\nclass MatNativeDateModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatNativeDateModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: MatNativeDateModule, imports: [NativeDateModule] }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatNativeDateModule, providers: [{ provide: MAT_DATE_FORMATS, useValue: MAT_NATIVE_DATE_FORMATS }], imports: [NativeDateModule] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatNativeDateModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [NativeDateModule],\n                    providers: [{ provide: MAT_DATE_FORMATS, useValue: MAT_NATIVE_DATE_FORMATS }],\n                }]\n        }] });\n\n/** Error state matcher that matches when a control is invalid and dirty. */\nclass ShowOnDirtyErrorStateMatcher {\n    isErrorState(control, form) {\n        return !!(control && control.invalid && (control.dirty || (form && form.submitted)));\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ShowOnDirtyErrorStateMatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ShowOnDirtyErrorStateMatcher }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ShowOnDirtyErrorStateMatcher, decorators: [{\n            type: Injectable\n        }] });\n/** Provider that defines how form controls behave with regards to displaying error messages. */\nclass ErrorStateMatcher {\n    isErrorState(control, form) {\n        return !!(control && control.invalid && (control.touched || (form && form.submitted)));\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ErrorStateMatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ErrorStateMatcher, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ErrorStateMatcher, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }] });\n\n/**\n * Shared directive to count lines inside a text area, such as a list item.\n * Line elements can be extracted with a @ContentChildren(MatLine) query, then\n * counted by checking the query list's length.\n */\nclass MatLine {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatLine, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: MatLine, selector: \"[mat-line], [matLine]\", host: { classAttribute: \"mat-line\" }, ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatLine, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[mat-line], [matLine]',\n                    host: { 'class': 'mat-line' },\n                }]\n        }] });\n/**\n * Helper that takes a query list of lines and sets the correct class on the host.\n * @docs-private\n */\nfunction setLines(lines, element, prefix = 'mat') {\n    // Note: doesn't need to unsubscribe, because `changes`\n    // gets completed by Angular when the view is destroyed.\n    lines.changes.pipe(startWith(lines)).subscribe(({ length }) => {\n        setClass(element, `${prefix}-2-line`, false);\n        setClass(element, `${prefix}-3-line`, false);\n        setClass(element, `${prefix}-multi-line`, false);\n        if (length === 2 || length === 3) {\n            setClass(element, `${prefix}-${length}-line`, true);\n        }\n        else if (length > 3) {\n            setClass(element, `${prefix}-multi-line`, true);\n        }\n    });\n}\n/** Adds or removes a class from an element. */\nfunction setClass(element, className, isAdd) {\n    element.nativeElement.classList.toggle(className, isAdd);\n}\nclass MatLineModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatLineModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: MatLineModule, declarations: [MatLine], imports: [MatCommonModule], exports: [MatLine, MatCommonModule] }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatLineModule, imports: [MatCommonModule, MatCommonModule] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatLineModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [MatCommonModule],\n                    exports: [MatLine, MatCommonModule],\n                    declarations: [MatLine],\n                }]\n        }] });\n\n/**\n * Reference to a previously launched ripple element.\n */\nclass RippleRef {\n    constructor(_renderer, \n    /** Reference to the ripple HTML element. */\n    element, \n    /** Ripple configuration used for the ripple. */\n    config, \n    /* Whether animations are forcibly disabled for ripples through CSS. */\n    _animationForciblyDisabledThroughCss = false) {\n        this._renderer = _renderer;\n        this.element = element;\n        this.config = config;\n        this._animationForciblyDisabledThroughCss = _animationForciblyDisabledThroughCss;\n        /** Current state of the ripple. */\n        this.state = 3 /* RippleState.HIDDEN */;\n    }\n    /** Fades out the ripple element. */\n    fadeOut() {\n        this._renderer.fadeOutRipple(this);\n    }\n}\n\n/** Options used to bind a passive capturing event. */\nconst passiveCapturingEventOptions$1 = normalizePassiveListenerOptions({\n    passive: true,\n    capture: true,\n});\n/** Manages events through delegation so that as few event handlers as possible are bound. */\nclass RippleEventManager {\n    constructor() {\n        this._events = new Map();\n        /** Event handler that is bound and which dispatches the events to the different targets. */\n        this._delegateEventHandler = (event) => {\n            const target = _getEventTarget(event);\n            if (target) {\n                this._events.get(event.type)?.forEach((handlers, element) => {\n                    if (element === target || element.contains(target)) {\n                        handlers.forEach(handler => handler.handleEvent(event));\n                    }\n                });\n            }\n        };\n    }\n    /** Adds an event handler. */\n    addHandler(ngZone, name, element, handler) {\n        const handlersForEvent = this._events.get(name);\n        if (handlersForEvent) {\n            const handlersForElement = handlersForEvent.get(element);\n            if (handlersForElement) {\n                handlersForElement.add(handler);\n            }\n            else {\n                handlersForEvent.set(element, new Set([handler]));\n            }\n        }\n        else {\n            this._events.set(name, new Map([[element, new Set([handler])]]));\n            ngZone.runOutsideAngular(() => {\n                document.addEventListener(name, this._delegateEventHandler, passiveCapturingEventOptions$1);\n            });\n        }\n    }\n    /** Removes an event handler. */\n    removeHandler(name, element, handler) {\n        const handlersForEvent = this._events.get(name);\n        if (!handlersForEvent) {\n            return;\n        }\n        const handlersForElement = handlersForEvent.get(element);\n        if (!handlersForElement) {\n            return;\n        }\n        handlersForElement.delete(handler);\n        if (handlersForElement.size === 0) {\n            handlersForEvent.delete(element);\n        }\n        if (handlersForEvent.size === 0) {\n            this._events.delete(name);\n            document.removeEventListener(name, this._delegateEventHandler, passiveCapturingEventOptions$1);\n        }\n    }\n}\n\n/**\n * Default ripple animation configuration for ripples without an explicit\n * animation config specified.\n */\nconst defaultRippleAnimationConfig = {\n    enterDuration: 225,\n    exitDuration: 150,\n};\n/**\n * Timeout for ignoring mouse events. Mouse events will be temporary ignored after touch\n * events to avoid synthetic mouse events.\n */\nconst ignoreMouseEventsTimeout = 800;\n/** Options used to bind a passive capturing event. */\nconst passiveCapturingEventOptions = normalizePassiveListenerOptions({\n    passive: true,\n    capture: true,\n});\n/** Events that signal that the pointer is down. */\nconst pointerDownEvents = ['mousedown', 'touchstart'];\n/** Events that signal that the pointer is up. */\nconst pointerUpEvents = ['mouseup', 'mouseleave', 'touchend', 'touchcancel'];\n/**\n * Helper service that performs DOM manipulations. Not intended to be used outside this module.\n * The constructor takes a reference to the ripple directive's host element and a map of DOM\n * event handlers to be installed on the element that triggers ripple animations.\n * This will eventually become a custom renderer once Angular support exists.\n * @docs-private\n */\nclass RippleRenderer {\n    static { this._eventManager = new RippleEventManager(); }\n    constructor(_target, _ngZone, elementOrElementRef, _platform) {\n        this._target = _target;\n        this._ngZone = _ngZone;\n        this._platform = _platform;\n        /** Whether the pointer is currently down or not. */\n        this._isPointerDown = false;\n        /**\n         * Map of currently active ripple references.\n         * The ripple reference is mapped to its element event listeners.\n         * The reason why `| null` is used is that event listeners are added only\n         * when the condition is truthy (see the `_startFadeOutTransition` method).\n         */\n        this._activeRipples = new Map();\n        /** Whether pointer-up event listeners have been registered. */\n        this._pointerUpEventsRegistered = false;\n        // Only do anything if we're on the browser.\n        if (_platform.isBrowser) {\n            this._containerElement = coerceElement(elementOrElementRef);\n        }\n    }\n    /**\n     * Fades in a ripple at the given coordinates.\n     * @param x Coordinate within the element, along the X axis at which to start the ripple.\n     * @param y Coordinate within the element, along the Y axis at which to start the ripple.\n     * @param config Extra ripple options.\n     */\n    fadeInRipple(x, y, config = {}) {\n        const containerRect = (this._containerRect =\n            this._containerRect || this._containerElement.getBoundingClientRect());\n        const animationConfig = { ...defaultRippleAnimationConfig, ...config.animation };\n        if (config.centered) {\n            x = containerRect.left + containerRect.width / 2;\n            y = containerRect.top + containerRect.height / 2;\n        }\n        const radius = config.radius || distanceToFurthestCorner(x, y, containerRect);\n        const offsetX = x - containerRect.left;\n        const offsetY = y - containerRect.top;\n        const enterDuration = animationConfig.enterDuration;\n        const ripple = document.createElement('div');\n        ripple.classList.add('mat-ripple-element');\n        ripple.style.left = `${offsetX - radius}px`;\n        ripple.style.top = `${offsetY - radius}px`;\n        ripple.style.height = `${radius * 2}px`;\n        ripple.style.width = `${radius * 2}px`;\n        // If a custom color has been specified, set it as inline style. If no color is\n        // set, the default color will be applied through the ripple theme styles.\n        if (config.color != null) {\n            ripple.style.backgroundColor = config.color;\n        }\n        ripple.style.transitionDuration = `${enterDuration}ms`;\n        this._containerElement.appendChild(ripple);\n        // By default the browser does not recalculate the styles of dynamically created\n        // ripple elements. This is critical to ensure that the `scale` animates properly.\n        // We enforce a style recalculation by calling `getComputedStyle` and *accessing* a property.\n        // See: https://gist.github.com/paulirish/5d52fb081b3570c81e3a\n        const computedStyles = window.getComputedStyle(ripple);\n        const userTransitionProperty = computedStyles.transitionProperty;\n        const userTransitionDuration = computedStyles.transitionDuration;\n        // Note: We detect whether animation is forcibly disabled through CSS (e.g. through\n        // `transition: none` or `display: none`). This is technically unexpected since animations are\n        // controlled through the animation config, but this exists for backwards compatibility. This\n        // logic does not need to be super accurate since it covers some edge cases which can be easily\n        // avoided by users.\n        const animationForciblyDisabledThroughCss = userTransitionProperty === 'none' ||\n            // Note: The canonical unit for serialized CSS `<time>` properties is seconds. Additionally\n            // some browsers expand the duration for every property (in our case `opacity` and `transform`).\n            userTransitionDuration === '0s' ||\n            userTransitionDuration === '0s, 0s' ||\n            // If the container is 0x0, it's likely `display: none`.\n            (containerRect.width === 0 && containerRect.height === 0);\n        // Exposed reference to the ripple that will be returned.\n        const rippleRef = new RippleRef(this, ripple, config, animationForciblyDisabledThroughCss);\n        // Start the enter animation by setting the transform/scale to 100%. The animation will\n        // execute as part of this statement because we forced a style recalculation before.\n        // Note: We use a 3d transform here in order to avoid an issue in Safari where\n        // the ripples aren't clipped when inside the shadow DOM (see #24028).\n        ripple.style.transform = 'scale3d(1, 1, 1)';\n        rippleRef.state = 0 /* RippleState.FADING_IN */;\n        if (!config.persistent) {\n            this._mostRecentTransientRipple = rippleRef;\n        }\n        let eventListeners = null;\n        // Do not register the `transition` event listener if fade-in and fade-out duration\n        // are set to zero. The events won't fire anyway and we can save resources here.\n        if (!animationForciblyDisabledThroughCss && (enterDuration || animationConfig.exitDuration)) {\n            this._ngZone.runOutsideAngular(() => {\n                const onTransitionEnd = () => this._finishRippleTransition(rippleRef);\n                const onTransitionCancel = () => this._destroyRipple(rippleRef);\n                ripple.addEventListener('transitionend', onTransitionEnd);\n                // If the transition is cancelled (e.g. due to DOM removal), we destroy the ripple\n                // directly as otherwise we would keep it part of the ripple container forever.\n                // https://www.w3.org/TR/css-transitions-1/#:~:text=no%20longer%20in%20the%20document.\n                ripple.addEventListener('transitioncancel', onTransitionCancel);\n                eventListeners = { onTransitionEnd, onTransitionCancel };\n            });\n        }\n        // Add the ripple reference to the list of all active ripples.\n        this._activeRipples.set(rippleRef, eventListeners);\n        // In case there is no fade-in transition duration, we need to manually call the transition\n        // end listener because `transitionend` doesn't fire if there is no transition.\n        if (animationForciblyDisabledThroughCss || !enterDuration) {\n            this._finishRippleTransition(rippleRef);\n        }\n        return rippleRef;\n    }\n    /** Fades out a ripple reference. */\n    fadeOutRipple(rippleRef) {\n        // For ripples already fading out or hidden, this should be a noop.\n        if (rippleRef.state === 2 /* RippleState.FADING_OUT */ || rippleRef.state === 3 /* RippleState.HIDDEN */) {\n            return;\n        }\n        const rippleEl = rippleRef.element;\n        const animationConfig = { ...defaultRippleAnimationConfig, ...rippleRef.config.animation };\n        // This starts the fade-out transition and will fire the transition end listener that\n        // removes the ripple element from the DOM.\n        rippleEl.style.transitionDuration = `${animationConfig.exitDuration}ms`;\n        rippleEl.style.opacity = '0';\n        rippleRef.state = 2 /* RippleState.FADING_OUT */;\n        // In case there is no fade-out transition duration, we need to manually call the\n        // transition end listener because `transitionend` doesn't fire if there is no transition.\n        if (rippleRef._animationForciblyDisabledThroughCss || !animationConfig.exitDuration) {\n            this._finishRippleTransition(rippleRef);\n        }\n    }\n    /** Fades out all currently active ripples. */\n    fadeOutAll() {\n        this._getActiveRipples().forEach(ripple => ripple.fadeOut());\n    }\n    /** Fades out all currently active non-persistent ripples. */\n    fadeOutAllNonPersistent() {\n        this._getActiveRipples().forEach(ripple => {\n            if (!ripple.config.persistent) {\n                ripple.fadeOut();\n            }\n        });\n    }\n    /** Sets up the trigger event listeners */\n    setupTriggerEvents(elementOrElementRef) {\n        const element = coerceElement(elementOrElementRef);\n        if (!this._platform.isBrowser || !element || element === this._triggerElement) {\n            return;\n        }\n        // Remove all previously registered event listeners from the trigger element.\n        this._removeTriggerEvents();\n        this._triggerElement = element;\n        // Use event delegation for the trigger events since they're\n        // set up during creation and are performance-sensitive.\n        pointerDownEvents.forEach(type => {\n            RippleRenderer._eventManager.addHandler(this._ngZone, type, element, this);\n        });\n    }\n    /**\n     * Handles all registered events.\n     * @docs-private\n     */\n    handleEvent(event) {\n        if (event.type === 'mousedown') {\n            this._onMousedown(event);\n        }\n        else if (event.type === 'touchstart') {\n            this._onTouchStart(event);\n        }\n        else {\n            this._onPointerUp();\n        }\n        // If pointer-up events haven't been registered yet, do so now.\n        // We do this on-demand in order to reduce the total number of event listeners\n        // registered by the ripples, which speeds up the rendering time for large UIs.\n        if (!this._pointerUpEventsRegistered) {\n            // The events for hiding the ripple are bound directly on the trigger, because:\n            // 1. Some of them occur frequently (e.g. `mouseleave`) and any advantage we get from\n            // delegation will be diminished by having to look through all the data structures often.\n            // 2. They aren't as performance-sensitive, because they're bound only after the user\n            // has interacted with an element.\n            this._ngZone.runOutsideAngular(() => {\n                pointerUpEvents.forEach(type => {\n                    this._triggerElement.addEventListener(type, this, passiveCapturingEventOptions);\n                });\n            });\n            this._pointerUpEventsRegistered = true;\n        }\n    }\n    /** Method that will be called if the fade-in or fade-in transition completed. */\n    _finishRippleTransition(rippleRef) {\n        if (rippleRef.state === 0 /* RippleState.FADING_IN */) {\n            this._startFadeOutTransition(rippleRef);\n        }\n        else if (rippleRef.state === 2 /* RippleState.FADING_OUT */) {\n            this._destroyRipple(rippleRef);\n        }\n    }\n    /**\n     * Starts the fade-out transition of the given ripple if it's not persistent and the pointer\n     * is not held down anymore.\n     */\n    _startFadeOutTransition(rippleRef) {\n        const isMostRecentTransientRipple = rippleRef === this._mostRecentTransientRipple;\n        const { persistent } = rippleRef.config;\n        rippleRef.state = 1 /* RippleState.VISIBLE */;\n        // When the timer runs out while the user has kept their pointer down, we want to\n        // keep only the persistent ripples and the latest transient ripple. We do this,\n        // because we don't want stacked transient ripples to appear after their enter\n        // animation has finished.\n        if (!persistent && (!isMostRecentTransientRipple || !this._isPointerDown)) {\n            rippleRef.fadeOut();\n        }\n    }\n    /** Destroys the given ripple by removing it from the DOM and updating its state. */\n    _destroyRipple(rippleRef) {\n        const eventListeners = this._activeRipples.get(rippleRef) ?? null;\n        this._activeRipples.delete(rippleRef);\n        // Clear out the cached bounding rect if we have no more ripples.\n        if (!this._activeRipples.size) {\n            this._containerRect = null;\n        }\n        // If the current ref is the most recent transient ripple, unset it\n        // avoid memory leaks.\n        if (rippleRef === this._mostRecentTransientRipple) {\n            this._mostRecentTransientRipple = null;\n        }\n        rippleRef.state = 3 /* RippleState.HIDDEN */;\n        if (eventListeners !== null) {\n            rippleRef.element.removeEventListener('transitionend', eventListeners.onTransitionEnd);\n            rippleRef.element.removeEventListener('transitioncancel', eventListeners.onTransitionCancel);\n        }\n        rippleRef.element.remove();\n    }\n    /** Function being called whenever the trigger is being pressed using mouse. */\n    _onMousedown(event) {\n        // Screen readers will fire fake mouse events for space/enter. Skip launching a\n        // ripple in this case for consistency with the non-screen-reader experience.\n        const isFakeMousedown = isFakeMousedownFromScreenReader(event);\n        const isSyntheticEvent = this._lastTouchStartEvent &&\n            Date.now() < this._lastTouchStartEvent + ignoreMouseEventsTimeout;\n        if (!this._target.rippleDisabled && !isFakeMousedown && !isSyntheticEvent) {\n            this._isPointerDown = true;\n            this.fadeInRipple(event.clientX, event.clientY, this._target.rippleConfig);\n        }\n    }\n    /** Function being called whenever the trigger is being pressed using touch. */\n    _onTouchStart(event) {\n        if (!this._target.rippleDisabled && !isFakeTouchstartFromScreenReader(event)) {\n            // Some browsers fire mouse events after a `touchstart` event. Those synthetic mouse\n            // events will launch a second ripple if we don't ignore mouse events for a specific\n            // time after a touchstart event.\n            this._lastTouchStartEvent = Date.now();\n            this._isPointerDown = true;\n            // Use `changedTouches` so we skip any touches where the user put\n            // their finger down, but used another finger to tap the element again.\n            const touches = event.changedTouches;\n            // According to the typings the touches should always be defined, but in some cases\n            // the browser appears to not assign them in tests which leads to flakes.\n            if (touches) {\n                for (let i = 0; i < touches.length; i++) {\n                    this.fadeInRipple(touches[i].clientX, touches[i].clientY, this._target.rippleConfig);\n                }\n            }\n        }\n    }\n    /** Function being called whenever the trigger is being released. */\n    _onPointerUp() {\n        if (!this._isPointerDown) {\n            return;\n        }\n        this._isPointerDown = false;\n        // Fade-out all ripples that are visible and not persistent.\n        this._getActiveRipples().forEach(ripple => {\n            // By default, only ripples that are completely visible will fade out on pointer release.\n            // If the `terminateOnPointerUp` option is set, ripples that still fade in will also fade out.\n            const isVisible = ripple.state === 1 /* RippleState.VISIBLE */ ||\n                (ripple.config.terminateOnPointerUp && ripple.state === 0 /* RippleState.FADING_IN */);\n            if (!ripple.config.persistent && isVisible) {\n                ripple.fadeOut();\n            }\n        });\n    }\n    _getActiveRipples() {\n        return Array.from(this._activeRipples.keys());\n    }\n    /** Removes previously registered event listeners from the trigger element. */\n    _removeTriggerEvents() {\n        const trigger = this._triggerElement;\n        if (trigger) {\n            pointerDownEvents.forEach(type => RippleRenderer._eventManager.removeHandler(type, trigger, this));\n            if (this._pointerUpEventsRegistered) {\n                pointerUpEvents.forEach(type => trigger.removeEventListener(type, this, passiveCapturingEventOptions));\n            }\n        }\n    }\n}\n/**\n * Returns the distance from the point (x, y) to the furthest corner of a rectangle.\n */\nfunction distanceToFurthestCorner(x, y, rect) {\n    const distX = Math.max(Math.abs(x - rect.left), Math.abs(x - rect.right));\n    const distY = Math.max(Math.abs(y - rect.top), Math.abs(y - rect.bottom));\n    return Math.sqrt(distX * distX + distY * distY);\n}\n\n/** Injection token that can be used to specify the global ripple options. */\nconst MAT_RIPPLE_GLOBAL_OPTIONS = new InjectionToken('mat-ripple-global-options');\nclass MatRipple {\n    /**\n     * Whether click events will not trigger the ripple. Ripples can be still launched manually\n     * by using the `launch()` method.\n     */\n    get disabled() {\n        return this._disabled;\n    }\n    set disabled(value) {\n        if (value) {\n            this.fadeOutAllNonPersistent();\n        }\n        this._disabled = value;\n        this._setupTriggerEventsIfEnabled();\n    }\n    /**\n     * The element that triggers the ripple when click events are received.\n     * Defaults to the directive's host element.\n     */\n    get trigger() {\n        return this._trigger || this._elementRef.nativeElement;\n    }\n    set trigger(trigger) {\n        this._trigger = trigger;\n        this._setupTriggerEventsIfEnabled();\n    }\n    constructor(_elementRef, ngZone, platform, globalOptions, _animationMode) {\n        this._elementRef = _elementRef;\n        this._animationMode = _animationMode;\n        /**\n         * If set, the radius in pixels of foreground ripples when fully expanded. If unset, the radius\n         * will be the distance from the center of the ripple to the furthest corner of the host element's\n         * bounding rectangle.\n         */\n        this.radius = 0;\n        this._disabled = false;\n        /** @docs-private Whether ripple directive is initialized and the input bindings are set. */\n        this._isInitialized = false;\n        this._globalOptions = globalOptions || {};\n        this._rippleRenderer = new RippleRenderer(this, ngZone, _elementRef, platform);\n    }\n    ngOnInit() {\n        this._isInitialized = true;\n        this._setupTriggerEventsIfEnabled();\n    }\n    ngOnDestroy() {\n        this._rippleRenderer._removeTriggerEvents();\n    }\n    /** Fades out all currently showing ripple elements. */\n    fadeOutAll() {\n        this._rippleRenderer.fadeOutAll();\n    }\n    /** Fades out all currently showing non-persistent ripple elements. */\n    fadeOutAllNonPersistent() {\n        this._rippleRenderer.fadeOutAllNonPersistent();\n    }\n    /**\n     * Ripple configuration from the directive's input values.\n     * @docs-private Implemented as part of RippleTarget\n     */\n    get rippleConfig() {\n        return {\n            centered: this.centered,\n            radius: this.radius,\n            color: this.color,\n            animation: {\n                ...this._globalOptions.animation,\n                ...(this._animationMode === 'NoopAnimations' ? { enterDuration: 0, exitDuration: 0 } : {}),\n                ...this.animation,\n            },\n            terminateOnPointerUp: this._globalOptions.terminateOnPointerUp,\n        };\n    }\n    /**\n     * Whether ripples on pointer-down are disabled or not.\n     * @docs-private Implemented as part of RippleTarget\n     */\n    get rippleDisabled() {\n        return this.disabled || !!this._globalOptions.disabled;\n    }\n    /** Sets up the trigger event listeners if ripples are enabled. */\n    _setupTriggerEventsIfEnabled() {\n        if (!this.disabled && this._isInitialized) {\n            this._rippleRenderer.setupTriggerEvents(this.trigger);\n        }\n    }\n    /** Launches a manual ripple at the specified coordinated or just by the ripple config. */\n    launch(configOrX, y = 0, config) {\n        if (typeof configOrX === 'number') {\n            return this._rippleRenderer.fadeInRipple(configOrX, y, { ...this.rippleConfig, ...config });\n        }\n        else {\n            return this._rippleRenderer.fadeInRipple(0, 0, { ...this.rippleConfig, ...configOrX });\n        }\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatRipple, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: i1$1.Platform }, { token: MAT_RIPPLE_GLOBAL_OPTIONS, optional: true }, { token: ANIMATION_MODULE_TYPE, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: MatRipple, selector: \"[mat-ripple], [matRipple]\", inputs: { color: [\"matRippleColor\", \"color\"], unbounded: [\"matRippleUnbounded\", \"unbounded\"], centered: [\"matRippleCentered\", \"centered\"], radius: [\"matRippleRadius\", \"radius\"], animation: [\"matRippleAnimation\", \"animation\"], disabled: [\"matRippleDisabled\", \"disabled\"], trigger: [\"matRippleTrigger\", \"trigger\"] }, host: { properties: { \"class.mat-ripple-unbounded\": \"unbounded\" }, classAttribute: \"mat-ripple\" }, exportAs: [\"matRipple\"], ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatRipple, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[mat-ripple], [matRipple]',\n                    exportAs: 'matRipple',\n                    host: {\n                        'class': 'mat-ripple',\n                        '[class.mat-ripple-unbounded]': 'unbounded',\n                    },\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: i1$1.Platform }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_RIPPLE_GLOBAL_OPTIONS]\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [ANIMATION_MODULE_TYPE]\n                }] }]; }, propDecorators: { color: [{\n                type: Input,\n                args: ['matRippleColor']\n            }], unbounded: [{\n                type: Input,\n                args: ['matRippleUnbounded']\n            }], centered: [{\n                type: Input,\n                args: ['matRippleCentered']\n            }], radius: [{\n                type: Input,\n                args: ['matRippleRadius']\n            }], animation: [{\n                type: Input,\n                args: ['matRippleAnimation']\n            }], disabled: [{\n                type: Input,\n                args: ['matRippleDisabled']\n            }], trigger: [{\n                type: Input,\n                args: ['matRippleTrigger']\n            }] } });\n\nclass MatRippleModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatRippleModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: MatRippleModule, declarations: [MatRipple], imports: [MatCommonModule], exports: [MatRipple, MatCommonModule] }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatRippleModule, imports: [MatCommonModule, MatCommonModule] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatRippleModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [MatCommonModule],\n                    exports: [MatRipple, MatCommonModule],\n                    declarations: [MatRipple],\n                }]\n        }] });\n\n/**\n * Component that shows a simplified checkbox without including any kind of \"real\" checkbox.\n * Meant to be used when the checkbox is purely decorative and a large number of them will be\n * included, such as for the options in a multi-select. Uses no SVGs or complex animations.\n * Note that theming is meant to be handled by the parent element, e.g.\n * `mat-primary .mat-pseudo-checkbox`.\n *\n * Note that this component will be completely invisible to screen-reader users. This is *not*\n * interchangeable with `<mat-checkbox>` and should *not* be used if the user would directly\n * interact with the checkbox. The pseudo-checkbox should only be used as an implementation detail\n * of more complex components that appropriately handle selected / checked state.\n * @docs-private\n */\nclass MatPseudoCheckbox {\n    constructor(_animationMode) {\n        this._animationMode = _animationMode;\n        /** Display state of the checkbox. */\n        this.state = 'unchecked';\n        /** Whether the checkbox is disabled. */\n        this.disabled = false;\n        /**\n         * Appearance of the pseudo checkbox. Default appearance of 'full' renders a checkmark/mixedmark\n         * indicator inside a square box. 'minimal' appearance only renders the checkmark/mixedmark.\n         */\n        this.appearance = 'full';\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatPseudoCheckbox, deps: [{ token: ANIMATION_MODULE_TYPE, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }\n    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"14.0.0\", version: \"16.1.1\", type: MatPseudoCheckbox, selector: \"mat-pseudo-checkbox\", inputs: { state: \"state\", disabled: \"disabled\", appearance: \"appearance\" }, host: { properties: { \"class.mat-pseudo-checkbox-indeterminate\": \"state === \\\"indeterminate\\\"\", \"class.mat-pseudo-checkbox-checked\": \"state === \\\"checked\\\"\", \"class.mat-pseudo-checkbox-disabled\": \"disabled\", \"class.mat-pseudo-checkbox-minimal\": \"appearance === \\\"minimal\\\"\", \"class.mat-pseudo-checkbox-full\": \"appearance === \\\"full\\\"\", \"class._mat-animation-noopable\": \"_animationMode === \\\"NoopAnimations\\\"\" }, classAttribute: \"mat-pseudo-checkbox\" }, ngImport: i0, template: '', isInline: true, styles: [\".mat-pseudo-checkbox{border-radius:2px;cursor:pointer;display:inline-block;vertical-align:middle;box-sizing:border-box;position:relative;flex-shrink:0;transition:border-color 90ms cubic-bezier(0, 0, 0.2, 0.1),background-color 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox::after{position:absolute;opacity:0;content:\\\"\\\";border-bottom:2px solid currentColor;transition:opacity 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox._mat-animation-noopable{transition:none !important;animation:none !important}.mat-pseudo-checkbox._mat-animation-noopable::after{transition:none}.mat-pseudo-checkbox-disabled{cursor:default}.mat-pseudo-checkbox-indeterminate::after{left:1px;opacity:1;border-radius:2px}.mat-pseudo-checkbox-checked::after{left:1px;border-left:2px solid currentColor;transform:rotate(-45deg);opacity:1;box-sizing:content-box}.mat-pseudo-checkbox-full{border:2px solid}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-checked,.mat-pseudo-checkbox-full.mat-pseudo-checkbox-indeterminate{border-color:rgba(0,0,0,0)}.mat-pseudo-checkbox{width:18px;height:18px}.mat-pseudo-checkbox-minimal.mat-pseudo-checkbox-checked::after{width:14px;height:6px;transform-origin:center;top:-4.2426406871px;left:0;bottom:0;right:0;margin:auto}.mat-pseudo-checkbox-minimal.mat-pseudo-checkbox-indeterminate::after{top:8px;width:16px}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-checked::after{width:10px;height:4px;transform-origin:center;top:-2.8284271247px;left:0;bottom:0;right:0;margin:auto}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-indeterminate::after{top:6px;width:12px}\"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatPseudoCheckbox, decorators: [{\n            type: Component,\n            args: [{ encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, selector: 'mat-pseudo-checkbox', template: '', host: {\n                        'class': 'mat-pseudo-checkbox',\n                        '[class.mat-pseudo-checkbox-indeterminate]': 'state === \"indeterminate\"',\n                        '[class.mat-pseudo-checkbox-checked]': 'state === \"checked\"',\n                        '[class.mat-pseudo-checkbox-disabled]': 'disabled',\n                        '[class.mat-pseudo-checkbox-minimal]': 'appearance === \"minimal\"',\n                        '[class.mat-pseudo-checkbox-full]': 'appearance === \"full\"',\n                        '[class._mat-animation-noopable]': '_animationMode === \"NoopAnimations\"',\n                    }, styles: [\".mat-pseudo-checkbox{border-radius:2px;cursor:pointer;display:inline-block;vertical-align:middle;box-sizing:border-box;position:relative;flex-shrink:0;transition:border-color 90ms cubic-bezier(0, 0, 0.2, 0.1),background-color 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox::after{position:absolute;opacity:0;content:\\\"\\\";border-bottom:2px solid currentColor;transition:opacity 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox._mat-animation-noopable{transition:none !important;animation:none !important}.mat-pseudo-checkbox._mat-animation-noopable::after{transition:none}.mat-pseudo-checkbox-disabled{cursor:default}.mat-pseudo-checkbox-indeterminate::after{left:1px;opacity:1;border-radius:2px}.mat-pseudo-checkbox-checked::after{left:1px;border-left:2px solid currentColor;transform:rotate(-45deg);opacity:1;box-sizing:content-box}.mat-pseudo-checkbox-full{border:2px solid}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-checked,.mat-pseudo-checkbox-full.mat-pseudo-checkbox-indeterminate{border-color:rgba(0,0,0,0)}.mat-pseudo-checkbox{width:18px;height:18px}.mat-pseudo-checkbox-minimal.mat-pseudo-checkbox-checked::after{width:14px;height:6px;transform-origin:center;top:-4.2426406871px;left:0;bottom:0;right:0;margin:auto}.mat-pseudo-checkbox-minimal.mat-pseudo-checkbox-indeterminate::after{top:8px;width:16px}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-checked::after{width:10px;height:4px;transform-origin:center;top:-2.8284271247px;left:0;bottom:0;right:0;margin:auto}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-indeterminate::after{top:6px;width:12px}\"] }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [ANIMATION_MODULE_TYPE]\n                }] }]; }, propDecorators: { state: [{\n                type: Input\n            }], disabled: [{\n                type: Input\n            }], appearance: [{\n                type: Input\n            }] } });\n\nclass MatPseudoCheckboxModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatPseudoCheckboxModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: MatPseudoCheckboxModule, declarations: [MatPseudoCheckbox], imports: [MatCommonModule], exports: [MatPseudoCheckbox] }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatPseudoCheckboxModule, imports: [MatCommonModule] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatPseudoCheckboxModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [MatCommonModule],\n                    exports: [MatPseudoCheckbox],\n                    declarations: [MatPseudoCheckbox],\n                }]\n        }] });\n\n/**\n * Injection token used to provide the parent component to options.\n */\nconst MAT_OPTION_PARENT_COMPONENT = new InjectionToken('MAT_OPTION_PARENT_COMPONENT');\n\n// Notes on the accessibility pattern used for `mat-optgroup`.\n// The option group has two different \"modes\": regular and inert. The regular mode uses the\n// recommended a11y pattern which has `role=\"group\"` on the group element with `aria-labelledby`\n// pointing to the label. This works for `mat-select`, but it seems to hit a bug for autocomplete\n// under VoiceOver where the group doesn't get read out at all. The bug appears to be that if\n// there's __any__ a11y-related attribute on the group (e.g. `role` or `aria-labelledby`),\n// VoiceOver on Safari won't read it out.\n// We've introduced the `inert` mode as a workaround. Under this mode, all a11y attributes are\n// removed from the group, and we get the screen reader to read out the group label by mirroring it\n// inside an invisible element in the option. This is sub-optimal, because the screen reader will\n// repeat the group label on each navigation, whereas the default pattern only reads the group when\n// the user enters a new group. The following alternate approaches were considered:\n// 1. Reading out the group label using the `LiveAnnouncer` solves the problem, but we can't control\n//    when the text will be read out so sometimes it comes in too late or never if the user\n//    navigates quickly.\n// 2. `<mat-option aria-describedby=\"groupLabel\"` - This works on Safari, but VoiceOver in Chrome\n//    won't read out the description at all.\n// 3. `<mat-option aria-labelledby=\"optionLabel groupLabel\"` - This works on Chrome, but Safari\n//     doesn't read out the text at all. Furthermore, on\n// Boilerplate for applying mixins to MatOptgroup.\n/** @docs-private */\nconst _MatOptgroupMixinBase = mixinDisabled(class {\n});\n// Counter for unique group ids.\nlet _uniqueOptgroupIdCounter = 0;\nclass _MatOptgroupBase extends _MatOptgroupMixinBase {\n    constructor(parent) {\n        super();\n        /** Unique id for the underlying label. */\n        this._labelId = `mat-optgroup-label-${_uniqueOptgroupIdCounter++}`;\n        this._inert = parent?.inertGroups ?? false;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: _MatOptgroupBase, deps: [{ token: MAT_OPTION_PARENT_COMPONENT, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: _MatOptgroupBase, inputs: { label: \"label\" }, usesInheritance: true, ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: _MatOptgroupBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_OPTION_PARENT_COMPONENT]\n                }, {\n                    type: Optional\n                }] }]; }, propDecorators: { label: [{\n                type: Input\n            }] } });\n/**\n * Injection token that can be used to reference instances of `MatOptgroup`. It serves as\n * alternative token to the actual `MatOptgroup` class which could cause unnecessary\n * retention of the class and its component metadata.\n */\nconst MAT_OPTGROUP = new InjectionToken('MatOptgroup');\n/**\n * Component that is used to group instances of `mat-option`.\n */\nclass MatOptgroup extends _MatOptgroupBase {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatOptgroup, deps: null, target: i0.ɵɵFactoryTarget.Component }); }\n    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"14.0.0\", version: \"16.1.1\", type: MatOptgroup, selector: \"mat-optgroup\", inputs: { disabled: \"disabled\" }, host: { properties: { \"attr.role\": \"_inert ? null : \\\"group\\\"\", \"attr.aria-disabled\": \"_inert ? null : disabled.toString()\", \"attr.aria-labelledby\": \"_inert ? null : _labelId\" }, classAttribute: \"mat-mdc-optgroup\" }, providers: [{ provide: MAT_OPTGROUP, useExisting: MatOptgroup }], exportAs: [\"matOptgroup\"], usesInheritance: true, ngImport: i0, template: \"<span\\n  class=\\\"mat-mdc-optgroup-label\\\"\\n  role=\\\"presentation\\\"\\n  [class.mdc-list-item--disabled]=\\\"disabled\\\"\\n  [id]=\\\"_labelId\\\">\\n  <span class=\\\"mdc-list-item__primary-text\\\">{{ label }} <ng-content></ng-content></span>\\n</span>\\n\\n<ng-content select=\\\"mat-option, ng-container\\\"></ng-content>\\n\", styles: [\".mat-mdc-optgroup{color:var(--mat-optgroup-label-text-color);font-family:var(--mat-optgroup-label-text-font);line-height:var(--mat-optgroup-label-text-line-height);font-size:var(--mat-optgroup-label-text-size);letter-spacing:var(--mat-optgroup-label-text-tracking);font-weight:var(--mat-optgroup-label-text-weight)}.mat-mdc-optgroup-label{display:flex;position:relative;align-items:center;justify-content:flex-start;overflow:hidden;padding:0;padding-left:16px;padding-right:16px;min-height:48px}.mat-mdc-optgroup-label:focus{outline:none}[dir=rtl] .mat-mdc-optgroup-label,.mat-mdc-optgroup-label[dir=rtl]{padding-left:16px;padding-right:16px}.mat-mdc-optgroup-label.mdc-list-item--disabled{opacity:.38}.mat-mdc-optgroup-label .mdc-list-item__primary-text{font-size:inherit;font-weight:inherit;letter-spacing:inherit;line-height:inherit;font-family:inherit;text-decoration:inherit;text-transform:inherit;white-space:normal}\"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatOptgroup, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-optgroup', exportAs: 'matOptgroup', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, inputs: ['disabled'], host: {\n                        'class': 'mat-mdc-optgroup',\n                        '[attr.role]': '_inert ? null : \"group\"',\n                        '[attr.aria-disabled]': '_inert ? null : disabled.toString()',\n                        '[attr.aria-labelledby]': '_inert ? null : _labelId',\n                    }, providers: [{ provide: MAT_OPTGROUP, useExisting: MatOptgroup }], template: \"<span\\n  class=\\\"mat-mdc-optgroup-label\\\"\\n  role=\\\"presentation\\\"\\n  [class.mdc-list-item--disabled]=\\\"disabled\\\"\\n  [id]=\\\"_labelId\\\">\\n  <span class=\\\"mdc-list-item__primary-text\\\">{{ label }} <ng-content></ng-content></span>\\n</span>\\n\\n<ng-content select=\\\"mat-option, ng-container\\\"></ng-content>\\n\", styles: [\".mat-mdc-optgroup{color:var(--mat-optgroup-label-text-color);font-family:var(--mat-optgroup-label-text-font);line-height:var(--mat-optgroup-label-text-line-height);font-size:var(--mat-optgroup-label-text-size);letter-spacing:var(--mat-optgroup-label-text-tracking);font-weight:var(--mat-optgroup-label-text-weight)}.mat-mdc-optgroup-label{display:flex;position:relative;align-items:center;justify-content:flex-start;overflow:hidden;padding:0;padding-left:16px;padding-right:16px;min-height:48px}.mat-mdc-optgroup-label:focus{outline:none}[dir=rtl] .mat-mdc-optgroup-label,.mat-mdc-optgroup-label[dir=rtl]{padding-left:16px;padding-right:16px}.mat-mdc-optgroup-label.mdc-list-item--disabled{opacity:.38}.mat-mdc-optgroup-label .mdc-list-item__primary-text{font-size:inherit;font-weight:inherit;letter-spacing:inherit;line-height:inherit;font-family:inherit;text-decoration:inherit;text-transform:inherit;white-space:normal}\"] }]\n        }] });\n\n/**\n * Option IDs need to be unique across components, so this counter exists outside of\n * the component definition.\n */\nlet _uniqueIdCounter = 0;\n/** Event object emitted by MatOption when selected or deselected. */\nclass MatOptionSelectionChange {\n    constructor(\n    /** Reference to the option that emitted the event. */\n    source, \n    /** Whether the change in the option's value was a result of a user action. */\n    isUserInput = false) {\n        this.source = source;\n        this.isUserInput = isUserInput;\n    }\n}\nclass _MatOptionBase {\n    /** Whether the wrapping component is in multiple selection mode. */\n    get multiple() {\n        return this._parent && this._parent.multiple;\n    }\n    /** Whether or not the option is currently selected. */\n    get selected() {\n        return this._selected;\n    }\n    /** Whether the option is disabled. */\n    get disabled() {\n        return (this.group && this.group.disabled) || this._disabled;\n    }\n    set disabled(value) {\n        this._disabled = coerceBooleanProperty(value);\n    }\n    /** Whether ripples for the option are disabled. */\n    get disableRipple() {\n        return !!(this._parent && this._parent.disableRipple);\n    }\n    /** Whether to display checkmark for single-selection. */\n    get hideSingleSelectionIndicator() {\n        return !!(this._parent && this._parent.hideSingleSelectionIndicator);\n    }\n    constructor(_element, _changeDetectorRef, _parent, group) {\n        this._element = _element;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._parent = _parent;\n        this.group = group;\n        this._selected = false;\n        this._active = false;\n        this._disabled = false;\n        this._mostRecentViewValue = '';\n        /** The unique ID of the option. */\n        this.id = `mat-option-${_uniqueIdCounter++}`;\n        /** Event emitted when the option is selected or deselected. */\n        // tslint:disable-next-line:no-output-on-prefix\n        this.onSelectionChange = new EventEmitter();\n        /** Emits when the state of the option changes and any parents have to be notified. */\n        this._stateChanges = new Subject();\n    }\n    /**\n     * Whether or not the option is currently active and ready to be selected.\n     * An active option displays styles as if it is focused, but the\n     * focus is actually retained somewhere else. This comes in handy\n     * for components like autocomplete where focus must remain on the input.\n     */\n    get active() {\n        return this._active;\n    }\n    /**\n     * The displayed value of the option. It is necessary to show the selected option in the\n     * select's trigger.\n     */\n    get viewValue() {\n        // TODO(kara): Add input property alternative for node envs.\n        return (this._text?.nativeElement.textContent || '').trim();\n    }\n    /** Selects the option. */\n    select(emitEvent = true) {\n        if (!this._selected) {\n            this._selected = true;\n            this._changeDetectorRef.markForCheck();\n            if (emitEvent) {\n                this._emitSelectionChangeEvent();\n            }\n        }\n    }\n    /** Deselects the option. */\n    deselect(emitEvent = true) {\n        if (this._selected) {\n            this._selected = false;\n            this._changeDetectorRef.markForCheck();\n            if (emitEvent) {\n                this._emitSelectionChangeEvent();\n            }\n        }\n    }\n    /** Sets focus onto this option. */\n    focus(_origin, options) {\n        // Note that we aren't using `_origin`, but we need to keep it because some internal consumers\n        // use `MatOption` in a `FocusKeyManager` and we need it to match `FocusableOption`.\n        const element = this._getHostElement();\n        if (typeof element.focus === 'function') {\n            element.focus(options);\n        }\n    }\n    /**\n     * This method sets display styles on the option to make it appear\n     * active. This is used by the ActiveDescendantKeyManager so key\n     * events will display the proper options as active on arrow key events.\n     */\n    setActiveStyles() {\n        if (!this._active) {\n            this._active = true;\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n    /**\n     * This method removes display styles on the option that made it appear\n     * active. This is used by the ActiveDescendantKeyManager so key\n     * events will display the proper options as active on arrow key events.\n     */\n    setInactiveStyles() {\n        if (this._active) {\n            this._active = false;\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n    /** Gets the label to be used when determining whether the option should be focused. */\n    getLabel() {\n        return this.viewValue;\n    }\n    /** Ensures the option is selected when activated from the keyboard. */\n    _handleKeydown(event) {\n        if ((event.keyCode === ENTER || event.keyCode === SPACE) && !hasModifierKey(event)) {\n            this._selectViaInteraction();\n            // Prevent the page from scrolling down and form submits.\n            event.preventDefault();\n        }\n    }\n    /**\n     * `Selects the option while indicating the selection came from the user. Used to\n     * determine if the select's view -> model callback should be invoked.`\n     */\n    _selectViaInteraction() {\n        if (!this.disabled) {\n            this._selected = this.multiple ? !this._selected : true;\n            this._changeDetectorRef.markForCheck();\n            this._emitSelectionChangeEvent(true);\n        }\n    }\n    /** Returns the correct tabindex for the option depending on disabled state. */\n    // This method is only used by `MatLegacyOption`. Keeping it here to avoid breaking the types.\n    // That's because `MatLegacyOption` use `MatOption` type in a few places such as\n    // `MatOptionSelectionChange`. It is safe to delete this when `MatLegacyOption` is deleted.\n    _getTabIndex() {\n        return this.disabled ? '-1' : '0';\n    }\n    /** Gets the host DOM element. */\n    _getHostElement() {\n        return this._element.nativeElement;\n    }\n    ngAfterViewChecked() {\n        // Since parent components could be using the option's label to display the selected values\n        // (e.g. `mat-select`) and they don't have a way of knowing if the option's label has changed\n        // we have to check for changes in the DOM ourselves and dispatch an event. These checks are\n        // relatively cheap, however we still limit them only to selected options in order to avoid\n        // hitting the DOM too often.\n        if (this._selected) {\n            const viewValue = this.viewValue;\n            if (viewValue !== this._mostRecentViewValue) {\n                if (this._mostRecentViewValue) {\n                    this._stateChanges.next();\n                }\n                this._mostRecentViewValue = viewValue;\n            }\n        }\n    }\n    ngOnDestroy() {\n        this._stateChanges.complete();\n    }\n    /** Emits the selection change event. */\n    _emitSelectionChangeEvent(isUserInput = false) {\n        this.onSelectionChange.emit(new MatOptionSelectionChange(this, isUserInput));\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: _MatOptionBase, deps: \"invalid\", target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: _MatOptionBase, inputs: { value: \"value\", id: \"id\", disabled: \"disabled\" }, outputs: { onSelectionChange: \"onSelectionChange\" }, viewQueries: [{ propertyName: \"_text\", first: true, predicate: [\"text\"], descendants: true, static: true }], ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: _MatOptionBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: undefined }, { type: _MatOptgroupBase }]; }, propDecorators: { value: [{\n                type: Input\n            }], id: [{\n                type: Input\n            }], disabled: [{\n                type: Input\n            }], onSelectionChange: [{\n                type: Output\n            }], _text: [{\n                type: ViewChild,\n                args: ['text', { static: true }]\n            }] } });\n/**\n * Single option inside of a `<mat-select>` element.\n */\nclass MatOption extends _MatOptionBase {\n    constructor(element, changeDetectorRef, parent, group) {\n        super(element, changeDetectorRef, parent, group);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatOption, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: MAT_OPTION_PARENT_COMPONENT, optional: true }, { token: MAT_OPTGROUP, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }\n    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"14.0.0\", version: \"16.1.1\", type: MatOption, selector: \"mat-option\", host: { attributes: { \"role\": \"option\" }, listeners: { \"click\": \"_selectViaInteraction()\", \"keydown\": \"_handleKeydown($event)\" }, properties: { \"class.mdc-list-item--selected\": \"selected\", \"class.mat-mdc-option-multiple\": \"multiple\", \"class.mat-mdc-option-active\": \"active\", \"class.mdc-list-item--disabled\": \"disabled\", \"id\": \"id\", \"attr.aria-selected\": \"selected\", \"attr.aria-disabled\": \"disabled.toString()\" }, classAttribute: \"mat-mdc-option mdc-list-item\" }, exportAs: [\"matOption\"], usesInheritance: true, ngImport: i0, template: \"<!-- Set aria-hidden=\\\"true\\\" to this DOM node and other decorative nodes in this file. This might\\n be contributing to issue where sometimes VoiceOver focuses on a TextNode in the a11y tree instead\\n of the Option node (#23202). Most assistive technology will generally ignore non-role,\\n non-text-content elements. Adding aria-hidden seems to make VoiceOver behave more consistently. -->\\n<mat-pseudo-checkbox *ngIf=\\\"multiple\\\" class=\\\"mat-mdc-option-pseudo-checkbox\\\" [disabled]=\\\"disabled\\\"\\n    [state]=\\\"selected ? 'checked' : 'unchecked'\\\" aria-hidden=\\\"true\\\"></mat-pseudo-checkbox>\\n\\n<ng-content select=\\\"mat-icon\\\"></ng-content>\\n\\n<span class=\\\"mdc-list-item__primary-text\\\" #text><ng-content></ng-content></span>\\n\\n<!-- Render checkmark at the end for single-selection. -->\\n<mat-pseudo-checkbox *ngIf=\\\"!multiple && selected && !hideSingleSelectionIndicator\\\"\\n    class=\\\"mat-mdc-option-pseudo-checkbox\\\" [disabled]=\\\"disabled\\\" state=\\\"checked\\\"\\n    aria-hidden=\\\"true\\\" appearance=\\\"minimal\\\"></mat-pseudo-checkbox>\\n\\n<!-- See a11y notes inside optgroup.ts for context behind this element. -->\\n<span class=\\\"cdk-visually-hidden\\\" *ngIf=\\\"group && group._inert\\\">({{ group.label }})</span>\\n\\n<div class=\\\"mat-mdc-option-ripple mat-mdc-focus-indicator\\\" aria-hidden=\\\"true\\\" mat-ripple\\n     [matRippleTrigger]=\\\"_getHostElement()\\\" [matRippleDisabled]=\\\"disabled || disableRipple\\\">\\n</div>\\n\", styles: [\".mat-mdc-option{display:flex;position:relative;align-items:center;justify-content:flex-start;overflow:hidden;padding:0;padding-left:16px;padding-right:16px;-webkit-user-select:none;user-select:none;-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;cursor:pointer;-webkit-tap-highlight-color:rgba(0,0,0,0);color:var(--mat-option-label-text-color);font-family:var(--mat-option-label-text-font);line-height:var(--mat-option-label-text-line-height);font-size:var(--mat-option-label-text-size);letter-spacing:var(--mat-option-label-text-tracking);font-weight:var(--mat-option-label-text-weight);min-height:48px}.mat-mdc-option:focus{outline:none}[dir=rtl] .mat-mdc-option,.mat-mdc-option[dir=rtl]{padding-left:16px;padding-right:16px}.mat-mdc-option:hover:not(.mdc-list-item--disabled){background-color:var(--mat-option-hover-state-layer-color)}.mat-mdc-option:focus.mdc-list-item,.mat-mdc-option.mat-mdc-option-active.mdc-list-item{background-color:var(--mat-option-focus-state-layer-color)}.mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mat-option-selected-state-label-text-color)}.mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled):not(.mat-mdc-option-multiple){background-color:var(--mat-option-selected-state-layer-color)}.mat-mdc-option.mdc-list-item{align-items:center}.mat-mdc-option.mdc-list-item--disabled{cursor:default;pointer-events:none}.mat-mdc-option.mdc-list-item--disabled .mat-mdc-option-pseudo-checkbox,.mat-mdc-option.mdc-list-item--disabled .mdc-list-item__primary-text,.mat-mdc-option.mdc-list-item--disabled>mat-icon{opacity:.38}.mat-mdc-optgroup .mat-mdc-option:not(.mat-mdc-option-multiple){padding-left:32px}[dir=rtl] .mat-mdc-optgroup .mat-mdc-option:not(.mat-mdc-option-multiple){padding-left:16px;padding-right:32px}.mat-mdc-option .mat-icon,.mat-mdc-option .mat-pseudo-checkbox-full{margin-right:16px;flex-shrink:0}[dir=rtl] .mat-mdc-option .mat-icon,[dir=rtl] .mat-mdc-option .mat-pseudo-checkbox-full{margin-right:0;margin-left:16px}.mat-mdc-option .mat-pseudo-checkbox-minimal{margin-left:16px;flex-shrink:0}[dir=rtl] .mat-mdc-option .mat-pseudo-checkbox-minimal{margin-right:16px;margin-left:0}.mat-mdc-option .mat-mdc-option-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.mat-mdc-option .mdc-list-item__primary-text{white-space:normal;font-size:inherit;font-weight:inherit;letter-spacing:inherit;line-height:inherit;font-family:inherit;text-decoration:inherit;text-transform:inherit;margin-right:auto}[dir=rtl] .mat-mdc-option .mdc-list-item__primary-text{margin-right:0;margin-left:auto}.cdk-high-contrast-active .mat-mdc-option.mdc-list-item--selected:not(.mat-mdc-option-multiple)::after{content:\\\"\\\";position:absolute;top:50%;right:16px;transform:translateY(-50%);width:10px;height:0;border-bottom:solid 10px;border-radius:10px}[dir=rtl] .cdk-high-contrast-active .mat-mdc-option.mdc-list-item--selected:not(.mat-mdc-option-multiple)::after{right:auto;left:16px}.mat-mdc-option-active .mat-mdc-focus-indicator::before{content:\\\"\\\"}\"], dependencies: [{ kind: \"directive\", type: MatRipple, selector: \"[mat-ripple], [matRipple]\", inputs: [\"matRippleColor\", \"matRippleUnbounded\", \"matRippleCentered\", \"matRippleRadius\", \"matRippleAnimation\", \"matRippleDisabled\", \"matRippleTrigger\"], exportAs: [\"matRipple\"] }, { kind: \"directive\", type: i3.NgIf, selector: \"[ngIf]\", inputs: [\"ngIf\", \"ngIfThen\", \"ngIfElse\"] }, { kind: \"component\", type: MatPseudoCheckbox, selector: \"mat-pseudo-checkbox\", inputs: [\"state\", \"disabled\", \"appearance\"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatOption, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-option', exportAs: 'matOption', host: {\n                        'role': 'option',\n                        '[class.mdc-list-item--selected]': 'selected',\n                        '[class.mat-mdc-option-multiple]': 'multiple',\n                        '[class.mat-mdc-option-active]': 'active',\n                        '[class.mdc-list-item--disabled]': 'disabled',\n                        '[id]': 'id',\n                        // Set aria-selected to false for non-selected items and true for selected items. Conform to\n                        // [WAI ARIA Listbox authoring practices guide](\n                        //  https://www.w3.org/WAI/ARIA/apg/patterns/listbox/), \"If any options are selected, each\n                        // selected option has either aria-selected or aria-checked  set to true. All options that are\n                        // selectable but not selected have either aria-selected or aria-checked set to false.\" Align\n                        // aria-selected implementation of Chips and List components.\n                        //\n                        // Set `aria-selected=\"false\"` on not-selected listbox options to fix VoiceOver announcing\n                        // every option as \"selected\" (#21491).\n                        '[attr.aria-selected]': 'selected',\n                        '[attr.aria-disabled]': 'disabled.toString()',\n                        '(click)': '_selectViaInteraction()',\n                        '(keydown)': '_handleKeydown($event)',\n                        'class': 'mat-mdc-option mdc-list-item',\n                    }, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: \"<!-- Set aria-hidden=\\\"true\\\" to this DOM node and other decorative nodes in this file. This might\\n be contributing to issue where sometimes VoiceOver focuses on a TextNode in the a11y tree instead\\n of the Option node (#23202). Most assistive technology will generally ignore non-role,\\n non-text-content elements. Adding aria-hidden seems to make VoiceOver behave more consistently. -->\\n<mat-pseudo-checkbox *ngIf=\\\"multiple\\\" class=\\\"mat-mdc-option-pseudo-checkbox\\\" [disabled]=\\\"disabled\\\"\\n    [state]=\\\"selected ? 'checked' : 'unchecked'\\\" aria-hidden=\\\"true\\\"></mat-pseudo-checkbox>\\n\\n<ng-content select=\\\"mat-icon\\\"></ng-content>\\n\\n<span class=\\\"mdc-list-item__primary-text\\\" #text><ng-content></ng-content></span>\\n\\n<!-- Render checkmark at the end for single-selection. -->\\n<mat-pseudo-checkbox *ngIf=\\\"!multiple && selected && !hideSingleSelectionIndicator\\\"\\n    class=\\\"mat-mdc-option-pseudo-checkbox\\\" [disabled]=\\\"disabled\\\" state=\\\"checked\\\"\\n    aria-hidden=\\\"true\\\" appearance=\\\"minimal\\\"></mat-pseudo-checkbox>\\n\\n<!-- See a11y notes inside optgroup.ts for context behind this element. -->\\n<span class=\\\"cdk-visually-hidden\\\" *ngIf=\\\"group && group._inert\\\">({{ group.label }})</span>\\n\\n<div class=\\\"mat-mdc-option-ripple mat-mdc-focus-indicator\\\" aria-hidden=\\\"true\\\" mat-ripple\\n     [matRippleTrigger]=\\\"_getHostElement()\\\" [matRippleDisabled]=\\\"disabled || disableRipple\\\">\\n</div>\\n\", styles: [\".mat-mdc-option{display:flex;position:relative;align-items:center;justify-content:flex-start;overflow:hidden;padding:0;padding-left:16px;padding-right:16px;-webkit-user-select:none;user-select:none;-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;cursor:pointer;-webkit-tap-highlight-color:rgba(0,0,0,0);color:var(--mat-option-label-text-color);font-family:var(--mat-option-label-text-font);line-height:var(--mat-option-label-text-line-height);font-size:var(--mat-option-label-text-size);letter-spacing:var(--mat-option-label-text-tracking);font-weight:var(--mat-option-label-text-weight);min-height:48px}.mat-mdc-option:focus{outline:none}[dir=rtl] .mat-mdc-option,.mat-mdc-option[dir=rtl]{padding-left:16px;padding-right:16px}.mat-mdc-option:hover:not(.mdc-list-item--disabled){background-color:var(--mat-option-hover-state-layer-color)}.mat-mdc-option:focus.mdc-list-item,.mat-mdc-option.mat-mdc-option-active.mdc-list-item{background-color:var(--mat-option-focus-state-layer-color)}.mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mat-option-selected-state-label-text-color)}.mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled):not(.mat-mdc-option-multiple){background-color:var(--mat-option-selected-state-layer-color)}.mat-mdc-option.mdc-list-item{align-items:center}.mat-mdc-option.mdc-list-item--disabled{cursor:default;pointer-events:none}.mat-mdc-option.mdc-list-item--disabled .mat-mdc-option-pseudo-checkbox,.mat-mdc-option.mdc-list-item--disabled .mdc-list-item__primary-text,.mat-mdc-option.mdc-list-item--disabled>mat-icon{opacity:.38}.mat-mdc-optgroup .mat-mdc-option:not(.mat-mdc-option-multiple){padding-left:32px}[dir=rtl] .mat-mdc-optgroup .mat-mdc-option:not(.mat-mdc-option-multiple){padding-left:16px;padding-right:32px}.mat-mdc-option .mat-icon,.mat-mdc-option .mat-pseudo-checkbox-full{margin-right:16px;flex-shrink:0}[dir=rtl] .mat-mdc-option .mat-icon,[dir=rtl] .mat-mdc-option .mat-pseudo-checkbox-full{margin-right:0;margin-left:16px}.mat-mdc-option .mat-pseudo-checkbox-minimal{margin-left:16px;flex-shrink:0}[dir=rtl] .mat-mdc-option .mat-pseudo-checkbox-minimal{margin-right:16px;margin-left:0}.mat-mdc-option .mat-mdc-option-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.mat-mdc-option .mdc-list-item__primary-text{white-space:normal;font-size:inherit;font-weight:inherit;letter-spacing:inherit;line-height:inherit;font-family:inherit;text-decoration:inherit;text-transform:inherit;margin-right:auto}[dir=rtl] .mat-mdc-option .mdc-list-item__primary-text{margin-right:0;margin-left:auto}.cdk-high-contrast-active .mat-mdc-option.mdc-list-item--selected:not(.mat-mdc-option-multiple)::after{content:\\\"\\\";position:absolute;top:50%;right:16px;transform:translateY(-50%);width:10px;height:0;border-bottom:solid 10px;border-radius:10px}[dir=rtl] .cdk-high-contrast-active .mat-mdc-option.mdc-list-item--selected:not(.mat-mdc-option-multiple)::after{right:auto;left:16px}.mat-mdc-option-active .mat-mdc-focus-indicator::before{content:\\\"\\\"}\"] }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_OPTION_PARENT_COMPONENT]\n                }] }, { type: MatOptgroup, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_OPTGROUP]\n                }] }]; } });\n/**\n * Counts the amount of option group labels that precede the specified option.\n * @param optionIndex Index of the option at which to start counting.\n * @param options Flat list of all of the options.\n * @param optionGroups Flat list of all of the option groups.\n * @docs-private\n */\nfunction _countGroupLabelsBeforeOption(optionIndex, options, optionGroups) {\n    if (optionGroups.length) {\n        let optionsArray = options.toArray();\n        let groups = optionGroups.toArray();\n        let groupCounter = 0;\n        for (let i = 0; i < optionIndex + 1; i++) {\n            if (optionsArray[i].group && optionsArray[i].group === groups[groupCounter]) {\n                groupCounter++;\n            }\n        }\n        return groupCounter;\n    }\n    return 0;\n}\n/**\n * Determines the position to which to scroll a panel in order for an option to be into view.\n * @param optionOffset Offset of the option from the top of the panel.\n * @param optionHeight Height of the options.\n * @param currentScrollPosition Current scroll position of the panel.\n * @param panelHeight Height of the panel.\n * @docs-private\n */\nfunction _getOptionScrollPosition(optionOffset, optionHeight, currentScrollPosition, panelHeight) {\n    if (optionOffset < currentScrollPosition) {\n        return optionOffset;\n    }\n    if (optionOffset + optionHeight > currentScrollPosition + panelHeight) {\n        return Math.max(0, optionOffset - panelHeight + optionHeight);\n    }\n    return currentScrollPosition;\n}\n\nclass MatOptionModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatOptionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: MatOptionModule, declarations: [MatOption, MatOptgroup], imports: [MatRippleModule, CommonModule, MatCommonModule, MatPseudoCheckboxModule], exports: [MatOption, MatOptgroup] }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatOptionModule, imports: [MatRippleModule, CommonModule, MatCommonModule, MatPseudoCheckboxModule] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatOptionModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [MatRippleModule, CommonModule, MatCommonModule, MatPseudoCheckboxModule],\n                    exports: [MatOption, MatOptgroup],\n                    declarations: [MatOption, MatOptgroup],\n                }]\n        }] });\n\n/** The options for the MatRippleLoader's event listeners. */\nconst eventListenerOptions = { capture: true };\n/** The events that should trigger the initialization of the ripple. */\nconst rippleInteractionEvents = ['focus', 'click', 'mouseenter', 'touchstart'];\n/** The attribute attached to a component whose ripple has not yet been initialized. */\nconst matRippleUninitialized = 'mat-ripple-loader-uninitialized';\n/** Additional classes that should be added to the ripple when it is rendered. */\nconst matRippleClassName = 'mat-ripple-loader-class-name';\n/** Whether the ripple should be centered. */\nconst matRippleCentered = 'mat-ripple-loader-centered';\n/** Whether the ripple should be disabled. */\nconst matRippleDisabled = 'mat-ripple-loader-disabled';\n/**\n * Handles attaching ripples on demand.\n *\n * This service allows us to avoid eagerly creating & attaching MatRipples.\n * It works by creating & attaching a ripple only when a component is first interacted with.\n */\nclass MatRippleLoader {\n    constructor() {\n        this._document = inject(DOCUMENT, { optional: true });\n        this._animationMode = inject(ANIMATION_MODULE_TYPE$1, { optional: true });\n        this._globalRippleOptions = inject(MAT_RIPPLE_GLOBAL_OPTIONS, { optional: true });\n        this._platform = inject(Platform);\n        this._ngZone = inject(NgZone);\n        /** Handles creating and attaching component internals when a component it is initially interacted with. */\n        this._onInteraction = (event) => {\n            if (!(event.target instanceof HTMLElement)) {\n                return;\n            }\n            const eventTarget = event.target;\n            // TODO(wagnermaciel): Consider batching these events to improve runtime performance.\n            const element = eventTarget.closest(`[${matRippleUninitialized}]`);\n            if (element) {\n                this.createRipple(element);\n            }\n        };\n        this._ngZone.runOutsideAngular(() => {\n            for (const event of rippleInteractionEvents) {\n                this._document?.addEventListener(event, this._onInteraction, eventListenerOptions);\n            }\n        });\n    }\n    ngOnDestroy() {\n        for (const event of rippleInteractionEvents) {\n            this._document?.removeEventListener(event, this._onInteraction, eventListenerOptions);\n        }\n    }\n    /**\n     * Configures the ripple that will be rendered by the ripple loader.\n     *\n     * Stores the given information about how the ripple should be configured on the host\n     * element so that it can later be retrived & used when the ripple is actually created.\n     */\n    configureRipple(host, config) {\n        // Indicates that the ripple has not yet been rendered for this component.\n        host.setAttribute(matRippleUninitialized, '');\n        // Store the additional class name(s) that should be added to the ripple element.\n        if (config.className || !host.hasAttribute(matRippleClassName)) {\n            host.setAttribute(matRippleClassName, config.className || '');\n        }\n        // Store whether the ripple should be centered.\n        if (config.centered) {\n            host.setAttribute(matRippleCentered, '');\n        }\n        if (config.disabled) {\n            host.setAttribute(matRippleDisabled, '');\n        }\n    }\n    /** Returns the ripple instance for the given host element. */\n    getRipple(host) {\n        if (host.matRipple) {\n            return host.matRipple;\n        }\n        return this.createRipple(host);\n    }\n    /** Sets the disabled state on the ripple instance corresponding to the given host element. */\n    setDisabled(host, disabled) {\n        const ripple = host.matRipple;\n        // If the ripple has already been instantiated, just disable it.\n        if (ripple) {\n            ripple.disabled = disabled;\n            return;\n        }\n        // Otherwise, set an attribute so we know what the\n        // disabled state should be when the ripple is initialized.\n        if (disabled) {\n            host.setAttribute(matRippleDisabled, '');\n        }\n        else {\n            host.removeAttribute(matRippleDisabled);\n        }\n    }\n    /** Creates a MatRipple and appends it to the given element. */\n    createRipple(host) {\n        if (!this._document) {\n            return;\n        }\n        // Create the ripple element.\n        host.querySelector('.mat-ripple')?.remove();\n        const rippleEl = this._document.createElement('span');\n        rippleEl.classList.add('mat-ripple', host.getAttribute(matRippleClassName));\n        host.append(rippleEl);\n        // Create the MatRipple.\n        const ripple = new MatRipple(new ElementRef(rippleEl), this._ngZone, this._platform, this._globalRippleOptions ? this._globalRippleOptions : undefined, this._animationMode ? this._animationMode : undefined);\n        ripple._isInitialized = true;\n        ripple.trigger = host;\n        ripple.centered = host.hasAttribute(matRippleCentered);\n        ripple.disabled = host.hasAttribute(matRippleDisabled);\n        this.attachRipple(host, ripple);\n        return ripple;\n    }\n    attachRipple(host, ripple) {\n        host.removeAttribute(matRippleUninitialized);\n        host.matRipple = ripple;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatRippleLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatRippleLoader, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatRippleLoader, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return []; } });\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { AnimationCurves, AnimationDurations, DateAdapter, ErrorStateMatcher, MATERIAL_SANITY_CHECKS, MAT_DATE_FORMATS, MAT_DATE_LOCALE, MAT_DATE_LOCALE_FACTORY, MAT_NATIVE_DATE_FORMATS, MAT_OPTGROUP, MAT_OPTION_PARENT_COMPONENT, MAT_RIPPLE_GLOBAL_OPTIONS, MatCommonModule, MatLine, MatLineModule, MatNativeDateModule, MatOptgroup, MatOption, MatOptionModule, MatOptionSelectionChange, MatPseudoCheckbox, MatPseudoCheckboxModule, MatRipple, MatRippleLoader, MatRippleModule, NativeDateAdapter, NativeDateModule, RippleRef, RippleRenderer, ShowOnDirtyErrorStateMatcher, VERSION, _MatOptgroupBase, _MatOptionBase, _countGroupLabelsBeforeOption, _getOptionScrollPosition, defaultRippleAnimationConfig, mixinColor, mixinDisableRipple, mixinDisabled, mixinErrorState, mixinInitialized, mixinTabIndex, setLines };\n"],"x_google_ignoreList":[0,1,2,3,4,5,6,7]}