{"version":3,"file":"default-node_modules_angular_material_fesm2020_select_mjs.39c1bedc3f3f7413.js","mappings":"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","names":["i0","ctx_r2","ctx_r5","_r9","ctx_r8","ctx_r10","matSelectAnimations","transformPanelWrap","trigger","transition","query","animateChild","optional","transformPanel","state","style","transform","minWidth","opacity","animate","nextUniqueId","SELECT_PANEL_MAX_HEIGHT","MAT_SELECT_SCROLL_STRATEGY","InjectionToken","MAT_SELECT_CONFIG","MAT_SELECT_SCROLL_STRATEGY_PROVIDER","provide","deps","Overlay","useFactory","MAT_SELECT_SCROLL_STRATEGY_PROVIDER_FACTORY","overlay","scrollStrategies","reposition","MatSelectChange","constructor","source","value","this","_MatSelectMixinBase","mixinDisableRipple","mixinTabIndex","mixinDisabled","mixinErrorState","_elementRef","_defaultErrorStateMatcher","_parentForm","_parentFormGroup","ngControl","stateChanges","Subject","MAT_SELECT_TRIGGER","_MatSelectBase","_viewportRuler","_changeDetectorRef","_ngZone","elementRef","_dir","_parentFormField","tabIndex","scrollStrategyFactory","_liveAnnouncer","_defaultOptions","super","_panelOpen","_compareWith","o1","o2","_uid","_triggerAriaLabelledBy","_destroy","_onChange","_onTouched","_valueId","_panelDoneAnimatingStream","_overlayPanelClass","overlayPanelClass","_focused","controlType","_multiple","_disableOptionCentering","disableOptionCentering","ariaLabel","optionSelectionChanges","defer","options","changes","pipe","startWith","switchMap","merge","map","option","onSelectionChange","onStable","take","openedChange","EventEmitter","_openedStream","filter","o","_closedStream","selectionChange","valueChange","valueAccessor","typeaheadDebounceInterval","_typeaheadDebounceInterval","_scrollStrategyFactory","_scrollStrategy","parseInt","id","focused","placeholder","_placeholder","next","required","_required","control","hasValidator","Validators","coerceBooleanProperty","multiple","compareWith","fn","_selectionModel","_initializeSelection","_value","newValue","_assignValue","coerceNumberProperty","_id","ngOnInit","SelectionModel","distinctUntilChanged","takeUntil","subscribe","_panelDoneAnimating","panelOpen","ngAfterContentInit","_initKeyManager","changed","event","added","forEach","select","removed","deselect","_resetOptions","ngDoCheck","newAriaLabelledby","_getTriggerAriaLabelledby","element","nativeElement","setAttribute","removeAttribute","_previousControl","undefined","disabled","updateErrorState","ngOnChanges","userAriaDescribedBy","_keyManager","withTypeAhead","ngOnDestroy","complete","toggle","close","open","_canOpen","withHorizontalOrientation","_highlightCorrectOption","markForCheck","_isRtl","writeValue","registerOnChange","registerOnTouched","setDisabledState","isDisabled","selected","triggerValue","empty","selectedOptions","viewValue","reverse","join","_handleKeydown","_handleOpenKeydown","_handleClosedKeydown","keyCode","isArrowKey","DOWN_ARROW","UP_ARROW","LEFT_ARROW","RIGHT_ARROW","isOpenKey","ENTER","SPACE","manager","isTyping","hasModifierKey","altKey","preventDefault","previouslySelectedOption","onKeydown","selectedOption","announce","activeItem","A","ctrlKey","hasDeselectedOptions","some","opt","previouslyFocusedIndex","activeItemIndex","shiftKey","_selectViaInteraction","_onFocus","_onBlur","_onAttached","_overlayDir","positionChange","detectChanges","_positioningSettled","_getPanelTheme","color","isEmpty","Promise","resolve","then","_setSelectionByValue","setInactiveStyles","clear","Array","isArray","currentValue","_selectOptionByValue","_sortValues","correspondingOption","updateActiveItem","find","isSelected","ActiveDescendantKeyManager","withVerticalOrientation","withHomeAndEnd","withAllowedModifierKeys","tabOut","focus","change","panel","_scrollOptionIntoView","changedOrDestroyed","_onSelect","isUserInput","_stateChanges","wasSelected","setActiveItem","_propagateChanges","toArray","sort","a","b","sortComparator","indexOf","fallbackValue","valueToEmit","emit","_getChangeEvent","setFirstItemActive","length","_getPanelAriaLabelledby","labelId","getLabelId","ariaLabelledby","_getAriaActiveDescendant","isOpen","setDescribedByIds","ids","onContainerClick","shouldLabelFloat","ɵfac","i1","i2","i3","i4","MAT_FORM_FIELD","i5","ɵdir","viewQuery","_c0","_c1","CdkConnectedOverlay","_t","ctx","MatSelect","arguments","_scrollTop","_triggerFontSize","_transformOrigin","_offsetY","_positions","originX","originY","overlayX","overlayY","_calculateOverlayScroll","selectedIndex","scrollBuffer","maxScroll","itemHeight","_getItemHeight","Math","min","max","_triggerRect","getBoundingClientRect","getComputedStyle","fontSize","_calculateOverlayPosition","overlayRef","overlayElement","index","labelCount","_countGroupLabelsBeforeOption","optionGroups","scrollTop","_getOptionScrollPosition","_calculateOverlayOffsetX","offsetX","overlayRect","viewportSize","getViewportSize","isRtl","paddingWidth","SELECT_MULTIPLE_PANEL_PADDING_X","SELECT_PANEL_PADDING_X","first","group","leftOverflow","left","rightOverflow","right","width","round","updatePosition","_calculateOverlayOffsetY","optionHeightAdjustment","height","maxOptionsDisplayed","floor","optionOffsetFromPanelTop","_getItemCount","_checkOverlayWithinViewport","topSpaceAvailable","top","bottomSpaceAvailable","bottom","panelHeightTop","abs","panelHeightBottom","_adjustPanelUp","_adjustPanelDown","_getOriginBasedOnOption","distanceBelowViewport","distanceAboveViewport","items","panelHeight","selectedOptionOffset","t","ɵcmp","selectors","dirIndex","MatOption","MAT_OPTGROUP","MatFormFieldControl","useExisting","MAT_OPTION_PARENT_COMPONENT","ngContentSelectors","_c2","i7","i8","styles","changeDetection","MatSelectModule","ɵmod","ɵinj","imports","CommonModule","OverlayModule","MatOptionModule","MatCommonModule","CdkScrollableModule","MatFormFieldModule"],"sourceRoot":"webpack:///","sources":["./node_modules/@angular/material/fesm2020/select.mjs"],"sourcesContent":["import * as i8 from '@angular/cdk/overlay';\nimport { Overlay, CdkConnectedOverlay, OverlayModule } from '@angular/cdk/overlay';\nimport * as i7 from '@angular/common';\nimport { CommonModule } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { InjectionToken, Directive, EventEmitter, Optional, Inject, Self, Attribute, Input, ViewChild, Output, Component, ViewEncapsulation, ChangeDetectionStrategy, ContentChildren, ContentChild, NgModule } from '@angular/core';\nimport * as i2 from '@angular/material/core';\nimport { mixinDisableRipple, mixinTabIndex, mixinDisabled, mixinErrorState, _countGroupLabelsBeforeOption, _getOptionScrollPosition, MAT_OPTION_PARENT_COMPONENT, MatOption, MAT_OPTGROUP, MatOptionModule, MatCommonModule } from '@angular/material/core';\nimport * as i6 from '@angular/material/form-field';\nimport { MAT_FORM_FIELD, MatFormFieldControl, MatFormFieldModule } from '@angular/material/form-field';\nimport * as i1 from '@angular/cdk/scrolling';\nimport { CdkScrollableModule } from '@angular/cdk/scrolling';\nimport * as i5 from '@angular/cdk/a11y';\nimport { ActiveDescendantKeyManager } from '@angular/cdk/a11y';\nimport * as i3 from '@angular/cdk/bidi';\nimport { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';\nimport { SelectionModel } from '@angular/cdk/collections';\nimport { DOWN_ARROW, UP_ARROW, LEFT_ARROW, RIGHT_ARROW, ENTER, SPACE, hasModifierKey, A } from '@angular/cdk/keycodes';\nimport * as i4 from '@angular/forms';\nimport { Validators } from '@angular/forms';\nimport { Subject, defer, merge } from 'rxjs';\nimport { startWith, switchMap, take, filter, map, distinctUntilChanged, takeUntil } from 'rxjs/operators';\nimport { trigger, transition, query, animateChild, state, style, animate } from '@angular/animations';\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * The following are all the animations for the mat-select component, with each\n * const containing the metadata for one animation.\n *\n * The values below match the implementation of the AngularJS Material mat-select animation.\n * @docs-private\n */\nconst matSelectAnimations = {\n    /**\n     * This animation ensures the select's overlay panel animation (transformPanel) is called when\n     * closing the select.\n     * This is needed due to https://github.com/angular/angular/issues/23302\n     */\n    transformPanelWrap: trigger('transformPanelWrap', [\n        transition('* => void', query('@transformPanel', [animateChild()], { optional: true })),\n    ]),\n    /**\n     * This animation transforms the select's overlay panel on and off the page.\n     *\n     * When the panel is attached to the DOM, it expands its width by the amount of padding, scales it\n     * up to 100% on the Y axis, fades in its border, and translates slightly up and to the\n     * side to ensure the option text correctly overlaps the trigger text.\n     *\n     * When the panel is removed from the DOM, it simply fades out linearly.\n     */\n    transformPanel: trigger('transformPanel', [\n        state('void', style({\n            transform: 'scaleY(0.8)',\n            minWidth: '100%',\n            opacity: 0,\n        })),\n        state('showing', style({\n            opacity: 1,\n            minWidth: 'calc(100% + 32px)',\n            transform: 'scaleY(1)',\n        })),\n        state('showing-multiple', style({\n            opacity: 1,\n            minWidth: 'calc(100% + 64px)',\n            transform: 'scaleY(1)',\n        })),\n        transition('void => *', animate('120ms cubic-bezier(0, 0, 0.2, 1)')),\n        transition('* => void', animate('100ms 25ms linear', style({ opacity: 0 }))),\n    ]),\n};\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Returns an exception to be thrown when attempting to change a select's `multiple` option\n * after initialization.\n * @docs-private\n */\nfunction getMatSelectDynamicMultipleError() {\n    return Error('Cannot change `multiple` mode of select after initialization.');\n}\n/**\n * Returns an exception to be thrown when attempting to assign a non-array value to a select\n * in `multiple` mode. Note that `undefined` and `null` are still valid values to allow for\n * resetting the value.\n * @docs-private\n */\nfunction getMatSelectNonArrayValueError() {\n    return Error('Value must be an array in multiple-selection mode.');\n}\n/**\n * Returns an exception to be thrown when assigning a non-function value to the comparator\n * used to determine if a value corresponds to an option. Note that whether the function\n * actually takes two values and returns a boolean is not checked.\n */\nfunction getMatSelectNonFunctionValueError() {\n    return Error('`compareWith` must be a function.');\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nlet nextUniqueId = 0;\n/**\n * The following style constants are necessary to save here in order\n * to properly calculate the alignment of the selected option over\n * the trigger element.\n */\n/** The max height of the select's overlay panel. */\nconst SELECT_PANEL_MAX_HEIGHT = 256;\n/** The panel's padding on the x-axis. */\nconst SELECT_PANEL_PADDING_X = 16;\n/** The panel's x axis padding if it is indented (e.g. there is an option group). */\nconst SELECT_PANEL_INDENT_PADDING_X = SELECT_PANEL_PADDING_X * 2;\n/** The height of the select items in `em` units. */\nconst SELECT_ITEM_HEIGHT_EM = 3;\n// TODO(josephperrott): Revert to a constant after 2018 spec updates are fully merged.\n/**\n * Distance between the panel edge and the option text in\n * multi-selection mode.\n *\n * Calculated as:\n * (SELECT_PANEL_PADDING_X * 1.5) + 16 = 40\n * The padding is multiplied by 1.5 because the checkbox's margin is half the padding.\n * The checkbox width is 16px.\n */\nconst SELECT_MULTIPLE_PANEL_PADDING_X = SELECT_PANEL_PADDING_X * 1.5 + 16;\n/**\n * The select panel will only \"fit\" inside the viewport if it is positioned at\n * this value or more away from the viewport boundary.\n */\nconst SELECT_PANEL_VIEWPORT_PADDING = 8;\n/** Injection token that determines the scroll handling while a select is open. */\nconst MAT_SELECT_SCROLL_STRATEGY = new InjectionToken('mat-select-scroll-strategy');\n/** @docs-private */\nfunction MAT_SELECT_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {\n    return () => overlay.scrollStrategies.reposition();\n}\n/** Injection token that can be used to provide the default options the select module. */\nconst MAT_SELECT_CONFIG = new InjectionToken('MAT_SELECT_CONFIG');\n/** @docs-private */\nconst MAT_SELECT_SCROLL_STRATEGY_PROVIDER = {\n    provide: MAT_SELECT_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: MAT_SELECT_SCROLL_STRATEGY_PROVIDER_FACTORY,\n};\n/** Change event object that is emitted when the select value has changed. */\nclass MatSelectChange {\n    constructor(\n    /** Reference to the select that emitted the change event. */\n    source, \n    /** Current value of the select that emitted the event. */\n    value) {\n        this.source = source;\n        this.value = value;\n    }\n}\n// Boilerplate for applying mixins to MatSelect.\n/** @docs-private */\nconst _MatSelectMixinBase = mixinDisableRipple(mixinTabIndex(mixinDisabled(mixinErrorState(class {\n    constructor(_elementRef, _defaultErrorStateMatcher, _parentForm, _parentFormGroup, \n    /**\n     * Form control bound to the component.\n     * Implemented as part of `MatFormFieldControl`.\n     * @docs-private\n     */\n    ngControl) {\n        this._elementRef = _elementRef;\n        this._defaultErrorStateMatcher = _defaultErrorStateMatcher;\n        this._parentForm = _parentForm;\n        this._parentFormGroup = _parentFormGroup;\n        this.ngControl = ngControl;\n        /**\n         * Emits whenever the component state changes and should cause the parent\n         * form-field to update. Implemented as part of `MatFormFieldControl`.\n         * @docs-private\n         */\n        this.stateChanges = new Subject();\n    }\n}))));\n/**\n * Injection token that can be used to reference instances of `MatSelectTrigger`. It serves as\n * alternative token to the actual `MatSelectTrigger` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */\nconst MAT_SELECT_TRIGGER = new InjectionToken('MatSelectTrigger');\n/**\n * Allows the user to customize the trigger that is displayed when the select has a value.\n */\nclass MatSelectTrigger {\n}\nMatSelectTrigger.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: MatSelectTrigger, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatSelectTrigger.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.2.0-rc.0\", type: MatSelectTrigger, selector: \"mat-select-trigger\", providers: [{ provide: MAT_SELECT_TRIGGER, useExisting: MatSelectTrigger }], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: MatSelectTrigger, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-select-trigger',\n                    providers: [{ provide: MAT_SELECT_TRIGGER, useExisting: MatSelectTrigger }],\n                }]\n        }] });\n/** Base class with all of the `MatSelect` functionality. */\nclass _MatSelectBase extends _MatSelectMixinBase {\n    constructor(_viewportRuler, _changeDetectorRef, _ngZone, _defaultErrorStateMatcher, elementRef, _dir, _parentForm, _parentFormGroup, _parentFormField, ngControl, tabIndex, scrollStrategyFactory, _liveAnnouncer, _defaultOptions) {\n        super(elementRef, _defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl);\n        this._viewportRuler = _viewportRuler;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._ngZone = _ngZone;\n        this._dir = _dir;\n        this._parentFormField = _parentFormField;\n        this._liveAnnouncer = _liveAnnouncer;\n        this._defaultOptions = _defaultOptions;\n        /** Whether or not the overlay panel is open. */\n        this._panelOpen = false;\n        /** Comparison function to specify which option is displayed. Defaults to object equality. */\n        this._compareWith = (o1, o2) => o1 === o2;\n        /** Unique id for this input. */\n        this._uid = `mat-select-${nextUniqueId++}`;\n        /** Current `aria-labelledby` value for the select trigger. */\n        this._triggerAriaLabelledBy = null;\n        /** Emits whenever the component is destroyed. */\n        this._destroy = new Subject();\n        /** `View -> model callback called when value changes` */\n        this._onChange = () => { };\n        /** `View -> model callback called when select has been touched` */\n        this._onTouched = () => { };\n        /** ID for the DOM node containing the select's value. */\n        this._valueId = `mat-select-value-${nextUniqueId++}`;\n        /** Emits when the panel element is finished transforming in. */\n        this._panelDoneAnimatingStream = new Subject();\n        this._overlayPanelClass = this._defaultOptions?.overlayPanelClass || '';\n        this._focused = false;\n        /** A name for this control that can be used by `mat-form-field`. */\n        this.controlType = 'mat-select';\n        this._multiple = false;\n        this._disableOptionCentering = this._defaultOptions?.disableOptionCentering ?? false;\n        /** Aria label of the select. */\n        this.ariaLabel = '';\n        /** Combined stream of all of the child options' change events. */\n        this.optionSelectionChanges = defer(() => {\n            const options = this.options;\n            if (options) {\n                return options.changes.pipe(startWith(options), switchMap(() => merge(...options.map(option => option.onSelectionChange))));\n            }\n            return this._ngZone.onStable.pipe(take(1), switchMap(() => this.optionSelectionChanges));\n        });\n        /** Event emitted when the select panel has been toggled. */\n        this.openedChange = new EventEmitter();\n        /** Event emitted when the select has been opened. */\n        this._openedStream = this.openedChange.pipe(filter(o => o), map(() => { }));\n        /** Event emitted when the select has been closed. */\n        this._closedStream = this.openedChange.pipe(filter(o => !o), map(() => { }));\n        /** Event emitted when the selected value has been changed by the user. */\n        this.selectionChange = new EventEmitter();\n        /**\n         * Event that emits whenever the raw value of the select changes. This is here primarily\n         * to facilitate the two-way binding for the `value` input.\n         * @docs-private\n         */\n        this.valueChange = new EventEmitter();\n        if (this.ngControl) {\n            // Note: we provide the value accessor through here, instead of\n            // the `providers` to avoid running into a circular import.\n            this.ngControl.valueAccessor = this;\n        }\n        // Note that we only want to set this when the defaults pass it in, otherwise it should\n        // stay as `undefined` so that it falls back to the default in the key manager.\n        if (_defaultOptions?.typeaheadDebounceInterval != null) {\n            this._typeaheadDebounceInterval = _defaultOptions.typeaheadDebounceInterval;\n        }\n        this._scrollStrategyFactory = scrollStrategyFactory;\n        this._scrollStrategy = this._scrollStrategyFactory();\n        this.tabIndex = parseInt(tabIndex) || 0;\n        // Force setter to be called in case id was not specified.\n        this.id = this.id;\n    }\n    /** Whether the select is focused. */\n    get focused() {\n        return this._focused || this._panelOpen;\n    }\n    /** Placeholder to be shown if no value has been selected. */\n    get placeholder() {\n        return this._placeholder;\n    }\n    set placeholder(value) {\n        this._placeholder = value;\n        this.stateChanges.next();\n    }\n    /** Whether the component is required. */\n    get required() {\n        return this._required ?? this.ngControl?.control?.hasValidator(Validators.required) ?? false;\n    }\n    set required(value) {\n        this._required = coerceBooleanProperty(value);\n        this.stateChanges.next();\n    }\n    /** Whether the user should be allowed to select multiple options. */\n    get multiple() {\n        return this._multiple;\n    }\n    set multiple(value) {\n        if (this._selectionModel && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getMatSelectDynamicMultipleError();\n        }\n        this._multiple = coerceBooleanProperty(value);\n    }\n    /** Whether to center the active option over the trigger. */\n    get disableOptionCentering() {\n        return this._disableOptionCentering;\n    }\n    set disableOptionCentering(value) {\n        this._disableOptionCentering = coerceBooleanProperty(value);\n    }\n    /**\n     * Function to compare the option values with the selected values. The first argument\n     * is a value from an option. The second is a value from the selection. A boolean\n     * should be returned.\n     */\n    get compareWith() {\n        return this._compareWith;\n    }\n    set compareWith(fn) {\n        if (typeof fn !== 'function' && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getMatSelectNonFunctionValueError();\n        }\n        this._compareWith = fn;\n        if (this._selectionModel) {\n            // A different comparator means the selection could change.\n            this._initializeSelection();\n        }\n    }\n    /** Value of the select control. */\n    get value() {\n        return this._value;\n    }\n    set value(newValue) {\n        const hasAssigned = this._assignValue(newValue);\n        if (hasAssigned) {\n            this._onChange(newValue);\n        }\n    }\n    /** Time to wait in milliseconds after the last keystroke before moving focus to an item. */\n    get typeaheadDebounceInterval() {\n        return this._typeaheadDebounceInterval;\n    }\n    set typeaheadDebounceInterval(value) {\n        this._typeaheadDebounceInterval = coerceNumberProperty(value);\n    }\n    /** Unique id of the element. */\n    get id() {\n        return this._id;\n    }\n    set id(value) {\n        this._id = value || this._uid;\n        this.stateChanges.next();\n    }\n    ngOnInit() {\n        this._selectionModel = new SelectionModel(this.multiple);\n        this.stateChanges.next();\n        // We need `distinctUntilChanged` here, because some browsers will\n        // fire the animation end event twice for the same animation. See:\n        // https://github.com/angular/angular/issues/24084\n        this._panelDoneAnimatingStream\n            .pipe(distinctUntilChanged(), takeUntil(this._destroy))\n            .subscribe(() => this._panelDoneAnimating(this.panelOpen));\n    }\n    ngAfterContentInit() {\n        this._initKeyManager();\n        this._selectionModel.changed.pipe(takeUntil(this._destroy)).subscribe(event => {\n            event.added.forEach(option => option.select());\n            event.removed.forEach(option => option.deselect());\n        });\n        this.options.changes.pipe(startWith(null), takeUntil(this._destroy)).subscribe(() => {\n            this._resetOptions();\n            this._initializeSelection();\n        });\n    }\n    ngDoCheck() {\n        const newAriaLabelledby = this._getTriggerAriaLabelledby();\n        const ngControl = this.ngControl;\n        // We have to manage setting the `aria-labelledby` ourselves, because part of its value\n        // is computed as a result of a content query which can cause this binding to trigger a\n        // \"changed after checked\" error.\n        if (newAriaLabelledby !== this._triggerAriaLabelledBy) {\n            const element = this._elementRef.nativeElement;\n            this._triggerAriaLabelledBy = newAriaLabelledby;\n            if (newAriaLabelledby) {\n                element.setAttribute('aria-labelledby', newAriaLabelledby);\n            }\n            else {\n                element.removeAttribute('aria-labelledby');\n            }\n        }\n        if (ngControl) {\n            // The disabled state might go out of sync if the form group is swapped out. See #17860.\n            if (this._previousControl !== ngControl.control) {\n                if (this._previousControl !== undefined &&\n                    ngControl.disabled !== null &&\n                    ngControl.disabled !== this.disabled) {\n                    this.disabled = ngControl.disabled;\n                }\n                this._previousControl = ngControl.control;\n            }\n            this.updateErrorState();\n        }\n    }\n    ngOnChanges(changes) {\n        // Updating the disabled state is handled by `mixinDisabled`, but we need to additionally let\n        // the parent form field know to run change detection when the disabled state changes.\n        if (changes['disabled'] || changes['userAriaDescribedBy']) {\n            this.stateChanges.next();\n        }\n        if (changes['typeaheadDebounceInterval'] && this._keyManager) {\n            this._keyManager.withTypeAhead(this._typeaheadDebounceInterval);\n        }\n    }\n    ngOnDestroy() {\n        this._destroy.next();\n        this._destroy.complete();\n        this.stateChanges.complete();\n    }\n    /** Toggles the overlay panel open or closed. */\n    toggle() {\n        this.panelOpen ? this.close() : this.open();\n    }\n    /** Opens the overlay panel. */\n    open() {\n        if (this._canOpen()) {\n            this._panelOpen = true;\n            this._keyManager.withHorizontalOrientation(null);\n            this._highlightCorrectOption();\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n    /** Closes the overlay panel and focuses the host element. */\n    close() {\n        if (this._panelOpen) {\n            this._panelOpen = false;\n            this._keyManager.withHorizontalOrientation(this._isRtl() ? 'rtl' : 'ltr');\n            this._changeDetectorRef.markForCheck();\n            this._onTouched();\n        }\n    }\n    /**\n     * Sets the select's value. Part of the ControlValueAccessor interface\n     * required to integrate with Angular's core forms API.\n     *\n     * @param value New value to be written to the model.\n     */\n    writeValue(value) {\n        this._assignValue(value);\n    }\n    /**\n     * Saves a callback function to be invoked when the select's value\n     * changes from user input. Part of the ControlValueAccessor interface\n     * required to integrate with Angular's core forms API.\n     *\n     * @param fn Callback to be triggered when the value changes.\n     */\n    registerOnChange(fn) {\n        this._onChange = fn;\n    }\n    /**\n     * Saves a callback function to be invoked when the select is blurred\n     * by the user. Part of the ControlValueAccessor interface required\n     * to integrate with Angular's core forms API.\n     *\n     * @param fn Callback to be triggered when the component has been touched.\n     */\n    registerOnTouched(fn) {\n        this._onTouched = fn;\n    }\n    /**\n     * Disables the select. Part of the ControlValueAccessor interface required\n     * to integrate with Angular's core forms API.\n     *\n     * @param isDisabled Sets whether the component is disabled.\n     */\n    setDisabledState(isDisabled) {\n        this.disabled = isDisabled;\n        this._changeDetectorRef.markForCheck();\n        this.stateChanges.next();\n    }\n    /** Whether or not the overlay panel is open. */\n    get panelOpen() {\n        return this._panelOpen;\n    }\n    /** The currently selected option. */\n    get selected() {\n        return this.multiple ? this._selectionModel?.selected || [] : this._selectionModel?.selected[0];\n    }\n    /** The value displayed in the trigger. */\n    get triggerValue() {\n        if (this.empty) {\n            return '';\n        }\n        if (this._multiple) {\n            const selectedOptions = this._selectionModel.selected.map(option => option.viewValue);\n            if (this._isRtl()) {\n                selectedOptions.reverse();\n            }\n            // TODO(crisbeto): delimiter should be configurable for proper localization.\n            return selectedOptions.join(', ');\n        }\n        return this._selectionModel.selected[0].viewValue;\n    }\n    /** Whether the element is in RTL mode. */\n    _isRtl() {\n        return this._dir ? this._dir.value === 'rtl' : false;\n    }\n    /** Handles all keydown events on the select. */\n    _handleKeydown(event) {\n        if (!this.disabled) {\n            this.panelOpen ? this._handleOpenKeydown(event) : this._handleClosedKeydown(event);\n        }\n    }\n    /** Handles keyboard events while the select is closed. */\n    _handleClosedKeydown(event) {\n        const keyCode = event.keyCode;\n        const isArrowKey = keyCode === DOWN_ARROW ||\n            keyCode === UP_ARROW ||\n            keyCode === LEFT_ARROW ||\n            keyCode === RIGHT_ARROW;\n        const isOpenKey = keyCode === ENTER || keyCode === SPACE;\n        const manager = this._keyManager;\n        // Open the select on ALT + arrow key to match the native <select>\n        if ((!manager.isTyping() && isOpenKey && !hasModifierKey(event)) ||\n            ((this.multiple || event.altKey) && isArrowKey)) {\n            event.preventDefault(); // prevents the page from scrolling down when pressing space\n            this.open();\n        }\n        else if (!this.multiple) {\n            const previouslySelectedOption = this.selected;\n            manager.onKeydown(event);\n            const selectedOption = this.selected;\n            // Since the value has changed, we need to announce it ourselves.\n            if (selectedOption && previouslySelectedOption !== selectedOption) {\n                // We set a duration on the live announcement, because we want the live element to be\n                // cleared after a while so that users can't navigate to it using the arrow keys.\n                this._liveAnnouncer.announce(selectedOption.viewValue, 10000);\n            }\n        }\n    }\n    /** Handles keyboard events when the selected is open. */\n    _handleOpenKeydown(event) {\n        const manager = this._keyManager;\n        const keyCode = event.keyCode;\n        const isArrowKey = keyCode === DOWN_ARROW || keyCode === UP_ARROW;\n        const isTyping = manager.isTyping();\n        if (isArrowKey && event.altKey) {\n            // Close the select on ALT + arrow key to match the native <select>\n            event.preventDefault();\n            this.close();\n            // Don't do anything in this case if the user is typing,\n            // because the typing sequence can include the space key.\n        }\n        else if (!isTyping &&\n            (keyCode === ENTER || keyCode === SPACE) &&\n            manager.activeItem &&\n            !hasModifierKey(event)) {\n            event.preventDefault();\n            manager.activeItem._selectViaInteraction();\n        }\n        else if (!isTyping && this._multiple && keyCode === A && event.ctrlKey) {\n            event.preventDefault();\n            const hasDeselectedOptions = this.options.some(opt => !opt.disabled && !opt.selected);\n            this.options.forEach(option => {\n                if (!option.disabled) {\n                    hasDeselectedOptions ? option.select() : option.deselect();\n                }\n            });\n        }\n        else {\n            const previouslyFocusedIndex = manager.activeItemIndex;\n            manager.onKeydown(event);\n            if (this._multiple &&\n                isArrowKey &&\n                event.shiftKey &&\n                manager.activeItem &&\n                manager.activeItemIndex !== previouslyFocusedIndex) {\n                manager.activeItem._selectViaInteraction();\n            }\n        }\n    }\n    _onFocus() {\n        if (!this.disabled) {\n            this._focused = true;\n            this.stateChanges.next();\n        }\n    }\n    /**\n     * Calls the touched callback only if the panel is closed. Otherwise, the trigger will\n     * \"blur\" to the panel when it opens, causing a false positive.\n     */\n    _onBlur() {\n        this._focused = false;\n        if (!this.disabled && !this.panelOpen) {\n            this._onTouched();\n            this._changeDetectorRef.markForCheck();\n            this.stateChanges.next();\n        }\n    }\n    /**\n     * Callback that is invoked when the overlay panel has been attached.\n     */\n    _onAttached() {\n        this._overlayDir.positionChange.pipe(take(1)).subscribe(() => {\n            this._changeDetectorRef.detectChanges();\n            this._positioningSettled();\n        });\n    }\n    /** Returns the theme to be used on the panel. */\n    _getPanelTheme() {\n        return this._parentFormField ? `mat-${this._parentFormField.color}` : '';\n    }\n    /** Whether the select has a value. */\n    get empty() {\n        return !this._selectionModel || this._selectionModel.isEmpty();\n    }\n    _initializeSelection() {\n        // Defer setting the value in order to avoid the \"Expression\n        // has changed after it was checked\" errors from Angular.\n        Promise.resolve().then(() => {\n            if (this.ngControl) {\n                this._value = this.ngControl.value;\n            }\n            this._setSelectionByValue(this._value);\n            this.stateChanges.next();\n        });\n    }\n    /**\n     * Sets the selected option based on a value. If no option can be\n     * found with the designated value, the select trigger is cleared.\n     */\n    _setSelectionByValue(value) {\n        this._selectionModel.selected.forEach(option => option.setInactiveStyles());\n        this._selectionModel.clear();\n        if (this.multiple && value) {\n            if (!Array.isArray(value) && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                throw getMatSelectNonArrayValueError();\n            }\n            value.forEach((currentValue) => this._selectOptionByValue(currentValue));\n            this._sortValues();\n        }\n        else {\n            const correspondingOption = this._selectOptionByValue(value);\n            // Shift focus to the active item. Note that we shouldn't do this in multiple\n            // mode, because we don't know what option the user interacted with last.\n            if (correspondingOption) {\n                this._keyManager.updateActiveItem(correspondingOption);\n            }\n            else if (!this.panelOpen) {\n                // Otherwise reset the highlighted option. Note that we only want to do this while\n                // closed, because doing it while open can shift the user's focus unnecessarily.\n                this._keyManager.updateActiveItem(-1);\n            }\n        }\n        this._changeDetectorRef.markForCheck();\n    }\n    /**\n     * Finds and selects and option based on its value.\n     * @returns Option that has the corresponding value.\n     */\n    _selectOptionByValue(value) {\n        const correspondingOption = this.options.find((option) => {\n            // Skip options that are already in the model. This allows us to handle cases\n            // where the same primitive value is selected multiple times.\n            if (this._selectionModel.isSelected(option)) {\n                return false;\n            }\n            try {\n                // Treat null as a special reset value.\n                return option.value != null && this._compareWith(option.value, value);\n            }\n            catch (error) {\n                if (typeof ngDevMode === 'undefined' || ngDevMode) {\n                    // Notify developers of errors in their comparator.\n                    console.warn(error);\n                }\n                return false;\n            }\n        });\n        if (correspondingOption) {\n            this._selectionModel.select(correspondingOption);\n        }\n        return correspondingOption;\n    }\n    /** Assigns a specific value to the select. Returns whether the value has changed. */\n    _assignValue(newValue) {\n        // Always re-assign an array, because it might have been mutated.\n        if (newValue !== this._value || (this._multiple && Array.isArray(newValue))) {\n            if (this.options) {\n                this._setSelectionByValue(newValue);\n            }\n            this._value = newValue;\n            return true;\n        }\n        return false;\n    }\n    /** Sets up a key manager to listen to keyboard events on the overlay panel. */\n    _initKeyManager() {\n        this._keyManager = new ActiveDescendantKeyManager(this.options)\n            .withTypeAhead(this._typeaheadDebounceInterval)\n            .withVerticalOrientation()\n            .withHorizontalOrientation(this._isRtl() ? 'rtl' : 'ltr')\n            .withHomeAndEnd()\n            .withAllowedModifierKeys(['shiftKey']);\n        this._keyManager.tabOut.pipe(takeUntil(this._destroy)).subscribe(() => {\n            if (this.panelOpen) {\n                // Select the active item when tabbing away. This is consistent with how the native\n                // select behaves. Note that we only want to do this in single selection mode.\n                if (!this.multiple && this._keyManager.activeItem) {\n                    this._keyManager.activeItem._selectViaInteraction();\n                }\n                // Restore focus to the trigger before closing. Ensures that the focus\n                // position won't be lost if the user got focus into the overlay.\n                this.focus();\n                this.close();\n            }\n        });\n        this._keyManager.change.pipe(takeUntil(this._destroy)).subscribe(() => {\n            if (this._panelOpen && this.panel) {\n                this._scrollOptionIntoView(this._keyManager.activeItemIndex || 0);\n            }\n            else if (!this._panelOpen && !this.multiple && this._keyManager.activeItem) {\n                this._keyManager.activeItem._selectViaInteraction();\n            }\n        });\n    }\n    /** Drops current option subscriptions and IDs and resets from scratch. */\n    _resetOptions() {\n        const changedOrDestroyed = merge(this.options.changes, this._destroy);\n        this.optionSelectionChanges.pipe(takeUntil(changedOrDestroyed)).subscribe(event => {\n            this._onSelect(event.source, event.isUserInput);\n            if (event.isUserInput && !this.multiple && this._panelOpen) {\n                this.close();\n                this.focus();\n            }\n        });\n        // Listen to changes in the internal state of the options and react accordingly.\n        // Handles cases like the labels of the selected options changing.\n        merge(...this.options.map(option => option._stateChanges))\n            .pipe(takeUntil(changedOrDestroyed))\n            .subscribe(() => {\n            this._changeDetectorRef.markForCheck();\n            this.stateChanges.next();\n        });\n    }\n    /** Invoked when an option is clicked. */\n    _onSelect(option, isUserInput) {\n        const wasSelected = this._selectionModel.isSelected(option);\n        if (option.value == null && !this._multiple) {\n            option.deselect();\n            this._selectionModel.clear();\n            if (this.value != null) {\n                this._propagateChanges(option.value);\n            }\n        }\n        else {\n            if (wasSelected !== option.selected) {\n                option.selected\n                    ? this._selectionModel.select(option)\n                    : this._selectionModel.deselect(option);\n            }\n            if (isUserInput) {\n                this._keyManager.setActiveItem(option);\n            }\n            if (this.multiple) {\n                this._sortValues();\n                if (isUserInput) {\n                    // In case the user selected the option with their mouse, we\n                    // want to restore focus back to the trigger, in order to\n                    // prevent the select keyboard controls from clashing with\n                    // the ones from `mat-option`.\n                    this.focus();\n                }\n            }\n        }\n        if (wasSelected !== this._selectionModel.isSelected(option)) {\n            this._propagateChanges();\n        }\n        this.stateChanges.next();\n    }\n    /** Sorts the selected values in the selected based on their order in the panel. */\n    _sortValues() {\n        if (this.multiple) {\n            const options = this.options.toArray();\n            this._selectionModel.sort((a, b) => {\n                return this.sortComparator\n                    ? this.sortComparator(a, b, options)\n                    : options.indexOf(a) - options.indexOf(b);\n            });\n            this.stateChanges.next();\n        }\n    }\n    /** Emits change event to set the model value. */\n    _propagateChanges(fallbackValue) {\n        let valueToEmit = null;\n        if (this.multiple) {\n            valueToEmit = this.selected.map(option => option.value);\n        }\n        else {\n            valueToEmit = this.selected ? this.selected.value : fallbackValue;\n        }\n        this._value = valueToEmit;\n        this.valueChange.emit(valueToEmit);\n        this._onChange(valueToEmit);\n        this.selectionChange.emit(this._getChangeEvent(valueToEmit));\n        this._changeDetectorRef.markForCheck();\n    }\n    /**\n     * Highlights the selected item. If no option is selected, it will highlight\n     * the first item instead.\n     */\n    _highlightCorrectOption() {\n        if (this._keyManager) {\n            if (this.empty) {\n                this._keyManager.setFirstItemActive();\n            }\n            else {\n                this._keyManager.setActiveItem(this._selectionModel.selected[0]);\n            }\n        }\n    }\n    /** Whether the panel is allowed to open. */\n    _canOpen() {\n        return !this._panelOpen && !this.disabled && this.options?.length > 0;\n    }\n    /** Focuses the select element. */\n    focus(options) {\n        this._elementRef.nativeElement.focus(options);\n    }\n    /** Gets the aria-labelledby for the select panel. */\n    _getPanelAriaLabelledby() {\n        if (this.ariaLabel) {\n            return null;\n        }\n        const labelId = this._parentFormField?.getLabelId();\n        const labelExpression = labelId ? labelId + ' ' : '';\n        return this.ariaLabelledby ? labelExpression + this.ariaLabelledby : labelId;\n    }\n    /** Determines the `aria-activedescendant` to be set on the host. */\n    _getAriaActiveDescendant() {\n        if (this.panelOpen && this._keyManager && this._keyManager.activeItem) {\n            return this._keyManager.activeItem.id;\n        }\n        return null;\n    }\n    /** Gets the aria-labelledby of the select component trigger. */\n    _getTriggerAriaLabelledby() {\n        if (this.ariaLabel) {\n            return null;\n        }\n        const labelId = this._parentFormField?.getLabelId();\n        let value = (labelId ? labelId + ' ' : '') + this._valueId;\n        if (this.ariaLabelledby) {\n            value += ' ' + this.ariaLabelledby;\n        }\n        return value;\n    }\n    /** Called when the overlay panel is done animating. */\n    _panelDoneAnimating(isOpen) {\n        this.openedChange.emit(isOpen);\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    setDescribedByIds(ids) {\n        if (ids.length) {\n            this._elementRef.nativeElement.setAttribute('aria-describedby', ids.join(' '));\n        }\n        else {\n            this._elementRef.nativeElement.removeAttribute('aria-describedby');\n        }\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    onContainerClick() {\n        this.focus();\n        this.open();\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get shouldLabelFloat() {\n        return this._panelOpen || !this.empty || (this._focused && !!this._placeholder);\n    }\n}\n_MatSelectBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: _MatSelectBase, deps: [{ token: i1.ViewportRuler }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }, { token: i2.ErrorStateMatcher }, { token: i0.ElementRef }, { token: i3.Directionality, optional: true }, { token: i4.NgForm, optional: true }, { token: i4.FormGroupDirective, optional: true }, { token: MAT_FORM_FIELD, optional: true }, { token: i4.NgControl, optional: true, self: true }, { token: 'tabindex', attribute: true }, { token: MAT_SELECT_SCROLL_STRATEGY }, { token: i5.LiveAnnouncer }, { token: MAT_SELECT_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\n_MatSelectBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.2.0-rc.0\", type: _MatSelectBase, inputs: { userAriaDescribedBy: [\"aria-describedby\", \"userAriaDescribedBy\"], panelClass: \"panelClass\", placeholder: \"placeholder\", required: \"required\", multiple: \"multiple\", disableOptionCentering: \"disableOptionCentering\", compareWith: \"compareWith\", value: \"value\", ariaLabel: [\"aria-label\", \"ariaLabel\"], ariaLabelledby: [\"aria-labelledby\", \"ariaLabelledby\"], errorStateMatcher: \"errorStateMatcher\", typeaheadDebounceInterval: \"typeaheadDebounceInterval\", sortComparator: \"sortComparator\", id: \"id\" }, outputs: { openedChange: \"openedChange\", _openedStream: \"opened\", _closedStream: \"closed\", selectionChange: \"selectionChange\", valueChange: \"valueChange\" }, viewQueries: [{ propertyName: \"trigger\", first: true, predicate: [\"trigger\"], descendants: true }, { propertyName: \"panel\", first: true, predicate: [\"panel\"], descendants: true }, { propertyName: \"_overlayDir\", first: true, predicate: CdkConnectedOverlay, descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: _MatSelectBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i1.ViewportRuler }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }, { type: i2.ErrorStateMatcher }, { type: i0.ElementRef }, { type: i3.Directionality, decorators: [{\n                    type: Optional\n                }] }, { type: i4.NgForm, decorators: [{\n                    type: Optional\n                }] }, { type: i4.FormGroupDirective, decorators: [{\n                    type: Optional\n                }] }, { type: i6.MatFormField, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_FORM_FIELD]\n                }] }, { type: i4.NgControl, decorators: [{\n                    type: Self\n                }, {\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Attribute,\n                    args: ['tabindex']\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_SELECT_SCROLL_STRATEGY]\n                }] }, { type: i5.LiveAnnouncer }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_SELECT_CONFIG]\n                }] }]; }, propDecorators: { userAriaDescribedBy: [{\n                type: Input,\n                args: ['aria-describedby']\n            }], trigger: [{\n                type: ViewChild,\n                args: ['trigger']\n            }], panel: [{\n                type: ViewChild,\n                args: ['panel']\n            }], _overlayDir: [{\n                type: ViewChild,\n                args: [CdkConnectedOverlay]\n            }], panelClass: [{\n                type: Input\n            }], placeholder: [{\n                type: Input\n            }], required: [{\n                type: Input\n            }], multiple: [{\n                type: Input\n            }], disableOptionCentering: [{\n                type: Input\n            }], compareWith: [{\n                type: Input\n            }], value: [{\n                type: Input\n            }], ariaLabel: [{\n                type: Input,\n                args: ['aria-label']\n            }], ariaLabelledby: [{\n                type: Input,\n                args: ['aria-labelledby']\n            }], errorStateMatcher: [{\n                type: Input\n            }], typeaheadDebounceInterval: [{\n                type: Input\n            }], sortComparator: [{\n                type: Input\n            }], id: [{\n                type: Input\n            }], openedChange: [{\n                type: Output\n            }], _openedStream: [{\n                type: Output,\n                args: ['opened']\n            }], _closedStream: [{\n                type: Output,\n                args: ['closed']\n            }], selectionChange: [{\n                type: Output\n            }], valueChange: [{\n                type: Output\n            }] } });\nclass MatSelect extends _MatSelectBase {\n    constructor() {\n        super(...arguments);\n        /** The scroll position of the overlay panel, calculated to center the selected option. */\n        this._scrollTop = 0;\n        /** The cached font-size of the trigger element. */\n        this._triggerFontSize = 0;\n        /** The value of the select panel's transform-origin property. */\n        this._transformOrigin = 'top';\n        /**\n         * The y-offset of the overlay panel in relation to the trigger's top start corner.\n         * This must be adjusted to align the selected option text over the trigger text.\n         * when the panel opens. Will change based on the y-position of the selected option.\n         */\n        this._offsetY = 0;\n        this._positions = [\n            {\n                originX: 'start',\n                originY: 'top',\n                overlayX: 'start',\n                overlayY: 'top',\n            },\n            {\n                originX: 'start',\n                originY: 'bottom',\n                overlayX: 'start',\n                overlayY: 'bottom',\n            },\n        ];\n    }\n    /**\n     * Calculates the scroll position of the select's overlay panel.\n     *\n     * Attempts to center the selected option in the panel. If the option is\n     * too high or too low in the panel to be scrolled to the center, it clamps the\n     * scroll position to the min or max scroll positions respectively.\n     */\n    _calculateOverlayScroll(selectedIndex, scrollBuffer, maxScroll) {\n        const itemHeight = this._getItemHeight();\n        const optionOffsetFromScrollTop = itemHeight * selectedIndex;\n        const halfOptionHeight = itemHeight / 2;\n        // Starts at the optionOffsetFromScrollTop, which scrolls the option to the top of the\n        // scroll container, then subtracts the scroll buffer to scroll the option down to\n        // the center of the overlay panel. Half the option height must be re-added to the\n        // scrollTop so the option is centered based on its middle, not its top edge.\n        const optimalScrollPosition = optionOffsetFromScrollTop - scrollBuffer + halfOptionHeight;\n        return Math.min(Math.max(0, optimalScrollPosition), maxScroll);\n    }\n    ngOnInit() {\n        super.ngOnInit();\n        this._viewportRuler\n            .change()\n            .pipe(takeUntil(this._destroy))\n            .subscribe(() => {\n            if (this.panelOpen) {\n                this._triggerRect = this.trigger.nativeElement.getBoundingClientRect();\n                this._changeDetectorRef.markForCheck();\n            }\n        });\n    }\n    open() {\n        if (super._canOpen()) {\n            super.open();\n            this._triggerRect = this.trigger.nativeElement.getBoundingClientRect();\n            // Note: The computed font-size will be a string pixel value (e.g. \"16px\").\n            // `parseInt` ignores the trailing 'px' and converts this to a number.\n            this._triggerFontSize = parseInt(getComputedStyle(this.trigger.nativeElement).fontSize || '0');\n            this._calculateOverlayPosition();\n            // Set the font size on the panel element once it exists.\n            this._ngZone.onStable.pipe(take(1)).subscribe(() => {\n                if (this._triggerFontSize &&\n                    this._overlayDir.overlayRef &&\n                    this._overlayDir.overlayRef.overlayElement) {\n                    this._overlayDir.overlayRef.overlayElement.style.fontSize = `${this._triggerFontSize}px`;\n                }\n            });\n        }\n    }\n    /** Scrolls the active option into view. */\n    _scrollOptionIntoView(index) {\n        const labelCount = _countGroupLabelsBeforeOption(index, this.options, this.optionGroups);\n        const itemHeight = this._getItemHeight();\n        if (index === 0 && labelCount === 1) {\n            // If we've got one group label before the option and we're at the top option,\n            // scroll the list to the top. This is better UX than scrolling the list to the\n            // top of the option, because it allows the user to read the top group's label.\n            this.panel.nativeElement.scrollTop = 0;\n        }\n        else {\n            this.panel.nativeElement.scrollTop = _getOptionScrollPosition((index + labelCount) * itemHeight, itemHeight, this.panel.nativeElement.scrollTop, SELECT_PANEL_MAX_HEIGHT);\n        }\n    }\n    _positioningSettled() {\n        this._calculateOverlayOffsetX();\n        this.panel.nativeElement.scrollTop = this._scrollTop;\n    }\n    _panelDoneAnimating(isOpen) {\n        if (this.panelOpen) {\n            this._scrollTop = 0;\n        }\n        else {\n            this._overlayDir.offsetX = 0;\n            this._changeDetectorRef.markForCheck();\n        }\n        super._panelDoneAnimating(isOpen);\n    }\n    _getChangeEvent(value) {\n        return new MatSelectChange(this, value);\n    }\n    /**\n     * Sets the x-offset of the overlay panel in relation to the trigger's top start corner.\n     * This must be adjusted to align the selected option text over the trigger text when\n     * the panel opens. Will change based on LTR or RTL text direction. Note that the offset\n     * can't be calculated until the panel has been attached, because we need to know the\n     * content width in order to constrain the panel within the viewport.\n     */\n    _calculateOverlayOffsetX() {\n        const overlayRect = this._overlayDir.overlayRef.overlayElement.getBoundingClientRect();\n        const viewportSize = this._viewportRuler.getViewportSize();\n        const isRtl = this._isRtl();\n        const paddingWidth = this.multiple\n            ? SELECT_MULTIPLE_PANEL_PADDING_X + SELECT_PANEL_PADDING_X\n            : SELECT_PANEL_PADDING_X * 2;\n        let offsetX;\n        // Adjust the offset, depending on the option padding.\n        if (this.multiple) {\n            offsetX = SELECT_MULTIPLE_PANEL_PADDING_X;\n        }\n        else if (this.disableOptionCentering) {\n            offsetX = SELECT_PANEL_PADDING_X;\n        }\n        else {\n            let selected = this._selectionModel.selected[0] || this.options.first;\n            offsetX = selected && selected.group ? SELECT_PANEL_INDENT_PADDING_X : SELECT_PANEL_PADDING_X;\n        }\n        // Invert the offset in LTR.\n        if (!isRtl) {\n            offsetX *= -1;\n        }\n        // Determine how much the select overflows on each side.\n        const leftOverflow = 0 - (overlayRect.left + offsetX - (isRtl ? paddingWidth : 0));\n        const rightOverflow = overlayRect.right + offsetX - viewportSize.width + (isRtl ? 0 : paddingWidth);\n        // If the element overflows on either side, reduce the offset to allow it to fit.\n        if (leftOverflow > 0) {\n            offsetX += leftOverflow + SELECT_PANEL_VIEWPORT_PADDING;\n        }\n        else if (rightOverflow > 0) {\n            offsetX -= rightOverflow + SELECT_PANEL_VIEWPORT_PADDING;\n        }\n        // Set the offset directly in order to avoid having to go through change detection and\n        // potentially triggering \"changed after it was checked\" errors. Round the value to avoid\n        // blurry content in some browsers.\n        this._overlayDir.offsetX = Math.round(offsetX);\n        this._overlayDir.overlayRef.updatePosition();\n    }\n    /**\n     * Calculates the y-offset of the select's overlay panel in relation to the\n     * top start corner of the trigger. It has to be adjusted in order for the\n     * selected option to be aligned over the trigger when the panel opens.\n     */\n    _calculateOverlayOffsetY(selectedIndex, scrollBuffer, maxScroll) {\n        const itemHeight = this._getItemHeight();\n        const optionHeightAdjustment = (itemHeight - this._triggerRect.height) / 2;\n        const maxOptionsDisplayed = Math.floor(SELECT_PANEL_MAX_HEIGHT / itemHeight);\n        let optionOffsetFromPanelTop;\n        // Disable offset if requested by user by returning 0 as value to offset\n        if (this.disableOptionCentering) {\n            return 0;\n        }\n        if (this._scrollTop === 0) {\n            optionOffsetFromPanelTop = selectedIndex * itemHeight;\n        }\n        else if (this._scrollTop === maxScroll) {\n            const firstDisplayedIndex = this._getItemCount() - maxOptionsDisplayed;\n            const selectedDisplayIndex = selectedIndex - firstDisplayedIndex;\n            // The first item is partially out of the viewport. Therefore we need to calculate what\n            // portion of it is shown in the viewport and account for it in our offset.\n            let partialItemHeight = itemHeight - ((this._getItemCount() * itemHeight - SELECT_PANEL_MAX_HEIGHT) % itemHeight);\n            // Because the panel height is longer than the height of the options alone,\n            // there is always extra padding at the top or bottom of the panel. When\n            // scrolled to the very bottom, this padding is at the top of the panel and\n            // must be added to the offset.\n            optionOffsetFromPanelTop = selectedDisplayIndex * itemHeight + partialItemHeight;\n        }\n        else {\n            // If the option was scrolled to the middle of the panel using a scroll buffer,\n            // its offset will be the scroll buffer minus the half height that was added to\n            // center it.\n            optionOffsetFromPanelTop = scrollBuffer - itemHeight / 2;\n        }\n        // The final offset is the option's offset from the top, adjusted for the height difference,\n        // multiplied by -1 to ensure that the overlay moves in the correct direction up the page.\n        // The value is rounded to prevent some browsers from blurring the content.\n        return Math.round(optionOffsetFromPanelTop * -1 - optionHeightAdjustment);\n    }\n    /**\n     * Checks that the attempted overlay position will fit within the viewport.\n     * If it will not fit, tries to adjust the scroll position and the associated\n     * y-offset so the panel can open fully on-screen. If it still won't fit,\n     * sets the offset back to 0 to allow the fallback position to take over.\n     */\n    _checkOverlayWithinViewport(maxScroll) {\n        const itemHeight = this._getItemHeight();\n        const viewportSize = this._viewportRuler.getViewportSize();\n        const topSpaceAvailable = this._triggerRect.top - SELECT_PANEL_VIEWPORT_PADDING;\n        const bottomSpaceAvailable = viewportSize.height - this._triggerRect.bottom - SELECT_PANEL_VIEWPORT_PADDING;\n        const panelHeightTop = Math.abs(this._offsetY);\n        const totalPanelHeight = Math.min(this._getItemCount() * itemHeight, SELECT_PANEL_MAX_HEIGHT);\n        const panelHeightBottom = totalPanelHeight - panelHeightTop - this._triggerRect.height;\n        if (panelHeightBottom > bottomSpaceAvailable) {\n            this._adjustPanelUp(panelHeightBottom, bottomSpaceAvailable);\n        }\n        else if (panelHeightTop > topSpaceAvailable) {\n            this._adjustPanelDown(panelHeightTop, topSpaceAvailable, maxScroll);\n        }\n        else {\n            this._transformOrigin = this._getOriginBasedOnOption();\n        }\n    }\n    /** Adjusts the overlay panel up to fit in the viewport. */\n    _adjustPanelUp(panelHeightBottom, bottomSpaceAvailable) {\n        // Browsers ignore fractional scroll offsets, so we need to round.\n        const distanceBelowViewport = Math.round(panelHeightBottom - bottomSpaceAvailable);\n        // Scrolls the panel up by the distance it was extending past the boundary, then\n        // adjusts the offset by that amount to move the panel up into the viewport.\n        this._scrollTop -= distanceBelowViewport;\n        this._offsetY -= distanceBelowViewport;\n        this._transformOrigin = this._getOriginBasedOnOption();\n        // If the panel is scrolled to the very top, it won't be able to fit the panel\n        // by scrolling, so set the offset to 0 to allow the fallback position to take\n        // effect.\n        if (this._scrollTop <= 0) {\n            this._scrollTop = 0;\n            this._offsetY = 0;\n            this._transformOrigin = `50% bottom 0px`;\n        }\n    }\n    /** Adjusts the overlay panel down to fit in the viewport. */\n    _adjustPanelDown(panelHeightTop, topSpaceAvailable, maxScroll) {\n        // Browsers ignore fractional scroll offsets, so we need to round.\n        const distanceAboveViewport = Math.round(panelHeightTop - topSpaceAvailable);\n        // Scrolls the panel down by the distance it was extending past the boundary, then\n        // adjusts the offset by that amount to move the panel down into the viewport.\n        this._scrollTop += distanceAboveViewport;\n        this._offsetY += distanceAboveViewport;\n        this._transformOrigin = this._getOriginBasedOnOption();\n        // If the panel is scrolled to the very bottom, it won't be able to fit the\n        // panel by scrolling, so set the offset to 0 to allow the fallback position\n        // to take effect.\n        if (this._scrollTop >= maxScroll) {\n            this._scrollTop = maxScroll;\n            this._offsetY = 0;\n            this._transformOrigin = `50% top 0px`;\n            return;\n        }\n    }\n    /** Calculates the scroll position and x- and y-offsets of the overlay panel. */\n    _calculateOverlayPosition() {\n        const itemHeight = this._getItemHeight();\n        const items = this._getItemCount();\n        const panelHeight = Math.min(items * itemHeight, SELECT_PANEL_MAX_HEIGHT);\n        const scrollContainerHeight = items * itemHeight;\n        // The farthest the panel can be scrolled before it hits the bottom\n        const maxScroll = scrollContainerHeight - panelHeight;\n        // If no value is selected we open the popup to the first item.\n        let selectedOptionOffset;\n        if (this.empty) {\n            selectedOptionOffset = 0;\n        }\n        else {\n            selectedOptionOffset = Math.max(this.options.toArray().indexOf(this._selectionModel.selected[0]), 0);\n        }\n        selectedOptionOffset += _countGroupLabelsBeforeOption(selectedOptionOffset, this.options, this.optionGroups);\n        // We must maintain a scroll buffer so the selected option will be scrolled to the\n        // center of the overlay panel rather than the top.\n        const scrollBuffer = panelHeight / 2;\n        this._scrollTop = this._calculateOverlayScroll(selectedOptionOffset, scrollBuffer, maxScroll);\n        this._offsetY = this._calculateOverlayOffsetY(selectedOptionOffset, scrollBuffer, maxScroll);\n        this._checkOverlayWithinViewport(maxScroll);\n    }\n    /** Sets the transform origin point based on the selected option. */\n    _getOriginBasedOnOption() {\n        const itemHeight = this._getItemHeight();\n        const optionHeightAdjustment = (itemHeight - this._triggerRect.height) / 2;\n        const originY = Math.abs(this._offsetY) - optionHeightAdjustment + itemHeight / 2;\n        return `50% ${originY}px 0px`;\n    }\n    /** Calculates the height of the select's options. */\n    _getItemHeight() {\n        return this._triggerFontSize * SELECT_ITEM_HEIGHT_EM;\n    }\n    /** Calculates the amount of items in the select. This includes options and group labels. */\n    _getItemCount() {\n        return this.options.length + this.optionGroups.length;\n    }\n}\nMatSelect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: MatSelect, deps: null, target: i0.ɵɵFactoryTarget.Component });\nMatSelect.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"14.0.0\", version: \"14.2.0-rc.0\", type: MatSelect, selector: \"mat-select\", inputs: { disabled: \"disabled\", disableRipple: \"disableRipple\", tabIndex: \"tabIndex\" }, host: { attributes: { \"role\": \"combobox\", \"aria-autocomplete\": \"none\", \"aria-haspopup\": \"true\" }, listeners: { \"keydown\": \"_handleKeydown($event)\", \"focus\": \"_onFocus()\", \"blur\": \"_onBlur()\" }, properties: { \"attr.id\": \"id\", \"attr.tabindex\": \"tabIndex\", \"attr.aria-controls\": \"panelOpen ? id + \\\"-panel\\\" : null\", \"attr.aria-expanded\": \"panelOpen\", \"attr.aria-label\": \"ariaLabel || null\", \"attr.aria-required\": \"required.toString()\", \"attr.aria-disabled\": \"disabled.toString()\", \"attr.aria-invalid\": \"errorState\", \"attr.aria-activedescendant\": \"_getAriaActiveDescendant()\", \"class.mat-select-disabled\": \"disabled\", \"class.mat-select-invalid\": \"errorState\", \"class.mat-select-required\": \"required\", \"class.mat-select-empty\": \"empty\", \"class.mat-select-multiple\": \"multiple\" }, classAttribute: \"mat-select\" }, providers: [\n        { provide: MatFormFieldControl, useExisting: MatSelect },\n        { provide: MAT_OPTION_PARENT_COMPONENT, useExisting: MatSelect },\n    ], queries: [{ propertyName: \"customTrigger\", first: true, predicate: MAT_SELECT_TRIGGER, descendants: true }, { propertyName: \"options\", predicate: MatOption, descendants: true }, { propertyName: \"optionGroups\", predicate: MAT_OPTGROUP, descendants: true }], exportAs: [\"matSelect\"], usesInheritance: true, ngImport: i0, template: \"<!--\\n Note that the select trigger element specifies `aria-owns` pointing to the listbox overlay.\\n While aria-owns is not required for the ARIA 1.2 `role=\\\"combobox\\\"` interaction pattern,\\n it fixes an issue with VoiceOver when the select appears inside of an `aria-model=\\\"true\\\"`\\n element (e.g. a dialog). Without this `aria-owns`, the `aria-modal` on a dialog prevents\\n VoiceOver from \\\"seeing\\\" the select's listbox overlay for aria-activedescendant.\\n Using `aria-owns` re-parents the select overlay so that it works again.\\n See https://github.com/angular/components/issues/20694\\n-->\\n<div cdk-overlay-origin\\n     [attr.aria-owns]=\\\"panelOpen ? id + '-panel' : null\\\"\\n     class=\\\"mat-select-trigger\\\"\\n     (click)=\\\"toggle()\\\"\\n     #origin=\\\"cdkOverlayOrigin\\\"\\n     #trigger>\\n  <div class=\\\"mat-select-value\\\" [ngSwitch]=\\\"empty\\\" [attr.id]=\\\"_valueId\\\">\\n    <span class=\\\"mat-select-placeholder mat-select-min-line\\\" *ngSwitchCase=\\\"true\\\">{{placeholder}}</span>\\n    <span class=\\\"mat-select-value-text\\\" *ngSwitchCase=\\\"false\\\" [ngSwitch]=\\\"!!customTrigger\\\">\\n      <span class=\\\"mat-select-min-line\\\" *ngSwitchDefault>{{triggerValue}}</span>\\n      <ng-content select=\\\"mat-select-trigger\\\" *ngSwitchCase=\\\"true\\\"></ng-content>\\n    </span>\\n  </div>\\n\\n  <div class=\\\"mat-select-arrow-wrapper\\\"><div class=\\\"mat-select-arrow\\\"></div></div>\\n</div>\\n\\n<ng-template\\n  cdk-connected-overlay\\n  cdkConnectedOverlayLockPosition\\n  cdkConnectedOverlayHasBackdrop\\n  cdkConnectedOverlayBackdropClass=\\\"cdk-overlay-transparent-backdrop\\\"\\n  [cdkConnectedOverlayPanelClass]=\\\"_overlayPanelClass\\\"\\n  [cdkConnectedOverlayScrollStrategy]=\\\"_scrollStrategy\\\"\\n  [cdkConnectedOverlayOrigin]=\\\"origin\\\"\\n  [cdkConnectedOverlayOpen]=\\\"panelOpen\\\"\\n  [cdkConnectedOverlayPositions]=\\\"_positions\\\"\\n  [cdkConnectedOverlayMinWidth]=\\\"_triggerRect?.width!\\\"\\n  [cdkConnectedOverlayOffsetY]=\\\"_offsetY\\\"\\n  (backdropClick)=\\\"close()\\\"\\n  (attach)=\\\"_onAttached()\\\"\\n  (detach)=\\\"close()\\\">\\n  <div class=\\\"mat-select-panel-wrap\\\" [@transformPanelWrap]>\\n    <div\\n      #panel\\n      role=\\\"listbox\\\"\\n      tabindex=\\\"-1\\\"\\n      class=\\\"mat-select-panel {{ _getPanelTheme() }}\\\"\\n      [attr.id]=\\\"id + '-panel'\\\"\\n      [attr.aria-multiselectable]=\\\"multiple\\\"\\n      [attr.aria-label]=\\\"ariaLabel || null\\\"\\n      [attr.aria-labelledby]=\\\"_getPanelAriaLabelledby()\\\"\\n      [ngClass]=\\\"panelClass\\\"\\n      [@transformPanel]=\\\"multiple ? 'showing-multiple' : 'showing'\\\"\\n      (@transformPanel.done)=\\\"_panelDoneAnimatingStream.next($event.toState)\\\"\\n      [style.transformOrigin]=\\\"_transformOrigin\\\"\\n      [style.font-size.px]=\\\"_triggerFontSize\\\"\\n      (keydown)=\\\"_handleKeydown($event)\\\">\\n      <ng-content></ng-content>\\n    </div>\\n  </div>\\n</ng-template>\\n\", styles: [\".mat-select{display:inline-block;width:100%;outline:none}.mat-select-trigger{display:inline-flex;align-items:center;cursor:pointer;position:relative;box-sizing:border-box;width:100%}.mat-select-disabled .mat-select-trigger{-webkit-user-select:none;user-select:none;cursor:default}.mat-select-value{width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.mat-select-value-text{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.mat-select-arrow-wrapper{height:16px;flex-shrink:0;display:inline-flex;align-items:center}.mat-form-field-appearance-fill .mat-select-arrow-wrapper{transform:translateY(-50%)}.mat-form-field-appearance-outline .mat-select-arrow-wrapper{transform:translateY(-25%)}.mat-form-field-appearance-standard.mat-form-field-has-label .mat-select:not(.mat-select-empty) .mat-select-arrow-wrapper{transform:translateY(-50%)}.mat-form-field-appearance-standard .mat-select.mat-select-empty .mat-select-arrow-wrapper{transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}._mat-animation-noopable.mat-form-field-appearance-standard .mat-select.mat-select-empty .mat-select-arrow-wrapper{transition:none}.mat-select-arrow{width:0;height:0;border-left:5px solid rgba(0,0,0,0);border-right:5px solid rgba(0,0,0,0);border-top:5px solid;margin:0 4px}.mat-form-field.mat-focused .mat-select-arrow{transform:translateX(0)}.mat-select-panel-wrap{flex-basis:100%}.mat-select-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;padding-top:0;padding-bottom:0;max-height:256px;min-width:100%;border-radius:4px;outline:0}.cdk-high-contrast-active .mat-select-panel{outline:solid 1px}.mat-select-panel .mat-optgroup-label,.mat-select-panel .mat-option{font-size:inherit;line-height:3em;height:3em}.mat-form-field-type-mat-select:not(.mat-form-field-disabled) .mat-form-field-flex{cursor:pointer}.mat-form-field-type-mat-select .mat-form-field-label{width:calc(100% - 18px)}.mat-select-placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}._mat-animation-noopable .mat-select-placeholder{transition:none}.mat-form-field-hide-placeholder .mat-select-placeholder{color:rgba(0,0,0,0);-webkit-text-fill-color:rgba(0,0,0,0);transition:none;display:block}.mat-select-min-line:empty::before{content:\\\" \\\";white-space:pre;width:1px;display:inline-block;visibility:hidden}\"], dependencies: [{ kind: \"directive\", type: i7.NgClass, selector: \"[ngClass]\", inputs: [\"class\", \"ngClass\"] }, { kind: \"directive\", type: i7.NgSwitch, selector: \"[ngSwitch]\", inputs: [\"ngSwitch\"] }, { kind: \"directive\", type: i7.NgSwitchCase, selector: \"[ngSwitchCase]\", inputs: [\"ngSwitchCase\"] }, { kind: \"directive\", type: i7.NgSwitchDefault, selector: \"[ngSwitchDefault]\" }, { kind: \"directive\", type: i8.CdkConnectedOverlay, selector: \"[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]\", inputs: [\"cdkConnectedOverlayOrigin\", \"cdkConnectedOverlayPositions\", \"cdkConnectedOverlayPositionStrategy\", \"cdkConnectedOverlayOffsetX\", \"cdkConnectedOverlayOffsetY\", \"cdkConnectedOverlayWidth\", \"cdkConnectedOverlayHeight\", \"cdkConnectedOverlayMinWidth\", \"cdkConnectedOverlayMinHeight\", \"cdkConnectedOverlayBackdropClass\", \"cdkConnectedOverlayPanelClass\", \"cdkConnectedOverlayViewportMargin\", \"cdkConnectedOverlayScrollStrategy\", \"cdkConnectedOverlayOpen\", \"cdkConnectedOverlayDisableClose\", \"cdkConnectedOverlayTransformOriginOn\", \"cdkConnectedOverlayHasBackdrop\", \"cdkConnectedOverlayLockPosition\", \"cdkConnectedOverlayFlexibleDimensions\", \"cdkConnectedOverlayGrowAfterOpen\", \"cdkConnectedOverlayPush\"], outputs: [\"backdropClick\", \"positionChange\", \"attach\", \"detach\", \"overlayKeydown\", \"overlayOutsideClick\"], exportAs: [\"cdkConnectedOverlay\"] }, { kind: \"directive\", type: i8.CdkOverlayOrigin, selector: \"[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]\", exportAs: [\"cdkOverlayOrigin\"] }], animations: [matSelectAnimations.transformPanelWrap, matSelectAnimations.transformPanel], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: MatSelect, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-select', exportAs: 'matSelect', inputs: ['disabled', 'disableRipple', 'tabIndex'], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, host: {\n                        'role': 'combobox',\n                        'aria-autocomplete': 'none',\n                        // TODO(crisbeto): the value for aria-haspopup should be `listbox`, but currently it's difficult\n                        // to sync into Google, because of an outdated automated a11y check which flags it as an invalid\n                        // value. At some point we should try to switch it back to being `listbox`.\n                        'aria-haspopup': 'true',\n                        'class': 'mat-select',\n                        '[attr.id]': 'id',\n                        '[attr.tabindex]': 'tabIndex',\n                        '[attr.aria-controls]': 'panelOpen ? id + \"-panel\" : null',\n                        '[attr.aria-expanded]': 'panelOpen',\n                        '[attr.aria-label]': 'ariaLabel || null',\n                        '[attr.aria-required]': 'required.toString()',\n                        '[attr.aria-disabled]': 'disabled.toString()',\n                        '[attr.aria-invalid]': 'errorState',\n                        '[attr.aria-activedescendant]': '_getAriaActiveDescendant()',\n                        '[class.mat-select-disabled]': 'disabled',\n                        '[class.mat-select-invalid]': 'errorState',\n                        '[class.mat-select-required]': 'required',\n                        '[class.mat-select-empty]': 'empty',\n                        '[class.mat-select-multiple]': 'multiple',\n                        '(keydown)': '_handleKeydown($event)',\n                        '(focus)': '_onFocus()',\n                        '(blur)': '_onBlur()',\n                    }, animations: [matSelectAnimations.transformPanelWrap, matSelectAnimations.transformPanel], providers: [\n                        { provide: MatFormFieldControl, useExisting: MatSelect },\n                        { provide: MAT_OPTION_PARENT_COMPONENT, useExisting: MatSelect },\n                    ], template: \"<!--\\n Note that the select trigger element specifies `aria-owns` pointing to the listbox overlay.\\n While aria-owns is not required for the ARIA 1.2 `role=\\\"combobox\\\"` interaction pattern,\\n it fixes an issue with VoiceOver when the select appears inside of an `aria-model=\\\"true\\\"`\\n element (e.g. a dialog). Without this `aria-owns`, the `aria-modal` on a dialog prevents\\n VoiceOver from \\\"seeing\\\" the select's listbox overlay for aria-activedescendant.\\n Using `aria-owns` re-parents the select overlay so that it works again.\\n See https://github.com/angular/components/issues/20694\\n-->\\n<div cdk-overlay-origin\\n     [attr.aria-owns]=\\\"panelOpen ? id + '-panel' : null\\\"\\n     class=\\\"mat-select-trigger\\\"\\n     (click)=\\\"toggle()\\\"\\n     #origin=\\\"cdkOverlayOrigin\\\"\\n     #trigger>\\n  <div class=\\\"mat-select-value\\\" [ngSwitch]=\\\"empty\\\" [attr.id]=\\\"_valueId\\\">\\n    <span class=\\\"mat-select-placeholder mat-select-min-line\\\" *ngSwitchCase=\\\"true\\\">{{placeholder}}</span>\\n    <span class=\\\"mat-select-value-text\\\" *ngSwitchCase=\\\"false\\\" [ngSwitch]=\\\"!!customTrigger\\\">\\n      <span class=\\\"mat-select-min-line\\\" *ngSwitchDefault>{{triggerValue}}</span>\\n      <ng-content select=\\\"mat-select-trigger\\\" *ngSwitchCase=\\\"true\\\"></ng-content>\\n    </span>\\n  </div>\\n\\n  <div class=\\\"mat-select-arrow-wrapper\\\"><div class=\\\"mat-select-arrow\\\"></div></div>\\n</div>\\n\\n<ng-template\\n  cdk-connected-overlay\\n  cdkConnectedOverlayLockPosition\\n  cdkConnectedOverlayHasBackdrop\\n  cdkConnectedOverlayBackdropClass=\\\"cdk-overlay-transparent-backdrop\\\"\\n  [cdkConnectedOverlayPanelClass]=\\\"_overlayPanelClass\\\"\\n  [cdkConnectedOverlayScrollStrategy]=\\\"_scrollStrategy\\\"\\n  [cdkConnectedOverlayOrigin]=\\\"origin\\\"\\n  [cdkConnectedOverlayOpen]=\\\"panelOpen\\\"\\n  [cdkConnectedOverlayPositions]=\\\"_positions\\\"\\n  [cdkConnectedOverlayMinWidth]=\\\"_triggerRect?.width!\\\"\\n  [cdkConnectedOverlayOffsetY]=\\\"_offsetY\\\"\\n  (backdropClick)=\\\"close()\\\"\\n  (attach)=\\\"_onAttached()\\\"\\n  (detach)=\\\"close()\\\">\\n  <div class=\\\"mat-select-panel-wrap\\\" [@transformPanelWrap]>\\n    <div\\n      #panel\\n      role=\\\"listbox\\\"\\n      tabindex=\\\"-1\\\"\\n      class=\\\"mat-select-panel {{ _getPanelTheme() }}\\\"\\n      [attr.id]=\\\"id + '-panel'\\\"\\n      [attr.aria-multiselectable]=\\\"multiple\\\"\\n      [attr.aria-label]=\\\"ariaLabel || null\\\"\\n      [attr.aria-labelledby]=\\\"_getPanelAriaLabelledby()\\\"\\n      [ngClass]=\\\"panelClass\\\"\\n      [@transformPanel]=\\\"multiple ? 'showing-multiple' : 'showing'\\\"\\n      (@transformPanel.done)=\\\"_panelDoneAnimatingStream.next($event.toState)\\\"\\n      [style.transformOrigin]=\\\"_transformOrigin\\\"\\n      [style.font-size.px]=\\\"_triggerFontSize\\\"\\n      (keydown)=\\\"_handleKeydown($event)\\\">\\n      <ng-content></ng-content>\\n    </div>\\n  </div>\\n</ng-template>\\n\", styles: [\".mat-select{display:inline-block;width:100%;outline:none}.mat-select-trigger{display:inline-flex;align-items:center;cursor:pointer;position:relative;box-sizing:border-box;width:100%}.mat-select-disabled .mat-select-trigger{-webkit-user-select:none;user-select:none;cursor:default}.mat-select-value{width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.mat-select-value-text{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.mat-select-arrow-wrapper{height:16px;flex-shrink:0;display:inline-flex;align-items:center}.mat-form-field-appearance-fill .mat-select-arrow-wrapper{transform:translateY(-50%)}.mat-form-field-appearance-outline .mat-select-arrow-wrapper{transform:translateY(-25%)}.mat-form-field-appearance-standard.mat-form-field-has-label .mat-select:not(.mat-select-empty) .mat-select-arrow-wrapper{transform:translateY(-50%)}.mat-form-field-appearance-standard .mat-select.mat-select-empty .mat-select-arrow-wrapper{transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}._mat-animation-noopable.mat-form-field-appearance-standard .mat-select.mat-select-empty .mat-select-arrow-wrapper{transition:none}.mat-select-arrow{width:0;height:0;border-left:5px solid rgba(0,0,0,0);border-right:5px solid rgba(0,0,0,0);border-top:5px solid;margin:0 4px}.mat-form-field.mat-focused .mat-select-arrow{transform:translateX(0)}.mat-select-panel-wrap{flex-basis:100%}.mat-select-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;padding-top:0;padding-bottom:0;max-height:256px;min-width:100%;border-radius:4px;outline:0}.cdk-high-contrast-active .mat-select-panel{outline:solid 1px}.mat-select-panel .mat-optgroup-label,.mat-select-panel .mat-option{font-size:inherit;line-height:3em;height:3em}.mat-form-field-type-mat-select:not(.mat-form-field-disabled) .mat-form-field-flex{cursor:pointer}.mat-form-field-type-mat-select .mat-form-field-label{width:calc(100% - 18px)}.mat-select-placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}._mat-animation-noopable .mat-select-placeholder{transition:none}.mat-form-field-hide-placeholder .mat-select-placeholder{color:rgba(0,0,0,0);-webkit-text-fill-color:rgba(0,0,0,0);transition:none;display:block}.mat-select-min-line:empty::before{content:\\\" \\\";white-space:pre;width:1px;display:inline-block;visibility:hidden}\"] }]\n        }], propDecorators: { options: [{\n                type: ContentChildren,\n                args: [MatOption, { descendants: true }]\n            }], optionGroups: [{\n                type: ContentChildren,\n                args: [MAT_OPTGROUP, { descendants: true }]\n            }], customTrigger: [{\n                type: ContentChild,\n                args: [MAT_SELECT_TRIGGER]\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatSelectModule {\n}\nMatSelectModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: MatSelectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatSelectModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: MatSelectModule, declarations: [MatSelect, MatSelectTrigger], imports: [CommonModule, OverlayModule, MatOptionModule, MatCommonModule], exports: [CdkScrollableModule,\n        MatFormFieldModule,\n        MatSelect,\n        MatSelectTrigger,\n        MatOptionModule,\n        MatCommonModule] });\nMatSelectModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: MatSelectModule, providers: [MAT_SELECT_SCROLL_STRATEGY_PROVIDER], imports: [CommonModule, OverlayModule, MatOptionModule, MatCommonModule, CdkScrollableModule,\n        MatFormFieldModule,\n        MatOptionModule,\n        MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: MatSelectModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [CommonModule, OverlayModule, MatOptionModule, MatCommonModule],\n                    exports: [\n                        CdkScrollableModule,\n                        MatFormFieldModule,\n                        MatSelect,\n                        MatSelectTrigger,\n                        MatOptionModule,\n                        MatCommonModule,\n                    ],\n                    declarations: [MatSelect, MatSelectTrigger],\n                    providers: [MAT_SELECT_SCROLL_STRATEGY_PROVIDER],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_SELECT_CONFIG, MAT_SELECT_SCROLL_STRATEGY, MAT_SELECT_SCROLL_STRATEGY_PROVIDER, MAT_SELECT_SCROLL_STRATEGY_PROVIDER_FACTORY, MAT_SELECT_TRIGGER, MatSelect, MatSelectChange, MatSelectModule, MatSelectTrigger, _MatSelectBase, matSelectAnimations };\n"],"x_google_ignoreList":[0]}