{"version":3,"file":"default-_yarn___virtual___angular-material-virtual-894adb27e5_0_cache_angular-material-npm-15-9d9eed.9662a07520f1cb6b.js","mappings":"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","names":["i0","panelAnimation","trigger","state","style","opacity","transform","transition","group","animate","_uniqueAutocompleteIdCounter","MatAutocompleteSelectedEvent","constructor","source","option","this","_MatAutocompleteMixinBase","mixinDisableRipple","MAT_AUTOCOMPLETE_DEFAULT_OPTIONS","InjectionToken","providedIn","factory","MAT_AUTOCOMPLETE_DEFAULT_OPTIONS_FACTORY","autoActiveFirstOption","autoSelectActiveOption","hideSingleSelectionIndicator","_MatAutocompleteBase","isOpen","_isOpen","showPanel","_setColor","value","_color","_setThemeClasses","_classList","_autoActiveFirstOption","coerceBooleanProperty","_autoSelectActiveOption","classList","length","coerceStringArray","reduce","className","_setVisibilityClasses","_elementRef","nativeElement","_changeDetectorRef","_defaults","platform","super","_activeOptionChanges","Subscription","displayWith","optionSelected","EventEmitter","opened","closed","optionActivated","id","inertGroups","SAFARI","ngAfterContentInit","_keyManager","ActiveDescendantKeyManager","options","withWrap","change","subscribe","index","emit","toArray","_setVisibility","ngOnDestroy","destroy","unsubscribe","_setScrollTop","scrollTop","panel","_getScrollTop","markForCheck","_emitSelectEvent","event","_getPanelAriaLabelledby","labelId","ariaLabel","ariaLabelledby","_visibleClass","_hiddenClass","ɵfac","i1","ɵdir","viewQuery","TemplateRef","_c0","_t","ctx","MatAutocomplete","arguments","_hideSingleSelectionIndicator","_syncParentProperties","t","ɵcmp","selectors","dirIndex","MAT_OPTGROUP","MatOption","provide","MAT_OPTION_PARENT_COMPONENT","useExisting","ngContentSelectors","i2","styles","changeDetection","MAT_AUTOCOMPLETE_VALUE_ACCESSOR","NG_VALUE_ACCESSOR","forwardRef","MatAutocompleteTrigger","multi","MAT_AUTOCOMPLETE_SCROLL_STRATEGY","MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER","deps","Overlay","useFactory","MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY","overlay","scrollStrategies","reposition","_MatAutocompleteTriggerBase","autocompleteDisabled","_autocompleteDisabled","_element","_overlay","_viewContainerRef","_zone","scrollStrategy","_dir","_formField","_document","_viewportRuler","_componentDestroyed","_manuallyFloatingLabel","_viewportSubscription","_canOpenOnNextFocus","_closeKeyEventStream","Subject","_windowBlurHandler","activeElement","panelOpen","_onChange","_onTouched","position","autocompleteAttribute","_overlayAttached","optionSelections","defer","autocomplete","changes","pipe","startWith","switchMap","merge","map","onSelectionChange","onStable","take","_scrollStrategy","ngAfterViewInit","window","_getWindow","runOutsideAngular","addEventListener","ngOnChanges","_positionStrategy","_setStrategyPositions","_overlayRef","updatePosition","removeEventListener","_destroyPanel","complete","openPanel","_attachOverlay","_floatLabel","closePanel","_resetLabel","run","_pendingAutoselectedOption","hasAttached","detach","_closingActionsSubscription","detectChanges","panelClosingActions","tabOut","filter","_getOutsideClickStream","detachments","of","MatOptionSelectionChange","activeOption","activeItem","fromEvent","clickTarget","_getEventTarget","formField","customOrigin","connectedTo","elementRef","contains","overlayElement","writeValue","Promise","resolve","then","_assignOptionValue","registerOnChange","fn","registerOnTouched","setDisabledState","isDisabled","disabled","_handleKeydown","keyCode","hasModifier","hasModifierKey","ESCAPE","preventDefault","ENTER","_selectViaInteraction","_resetActiveItem","prevActiveItem","isArrowKey","UP_ARROW","DOWN_ARROW","TAB","onKeydown","_canOpen","_scrollToOption","activeItemIndex","_valueBeforeAutoSelection","_handleInput","target","type","parseFloat","_previousValue","_handleFocus","_handleClick","shouldAnimate","floatLabel","_animateAndLockLabel","_subscribeToClosingActions","firstStable","optionChanges","tap","reapplyLastPosition","delay","wasOpen","_setValueAndClose","dispose","toDisplay","_updateNativeInputValue","_control","toSelect","_clearPreviousSelectedOption","focus","skip","forEach","selected","deselect","overlayRef","setOrigin","_getConnectedElement","updateSize","width","_getPanelWidth","_portal","TemplatePortal","template","getLabelId","create","_getOverlayConfig","_handleOverlayEvents","attach","color","OverlayConfig","positionStrategy","_getOverlayPosition","direction","undefined","panelClass","overlayPanelClass","strategy","flexibleConnectedTo","withFlexibleDimensions","withPush","belowPositions","originX","originY","overlayX","overlayY","_aboveClass","abovePositions","positions","withPositions","getConnectedOverlayOrigin","panelWidth","_getHostWidth","getBoundingClientRect","setFirstItemActive","setActiveItem","element","readOnly","defaultView","labelCount","_countGroupLabelsBeforeOption","optionGroups","_getHostElement","newScrollPosition","_getOptionScrollPosition","offsetTop","offsetHeight","keydownEvents","next","stopPropagation","outsidePointerEvents","i1$1","i2$1","MAT_FORM_FIELD","DOCUMENT","i3","inputs","MatAutocompleteModule","ɵmod","ɵinj","imports","OverlayModule","MatOptionModule","MatCommonModule","CommonModule","CdkScrollableModule"],"sourceRoot":"webpack:///","sources":["./.yarn/__virtual__/@angular-material-virtual-894adb27e5/0/cache/@angular-material-npm-15.2.6-c3a4b7c31c-45a31fd989.zip/node_modules/@angular/material/fesm2020/autocomplete.mjs"],"sourcesContent":["import * as i0 from '@angular/core';\nimport { InjectionToken, EventEmitter, TemplateRef, Directive, Inject, ViewChild, Input, Output, Component, ViewEncapsulation, ChangeDetectionStrategy, ContentChildren, forwardRef, Optional, Host, NgModule } from '@angular/core';\nimport { mixinDisableRipple, MAT_OPTION_PARENT_COMPONENT, MAT_OPTGROUP, MatOption, MatOptionSelectionChange, _countGroupLabelsBeforeOption, _getOptionScrollPosition, MatOptionModule, MatCommonModule } from '@angular/material/core';\nimport * as i2 from '@angular/common';\nimport { DOCUMENT, CommonModule } from '@angular/common';\nimport * as i3 from '@angular/cdk/scrolling';\nimport { CdkScrollableModule } from '@angular/cdk/scrolling';\nimport * as i1$1 from '@angular/cdk/overlay';\nimport { Overlay, OverlayConfig, OverlayModule } from '@angular/cdk/overlay';\nimport { ActiveDescendantKeyManager } from '@angular/cdk/a11y';\nimport { coerceBooleanProperty, coerceStringArray } from '@angular/cdk/coercion';\nimport * as i1 from '@angular/cdk/platform';\nimport { _getEventTarget } from '@angular/cdk/platform';\nimport { trigger, state, style, transition, group, animate } from '@angular/animations';\nimport { Subscription, Subject, defer, merge, of, fromEvent } from 'rxjs';\nimport { hasModifierKey, ESCAPE, ENTER, UP_ARROW, DOWN_ARROW, TAB } from '@angular/cdk/keycodes';\nimport { TemplatePortal } from '@angular/cdk/portal';\nimport { NG_VALUE_ACCESSOR } from '@angular/forms';\nimport * as i4 from '@angular/material/form-field';\nimport { MAT_FORM_FIELD } from '@angular/material/form-field';\nimport { startWith, switchMap, take, filter, map, tap, delay } from 'rxjs/operators';\nimport * as i2$1 from '@angular/cdk/bidi';\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// Animation values come from\n// https://github.com/material-components/material-components-web/blob/master/packages/mdc-menu-surface/_mixins.scss\n// TODO(mmalerba): Ideally find a way to import the values from MDC's code.\nconst panelAnimation = trigger('panelAnimation', [\n    state('void, hidden', style({\n        opacity: 0,\n        transform: 'scaleY(0.8)',\n    })),\n    transition(':enter, hidden => visible', [\n        group([\n            animate('0.03s linear', style({ opacity: 1 })),\n            animate('0.12s cubic-bezier(0, 0, 0.2, 1)', style({ transform: 'scaleY(1)' })),\n        ]),\n    ]),\n    transition(':leave, visible => hidden', [animate('0.075s linear', style({ opacity: 0 }))]),\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 * Autocomplete IDs need to be unique across components, so this counter exists outside of\n * the component definition.\n */\nlet _uniqueAutocompleteIdCounter = 0;\n/** Event object that is emitted when an autocomplete option is selected. */\nclass MatAutocompleteSelectedEvent {\n    constructor(\n    /** Reference to the autocomplete panel that emitted the event. */\n    source, \n    /** Option that was selected. */\n    option) {\n        this.source = source;\n        this.option = option;\n    }\n}\n// Boilerplate for applying mixins to MatAutocomplete.\n/** @docs-private */\nconst _MatAutocompleteMixinBase = mixinDisableRipple(class {\n});\n/** Injection token to be used to override the default options for `mat-autocomplete`. */\nconst MAT_AUTOCOMPLETE_DEFAULT_OPTIONS = new InjectionToken('mat-autocomplete-default-options', {\n    providedIn: 'root',\n    factory: MAT_AUTOCOMPLETE_DEFAULT_OPTIONS_FACTORY,\n});\n/** @docs-private */\nfunction MAT_AUTOCOMPLETE_DEFAULT_OPTIONS_FACTORY() {\n    return {\n        autoActiveFirstOption: false,\n        autoSelectActiveOption: false,\n        hideSingleSelectionIndicator: false,\n    };\n}\n/** Base class with all of the `MatAutocomplete` functionality. */\nclass _MatAutocompleteBase extends _MatAutocompleteMixinBase {\n    /** Whether the autocomplete panel is open. */\n    get isOpen() {\n        return this._isOpen && this.showPanel;\n    }\n    /** @docs-private Sets the theme color of the panel. */\n    _setColor(value) {\n        this._color = value;\n        this._setThemeClasses(this._classList);\n    }\n    /**\n     * Whether the first option should be highlighted when the autocomplete panel is opened.\n     * Can be configured globally through the `MAT_AUTOCOMPLETE_DEFAULT_OPTIONS` token.\n     */\n    get autoActiveFirstOption() {\n        return this._autoActiveFirstOption;\n    }\n    set autoActiveFirstOption(value) {\n        this._autoActiveFirstOption = coerceBooleanProperty(value);\n    }\n    /** Whether the active option should be selected as the user is navigating. */\n    get autoSelectActiveOption() {\n        return this._autoSelectActiveOption;\n    }\n    set autoSelectActiveOption(value) {\n        this._autoSelectActiveOption = coerceBooleanProperty(value);\n    }\n    /**\n     * Takes classes set on the host mat-autocomplete element and applies them to the panel\n     * inside the overlay container to allow for easy styling.\n     */\n    set classList(value) {\n        if (value && value.length) {\n            this._classList = coerceStringArray(value).reduce((classList, className) => {\n                classList[className] = true;\n                return classList;\n            }, {});\n        }\n        else {\n            this._classList = {};\n        }\n        this._setVisibilityClasses(this._classList);\n        this._setThemeClasses(this._classList);\n        this._elementRef.nativeElement.className = '';\n    }\n    constructor(_changeDetectorRef, _elementRef, _defaults, platform) {\n        super();\n        this._changeDetectorRef = _changeDetectorRef;\n        this._elementRef = _elementRef;\n        this._defaults = _defaults;\n        this._activeOptionChanges = Subscription.EMPTY;\n        /** Whether the autocomplete panel should be visible, depending on option length. */\n        this.showPanel = false;\n        this._isOpen = false;\n        /** Function that maps an option's control value to its display value in the trigger. */\n        this.displayWith = null;\n        this._autoActiveFirstOption = !!this._defaults.autoActiveFirstOption;\n        this._autoSelectActiveOption = !!this._defaults.autoSelectActiveOption;\n        /** Event that is emitted whenever an option from the list is selected. */\n        this.optionSelected = new EventEmitter();\n        /** Event that is emitted when the autocomplete panel is opened. */\n        this.opened = new EventEmitter();\n        /** Event that is emitted when the autocomplete panel is closed. */\n        this.closed = new EventEmitter();\n        /** Emits whenever an option is activated. */\n        this.optionActivated = new EventEmitter();\n        this._classList = {};\n        /** Unique ID to be used by autocomplete trigger's \"aria-owns\" property. */\n        this.id = `mat-autocomplete-${_uniqueAutocompleteIdCounter++}`;\n        // TODO(crisbeto): the problem that the `inertGroups` option resolves is only present on\n        // Safari using VoiceOver. We should occasionally check back to see whether the bug\n        // wasn't resolved in VoiceOver, and if it has, we can remove this and the `inertGroups`\n        // option altogether.\n        this.inertGroups = platform?.SAFARI || false;\n    }\n    ngAfterContentInit() {\n        this._keyManager = new ActiveDescendantKeyManager(this.options).withWrap();\n        this._activeOptionChanges = this._keyManager.change.subscribe(index => {\n            if (this.isOpen) {\n                this.optionActivated.emit({ source: this, option: this.options.toArray()[index] || null });\n            }\n        });\n        // Set the initial visibility state.\n        this._setVisibility();\n    }\n    ngOnDestroy() {\n        this._keyManager?.destroy();\n        this._activeOptionChanges.unsubscribe();\n    }\n    /**\n     * Sets the panel scrollTop. This allows us to manually scroll to display options\n     * above or below the fold, as they are not actually being focused when active.\n     */\n    _setScrollTop(scrollTop) {\n        if (this.panel) {\n            this.panel.nativeElement.scrollTop = scrollTop;\n        }\n    }\n    /** Returns the panel's scrollTop. */\n    _getScrollTop() {\n        return this.panel ? this.panel.nativeElement.scrollTop : 0;\n    }\n    /** Panel should hide itself when the option list is empty. */\n    _setVisibility() {\n        this.showPanel = !!this.options.length;\n        this._setVisibilityClasses(this._classList);\n        this._changeDetectorRef.markForCheck();\n    }\n    /** Emits the `select` event. */\n    _emitSelectEvent(option) {\n        const event = new MatAutocompleteSelectedEvent(this, option);\n        this.optionSelected.emit(event);\n    }\n    /** Gets the aria-labelledby for the autocomplete panel. */\n    _getPanelAriaLabelledby(labelId) {\n        if (this.ariaLabel) {\n            return null;\n        }\n        const labelExpression = labelId ? labelId + ' ' : '';\n        return this.ariaLabelledby ? labelExpression + this.ariaLabelledby : labelId;\n    }\n    /** Sets the autocomplete visibility classes on a classlist based on the panel is visible. */\n    _setVisibilityClasses(classList) {\n        classList[this._visibleClass] = this.showPanel;\n        classList[this._hiddenClass] = !this.showPanel;\n    }\n    /** Sets the theming classes on a classlist based on the theme of the panel. */\n    _setThemeClasses(classList) {\n        classList['mat-primary'] = this._color === 'primary';\n        classList['mat-warn'] = this._color === 'warn';\n        classList['mat-accent'] = this._color === 'accent';\n    }\n}\n_MatAutocompleteBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: _MatAutocompleteBase, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: MAT_AUTOCOMPLETE_DEFAULT_OPTIONS }, { token: i1.Platform }], target: i0.ɵɵFactoryTarget.Directive });\n_MatAutocompleteBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", type: _MatAutocompleteBase, inputs: { ariaLabel: [\"aria-label\", \"ariaLabel\"], ariaLabelledby: [\"aria-labelledby\", \"ariaLabelledby\"], displayWith: \"displayWith\", autoActiveFirstOption: \"autoActiveFirstOption\", autoSelectActiveOption: \"autoSelectActiveOption\", panelWidth: \"panelWidth\", classList: [\"class\", \"classList\"] }, outputs: { optionSelected: \"optionSelected\", opened: \"opened\", closed: \"closed\", optionActivated: \"optionActivated\" }, viewQueries: [{ propertyName: \"template\", first: true, predicate: TemplateRef, descendants: true, static: true }, { propertyName: \"panel\", first: true, predicate: [\"panel\"], descendants: true }], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: _MatAutocompleteBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_AUTOCOMPLETE_DEFAULT_OPTIONS]\n                }] }, { type: i1.Platform }]; }, propDecorators: { template: [{\n                type: ViewChild,\n                args: [TemplateRef, { static: true }]\n            }], panel: [{\n                type: ViewChild,\n                args: ['panel']\n            }], ariaLabel: [{\n                type: Input,\n                args: ['aria-label']\n            }], ariaLabelledby: [{\n                type: Input,\n                args: ['aria-labelledby']\n            }], displayWith: [{\n                type: Input\n            }], autoActiveFirstOption: [{\n                type: Input\n            }], autoSelectActiveOption: [{\n                type: Input\n            }], panelWidth: [{\n                type: Input\n            }], optionSelected: [{\n                type: Output\n            }], opened: [{\n                type: Output\n            }], closed: [{\n                type: Output\n            }], optionActivated: [{\n                type: Output\n            }], classList: [{\n                type: Input,\n                args: ['class']\n            }] } });\nclass MatAutocomplete extends _MatAutocompleteBase {\n    constructor() {\n        super(...arguments);\n        this._visibleClass = 'mat-mdc-autocomplete-visible';\n        this._hiddenClass = 'mat-mdc-autocomplete-hidden';\n        this._hideSingleSelectionIndicator = this._defaults.hideSingleSelectionIndicator ?? false;\n    }\n    /** Whether checkmark indicator for single-selection options is hidden. */\n    get hideSingleSelectionIndicator() {\n        return this._hideSingleSelectionIndicator;\n    }\n    set hideSingleSelectionIndicator(value) {\n        this._hideSingleSelectionIndicator = coerceBooleanProperty(value);\n        this._syncParentProperties();\n    }\n    /** Syncs the parent state with the individual options. */\n    _syncParentProperties() {\n        if (this.options) {\n            for (const option of this.options) {\n                option._changeDetectorRef.markForCheck();\n            }\n        }\n    }\n}\nMatAutocomplete.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatAutocomplete, deps: null, target: i0.ɵɵFactoryTarget.Component });\nMatAutocomplete.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", type: MatAutocomplete, selector: \"mat-autocomplete\", inputs: { disableRipple: \"disableRipple\", hideSingleSelectionIndicator: \"hideSingleSelectionIndicator\" }, host: { classAttribute: \"mat-mdc-autocomplete\" }, providers: [{ provide: MAT_OPTION_PARENT_COMPONENT, useExisting: MatAutocomplete }], queries: [{ propertyName: \"optionGroups\", predicate: MAT_OPTGROUP, descendants: true }, { propertyName: \"options\", predicate: MatOption, descendants: true }], exportAs: [\"matAutocomplete\"], usesInheritance: true, ngImport: i0, template: \"<ng-template let-formFieldId=\\\"id\\\">\\n  <div\\n    class=\\\"mat-mdc-autocomplete-panel mdc-menu-surface mdc-menu-surface--open\\\"\\n    role=\\\"listbox\\\"\\n    [id]=\\\"id\\\"\\n    [ngClass]=\\\"_classList\\\"\\n    [attr.aria-label]=\\\"ariaLabel || null\\\"\\n    [attr.aria-labelledby]=\\\"_getPanelAriaLabelledby(formFieldId)\\\"\\n    [@panelAnimation]=\\\"isOpen ? 'visible' : 'hidden'\\\"\\n    #panel>\\n    <ng-content></ng-content>\\n  </div>\\n</ng-template>\\n\", styles: [\".mdc-menu-surface{display:none;position:absolute;box-sizing:border-box;max-width:calc(100vw - 32px);max-width:var(--mdc-menu-max-width, calc(100vw - 32px));max-height:calc(100vh - 32px);max-height:var(--mdc-menu-max-height, calc(100vh - 32px));margin:0;padding:0;transform:scale(1);transform-origin:top left;opacity:0;overflow:auto;will-change:transform,opacity;z-index:8;border-radius:4px;border-radius:var(--mdc-shape-medium, 4px);transform-origin-left:top left;transform-origin-right:top right}.mdc-menu-surface:focus{outline:none}.mdc-menu-surface--animating-open{display:inline-block;transform:scale(0.8);opacity:0}.mdc-menu-surface--open{display:inline-block;transform:scale(1);opacity:1}.mdc-menu-surface--animating-closed{display:inline-block;opacity:0}[dir=rtl] .mdc-menu-surface,.mdc-menu-surface[dir=rtl]{transform-origin-left:top right;transform-origin-right:top left}.mdc-menu-surface--anchor{position:relative;overflow:visible}.mdc-menu-surface--fixed{position:fixed}.mdc-menu-surface--fullwidth{width:100%}.mdc-menu-surface.mat-mdc-autocomplete-panel{width:100%;max-height:256px;position:static;visibility:hidden;transform-origin:center top;margin:0;padding:8px 0;list-style-type:none}.mdc-menu-surface.mat-mdc-autocomplete-panel:focus{outline:none}.cdk-high-contrast-active .mdc-menu-surface.mat-mdc-autocomplete-panel{outline:solid 1px}.cdk-overlay-pane:not(.mat-mdc-autocomplete-panel-above) .mdc-menu-surface.mat-mdc-autocomplete-panel{border-top-left-radius:0;border-top-right-radius:0}.mat-mdc-autocomplete-panel-above .mdc-menu-surface.mat-mdc-autocomplete-panel{border-bottom-left-radius:0;border-bottom-right-radius:0;transform-origin:center bottom}.mdc-menu-surface.mat-mdc-autocomplete-panel.mat-mdc-autocomplete-visible{visibility:visible}.mdc-menu-surface.mat-mdc-autocomplete-panel.mat-mdc-autocomplete-hidden{visibility:hidden}mat-autocomplete{display:none}\"], dependencies: [{ kind: \"directive\", type: i2.NgClass, selector: \"[ngClass]\", inputs: [\"class\", \"ngClass\"] }], animations: [panelAnimation], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatAutocomplete, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-autocomplete', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, exportAs: 'matAutocomplete', inputs: ['disableRipple'], host: {\n                        'class': 'mat-mdc-autocomplete',\n                    }, providers: [{ provide: MAT_OPTION_PARENT_COMPONENT, useExisting: MatAutocomplete }], animations: [panelAnimation], template: \"<ng-template let-formFieldId=\\\"id\\\">\\n  <div\\n    class=\\\"mat-mdc-autocomplete-panel mdc-menu-surface mdc-menu-surface--open\\\"\\n    role=\\\"listbox\\\"\\n    [id]=\\\"id\\\"\\n    [ngClass]=\\\"_classList\\\"\\n    [attr.aria-label]=\\\"ariaLabel || null\\\"\\n    [attr.aria-labelledby]=\\\"_getPanelAriaLabelledby(formFieldId)\\\"\\n    [@panelAnimation]=\\\"isOpen ? 'visible' : 'hidden'\\\"\\n    #panel>\\n    <ng-content></ng-content>\\n  </div>\\n</ng-template>\\n\", styles: [\".mdc-menu-surface{display:none;position:absolute;box-sizing:border-box;max-width:calc(100vw - 32px);max-width:var(--mdc-menu-max-width, calc(100vw - 32px));max-height:calc(100vh - 32px);max-height:var(--mdc-menu-max-height, calc(100vh - 32px));margin:0;padding:0;transform:scale(1);transform-origin:top left;opacity:0;overflow:auto;will-change:transform,opacity;z-index:8;border-radius:4px;border-radius:var(--mdc-shape-medium, 4px);transform-origin-left:top left;transform-origin-right:top right}.mdc-menu-surface:focus{outline:none}.mdc-menu-surface--animating-open{display:inline-block;transform:scale(0.8);opacity:0}.mdc-menu-surface--open{display:inline-block;transform:scale(1);opacity:1}.mdc-menu-surface--animating-closed{display:inline-block;opacity:0}[dir=rtl] .mdc-menu-surface,.mdc-menu-surface[dir=rtl]{transform-origin-left:top right;transform-origin-right:top left}.mdc-menu-surface--anchor{position:relative;overflow:visible}.mdc-menu-surface--fixed{position:fixed}.mdc-menu-surface--fullwidth{width:100%}.mdc-menu-surface.mat-mdc-autocomplete-panel{width:100%;max-height:256px;position:static;visibility:hidden;transform-origin:center top;margin:0;padding:8px 0;list-style-type:none}.mdc-menu-surface.mat-mdc-autocomplete-panel:focus{outline:none}.cdk-high-contrast-active .mdc-menu-surface.mat-mdc-autocomplete-panel{outline:solid 1px}.cdk-overlay-pane:not(.mat-mdc-autocomplete-panel-above) .mdc-menu-surface.mat-mdc-autocomplete-panel{border-top-left-radius:0;border-top-right-radius:0}.mat-mdc-autocomplete-panel-above .mdc-menu-surface.mat-mdc-autocomplete-panel{border-bottom-left-radius:0;border-bottom-right-radius:0;transform-origin:center bottom}.mdc-menu-surface.mat-mdc-autocomplete-panel.mat-mdc-autocomplete-visible{visibility:visible}.mdc-menu-surface.mat-mdc-autocomplete-panel.mat-mdc-autocomplete-hidden{visibility:hidden}mat-autocomplete{display:none}\"] }]\n        }], propDecorators: { optionGroups: [{\n                type: ContentChildren,\n                args: [MAT_OPTGROUP, { descendants: true }]\n            }], options: [{\n                type: ContentChildren,\n                args: [MatOption, { descendants: true }]\n            }], hideSingleSelectionIndicator: [{\n                type: Input\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Base class containing all of the functionality for `MatAutocompleteOrigin`. */\nclass _MatAutocompleteOriginBase {\n    constructor(\n    /** Reference to the element on which the directive is applied. */\n    elementRef) {\n        this.elementRef = elementRef;\n    }\n}\n_MatAutocompleteOriginBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: _MatAutocompleteOriginBase, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });\n_MatAutocompleteOriginBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", type: _MatAutocompleteOriginBase, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: _MatAutocompleteOriginBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; } });\n/**\n * Directive applied to an element to make it usable\n * as a connection point for an autocomplete panel.\n */\nclass MatAutocompleteOrigin extends _MatAutocompleteOriginBase {\n}\nMatAutocompleteOrigin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatAutocompleteOrigin, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatAutocompleteOrigin.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", type: MatAutocompleteOrigin, selector: \"[matAutocompleteOrigin]\", exportAs: [\"matAutocompleteOrigin\"], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatAutocompleteOrigin, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matAutocompleteOrigin]',\n                    exportAs: 'matAutocompleteOrigin',\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Provider that allows the autocomplete to register as a ControlValueAccessor.\n * @docs-private\n */\nconst MAT_AUTOCOMPLETE_VALUE_ACCESSOR = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => MatAutocompleteTrigger),\n    multi: true,\n};\n/**\n * Creates an error to be thrown when attempting to use an autocomplete trigger without a panel.\n * @docs-private\n */\nfunction getMatAutocompleteMissingPanelError() {\n    return Error('Attempting to open an undefined instance of `mat-autocomplete`. ' +\n        'Make sure that the id passed to the `matAutocomplete` is correct and that ' +\n        \"you're attempting to open it after the ngAfterContentInit hook.\");\n}\n/** Injection token that determines the scroll handling while the autocomplete panel is open. */\nconst MAT_AUTOCOMPLETE_SCROLL_STRATEGY = new InjectionToken('mat-autocomplete-scroll-strategy');\n/** @docs-private */\nfunction MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY(overlay) {\n    return () => overlay.scrollStrategies.reposition();\n}\n/** @docs-private */\nconst MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER = {\n    provide: MAT_AUTOCOMPLETE_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY,\n};\n/** Base class with all of the `MatAutocompleteTrigger` functionality. */\nclass _MatAutocompleteTriggerBase {\n    /**\n     * Whether the autocomplete is disabled. When disabled, the element will\n     * act as a regular input and the user won't be able to open the panel.\n     */\n    get autocompleteDisabled() {\n        return this._autocompleteDisabled;\n    }\n    set autocompleteDisabled(value) {\n        this._autocompleteDisabled = coerceBooleanProperty(value);\n    }\n    constructor(_element, _overlay, _viewContainerRef, _zone, _changeDetectorRef, scrollStrategy, _dir, _formField, _document, _viewportRuler, _defaults) {\n        this._element = _element;\n        this._overlay = _overlay;\n        this._viewContainerRef = _viewContainerRef;\n        this._zone = _zone;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._dir = _dir;\n        this._formField = _formField;\n        this._document = _document;\n        this._viewportRuler = _viewportRuler;\n        this._defaults = _defaults;\n        this._componentDestroyed = false;\n        this._autocompleteDisabled = false;\n        /** Whether or not the label state is being overridden. */\n        this._manuallyFloatingLabel = false;\n        /** Subscription to viewport size changes. */\n        this._viewportSubscription = Subscription.EMPTY;\n        /**\n         * Whether the autocomplete can open the next time it is focused. Used to prevent a focused,\n         * closed autocomplete from being reopened if the user switches to another browser tab and then\n         * comes back.\n         */\n        this._canOpenOnNextFocus = true;\n        /** Stream of keyboard events that can close the panel. */\n        this._closeKeyEventStream = new Subject();\n        /**\n         * Event handler for when the window is blurred. Needs to be an\n         * arrow function in order to preserve the context.\n         */\n        this._windowBlurHandler = () => {\n            // If the user blurred the window while the autocomplete is focused, it means that it'll be\n            // refocused when they come back. In this case we want to skip the first focus event, if the\n            // pane was closed, in order to avoid reopening it unintentionally.\n            this._canOpenOnNextFocus =\n                this._document.activeElement !== this._element.nativeElement || this.panelOpen;\n        };\n        /** `View -> model callback called when value changes` */\n        this._onChange = () => { };\n        /** `View -> model callback called when autocomplete has been touched` */\n        this._onTouched = () => { };\n        /**\n         * Position of the autocomplete panel relative to the trigger element. A position of `auto`\n         * will render the panel underneath the trigger if there is enough space for it to fit in\n         * the viewport, otherwise the panel will be shown above it. If the position is set to\n         * `above` or `below`, the panel will always be shown above or below the trigger. no matter\n         * whether it fits completely in the viewport.\n         */\n        this.position = 'auto';\n        /**\n         * `autocomplete` attribute to be set on the input element.\n         * @docs-private\n         */\n        this.autocompleteAttribute = 'off';\n        this._overlayAttached = false;\n        /** Stream of changes to the selection state of the autocomplete options. */\n        this.optionSelections = defer(() => {\n            const options = this.autocomplete ? this.autocomplete.options : null;\n            if (options) {\n                return options.changes.pipe(startWith(options), switchMap(() => merge(...options.map(option => option.onSelectionChange))));\n            }\n            // If there are any subscribers before `ngAfterViewInit`, the `autocomplete` will be undefined.\n            // Return a stream that we'll replace with the real one once everything is in place.\n            return this._zone.onStable.pipe(take(1), switchMap(() => this.optionSelections));\n        });\n        this._scrollStrategy = scrollStrategy;\n    }\n    ngAfterViewInit() {\n        const window = this._getWindow();\n        if (typeof window !== 'undefined') {\n            this._zone.runOutsideAngular(() => window.addEventListener('blur', this._windowBlurHandler));\n        }\n    }\n    ngOnChanges(changes) {\n        if (changes['position'] && this._positionStrategy) {\n            this._setStrategyPositions(this._positionStrategy);\n            if (this.panelOpen) {\n                this._overlayRef.updatePosition();\n            }\n        }\n    }\n    ngOnDestroy() {\n        const window = this._getWindow();\n        if (typeof window !== 'undefined') {\n            window.removeEventListener('blur', this._windowBlurHandler);\n        }\n        this._viewportSubscription.unsubscribe();\n        this._componentDestroyed = true;\n        this._destroyPanel();\n        this._closeKeyEventStream.complete();\n    }\n    /** Whether or not the autocomplete panel is open. */\n    get panelOpen() {\n        return this._overlayAttached && this.autocomplete.showPanel;\n    }\n    /** Opens the autocomplete suggestion panel. */\n    openPanel() {\n        this._attachOverlay();\n        this._floatLabel();\n    }\n    /** Closes the autocomplete suggestion panel. */\n    closePanel() {\n        this._resetLabel();\n        if (!this._overlayAttached) {\n            return;\n        }\n        if (this.panelOpen) {\n            // Only emit if the panel was visible.\n            // The `NgZone.onStable` always emits outside of the Angular zone,\n            // so all the subscriptions from `_subscribeToClosingActions()` are also outside of the Angular zone.\n            // We should manually run in Angular zone to update UI after panel closing.\n            this._zone.run(() => {\n                this.autocomplete.closed.emit();\n            });\n        }\n        this.autocomplete._isOpen = this._overlayAttached = false;\n        this._pendingAutoselectedOption = null;\n        if (this._overlayRef && this._overlayRef.hasAttached()) {\n            this._overlayRef.detach();\n            this._closingActionsSubscription.unsubscribe();\n        }\n        // Note that in some cases this can end up being called after the component is destroyed.\n        // Add a check to ensure that we don't try to run change detection on a destroyed view.\n        if (!this._componentDestroyed) {\n            // We need to trigger change detection manually, because\n            // `fromEvent` doesn't seem to do it at the proper time.\n            // This ensures that the label is reset when the\n            // user clicks outside.\n            this._changeDetectorRef.detectChanges();\n        }\n    }\n    /**\n     * Updates the position of the autocomplete suggestion panel to ensure that it fits all options\n     * within the viewport.\n     */\n    updatePosition() {\n        if (this._overlayAttached) {\n            this._overlayRef.updatePosition();\n        }\n    }\n    /**\n     * A stream of actions that should close the autocomplete panel, including\n     * when an option is selected, on blur, and when TAB is pressed.\n     */\n    get panelClosingActions() {\n        return merge(this.optionSelections, this.autocomplete._keyManager.tabOut.pipe(filter(() => this._overlayAttached)), this._closeKeyEventStream, this._getOutsideClickStream(), this._overlayRef\n            ? this._overlayRef.detachments().pipe(filter(() => this._overlayAttached))\n            : of()).pipe(\n        // Normalize the output so we return a consistent type.\n        map(event => (event instanceof MatOptionSelectionChange ? event : null)));\n    }\n    /** The currently active option, coerced to MatOption type. */\n    get activeOption() {\n        if (this.autocomplete && this.autocomplete._keyManager) {\n            return this.autocomplete._keyManager.activeItem;\n        }\n        return null;\n    }\n    /** Stream of clicks outside of the autocomplete panel. */\n    _getOutsideClickStream() {\n        return merge(fromEvent(this._document, 'click'), fromEvent(this._document, 'auxclick'), fromEvent(this._document, 'touchend')).pipe(filter(event => {\n            // If we're in the Shadow DOM, the event target will be the shadow root, so we have to\n            // fall back to check the first element in the path of the click event.\n            const clickTarget = _getEventTarget(event);\n            const formField = this._formField ? this._formField._elementRef.nativeElement : null;\n            const customOrigin = this.connectedTo ? this.connectedTo.elementRef.nativeElement : null;\n            return (this._overlayAttached &&\n                clickTarget !== this._element.nativeElement &&\n                // Normally focus moves inside `mousedown` so this condition will almost always be\n                // true. Its main purpose is to handle the case where the input is focused from an\n                // outside click which propagates up to the `body` listener within the same sequence\n                // and causes the panel to close immediately (see #3106).\n                this._document.activeElement !== this._element.nativeElement &&\n                (!formField || !formField.contains(clickTarget)) &&\n                (!customOrigin || !customOrigin.contains(clickTarget)) &&\n                !!this._overlayRef &&\n                !this._overlayRef.overlayElement.contains(clickTarget));\n        }));\n    }\n    // Implemented as part of ControlValueAccessor.\n    writeValue(value) {\n        Promise.resolve(null).then(() => this._assignOptionValue(value));\n    }\n    // Implemented as part of ControlValueAccessor.\n    registerOnChange(fn) {\n        this._onChange = fn;\n    }\n    // Implemented as part of ControlValueAccessor.\n    registerOnTouched(fn) {\n        this._onTouched = fn;\n    }\n    // Implemented as part of ControlValueAccessor.\n    setDisabledState(isDisabled) {\n        this._element.nativeElement.disabled = isDisabled;\n    }\n    _handleKeydown(event) {\n        const keyCode = event.keyCode;\n        const hasModifier = hasModifierKey(event);\n        // Prevent the default action on all escape key presses. This is here primarily to bring IE\n        // in line with other browsers. By default, pressing escape on IE will cause it to revert\n        // the input value to the one that it had on focus, however it won't dispatch any events\n        // which means that the model value will be out of sync with the view.\n        if (keyCode === ESCAPE && !hasModifier) {\n            event.preventDefault();\n        }\n        if (this.activeOption && keyCode === ENTER && this.panelOpen && !hasModifier) {\n            this.activeOption._selectViaInteraction();\n            this._resetActiveItem();\n            event.preventDefault();\n        }\n        else if (this.autocomplete) {\n            const prevActiveItem = this.autocomplete._keyManager.activeItem;\n            const isArrowKey = keyCode === UP_ARROW || keyCode === DOWN_ARROW;\n            if (keyCode === TAB || (isArrowKey && !hasModifier && this.panelOpen)) {\n                this.autocomplete._keyManager.onKeydown(event);\n            }\n            else if (isArrowKey && this._canOpen()) {\n                this.openPanel();\n            }\n            if (isArrowKey || this.autocomplete._keyManager.activeItem !== prevActiveItem) {\n                this._scrollToOption(this.autocomplete._keyManager.activeItemIndex || 0);\n                if (this.autocomplete.autoSelectActiveOption && this.activeOption) {\n                    if (!this._pendingAutoselectedOption) {\n                        this._valueBeforeAutoSelection = this._element.nativeElement.value;\n                    }\n                    this._pendingAutoselectedOption = this.activeOption;\n                    this._assignOptionValue(this.activeOption.value);\n                }\n            }\n        }\n    }\n    _handleInput(event) {\n        let target = event.target;\n        let value = target.value;\n        // Based on `NumberValueAccessor` from forms.\n        if (target.type === 'number') {\n            value = value == '' ? null : parseFloat(value);\n        }\n        // If the input has a placeholder, IE will fire the `input` event on page load,\n        // focus and blur, in addition to when the user actually changed the value. To\n        // filter out all of the extra events, we save the value on focus and between\n        // `input` events, and we check whether it changed.\n        // See: https://connect.microsoft.com/IE/feedback/details/885747/\n        if (this._previousValue !== value) {\n            this._previousValue = value;\n            this._pendingAutoselectedOption = null;\n            this._onChange(value);\n            if (this._canOpen() && this._document.activeElement === event.target) {\n                this.openPanel();\n            }\n        }\n    }\n    _handleFocus() {\n        if (!this._canOpenOnNextFocus) {\n            this._canOpenOnNextFocus = true;\n        }\n        else if (this._canOpen()) {\n            this._previousValue = this._element.nativeElement.value;\n            this._attachOverlay();\n            this._floatLabel(true);\n        }\n    }\n    _handleClick() {\n        if (this._canOpen() && !this.panelOpen) {\n            this.openPanel();\n        }\n    }\n    /**\n     * In \"auto\" mode, the label will animate down as soon as focus is lost.\n     * This causes the value to jump when selecting an option with the mouse.\n     * This method manually floats the label until the panel can be closed.\n     * @param shouldAnimate Whether the label should be animated when it is floated.\n     */\n    _floatLabel(shouldAnimate = false) {\n        if (this._formField && this._formField.floatLabel === 'auto') {\n            if (shouldAnimate) {\n                this._formField._animateAndLockLabel();\n            }\n            else {\n                this._formField.floatLabel = 'always';\n            }\n            this._manuallyFloatingLabel = true;\n        }\n    }\n    /** If the label has been manually elevated, return it to its normal state. */\n    _resetLabel() {\n        if (this._manuallyFloatingLabel) {\n            if (this._formField) {\n                this._formField.floatLabel = 'auto';\n            }\n            this._manuallyFloatingLabel = false;\n        }\n    }\n    /**\n     * This method listens to a stream of panel closing actions and resets the\n     * stream every time the option list changes.\n     */\n    _subscribeToClosingActions() {\n        const firstStable = this._zone.onStable.pipe(take(1));\n        const optionChanges = this.autocomplete.options.changes.pipe(tap(() => this._positionStrategy.reapplyLastPosition()), \n        // Defer emitting to the stream until the next tick, because changing\n        // bindings in here will cause \"changed after checked\" errors.\n        delay(0));\n        // When the zone is stable initially, and when the option list changes...\n        return (merge(firstStable, optionChanges)\n            .pipe(\n        // create a new stream of panelClosingActions, replacing any previous streams\n        // that were created, and flatten it so our stream only emits closing events...\n        switchMap(() => {\n            // The `NgZone.onStable` always emits outside of the Angular zone, thus we have to re-enter\n            // the Angular zone. This will lead to change detection being called outside of the Angular\n            // zone and the `autocomplete.opened` will also emit outside of the Angular.\n            this._zone.run(() => {\n                const wasOpen = this.panelOpen;\n                this._resetActiveItem();\n                this.autocomplete._setVisibility();\n                this._changeDetectorRef.detectChanges();\n                if (this.panelOpen) {\n                    this._overlayRef.updatePosition();\n                }\n                if (wasOpen !== this.panelOpen) {\n                    // If the `panelOpen` state changed, we need to make sure to emit the `opened` or\n                    // `closed` event, because we may not have emitted it. This can happen\n                    // - if the users opens the panel and there are no options, but the\n                    //   options come in slightly later or as a result of the value changing,\n                    // - if the panel is closed after the user entered a string that did not match any\n                    //   of the available options,\n                    // - if a valid string is entered after an invalid one.\n                    if (this.panelOpen) {\n                        this.autocomplete.opened.emit();\n                    }\n                    else {\n                        this.autocomplete.closed.emit();\n                    }\n                }\n            });\n            return this.panelClosingActions;\n        }), \n        // when the first closing event occurs...\n        take(1))\n            // set the value, close the panel, and complete.\n            .subscribe(event => this._setValueAndClose(event)));\n    }\n    /** Destroys the autocomplete suggestion panel. */\n    _destroyPanel() {\n        if (this._overlayRef) {\n            this.closePanel();\n            this._overlayRef.dispose();\n            this._overlayRef = null;\n        }\n    }\n    _assignOptionValue(value) {\n        const toDisplay = this.autocomplete && this.autocomplete.displayWith\n            ? this.autocomplete.displayWith(value)\n            : value;\n        // Simply falling back to an empty string if the display value is falsy does not work properly.\n        // The display value can also be the number zero and shouldn't fall back to an empty string.\n        this._updateNativeInputValue(toDisplay != null ? toDisplay : '');\n    }\n    _updateNativeInputValue(value) {\n        // If it's used within a `MatFormField`, we should set it through the property so it can go\n        // through change detection.\n        if (this._formField) {\n            this._formField._control.value = value;\n        }\n        else {\n            this._element.nativeElement.value = value;\n        }\n        this._previousValue = value;\n    }\n    /**\n     * This method closes the panel, and if a value is specified, also sets the associated\n     * control to that value. It will also mark the control as dirty if this interaction\n     * stemmed from the user.\n     */\n    _setValueAndClose(event) {\n        const toSelect = event ? event.source : this._pendingAutoselectedOption;\n        if (toSelect) {\n            this._clearPreviousSelectedOption(toSelect);\n            this._assignOptionValue(toSelect.value);\n            this._onChange(toSelect.value);\n            this.autocomplete._emitSelectEvent(toSelect);\n            this._element.nativeElement.focus();\n        }\n        this.closePanel();\n    }\n    /**\n     * Clear any previous selected option and emit a selection change event for this option\n     */\n    _clearPreviousSelectedOption(skip) {\n        this.autocomplete.options.forEach(option => {\n            if (option !== skip && option.selected) {\n                option.deselect();\n            }\n        });\n    }\n    _attachOverlay() {\n        if (!this.autocomplete && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getMatAutocompleteMissingPanelError();\n        }\n        let overlayRef = this._overlayRef;\n        if (!overlayRef) {\n            this._portal = new TemplatePortal(this.autocomplete.template, this._viewContainerRef, {\n                id: this._formField?.getLabelId(),\n            });\n            overlayRef = this._overlay.create(this._getOverlayConfig());\n            this._overlayRef = overlayRef;\n            this._handleOverlayEvents(overlayRef);\n            this._viewportSubscription = this._viewportRuler.change().subscribe(() => {\n                if (this.panelOpen && overlayRef) {\n                    overlayRef.updateSize({ width: this._getPanelWidth() });\n                }\n            });\n        }\n        else {\n            // Update the trigger, panel width and direction, in case anything has changed.\n            this._positionStrategy.setOrigin(this._getConnectedElement());\n            overlayRef.updateSize({ width: this._getPanelWidth() });\n        }\n        if (overlayRef && !overlayRef.hasAttached()) {\n            overlayRef.attach(this._portal);\n            this._closingActionsSubscription = this._subscribeToClosingActions();\n        }\n        const wasOpen = this.panelOpen;\n        this.autocomplete._setVisibility();\n        this.autocomplete._isOpen = this._overlayAttached = true;\n        this.autocomplete._setColor(this._formField?.color);\n        // We need to do an extra `panelOpen` check in here, because the\n        // autocomplete won't be shown if there are no options.\n        if (this.panelOpen && wasOpen !== this.panelOpen) {\n            this.autocomplete.opened.emit();\n        }\n    }\n    _getOverlayConfig() {\n        return new OverlayConfig({\n            positionStrategy: this._getOverlayPosition(),\n            scrollStrategy: this._scrollStrategy(),\n            width: this._getPanelWidth(),\n            direction: this._dir ?? undefined,\n            panelClass: this._defaults?.overlayPanelClass,\n        });\n    }\n    _getOverlayPosition() {\n        const strategy = this._overlay\n            .position()\n            .flexibleConnectedTo(this._getConnectedElement())\n            .withFlexibleDimensions(false)\n            .withPush(false);\n        this._setStrategyPositions(strategy);\n        this._positionStrategy = strategy;\n        return strategy;\n    }\n    /** Sets the positions on a position strategy based on the directive's input state. */\n    _setStrategyPositions(positionStrategy) {\n        // Note that we provide horizontal fallback positions, even though by default the dropdown\n        // width matches the input, because consumers can override the width. See #18854.\n        const belowPositions = [\n            { originX: 'start', originY: 'bottom', overlayX: 'start', overlayY: 'top' },\n            { originX: 'end', originY: 'bottom', overlayX: 'end', overlayY: 'top' },\n        ];\n        // The overlay edge connected to the trigger should have squared corners, while\n        // the opposite end has rounded corners. We apply a CSS class to swap the\n        // border-radius based on the overlay position.\n        const panelClass = this._aboveClass;\n        const abovePositions = [\n            { originX: 'start', originY: 'top', overlayX: 'start', overlayY: 'bottom', panelClass },\n            { originX: 'end', originY: 'top', overlayX: 'end', overlayY: 'bottom', panelClass },\n        ];\n        let positions;\n        if (this.position === 'above') {\n            positions = abovePositions;\n        }\n        else if (this.position === 'below') {\n            positions = belowPositions;\n        }\n        else {\n            positions = [...belowPositions, ...abovePositions];\n        }\n        positionStrategy.withPositions(positions);\n    }\n    _getConnectedElement() {\n        if (this.connectedTo) {\n            return this.connectedTo.elementRef;\n        }\n        return this._formField ? this._formField.getConnectedOverlayOrigin() : this._element;\n    }\n    _getPanelWidth() {\n        return this.autocomplete.panelWidth || this._getHostWidth();\n    }\n    /** Returns the width of the input element, so the panel width can match it. */\n    _getHostWidth() {\n        return this._getConnectedElement().nativeElement.getBoundingClientRect().width;\n    }\n    /**\n     * Resets the active item to -1 so arrow events will activate the\n     * correct options, or to 0 if the consumer opted into it.\n     */\n    _resetActiveItem() {\n        const autocomplete = this.autocomplete;\n        if (autocomplete.autoActiveFirstOption) {\n            // Note that we go through `setFirstItemActive`, rather than `setActiveItem(0)`, because\n            // the former will find the next enabled option, if the first one is disabled.\n            autocomplete._keyManager.setFirstItemActive();\n        }\n        else {\n            autocomplete._keyManager.setActiveItem(-1);\n        }\n    }\n    /** Determines whether the panel can be opened. */\n    _canOpen() {\n        const element = this._element.nativeElement;\n        return !element.readOnly && !element.disabled && !this._autocompleteDisabled;\n    }\n    /** Use defaultView of injected document if available or fallback to global window reference */\n    _getWindow() {\n        return this._document?.defaultView || window;\n    }\n    /** Scrolls to a particular option in the list. */\n    _scrollToOption(index) {\n        // Given that we are not actually focusing active options, we must manually adjust scroll\n        // to reveal options below the fold. First, we find the offset of the option from the top\n        // of the panel. If that offset is below the fold, the new scrollTop will be the offset -\n        // the panel height + the option height, so the active option will be just visible at the\n        // bottom of the panel. If that offset is above the top of the visible panel, the new scrollTop\n        // will become the offset. If that offset is visible within the panel already, the scrollTop is\n        // not adjusted.\n        const autocomplete = this.autocomplete;\n        const labelCount = _countGroupLabelsBeforeOption(index, autocomplete.options, autocomplete.optionGroups);\n        if (index === 0 && labelCount === 1) {\n            // If we've got one group label before the option and we're at the top option,\n            // scroll the list to the top. This is better UX than scrolling the list to the\n            // top of the option, because it allows the user to read the top group's label.\n            autocomplete._setScrollTop(0);\n        }\n        else if (autocomplete.panel) {\n            const option = autocomplete.options.toArray()[index];\n            if (option) {\n                const element = option._getHostElement();\n                const newScrollPosition = _getOptionScrollPosition(element.offsetTop, element.offsetHeight, autocomplete._getScrollTop(), autocomplete.panel.nativeElement.offsetHeight);\n                autocomplete._setScrollTop(newScrollPosition);\n            }\n        }\n    }\n    /** Handles keyboard events coming from the overlay panel. */\n    _handleOverlayEvents(overlayRef) {\n        // Use the `keydownEvents` in order to take advantage of\n        // the overlay event targeting provided by the CDK overlay.\n        overlayRef.keydownEvents().subscribe(event => {\n            // Close when pressing ESCAPE or ALT + UP_ARROW, based on the a11y guidelines.\n            // See: https://www.w3.org/TR/wai-aria-practices-1.1/#textbox-keyboard-interaction\n            if ((event.keyCode === ESCAPE && !hasModifierKey(event)) ||\n                (event.keyCode === UP_ARROW && hasModifierKey(event, 'altKey'))) {\n                // If the user had typed something in before we autoselected an option, and they decided\n                // to cancel the selection, restore the input value to the one they had typed in.\n                if (this._pendingAutoselectedOption) {\n                    this._updateNativeInputValue(this._valueBeforeAutoSelection ?? '');\n                    this._pendingAutoselectedOption = null;\n                }\n                this._closeKeyEventStream.next();\n                this._resetActiveItem();\n                // We need to stop propagation, otherwise the event will eventually\n                // reach the input itself and cause the overlay to be reopened.\n                event.stopPropagation();\n                event.preventDefault();\n            }\n        });\n        // Subscribe to the pointer events stream so that it doesn't get picked up by other overlays.\n        // TODO(crisbeto): we should switch `_getOutsideClickStream` eventually to use this stream,\n        // but the behvior isn't exactly the same and it ends up breaking some internal tests.\n        overlayRef.outsidePointerEvents().subscribe();\n    }\n}\n_MatAutocompleteTriggerBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: _MatAutocompleteTriggerBase, deps: [{ token: i0.ElementRef }, { token: i1$1.Overlay }, { token: i0.ViewContainerRef }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }, { token: MAT_AUTOCOMPLETE_SCROLL_STRATEGY }, { token: i2$1.Directionality, optional: true }, { token: MAT_FORM_FIELD, host: true, optional: true }, { token: DOCUMENT, optional: true }, { token: i3.ViewportRuler }, { token: MAT_AUTOCOMPLETE_DEFAULT_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\n_MatAutocompleteTriggerBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", type: _MatAutocompleteTriggerBase, inputs: { autocomplete: [\"matAutocomplete\", \"autocomplete\"], position: [\"matAutocompletePosition\", \"position\"], connectedTo: [\"matAutocompleteConnectedTo\", \"connectedTo\"], autocompleteAttribute: [\"autocomplete\", \"autocompleteAttribute\"], autocompleteDisabled: [\"matAutocompleteDisabled\", \"autocompleteDisabled\"] }, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: _MatAutocompleteTriggerBase, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1$1.Overlay }, { type: i0.ViewContainerRef }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_AUTOCOMPLETE_SCROLL_STRATEGY]\n                }] }, { type: i2$1.Directionality, decorators: [{\n                    type: Optional\n                }] }, { type: i4.MatFormField, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_FORM_FIELD]\n                }, {\n                    type: Host\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: i3.ViewportRuler }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_AUTOCOMPLETE_DEFAULT_OPTIONS]\n                }] }]; }, propDecorators: { autocomplete: [{\n                type: Input,\n                args: ['matAutocomplete']\n            }], position: [{\n                type: Input,\n                args: ['matAutocompletePosition']\n            }], connectedTo: [{\n                type: Input,\n                args: ['matAutocompleteConnectedTo']\n            }], autocompleteAttribute: [{\n                type: Input,\n                args: ['autocomplete']\n            }], autocompleteDisabled: [{\n                type: Input,\n                args: ['matAutocompleteDisabled']\n            }] } });\nclass MatAutocompleteTrigger extends _MatAutocompleteTriggerBase {\n    constructor() {\n        super(...arguments);\n        this._aboveClass = 'mat-mdc-autocomplete-panel-above';\n    }\n}\nMatAutocompleteTrigger.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatAutocompleteTrigger, deps: null, target: i0.ɵɵFactoryTarget.Directive });\nMatAutocompleteTrigger.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", type: MatAutocompleteTrigger, selector: \"input[matAutocomplete], textarea[matAutocomplete]\", host: { listeners: { \"focusin\": \"_handleFocus()\", \"blur\": \"_onTouched()\", \"input\": \"_handleInput($event)\", \"keydown\": \"_handleKeydown($event)\", \"click\": \"_handleClick()\" }, properties: { \"attr.autocomplete\": \"autocompleteAttribute\", \"attr.role\": \"autocompleteDisabled ? null : \\\"combobox\\\"\", \"attr.aria-autocomplete\": \"autocompleteDisabled ? null : \\\"list\\\"\", \"attr.aria-activedescendant\": \"(panelOpen && activeOption) ? activeOption.id : null\", \"attr.aria-expanded\": \"autocompleteDisabled ? null : panelOpen.toString()\", \"attr.aria-owns\": \"(autocompleteDisabled || !panelOpen) ? null : autocomplete?.id\", \"attr.aria-haspopup\": \"autocompleteDisabled ? null : \\\"listbox\\\"\" }, classAttribute: \"mat-mdc-autocomplete-trigger\" }, providers: [MAT_AUTOCOMPLETE_VALUE_ACCESSOR], exportAs: [\"matAutocompleteTrigger\"], usesInheritance: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatAutocompleteTrigger, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: `input[matAutocomplete], textarea[matAutocomplete]`,\n                    host: {\n                        'class': 'mat-mdc-autocomplete-trigger',\n                        '[attr.autocomplete]': 'autocompleteAttribute',\n                        '[attr.role]': 'autocompleteDisabled ? null : \"combobox\"',\n                        '[attr.aria-autocomplete]': 'autocompleteDisabled ? null : \"list\"',\n                        '[attr.aria-activedescendant]': '(panelOpen && activeOption) ? activeOption.id : null',\n                        '[attr.aria-expanded]': 'autocompleteDisabled ? null : panelOpen.toString()',\n                        '[attr.aria-owns]': '(autocompleteDisabled || !panelOpen) ? null : autocomplete?.id',\n                        '[attr.aria-haspopup]': 'autocompleteDisabled ? null : \"listbox\"',\n                        // Note: we use `focusin`, as opposed to `focus`, in order to open the panel\n                        // a little earlier. This avoids issues where IE delays the focusing of the input.\n                        '(focusin)': '_handleFocus()',\n                        '(blur)': '_onTouched()',\n                        '(input)': '_handleInput($event)',\n                        '(keydown)': '_handleKeydown($event)',\n                        '(click)': '_handleClick()',\n                    },\n                    exportAs: 'matAutocompleteTrigger',\n                    providers: [MAT_AUTOCOMPLETE_VALUE_ACCESSOR],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatAutocompleteModule {\n}\nMatAutocompleteModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatAutocompleteModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatAutocompleteModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatAutocompleteModule, declarations: [MatAutocomplete, MatAutocompleteTrigger, MatAutocompleteOrigin], imports: [OverlayModule, MatOptionModule, MatCommonModule, CommonModule], exports: [CdkScrollableModule,\n        MatAutocomplete,\n        MatOptionModule,\n        MatCommonModule,\n        MatAutocompleteTrigger,\n        MatAutocompleteOrigin] });\nMatAutocompleteModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatAutocompleteModule, providers: [MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER], imports: [OverlayModule, MatOptionModule, MatCommonModule, CommonModule, CdkScrollableModule,\n        MatOptionModule,\n        MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatAutocompleteModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [OverlayModule, MatOptionModule, MatCommonModule, CommonModule],\n                    exports: [\n                        CdkScrollableModule,\n                        MatAutocomplete,\n                        MatOptionModule,\n                        MatCommonModule,\n                        MatAutocompleteTrigger,\n                        MatAutocompleteOrigin,\n                    ],\n                    declarations: [MatAutocomplete, MatAutocompleteTrigger, MatAutocompleteOrigin],\n                    providers: [MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_AUTOCOMPLETE_DEFAULT_OPTIONS, MAT_AUTOCOMPLETE_DEFAULT_OPTIONS_FACTORY, MAT_AUTOCOMPLETE_SCROLL_STRATEGY, MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY, MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER, MAT_AUTOCOMPLETE_VALUE_ACCESSOR, MatAutocomplete, MatAutocompleteModule, MatAutocompleteOrigin, MatAutocompleteSelectedEvent, MatAutocompleteTrigger, _MatAutocompleteBase, _MatAutocompleteOriginBase, _MatAutocompleteTriggerBase, getMatAutocompleteMissingPanelError };\n"],"x_google_ignoreList":[0]}