Index: trip-planner-front/node_modules/primeng/esm2020/dropdown/dropdown.mjs
===================================================================
--- trip-planner-front/node_modules/primeng/esm2020/dropdown/dropdown.mjs	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ trip-planner-front/node_modules/primeng/esm2020/dropdown/dropdown.mjs	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
@@ -0,0 +1,1202 @@
+import { ScrollingModule, CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { NgModule, Component, Input, Output, EventEmitter, ContentChildren, ViewChild, forwardRef, ChangeDetectionStrategy, ViewEncapsulation } from '@angular/core';
+import { trigger, style, transition, animate } from '@angular/animations';
+import { CommonModule } from '@angular/common';
+import { TranslationKeys } from 'primeng/api';
+import { SharedModule, PrimeTemplate } from 'primeng/api';
+import { DomHandler, ConnectedOverlayScrollHandler } from 'primeng/dom';
+import { ObjectUtils, UniqueComponentId, ZIndexUtils } from 'primeng/utils';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { TooltipModule } from 'primeng/tooltip';
+import { RippleModule } from 'primeng/ripple';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/ripple";
+import * as i2 from "@angular/common";
+import * as i3 from "primeng/api";
+import * as i4 from "@angular/cdk/scrolling";
+import * as i5 from "primeng/tooltip";
+export const DROPDOWN_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => Dropdown),
+    multi: true
+};
+export class DropdownItem {
+    constructor() {
+        this.onClick = new EventEmitter();
+    }
+    onOptionClick(event) {
+        this.onClick.emit({
+            originalEvent: event,
+            option: this.option
+        });
+    }
+}
+DropdownItem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DropdownItem, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DropdownItem.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: DropdownItem, selector: "p-dropdownItem", inputs: { option: "option", selected: "selected", label: "label", disabled: "disabled", visible: "visible", itemSize: "itemSize", template: "template" }, outputs: { onClick: "onClick" }, host: { classAttribute: "p-element" }, ngImport: i0, template: `
+        <li (click)="onOptionClick($event)" role="option" pRipple
+            [attr.aria-label]="label" [attr.aria-selected]="selected"
+            [ngStyle]="{'height': itemSize + 'px'}" [id]="selected ? 'p-highlighted-option':''"
+            [ngClass]="{'p-dropdown-item':true, 'p-highlight': selected, 'p-disabled': disabled}">
+            <span *ngIf="!template">{{label||'empty'}}</span>
+            <ng-container *ngTemplateOutlet="template; context: {$implicit: option}"></ng-container>
+        </li>
+    `, isInline: true, directives: [{ type: i1.Ripple, selector: "[pRipple]" }, { type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DropdownItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'p-dropdownItem',
+                    template: `
+        <li (click)="onOptionClick($event)" role="option" pRipple
+            [attr.aria-label]="label" [attr.aria-selected]="selected"
+            [ngStyle]="{'height': itemSize + 'px'}" [id]="selected ? 'p-highlighted-option':''"
+            [ngClass]="{'p-dropdown-item':true, 'p-highlight': selected, 'p-disabled': disabled}">
+            <span *ngIf="!template">{{label||'empty'}}</span>
+            <ng-container *ngTemplateOutlet="template; context: {$implicit: option}"></ng-container>
+        </li>
+    `,
+                    host: {
+                        'class': 'p-element'
+                    }
+                }]
+        }], propDecorators: { option: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], visible: [{
+                type: Input
+            }], itemSize: [{
+                type: Input
+            }], template: [{
+                type: Input
+            }], onClick: [{
+                type: Output
+            }] } });
+export class Dropdown {
+    constructor(el, renderer, cd, zone, filterService, config, overlayService) {
+        this.el = el;
+        this.renderer = renderer;
+        this.cd = cd;
+        this.zone = zone;
+        this.filterService = filterService;
+        this.config = config;
+        this.overlayService = overlayService;
+        this.scrollHeight = '200px';
+        this.resetFilterOnHide = false;
+        this.dropdownIcon = 'pi pi-chevron-down';
+        this.optionGroupChildren = "items";
+        this.autoDisplayFirst = true;
+        this.emptyFilterMessage = '';
+        this.emptyMessage = '';
+        this.autoZIndex = true;
+        this.baseZIndex = 0;
+        this.showTransitionOptions = '.12s cubic-bezier(0, 0, 0.2, 1)';
+        this.hideTransitionOptions = '.1s linear';
+        this.filterMatchMode = "contains";
+        this.tooltip = '';
+        this.tooltipPosition = 'right';
+        this.tooltipPositionStyle = 'absolute';
+        this.autofocusFilter = true;
+        this.onChange = new EventEmitter();
+        this.onFilter = new EventEmitter();
+        this.onFocus = new EventEmitter();
+        this.onBlur = new EventEmitter();
+        this.onClick = new EventEmitter();
+        this.onShow = new EventEmitter();
+        this.onHide = new EventEmitter();
+        this.onClear = new EventEmitter();
+        this.onModelChange = () => { };
+        this.onModelTouched = () => { };
+        this.viewPortOffsetTop = 0;
+        this.id = UniqueComponentId();
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    ;
+    set disabled(_disabled) {
+        if (_disabled) {
+            this.focused = false;
+            if (this.overlayVisible)
+                this.hide();
+        }
+        this._disabled = _disabled;
+        if (!this.cd.destroyed) {
+            this.cd.detectChanges();
+        }
+    }
+    ngAfterContentInit() {
+        this.templates.forEach((item) => {
+            switch (item.getType()) {
+                case 'item':
+                    this.itemTemplate = item.template;
+                    break;
+                case 'selectedItem':
+                    this.selectedItemTemplate = item.template;
+                    break;
+                case 'header':
+                    this.headerTemplate = item.template;
+                    break;
+                case 'footer':
+                    this.footerTemplate = item.template;
+                    break;
+                case 'emptyfilter':
+                    this.emptyFilterTemplate = item.template;
+                    break;
+                case 'empty':
+                    this.emptyTemplate = item.template;
+                    break;
+                case 'group':
+                    this.groupTemplate = item.template;
+                    break;
+                default:
+                    this.itemTemplate = item.template;
+                    break;
+            }
+        });
+    }
+    ngOnInit() {
+        this.optionsToDisplay = this.options;
+        this.updateSelectedOption(null);
+        this.labelId = this.id + '_label';
+        this.listId = this.id + '_list';
+    }
+    get options() {
+        return this._options;
+    }
+    set options(val) {
+        this._options = val;
+        this.optionsToDisplay = this._options;
+        this.updateSelectedOption(this.value);
+        this.optionsChanged = true;
+        if (this._filterValue && this._filterValue.length) {
+            this.activateFilter();
+        }
+    }
+    get filterValue() {
+        return this._filterValue;
+    }
+    set filterValue(val) {
+        this._filterValue = val;
+        this.activateFilter();
+    }
+    ngAfterViewInit() {
+        if (this.editable) {
+            this.updateEditableLabel();
+        }
+    }
+    get label() {
+        return this.selectedOption ? this.getOptionLabel(this.selectedOption) : null;
+    }
+    get emptyMessageLabel() {
+        return this.emptyMessage || this.config.getTranslation(TranslationKeys.EMPTY_MESSAGE);
+    }
+    get emptyFilterMessageLabel() {
+        return this.emptyFilterMessage || this.config.getTranslation(TranslationKeys.EMPTY_FILTER_MESSAGE);
+    }
+    get filled() {
+        return this.value || this.value != null || this.value != undefined;
+    }
+    updateEditableLabel() {
+        if (this.editableInputViewChild && this.editableInputViewChild.nativeElement) {
+            this.editableInputViewChild.nativeElement.value = (this.selectedOption ? this.getOptionLabel(this.selectedOption) : this.value || '');
+        }
+    }
+    getOptionLabel(option) {
+        return this.optionLabel ? ObjectUtils.resolveFieldData(option, this.optionLabel) : (option.label != undefined ? option.label : option);
+    }
+    getOptionValue(option) {
+        return this.optionValue ? ObjectUtils.resolveFieldData(option, this.optionValue) : (this.optionLabel || option.value === undefined ? option : option.value);
+    }
+    isOptionDisabled(option) {
+        return this.optionDisabled ? ObjectUtils.resolveFieldData(option, this.optionDisabled) : (option.disabled !== undefined ? option.disabled : false);
+    }
+    getOptionGroupLabel(optionGroup) {
+        return this.optionGroupLabel ? ObjectUtils.resolveFieldData(optionGroup, this.optionGroupLabel) : (optionGroup.label != undefined ? optionGroup.label : optionGroup);
+    }
+    getOptionGroupChildren(optionGroup) {
+        return this.optionGroupChildren ? ObjectUtils.resolveFieldData(optionGroup, this.optionGroupChildren) : optionGroup.items;
+    }
+    onItemClick(event) {
+        const option = event.option;
+        if (!this.isOptionDisabled(option)) {
+            this.selectItem(event, option);
+            this.accessibleViewChild.nativeElement.focus();
+        }
+        setTimeout(() => {
+            this.hide();
+        }, 150);
+    }
+    selectItem(event, option) {
+        if (this.selectedOption != option) {
+            this.selectedOption = option;
+            this.value = this.getOptionValue(option);
+            this.onModelChange(this.value);
+            this.updateEditableLabel();
+            this.onChange.emit({
+                originalEvent: event.originalEvent,
+                value: this.value
+            });
+            if (this.virtualScroll) {
+                setTimeout(() => {
+                    this.viewPortOffsetTop = this.viewPort ? this.viewPort.measureScrollOffset() : 0;
+                }, 1);
+            }
+        }
+    }
+    ngAfterViewChecked() {
+        if (this.optionsChanged && this.overlayVisible) {
+            this.optionsChanged = false;
+            if (this.virtualScroll) {
+                this.updateVirtualScrollSelectedIndex(true);
+            }
+            this.zone.runOutsideAngular(() => {
+                setTimeout(() => {
+                    this.alignOverlay();
+                }, 1);
+            });
+        }
+        if (this.selectedOptionUpdated && this.itemsWrapper) {
+            if (this.virtualScroll && this.viewPort) {
+                let range = this.viewPort.getRenderedRange();
+                this.updateVirtualScrollSelectedIndex(false);
+                if (range.start > this.virtualScrollSelectedIndex || range.end < this.virtualScrollSelectedIndex) {
+                    this.viewPort.scrollToIndex(this.virtualScrollSelectedIndex);
+                }
+            }
+            let selectedItem = DomHandler.findSingle(this.overlay, 'li.p-highlight');
+            if (selectedItem) {
+                DomHandler.scrollInView(this.itemsWrapper, DomHandler.findSingle(this.overlay, 'li.p-highlight'));
+            }
+            this.selectedOptionUpdated = false;
+        }
+    }
+    writeValue(value) {
+        if (this.filter) {
+            this.resetFilter();
+        }
+        this.value = value;
+        this.updateSelectedOption(value);
+        this.updateEditableLabel();
+        this.cd.markForCheck();
+    }
+    resetFilter() {
+        this._filterValue = null;
+        if (this.filterViewChild && this.filterViewChild.nativeElement) {
+            this.filterViewChild.nativeElement.value = '';
+        }
+        this.optionsToDisplay = this.options;
+    }
+    updateSelectedOption(val) {
+        this.selectedOption = this.findOption(val, this.optionsToDisplay);
+        if (this.autoDisplayFirst && !this.placeholder && !this.selectedOption && this.optionsToDisplay && this.optionsToDisplay.length && !this.editable) {
+            this.selectedOption = this.optionsToDisplay[0];
+            this.value = this.getOptionValue(this.selectedOption);
+            this.onModelChange(this.value);
+        }
+        this.selectedOptionUpdated = true;
+    }
+    registerOnChange(fn) {
+        this.onModelChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onModelTouched = fn;
+    }
+    setDisabledState(val) {
+        this.disabled = val;
+        this.cd.markForCheck();
+    }
+    onMouseclick(event) {
+        if (this.disabled || this.readonly || this.isInputClick(event)) {
+            return;
+        }
+        this.onClick.emit(event);
+        this.accessibleViewChild.nativeElement.focus();
+        if (this.overlayVisible)
+            this.hide();
+        else
+            this.show();
+        this.cd.detectChanges();
+    }
+    onOverlayClick(event) {
+        this.overlayService.add({
+            originalEvent: event,
+            target: this.el.nativeElement
+        });
+    }
+    isInputClick(event) {
+        return DomHandler.hasClass(event.target, 'p-dropdown-clear-icon') ||
+            event.target.isSameNode(this.accessibleViewChild.nativeElement) ||
+            (this.editableInputViewChild && event.target.isSameNode(this.editableInputViewChild.nativeElement));
+    }
+    isOutsideClicked(event) {
+        return !(this.el.nativeElement.isSameNode(event.target) || this.el.nativeElement.contains(event.target) || (this.overlay && this.overlay.contains(event.target)));
+    }
+    isEmpty() {
+        return !this.optionsToDisplay || (this.optionsToDisplay && this.optionsToDisplay.length === 0);
+    }
+    onEditableInputClick() {
+        this.bindDocumentClickListener();
+    }
+    onEditableInputFocus(event) {
+        this.focused = true;
+        this.hide();
+        this.onFocus.emit(event);
+    }
+    onEditableInputChange(event) {
+        this.value = event.target.value;
+        this.updateSelectedOption(this.value);
+        this.onModelChange(this.value);
+        this.onChange.emit({
+            originalEvent: event,
+            value: this.value
+        });
+    }
+    show() {
+        this.overlayVisible = true;
+    }
+    onOverlayAnimationStart(event) {
+        switch (event.toState) {
+            case 'visible':
+                this.overlay = event.element;
+                let itemsWrapperSelector = this.virtualScroll ? '.cdk-virtual-scroll-viewport' : '.p-dropdown-items-wrapper';
+                this.itemsWrapper = DomHandler.findSingle(this.overlay, itemsWrapperSelector);
+                this.appendOverlay();
+                if (this.autoZIndex) {
+                    ZIndexUtils.set('overlay', this.overlay, this.baseZIndex + this.config.zIndex.overlay);
+                }
+                this.alignOverlay();
+                this.bindDocumentClickListener();
+                this.bindDocumentResizeListener();
+                this.bindScrollListener();
+                if (this.options && this.options.length) {
+                    if (!this.virtualScroll) {
+                        let selectedListItem = DomHandler.findSingle(this.itemsWrapper, '.p-dropdown-item.p-highlight');
+                        if (selectedListItem) {
+                            selectedListItem.scrollIntoView({ block: 'nearest', inline: 'start' });
+                        }
+                    }
+                }
+                if (this.filterViewChild && this.filterViewChild.nativeElement) {
+                    this.preventModelTouched = true;
+                    if (this.autofocusFilter) {
+                        this.filterViewChild.nativeElement.focus();
+                    }
+                }
+                this.onShow.emit(event);
+                break;
+            case 'void':
+                this.onOverlayHide();
+                this.onHide.emit(event);
+                break;
+        }
+    }
+    onOverlayAnimationEnd(event) {
+        switch (event.toState) {
+            case 'void':
+                ZIndexUtils.clear(event.element);
+                break;
+        }
+    }
+    scrollToSelectedVirtualScrollElement() {
+        if (!this.virtualAutoScrolled) {
+            if (this.viewPortOffsetTop) {
+                this.viewPort.scrollToOffset(this.viewPortOffsetTop);
+            }
+            else if (this.virtualScrollSelectedIndex > -1) {
+                this.viewPort.scrollToIndex(this.virtualScrollSelectedIndex);
+            }
+        }
+        this.virtualAutoScrolled = true;
+    }
+    updateVirtualScrollSelectedIndex(resetOffset) {
+        if (this.selectedOption && this.optionsToDisplay && this.optionsToDisplay.length) {
+            if (resetOffset) {
+                this.viewPortOffsetTop = 0;
+            }
+            this.virtualScrollSelectedIndex = this.findOptionIndex(this.getOptionValue(this.selectedOption), this.optionsToDisplay);
+        }
+    }
+    appendOverlay() {
+        if (this.appendTo) {
+            if (this.appendTo === 'body')
+                document.body.appendChild(this.overlay);
+            else
+                DomHandler.appendChild(this.overlay, this.appendTo);
+            if (!this.overlay.style.minWidth) {
+                this.overlay.style.minWidth = DomHandler.getWidth(this.containerViewChild.nativeElement) + 'px';
+            }
+        }
+    }
+    restoreOverlayAppend() {
+        if (this.overlay && this.appendTo) {
+            this.el.nativeElement.appendChild(this.overlay);
+        }
+    }
+    hide() {
+        this.overlayVisible = false;
+        if (this.filter && this.resetFilterOnHide) {
+            this.resetFilter();
+        }
+        if (this.virtualScroll) {
+            this.virtualAutoScrolled = false;
+        }
+        this.cd.markForCheck();
+    }
+    alignOverlay() {
+        if (this.overlay) {
+            if (this.appendTo)
+                DomHandler.absolutePosition(this.overlay, this.containerViewChild.nativeElement);
+            else
+                DomHandler.relativePosition(this.overlay, this.containerViewChild.nativeElement);
+        }
+    }
+    onInputFocus(event) {
+        this.focused = true;
+        this.onFocus.emit(event);
+    }
+    onInputBlur(event) {
+        this.focused = false;
+        this.onBlur.emit(event);
+        if (!this.preventModelTouched) {
+            this.onModelTouched();
+        }
+        this.preventModelTouched = false;
+    }
+    findPrevEnabledOption(index) {
+        let prevEnabledOption;
+        if (this.optionsToDisplay && this.optionsToDisplay.length) {
+            for (let i = (index - 1); 0 <= i; i--) {
+                let option = this.optionsToDisplay[i];
+                if (option.disabled) {
+                    continue;
+                }
+                else {
+                    prevEnabledOption = option;
+                    break;
+                }
+            }
+            if (!prevEnabledOption) {
+                for (let i = this.optionsToDisplay.length - 1; i >= index; i--) {
+                    let option = this.optionsToDisplay[i];
+                    if (this.isOptionDisabled(option)) {
+                        continue;
+                    }
+                    else {
+                        prevEnabledOption = option;
+                        break;
+                    }
+                }
+            }
+        }
+        return prevEnabledOption;
+    }
+    findNextEnabledOption(index) {
+        let nextEnabledOption;
+        if (this.optionsToDisplay && this.optionsToDisplay.length) {
+            for (let i = (index + 1); i < this.optionsToDisplay.length; i++) {
+                let option = this.optionsToDisplay[i];
+                if (this.isOptionDisabled(option)) {
+                    continue;
+                }
+                else {
+                    nextEnabledOption = option;
+                    break;
+                }
+            }
+            if (!nextEnabledOption) {
+                for (let i = 0; i < index; i++) {
+                    let option = this.optionsToDisplay[i];
+                    if (this.isOptionDisabled(option)) {
+                        continue;
+                    }
+                    else {
+                        nextEnabledOption = option;
+                        break;
+                    }
+                }
+            }
+        }
+        return nextEnabledOption;
+    }
+    onKeydown(event, search) {
+        if (this.readonly || !this.optionsToDisplay || this.optionsToDisplay.length === null) {
+            return;
+        }
+        switch (event.which) {
+            //down
+            case 40:
+                if (!this.overlayVisible && event.altKey) {
+                    this.show();
+                }
+                else {
+                    if (this.group) {
+                        let selectedItemIndex = this.selectedOption ? this.findOptionGroupIndex(this.getOptionValue(this.selectedOption), this.optionsToDisplay) : -1;
+                        if (selectedItemIndex !== -1) {
+                            let nextItemIndex = selectedItemIndex.itemIndex + 1;
+                            if (nextItemIndex < (this.getOptionGroupChildren(this.optionsToDisplay[selectedItemIndex.groupIndex]).length)) {
+                                this.selectItem(event, this.getOptionGroupChildren(this.optionsToDisplay[selectedItemIndex.groupIndex])[nextItemIndex]);
+                                this.selectedOptionUpdated = true;
+                            }
+                            else if (this.optionsToDisplay[selectedItemIndex.groupIndex + 1]) {
+                                this.selectItem(event, this.getOptionGroupChildren(this.optionsToDisplay[selectedItemIndex.groupIndex + 1])[0]);
+                                this.selectedOptionUpdated = true;
+                            }
+                        }
+                        else {
+                            if (this.optionsToDisplay && this.optionsToDisplay.length > 0) {
+                                this.selectItem(event, this.getOptionGroupChildren(this.optionsToDisplay[0])[0]);
+                            }
+                        }
+                    }
+                    else {
+                        let selectedItemIndex = this.selectedOption ? this.findOptionIndex(this.getOptionValue(this.selectedOption), this.optionsToDisplay) : -1;
+                        let nextEnabledOption = this.findNextEnabledOption(selectedItemIndex);
+                        if (nextEnabledOption) {
+                            this.selectItem(event, nextEnabledOption);
+                            this.selectedOptionUpdated = true;
+                        }
+                    }
+                }
+                event.preventDefault();
+                break;
+            //up
+            case 38:
+                if (this.group) {
+                    let selectedItemIndex = this.selectedOption ? this.findOptionGroupIndex(this.getOptionValue(this.selectedOption), this.optionsToDisplay) : -1;
+                    if (selectedItemIndex !== -1) {
+                        let prevItemIndex = selectedItemIndex.itemIndex - 1;
+                        if (prevItemIndex >= 0) {
+                            this.selectItem(event, this.getOptionGroupChildren(this.optionsToDisplay[selectedItemIndex.groupIndex])[prevItemIndex]);
+                            this.selectedOptionUpdated = true;
+                        }
+                        else if (prevItemIndex < 0) {
+                            let prevGroup = this.optionsToDisplay[selectedItemIndex.groupIndex - 1];
+                            if (prevGroup) {
+                                this.selectItem(event, this.getOptionGroupChildren(prevGroup)[this.getOptionGroupChildren(prevGroup).length - 1]);
+                                this.selectedOptionUpdated = true;
+                            }
+                        }
+                    }
+                }
+                else {
+                    let selectedItemIndex = this.selectedOption ? this.findOptionIndex(this.getOptionValue(this.selectedOption), this.optionsToDisplay) : -1;
+                    let prevEnabledOption = this.findPrevEnabledOption(selectedItemIndex);
+                    if (prevEnabledOption) {
+                        this.selectItem(event, prevEnabledOption);
+                        this.selectedOptionUpdated = true;
+                    }
+                }
+                event.preventDefault();
+                break;
+            //space
+            case 32:
+                if (search) {
+                    if (!this.overlayVisible) {
+                        this.show();
+                    }
+                    else {
+                        this.hide();
+                    }
+                    event.preventDefault();
+                }
+                break;
+            //enter
+            case 13:
+                if (this.overlayVisible && (!this.filter || (this.optionsToDisplay && this.optionsToDisplay.length > 0))) {
+                    this.hide();
+                }
+                else if (!this.overlayVisible) {
+                    this.show();
+                }
+                event.preventDefault();
+                break;
+            //escape and tab
+            case 27:
+            case 9:
+                this.hide();
+                break;
+            //search item based on keyboard input
+            default:
+                if (search && !event.metaKey) {
+                    this.search(event);
+                }
+                break;
+        }
+    }
+    search(event) {
+        if (this.searchTimeout) {
+            clearTimeout(this.searchTimeout);
+        }
+        const char = event.key;
+        this.previousSearchChar = this.currentSearchChar;
+        this.currentSearchChar = char;
+        if (this.previousSearchChar === this.currentSearchChar)
+            this.searchValue = this.currentSearchChar;
+        else
+            this.searchValue = this.searchValue ? this.searchValue + char : char;
+        let newOption;
+        if (this.group) {
+            let searchIndex = this.selectedOption ? this.findOptionGroupIndex(this.getOptionValue(this.selectedOption), this.optionsToDisplay) : { groupIndex: 0, itemIndex: 0 };
+            newOption = this.searchOptionWithinGroup(searchIndex);
+        }
+        else {
+            let searchIndex = this.selectedOption ? this.findOptionIndex(this.getOptionValue(this.selectedOption), this.optionsToDisplay) : -1;
+            newOption = this.searchOption(++searchIndex);
+        }
+        if (newOption && !this.isOptionDisabled(newOption)) {
+            this.selectItem(event, newOption);
+            this.selectedOptionUpdated = true;
+        }
+        this.searchTimeout = setTimeout(() => {
+            this.searchValue = null;
+        }, 250);
+    }
+    searchOption(index) {
+        let option;
+        if (this.searchValue) {
+            option = this.searchOptionInRange(index, this.optionsToDisplay.length);
+            if (!option) {
+                option = this.searchOptionInRange(0, index);
+            }
+        }
+        return option;
+    }
+    searchOptionInRange(start, end) {
+        for (let i = start; i < end; i++) {
+            let opt = this.optionsToDisplay[i];
+            if (this.getOptionLabel(opt).toLocaleLowerCase(this.filterLocale).startsWith(this.searchValue.toLocaleLowerCase(this.filterLocale)) && !this.isOptionDisabled(opt)) {
+                return opt;
+            }
+        }
+        return null;
+    }
+    searchOptionWithinGroup(index) {
+        let option;
+        if (this.searchValue) {
+            for (let i = index.groupIndex; i < this.optionsToDisplay.length; i++) {
+                for (let j = (index.groupIndex === i) ? (index.itemIndex + 1) : 0; j < this.getOptionGroupChildren(this.optionsToDisplay[i]).length; j++) {
+                    let opt = this.getOptionGroupChildren(this.optionsToDisplay[i])[j];
+                    if (this.getOptionLabel(opt).toLocaleLowerCase(this.filterLocale).startsWith(this.searchValue.toLocaleLowerCase(this.filterLocale)) && !this.isOptionDisabled(opt)) {
+                        return opt;
+                    }
+                }
+            }
+            if (!option) {
+                for (let i = 0; i <= index.groupIndex; i++) {
+                    for (let j = 0; j < ((index.groupIndex === i) ? index.itemIndex : this.getOptionGroupChildren(this.optionsToDisplay[i]).length); j++) {
+                        let opt = this.getOptionGroupChildren(this.optionsToDisplay[i])[j];
+                        if (this.getOptionLabel(opt).toLocaleLowerCase(this.filterLocale).startsWith(this.searchValue.toLocaleLowerCase(this.filterLocale)) && !this.isOptionDisabled(opt)) {
+                            return opt;
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    findOptionIndex(val, opts) {
+        let index = -1;
+        if (opts) {
+            for (let i = 0; i < opts.length; i++) {
+                if ((val == null && this.getOptionValue(opts[i]) == null) || ObjectUtils.equals(val, this.getOptionValue(opts[i]), this.dataKey)) {
+                    index = i;
+                    break;
+                }
+            }
+        }
+        return index;
+    }
+    findOptionGroupIndex(val, opts) {
+        let groupIndex, itemIndex;
+        if (opts) {
+            for (let i = 0; i < opts.length; i++) {
+                groupIndex = i;
+                itemIndex = this.findOptionIndex(val, this.getOptionGroupChildren(opts[i]));
+                if (itemIndex !== -1) {
+                    break;
+                }
+            }
+        }
+        if (itemIndex !== -1) {
+            return { groupIndex: groupIndex, itemIndex: itemIndex };
+        }
+        else {
+            return -1;
+        }
+    }
+    findOption(val, opts, inGroup) {
+        if (this.group && !inGroup) {
+            let opt;
+            if (opts && opts.length) {
+                for (let optgroup of opts) {
+                    opt = this.findOption(val, this.getOptionGroupChildren(optgroup), true);
+                    if (opt) {
+                        break;
+                    }
+                }
+            }
+            return opt;
+        }
+        else {
+            let index = this.findOptionIndex(val, opts);
+            return (index != -1) ? opts[index] : null;
+        }
+    }
+    onFilterInputChange(event) {
+        let inputValue = event.target.value;
+        if (inputValue && inputValue.length) {
+            this._filterValue = inputValue;
+            this.activateFilter();
+        }
+        else {
+            this._filterValue = null;
+            this.optionsToDisplay = this.options;
+        }
+        this.optionsChanged = true;
+        this.onFilter.emit({ originalEvent: event, filter: this._filterValue });
+    }
+    activateFilter() {
+        let searchFields = (this.filterBy || this.optionLabel || 'label').split(',');
+        if (this.options && this.options.length) {
+            if (this.group) {
+                let filteredGroups = [];
+                for (let optgroup of this.options) {
+                    let filteredSubOptions = this.filterService.filter(this.getOptionGroupChildren(optgroup), searchFields, this.filterValue, this.filterMatchMode, this.filterLocale);
+                    if (filteredSubOptions && filteredSubOptions.length) {
+                        filteredGroups.push({ ...optgroup, ...{ [this.optionGroupChildren]: filteredSubOptions } });
+                    }
+                }
+                this.optionsToDisplay = filteredGroups;
+            }
+            else {
+                this.optionsToDisplay = this.filterService.filter(this.options, searchFields, this.filterValue, this.filterMatchMode, this.filterLocale);
+            }
+            this.optionsChanged = true;
+        }
+    }
+    applyFocus() {
+        if (this.editable)
+            DomHandler.findSingle(this.el.nativeElement, '.p-dropdown-label.p-inputtext').focus();
+        else
+            DomHandler.findSingle(this.el.nativeElement, 'input[readonly]').focus();
+    }
+    focus() {
+        this.applyFocus();
+    }
+    bindDocumentClickListener() {
+        if (!this.documentClickListener) {
+            const documentTarget = this.el ? this.el.nativeElement.ownerDocument : 'document';
+            this.documentClickListener = this.renderer.listen(documentTarget, 'click', (event) => {
+                if (this.isOutsideClicked(event)) {
+                    this.hide();
+                    this.unbindDocumentClickListener();
+                }
+                this.cd.markForCheck();
+            });
+        }
+    }
+    unbindDocumentClickListener() {
+        if (this.documentClickListener) {
+            this.documentClickListener();
+            this.documentClickListener = null;
+        }
+    }
+    bindDocumentResizeListener() {
+        this.documentResizeListener = this.onWindowResize.bind(this);
+        window.addEventListener('resize', this.documentResizeListener);
+    }
+    unbindDocumentResizeListener() {
+        if (this.documentResizeListener) {
+            window.removeEventListener('resize', this.documentResizeListener);
+            this.documentResizeListener = null;
+        }
+    }
+    onWindowResize() {
+        if (this.overlayVisible && !DomHandler.isTouchDevice()) {
+            this.hide();
+        }
+    }
+    bindScrollListener() {
+        if (!this.scrollHandler) {
+            this.scrollHandler = new ConnectedOverlayScrollHandler(this.containerViewChild.nativeElement, (event) => {
+                if (this.overlayVisible) {
+                    this.hide();
+                }
+            });
+        }
+        this.scrollHandler.bindScrollListener();
+    }
+    unbindScrollListener() {
+        if (this.scrollHandler) {
+            this.scrollHandler.unbindScrollListener();
+        }
+    }
+    clear(event) {
+        this.value = null;
+        this.onModelChange(this.value);
+        this.onChange.emit({
+            originalEvent: event,
+            value: this.value
+        });
+        this.updateSelectedOption(this.value);
+        this.updateEditableLabel();
+        this.onClear.emit(event);
+    }
+    onOverlayHide() {
+        this.unbindDocumentClickListener();
+        this.unbindDocumentResizeListener();
+        this.unbindScrollListener();
+        this.overlay = null;
+        this.itemsWrapper = null;
+        this.onModelTouched();
+    }
+    ngOnDestroy() {
+        if (this.scrollHandler) {
+            this.scrollHandler.destroy();
+            this.scrollHandler = null;
+        }
+        if (this.overlay) {
+            ZIndexUtils.clear(this.overlay);
+        }
+        this.restoreOverlayAppend();
+        this.onOverlayHide();
+    }
+}
+Dropdown.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: Dropdown, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }, { token: i3.FilterService }, { token: i3.PrimeNGConfig }, { token: i3.OverlayService }], target: i0.ɵɵFactoryTarget.Component });
+Dropdown.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: Dropdown, selector: "p-dropdown", inputs: { scrollHeight: "scrollHeight", filter: "filter", name: "name", style: "style", panelStyle: "panelStyle", styleClass: "styleClass", panelStyleClass: "panelStyleClass", readonly: "readonly", required: "required", editable: "editable", appendTo: "appendTo", tabindex: "tabindex", placeholder: "placeholder", filterPlaceholder: "filterPlaceholder", filterLocale: "filterLocale", inputId: "inputId", selectId: "selectId", dataKey: "dataKey", filterBy: "filterBy", autofocus: "autofocus", resetFilterOnHide: "resetFilterOnHide", dropdownIcon: "dropdownIcon", optionLabel: "optionLabel", optionValue: "optionValue", optionDisabled: "optionDisabled", optionGroupLabel: "optionGroupLabel", optionGroupChildren: "optionGroupChildren", autoDisplayFirst: "autoDisplayFirst", group: "group", showClear: "showClear", emptyFilterMessage: "emptyFilterMessage", emptyMessage: "emptyMessage", virtualScroll: "virtualScroll", itemSize: "itemSize", autoZIndex: "autoZIndex", baseZIndex: "baseZIndex", showTransitionOptions: "showTransitionOptions", hideTransitionOptions: "hideTransitionOptions", ariaFilterLabel: "ariaFilterLabel", ariaLabelledBy: "ariaLabelledBy", filterMatchMode: "filterMatchMode", maxlength: "maxlength", tooltip: "tooltip", tooltipPosition: "tooltipPosition", tooltipPositionStyle: "tooltipPositionStyle", tooltipStyleClass: "tooltipStyleClass", autofocusFilter: "autofocusFilter", disabled: "disabled", options: "options", filterValue: "filterValue" }, outputs: { onChange: "onChange", onFilter: "onFilter", onFocus: "onFocus", onBlur: "onBlur", onClick: "onClick", onShow: "onShow", onHide: "onHide", onClear: "onClear" }, host: { properties: { "class.p-inputwrapper-filled": "filled", "class.p-inputwrapper-focus": "focused || overlayVisible" }, classAttribute: "p-element p-inputwrapper" }, providers: [DROPDOWN_VALUE_ACCESSOR], queries: [{ propertyName: "templates", predicate: PrimeTemplate }], viewQueries: [{ propertyName: "containerViewChild", first: true, predicate: ["container"], descendants: true }, { propertyName: "filterViewChild", first: true, predicate: ["filter"], descendants: true }, { propertyName: "accessibleViewChild", first: true, predicate: ["in"], descendants: true }, { propertyName: "viewPort", first: true, predicate: CdkVirtualScrollViewport, descendants: true }, { propertyName: "editableInputViewChild", first: true, predicate: ["editableInput"], descendants: true }], ngImport: i0, template: `
+         <div #container [ngClass]="{'p-dropdown p-component':true,
+            'p-disabled':disabled, 'p-dropdown-open':overlayVisible, 'p-focus':focused, 'p-dropdown-clearable': showClear && !disabled}"
+            (click)="onMouseclick($event)" [ngStyle]="style" [class]="styleClass">
+            <div class="p-hidden-accessible">
+                <input #in [attr.id]="inputId" type="text" readonly (focus)="onInputFocus($event)" aria-haspopup="listbox" [attr.placeholder]="placeholder"
+                    aria-haspopup="listbox" [attr.aria-expanded]="overlayVisible" [attr.aria-labelledby]="ariaLabelledBy" (blur)="onInputBlur($event)" (keydown)="onKeydown($event, true)"
+                    [disabled]="disabled" [attr.tabindex]="tabindex" [attr.autofocus]="autofocus" [attr.aria-activedescendant]="overlayVisible ? 'p-highlighted-option' : labelId" role="listbox">
+            </div>
+            <span [attr.id]="labelId" [ngClass]="{'p-dropdown-label p-inputtext':true,'p-dropdown-label-empty':(label == null || label.length === 0)}" *ngIf="!editable && (label != null)" [pTooltip]="tooltip" [tooltipPosition]="tooltipPosition" [positionStyle]="tooltipPositionStyle" [tooltipStyleClass]="tooltipStyleClass">
+                <ng-container *ngIf="!selectedItemTemplate">{{label||'empty'}}</ng-container>
+                <ng-container *ngTemplateOutlet="selectedItemTemplate; context: {$implicit: selectedOption}"></ng-container>
+            </span>
+            <span [ngClass]="{'p-dropdown-label p-inputtext p-placeholder':true,'p-dropdown-label-empty': (placeholder == null || placeholder.length === 0)}" *ngIf="!editable && (label == null)">{{placeholder||'empty'}}</span>
+            <input #editableInput type="text" [attr.maxlength]="maxlength" class="p-dropdown-label p-inputtext" *ngIf="editable" [disabled]="disabled" [attr.placeholder]="placeholder"
+                aria-haspopup="listbox" [attr.aria-expanded]="overlayVisible" (click)="onEditableInputClick()" (input)="onEditableInputChange($event)" (focus)="onEditableInputFocus($event)" (blur)="onInputBlur($event)">
+            <i class="p-dropdown-clear-icon pi pi-times" (click)="clear($event)" *ngIf="value != null && showClear && !disabled"></i>
+            <div class="p-dropdown-trigger" role="button" aria-haspopup="listbox" [attr.aria-expanded]="overlayVisible">
+                <span class="p-dropdown-trigger-icon" [ngClass]="dropdownIcon"></span>
+            </div>
+            <div *ngIf="overlayVisible" [ngClass]="'p-dropdown-panel p-component'" (click)="onOverlayClick($event)" [@overlayAnimation]="{value: 'visible', params: {showTransitionParams: showTransitionOptions, hideTransitionParams: hideTransitionOptions}}" (@overlayAnimation.start)="onOverlayAnimationStart($event)" (@overlayAnimation.start)="onOverlayAnimationEnd($event)"onOverlayAnimationEnd [ngStyle]="panelStyle" [class]="panelStyleClass">
+                <ng-container *ngTemplateOutlet="headerTemplate"></ng-container>
+                <div class="p-dropdown-header" *ngIf="filter" >
+                    <div class="p-dropdown-filter-container" (click)="$event.stopPropagation()">
+                        <input #filter type="text" autocomplete="off" [value]="filterValue||''" class="p-dropdown-filter p-inputtext p-component" [attr.placeholder]="filterPlaceholder"
+                        (keydown.enter)="$event.preventDefault()" (keydown)="onKeydown($event, false)" (input)="onFilterInputChange($event)" [attr.aria-label]="ariaFilterLabel" [attr.aria-activedescendant]="overlayVisible ? 'p-highlighted-option' : labelId">
+                        <span class="p-dropdown-filter-icon pi pi-search"></span>
+                    </div>
+                </div>
+                <div class="p-dropdown-items-wrapper" [style.max-height]="virtualScroll ? 'auto' : (scrollHeight||'auto')">
+                    <ul [attr.id]="listId" class="p-dropdown-items" [ngClass]="{'p-dropdown-virtualscroll': virtualScroll}" role="listbox">
+                        <ng-container *ngIf="group">
+                            <ng-template ngFor let-optgroup [ngForOf]="optionsToDisplay">
+                                <li class="p-dropdown-item-group">
+                                    <span *ngIf="!groupTemplate">{{getOptionGroupLabel(optgroup)||'empty'}}</span>
+                                    <ng-container *ngTemplateOutlet="groupTemplate; context: {$implicit: optgroup}"></ng-container>
+                                </li>
+                                <ng-container *ngTemplateOutlet="itemslist; context: {$implicit: getOptionGroupChildren(optgroup), selectedOption: selectedOption}"></ng-container>
+                            </ng-template>
+                        </ng-container>
+                        <ng-container *ngIf="!group">
+                            <ng-container *ngTemplateOutlet="itemslist; context: {$implicit: optionsToDisplay, selectedOption: selectedOption}"></ng-container>
+                        </ng-container>
+                        <ng-template #itemslist let-options let-selectedOption="selectedOption">
+                            <ng-container *ngIf="!virtualScroll; else virtualScrollList">
+                                <ng-template ngFor let-option let-i="index" [ngForOf]="options">
+                                    <p-dropdownItem [option]="option" [selected]="selectedOption == option" [label]="getOptionLabel(option)" [disabled]="isOptionDisabled(option)"
+                                                    (onClick)="onItemClick($event)"
+                                                    [template]="itemTemplate"></p-dropdownItem>
+                                </ng-template>
+                            </ng-container>
+                            <ng-template #virtualScrollList>
+                                <cdk-virtual-scroll-viewport (scrolledIndexChange)="scrollToSelectedVirtualScrollElement()" #viewport [ngStyle]="{'height': scrollHeight}" [itemSize]="itemSize" *ngIf="virtualScroll && optionsToDisplay && optionsToDisplay.length">
+                                    <ng-container *cdkVirtualFor="let option of options; let i = index; let c = count; let f = first; let l = last; let e = even; let o = odd">
+                                        <p-dropdownItem [option]="option" [selected]="selectedOption == option" [label]="getOptionLabel(option)" [disabled]="isOptionDisabled(option)"
+                                                                   (onClick)="onItemClick($event)"
+                                                                   [template]="itemTemplate"></p-dropdownItem>
+                                    </ng-container>
+                                </cdk-virtual-scroll-viewport>
+                            </ng-template>
+                        </ng-template>
+                        <li *ngIf="filterValue && isEmpty()" class="p-dropdown-empty-message">
+                            <ng-container *ngIf="!emptyFilterTemplate && !emptyTemplate; else emptyFilter">
+                                {{emptyFilterMessageLabel}}
+                            </ng-container>
+                            <ng-container #emptyFilter *ngTemplateOutlet="emptyFilterTemplate || emptyTemplate"></ng-container>
+                        </li>
+                        <li *ngIf="!filterValue && isEmpty()" class="p-dropdown-empty-message">
+                            <ng-container *ngIf="!emptyTemplate; else empty">
+                                {{emptyMessageLabel}}
+                            </ng-container>
+                            <ng-container #empty *ngTemplateOutlet="emptyTemplate"></ng-container>
+                        </li>
+                    </ul>
+                </div>
+                <ng-container *ngTemplateOutlet="footerTemplate"></ng-container>
+            </div>
+        </div>
+    `, isInline: true, styles: [".p-dropdown{display:inline-flex;cursor:pointer;position:relative;-webkit-user-select:none;-ms-user-select:none;user-select:none}.p-dropdown-clear-icon{position:absolute;top:50%;margin-top:-.5rem}.p-dropdown-trigger{display:flex;align-items:center;justify-content:center;flex-shrink:0}.p-dropdown-label{display:block;white-space:nowrap;overflow:hidden;flex:1 1 auto;width:1%;text-overflow:ellipsis;cursor:pointer}.p-dropdown-label-empty{overflow:hidden;visibility:hidden}input.p-dropdown-label{cursor:default}.p-dropdown .p-dropdown-panel{min-width:100%}.p-dropdown-panel{position:absolute;top:0;left:0}.p-dropdown-items-wrapper{overflow:auto}.p-dropdown-item{cursor:pointer;font-weight:normal;white-space:nowrap;position:relative;overflow:hidden}.p-dropdown-items{margin:0;padding:0;list-style-type:none}.p-dropdown-filter{width:100%}.p-dropdown-filter-container{position:relative}.p-dropdown-filter-icon{position:absolute;top:50%;margin-top:-.5rem}.p-fluid .p-dropdown{display:flex}.p-fluid .p-dropdown .p-dropdown-label{width:1%}\n"], components: [{ type: DropdownItem, selector: "p-dropdownItem", inputs: ["option", "selected", "label", "disabled", "visible", "itemSize", "template"], outputs: ["onClick"] }, { type: i4.CdkVirtualScrollViewport, selector: "cdk-virtual-scroll-viewport", inputs: ["orientation", "appendOnly"], outputs: ["scrolledIndexChange"] }], directives: [{ type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i4.CdkFixedSizeVirtualScroll, selector: "cdk-virtual-scroll-viewport[itemSize]", inputs: ["itemSize", "minBufferPx", "maxBufferPx"] }, { type: i4.CdkVirtualForOf, selector: "[cdkVirtualFor][cdkVirtualForOf]", inputs: ["cdkVirtualForOf", "cdkVirtualForTrackBy", "cdkVirtualForTemplate", "cdkVirtualForTemplateCacheSize"] }], animations: [
+        trigger('overlayAnimation', [
+            transition(':enter', [
+                style({ opacity: 0, transform: 'scaleY(0.8)' }),
+                animate('{{showTransitionParams}}')
+            ]),
+            transition(':leave', [
+                animate('{{hideTransitionParams}}', style({ opacity: 0 }))
+            ])
+        ])
+    ], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: Dropdown, decorators: [{
+            type: Component,
+            args: [{ selector: 'p-dropdown', template: `
+         <div #container [ngClass]="{'p-dropdown p-component':true,
+            'p-disabled':disabled, 'p-dropdown-open':overlayVisible, 'p-focus':focused, 'p-dropdown-clearable': showClear && !disabled}"
+            (click)="onMouseclick($event)" [ngStyle]="style" [class]="styleClass">
+            <div class="p-hidden-accessible">
+                <input #in [attr.id]="inputId" type="text" readonly (focus)="onInputFocus($event)" aria-haspopup="listbox" [attr.placeholder]="placeholder"
+                    aria-haspopup="listbox" [attr.aria-expanded]="overlayVisible" [attr.aria-labelledby]="ariaLabelledBy" (blur)="onInputBlur($event)" (keydown)="onKeydown($event, true)"
+                    [disabled]="disabled" [attr.tabindex]="tabindex" [attr.autofocus]="autofocus" [attr.aria-activedescendant]="overlayVisible ? 'p-highlighted-option' : labelId" role="listbox">
+            </div>
+            <span [attr.id]="labelId" [ngClass]="{'p-dropdown-label p-inputtext':true,'p-dropdown-label-empty':(label == null || label.length === 0)}" *ngIf="!editable && (label != null)" [pTooltip]="tooltip" [tooltipPosition]="tooltipPosition" [positionStyle]="tooltipPositionStyle" [tooltipStyleClass]="tooltipStyleClass">
+                <ng-container *ngIf="!selectedItemTemplate">{{label||'empty'}}</ng-container>
+                <ng-container *ngTemplateOutlet="selectedItemTemplate; context: {$implicit: selectedOption}"></ng-container>
+            </span>
+            <span [ngClass]="{'p-dropdown-label p-inputtext p-placeholder':true,'p-dropdown-label-empty': (placeholder == null || placeholder.length === 0)}" *ngIf="!editable && (label == null)">{{placeholder||'empty'}}</span>
+            <input #editableInput type="text" [attr.maxlength]="maxlength" class="p-dropdown-label p-inputtext" *ngIf="editable" [disabled]="disabled" [attr.placeholder]="placeholder"
+                aria-haspopup="listbox" [attr.aria-expanded]="overlayVisible" (click)="onEditableInputClick()" (input)="onEditableInputChange($event)" (focus)="onEditableInputFocus($event)" (blur)="onInputBlur($event)">
+            <i class="p-dropdown-clear-icon pi pi-times" (click)="clear($event)" *ngIf="value != null && showClear && !disabled"></i>
+            <div class="p-dropdown-trigger" role="button" aria-haspopup="listbox" [attr.aria-expanded]="overlayVisible">
+                <span class="p-dropdown-trigger-icon" [ngClass]="dropdownIcon"></span>
+            </div>
+            <div *ngIf="overlayVisible" [ngClass]="'p-dropdown-panel p-component'" (click)="onOverlayClick($event)" [@overlayAnimation]="{value: 'visible', params: {showTransitionParams: showTransitionOptions, hideTransitionParams: hideTransitionOptions}}" (@overlayAnimation.start)="onOverlayAnimationStart($event)" (@overlayAnimation.start)="onOverlayAnimationEnd($event)"onOverlayAnimationEnd [ngStyle]="panelStyle" [class]="panelStyleClass">
+                <ng-container *ngTemplateOutlet="headerTemplate"></ng-container>
+                <div class="p-dropdown-header" *ngIf="filter" >
+                    <div class="p-dropdown-filter-container" (click)="$event.stopPropagation()">
+                        <input #filter type="text" autocomplete="off" [value]="filterValue||''" class="p-dropdown-filter p-inputtext p-component" [attr.placeholder]="filterPlaceholder"
+                        (keydown.enter)="$event.preventDefault()" (keydown)="onKeydown($event, false)" (input)="onFilterInputChange($event)" [attr.aria-label]="ariaFilterLabel" [attr.aria-activedescendant]="overlayVisible ? 'p-highlighted-option' : labelId">
+                        <span class="p-dropdown-filter-icon pi pi-search"></span>
+                    </div>
+                </div>
+                <div class="p-dropdown-items-wrapper" [style.max-height]="virtualScroll ? 'auto' : (scrollHeight||'auto')">
+                    <ul [attr.id]="listId" class="p-dropdown-items" [ngClass]="{'p-dropdown-virtualscroll': virtualScroll}" role="listbox">
+                        <ng-container *ngIf="group">
+                            <ng-template ngFor let-optgroup [ngForOf]="optionsToDisplay">
+                                <li class="p-dropdown-item-group">
+                                    <span *ngIf="!groupTemplate">{{getOptionGroupLabel(optgroup)||'empty'}}</span>
+                                    <ng-container *ngTemplateOutlet="groupTemplate; context: {$implicit: optgroup}"></ng-container>
+                                </li>
+                                <ng-container *ngTemplateOutlet="itemslist; context: {$implicit: getOptionGroupChildren(optgroup), selectedOption: selectedOption}"></ng-container>
+                            </ng-template>
+                        </ng-container>
+                        <ng-container *ngIf="!group">
+                            <ng-container *ngTemplateOutlet="itemslist; context: {$implicit: optionsToDisplay, selectedOption: selectedOption}"></ng-container>
+                        </ng-container>
+                        <ng-template #itemslist let-options let-selectedOption="selectedOption">
+                            <ng-container *ngIf="!virtualScroll; else virtualScrollList">
+                                <ng-template ngFor let-option let-i="index" [ngForOf]="options">
+                                    <p-dropdownItem [option]="option" [selected]="selectedOption == option" [label]="getOptionLabel(option)" [disabled]="isOptionDisabled(option)"
+                                                    (onClick)="onItemClick($event)"
+                                                    [template]="itemTemplate"></p-dropdownItem>
+                                </ng-template>
+                            </ng-container>
+                            <ng-template #virtualScrollList>
+                                <cdk-virtual-scroll-viewport (scrolledIndexChange)="scrollToSelectedVirtualScrollElement()" #viewport [ngStyle]="{'height': scrollHeight}" [itemSize]="itemSize" *ngIf="virtualScroll && optionsToDisplay && optionsToDisplay.length">
+                                    <ng-container *cdkVirtualFor="let option of options; let i = index; let c = count; let f = first; let l = last; let e = even; let o = odd">
+                                        <p-dropdownItem [option]="option" [selected]="selectedOption == option" [label]="getOptionLabel(option)" [disabled]="isOptionDisabled(option)"
+                                                                   (onClick)="onItemClick($event)"
+                                                                   [template]="itemTemplate"></p-dropdownItem>
+                                    </ng-container>
+                                </cdk-virtual-scroll-viewport>
+                            </ng-template>
+                        </ng-template>
+                        <li *ngIf="filterValue && isEmpty()" class="p-dropdown-empty-message">
+                            <ng-container *ngIf="!emptyFilterTemplate && !emptyTemplate; else emptyFilter">
+                                {{emptyFilterMessageLabel}}
+                            </ng-container>
+                            <ng-container #emptyFilter *ngTemplateOutlet="emptyFilterTemplate || emptyTemplate"></ng-container>
+                        </li>
+                        <li *ngIf="!filterValue && isEmpty()" class="p-dropdown-empty-message">
+                            <ng-container *ngIf="!emptyTemplate; else empty">
+                                {{emptyMessageLabel}}
+                            </ng-container>
+                            <ng-container #empty *ngTemplateOutlet="emptyTemplate"></ng-container>
+                        </li>
+                    </ul>
+                </div>
+                <ng-container *ngTemplateOutlet="footerTemplate"></ng-container>
+            </div>
+        </div>
+    `, animations: [
+                        trigger('overlayAnimation', [
+                            transition(':enter', [
+                                style({ opacity: 0, transform: 'scaleY(0.8)' }),
+                                animate('{{showTransitionParams}}')
+                            ]),
+                            transition(':leave', [
+                                animate('{{hideTransitionParams}}', style({ opacity: 0 }))
+                            ])
+                        ])
+                    ], host: {
+                        'class': 'p-element p-inputwrapper',
+                        '[class.p-inputwrapper-filled]': 'filled',
+                        '[class.p-inputwrapper-focus]': 'focused || overlayVisible'
+                    }, providers: [DROPDOWN_VALUE_ACCESSOR], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, styles: [".p-dropdown{display:inline-flex;cursor:pointer;position:relative;-webkit-user-select:none;-ms-user-select:none;user-select:none}.p-dropdown-clear-icon{position:absolute;top:50%;margin-top:-.5rem}.p-dropdown-trigger{display:flex;align-items:center;justify-content:center;flex-shrink:0}.p-dropdown-label{display:block;white-space:nowrap;overflow:hidden;flex:1 1 auto;width:1%;text-overflow:ellipsis;cursor:pointer}.p-dropdown-label-empty{overflow:hidden;visibility:hidden}input.p-dropdown-label{cursor:default}.p-dropdown .p-dropdown-panel{min-width:100%}.p-dropdown-panel{position:absolute;top:0;left:0}.p-dropdown-items-wrapper{overflow:auto}.p-dropdown-item{cursor:pointer;font-weight:normal;white-space:nowrap;position:relative;overflow:hidden}.p-dropdown-items{margin:0;padding:0;list-style-type:none}.p-dropdown-filter{width:100%}.p-dropdown-filter-container{position:relative}.p-dropdown-filter-icon{position:absolute;top:50%;margin-top:-.5rem}.p-fluid .p-dropdown{display:flex}.p-fluid .p-dropdown .p-dropdown-label{width:1%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }, { type: i3.FilterService }, { type: i3.PrimeNGConfig }, { type: i3.OverlayService }]; }, propDecorators: { scrollHeight: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], style: [{
+                type: Input
+            }], panelStyle: [{
+                type: Input
+            }], styleClass: [{
+                type: Input
+            }], panelStyleClass: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], editable: [{
+                type: Input
+            }], appendTo: [{
+                type: Input
+            }], tabindex: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], filterPlaceholder: [{
+                type: Input
+            }], filterLocale: [{
+                type: Input
+            }], inputId: [{
+                type: Input
+            }], selectId: [{
+                type: Input
+            }], dataKey: [{
+                type: Input
+            }], filterBy: [{
+                type: Input
+            }], autofocus: [{
+                type: Input
+            }], resetFilterOnHide: [{
+                type: Input
+            }], dropdownIcon: [{
+                type: Input
+            }], optionLabel: [{
+                type: Input
+            }], optionValue: [{
+                type: Input
+            }], optionDisabled: [{
+                type: Input
+            }], optionGroupLabel: [{
+                type: Input
+            }], optionGroupChildren: [{
+                type: Input
+            }], autoDisplayFirst: [{
+                type: Input
+            }], group: [{
+                type: Input
+            }], showClear: [{
+                type: Input
+            }], emptyFilterMessage: [{
+                type: Input
+            }], emptyMessage: [{
+                type: Input
+            }], virtualScroll: [{
+                type: Input
+            }], itemSize: [{
+                type: Input
+            }], autoZIndex: [{
+                type: Input
+            }], baseZIndex: [{
+                type: Input
+            }], showTransitionOptions: [{
+                type: Input
+            }], hideTransitionOptions: [{
+                type: Input
+            }], ariaFilterLabel: [{
+                type: Input
+            }], ariaLabelledBy: [{
+                type: Input
+            }], filterMatchMode: [{
+                type: Input
+            }], maxlength: [{
+                type: Input
+            }], tooltip: [{
+                type: Input
+            }], tooltipPosition: [{
+                type: Input
+            }], tooltipPositionStyle: [{
+                type: Input
+            }], tooltipStyleClass: [{
+                type: Input
+            }], autofocusFilter: [{
+                type: Input
+            }], onChange: [{
+                type: Output
+            }], onFilter: [{
+                type: Output
+            }], onFocus: [{
+                type: Output
+            }], onBlur: [{
+                type: Output
+            }], onClick: [{
+                type: Output
+            }], onShow: [{
+                type: Output
+            }], onHide: [{
+                type: Output
+            }], onClear: [{
+                type: Output
+            }], containerViewChild: [{
+                type: ViewChild,
+                args: ['container']
+            }], filterViewChild: [{
+                type: ViewChild,
+                args: ['filter']
+            }], accessibleViewChild: [{
+                type: ViewChild,
+                args: ['in']
+            }], viewPort: [{
+                type: ViewChild,
+                args: [CdkVirtualScrollViewport]
+            }], editableInputViewChild: [{
+                type: ViewChild,
+                args: ['editableInput']
+            }], templates: [{
+                type: ContentChildren,
+                args: [PrimeTemplate]
+            }], disabled: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], filterValue: [{
+                type: Input
+            }] } });
+export class DropdownModule {
+}
+DropdownModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DropdownModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DropdownModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DropdownModule, declarations: [Dropdown, DropdownItem], imports: [CommonModule, SharedModule, ScrollingModule, TooltipModule, RippleModule], exports: [Dropdown, SharedModule, ScrollingModule] });
+DropdownModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DropdownModule, imports: [[CommonModule, SharedModule, ScrollingModule, TooltipModule, RippleModule], SharedModule, ScrollingModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DropdownModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, SharedModule, ScrollingModule, TooltipModule, RippleModule],
+                    exports: [Dropdown, SharedModule, ScrollingModule],
+                    declarations: [Dropdown, DropdownItem]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropdown.js","sourceRoot":"","sources":["../../../src/app/components/dropdown/dropdown.ts"],"names":[],"mappings":"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","sourcesContent":["import {ScrollingModule, CdkVirtualScrollViewport} from '@angular/cdk/scrolling';\nimport {NgModule,Component,ElementRef,OnInit,AfterViewInit,AfterContentInit,AfterViewChecked,OnDestroy,Input,Output,Renderer2,EventEmitter,ContentChildren,\n        QueryList,ViewChild,TemplateRef,forwardRef,ChangeDetectorRef,NgZone,ViewRef,ChangeDetectionStrategy, ViewEncapsulation} from '@angular/core';\nimport {trigger,style,transition,animate,AnimationEvent} from '@angular/animations';\nimport {CommonModule} from '@angular/common';\nimport {OverlayService, PrimeNGConfig, SelectItem, TranslationKeys} from 'primeng/api';\nimport {SharedModule,PrimeTemplate, FilterService} from 'primeng/api';\nimport {DomHandler, ConnectedOverlayScrollHandler} from 'primeng/dom';\nimport {ObjectUtils,UniqueComponentId,ZIndexUtils} from 'primeng/utils';\nimport {NG_VALUE_ACCESSOR, ControlValueAccessor} from '@angular/forms';\nimport {TooltipModule} from 'primeng/tooltip';\nimport {RippleModule} from 'primeng/ripple';\n\nexport const DROPDOWN_VALUE_ACCESSOR: any = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => Dropdown),\n  multi: true\n};\n\n@Component({\n    selector: 'p-dropdownItem',\n    template: `\n        <li (click)=\"onOptionClick($event)\" role=\"option\" pRipple\n            [attr.aria-label]=\"label\" [attr.aria-selected]=\"selected\"\n            [ngStyle]=\"{'height': itemSize + 'px'}\" [id]=\"selected ? 'p-highlighted-option':''\"\n            [ngClass]=\"{'p-dropdown-item':true, 'p-highlight': selected, 'p-disabled': disabled}\">\n            <span *ngIf=\"!template\">{{label||'empty'}}</span>\n            <ng-container *ngTemplateOutlet=\"template; context: {$implicit: option}\"></ng-container>\n        </li>\n    `,\n    host: {\n        'class': 'p-element'\n    }\n})\nexport class DropdownItem {\n\n    @Input() option: SelectItem;\n\n    @Input() selected: boolean;\n\n    @Input() label: string;\n\n    @Input() disabled: boolean;\n\n    @Input() visible: boolean;\n\n    @Input() itemSize: number;\n\n    @Input() template: TemplateRef<any>;\n\n    @Output() onClick: EventEmitter<any> = new EventEmitter();\n\n    onOptionClick(event: Event) {\n        this.onClick.emit({\n            originalEvent: event,\n            option: this.option\n        });\n    }\n}\n\n@Component({\n    selector: 'p-dropdown',\n    template: `\n         <div #container [ngClass]=\"{'p-dropdown p-component':true,\n            'p-disabled':disabled, 'p-dropdown-open':overlayVisible, 'p-focus':focused, 'p-dropdown-clearable': showClear && !disabled}\"\n            (click)=\"onMouseclick($event)\" [ngStyle]=\"style\" [class]=\"styleClass\">\n            <div class=\"p-hidden-accessible\">\n                <input #in [attr.id]=\"inputId\" type=\"text\" readonly (focus)=\"onInputFocus($event)\" aria-haspopup=\"listbox\" [attr.placeholder]=\"placeholder\"\n                    aria-haspopup=\"listbox\" [attr.aria-expanded]=\"overlayVisible\" [attr.aria-labelledby]=\"ariaLabelledBy\" (blur)=\"onInputBlur($event)\" (keydown)=\"onKeydown($event, true)\"\n                    [disabled]=\"disabled\" [attr.tabindex]=\"tabindex\" [attr.autofocus]=\"autofocus\" [attr.aria-activedescendant]=\"overlayVisible ? 'p-highlighted-option' : labelId\" role=\"listbox\">\n            </div>\n            <span [attr.id]=\"labelId\" [ngClass]=\"{'p-dropdown-label p-inputtext':true,'p-dropdown-label-empty':(label == null || label.length === 0)}\" *ngIf=\"!editable && (label != null)\" [pTooltip]=\"tooltip\" [tooltipPosition]=\"tooltipPosition\" [positionStyle]=\"tooltipPositionStyle\" [tooltipStyleClass]=\"tooltipStyleClass\">\n                <ng-container *ngIf=\"!selectedItemTemplate\">{{label||'empty'}}</ng-container>\n                <ng-container *ngTemplateOutlet=\"selectedItemTemplate; context: {$implicit: selectedOption}\"></ng-container>\n            </span>\n            <span [ngClass]=\"{'p-dropdown-label p-inputtext p-placeholder':true,'p-dropdown-label-empty': (placeholder == null || placeholder.length === 0)}\" *ngIf=\"!editable && (label == null)\">{{placeholder||'empty'}}</span>\n            <input #editableInput type=\"text\" [attr.maxlength]=\"maxlength\" class=\"p-dropdown-label p-inputtext\" *ngIf=\"editable\" [disabled]=\"disabled\" [attr.placeholder]=\"placeholder\"\n                aria-haspopup=\"listbox\" [attr.aria-expanded]=\"overlayVisible\" (click)=\"onEditableInputClick()\" (input)=\"onEditableInputChange($event)\" (focus)=\"onEditableInputFocus($event)\" (blur)=\"onInputBlur($event)\">\n            <i class=\"p-dropdown-clear-icon pi pi-times\" (click)=\"clear($event)\" *ngIf=\"value != null && showClear && !disabled\"></i>\n            <div class=\"p-dropdown-trigger\" role=\"button\" aria-haspopup=\"listbox\" [attr.aria-expanded]=\"overlayVisible\">\n                <span class=\"p-dropdown-trigger-icon\" [ngClass]=\"dropdownIcon\"></span>\n            </div>\n            <div *ngIf=\"overlayVisible\" [ngClass]=\"'p-dropdown-panel p-component'\" (click)=\"onOverlayClick($event)\" [@overlayAnimation]=\"{value: 'visible', params: {showTransitionParams: showTransitionOptions, hideTransitionParams: hideTransitionOptions}}\" (@overlayAnimation.start)=\"onOverlayAnimationStart($event)\" (@overlayAnimation.start)=\"onOverlayAnimationEnd($event)\"onOverlayAnimationEnd [ngStyle]=\"panelStyle\" [class]=\"panelStyleClass\">\n                <ng-container *ngTemplateOutlet=\"headerTemplate\"></ng-container>\n                <div class=\"p-dropdown-header\" *ngIf=\"filter\" >\n                    <div class=\"p-dropdown-filter-container\" (click)=\"$event.stopPropagation()\">\n                        <input #filter type=\"text\" autocomplete=\"off\" [value]=\"filterValue||''\" class=\"p-dropdown-filter p-inputtext p-component\" [attr.placeholder]=\"filterPlaceholder\"\n                        (keydown.enter)=\"$event.preventDefault()\" (keydown)=\"onKeydown($event, false)\" (input)=\"onFilterInputChange($event)\" [attr.aria-label]=\"ariaFilterLabel\" [attr.aria-activedescendant]=\"overlayVisible ? 'p-highlighted-option' : labelId\">\n                        <span class=\"p-dropdown-filter-icon pi pi-search\"></span>\n                    </div>\n                </div>\n                <div class=\"p-dropdown-items-wrapper\" [style.max-height]=\"virtualScroll ? 'auto' : (scrollHeight||'auto')\">\n                    <ul [attr.id]=\"listId\" class=\"p-dropdown-items\" [ngClass]=\"{'p-dropdown-virtualscroll': virtualScroll}\" role=\"listbox\">\n                        <ng-container *ngIf=\"group\">\n                            <ng-template ngFor let-optgroup [ngForOf]=\"optionsToDisplay\">\n                                <li class=\"p-dropdown-item-group\">\n                                    <span *ngIf=\"!groupTemplate\">{{getOptionGroupLabel(optgroup)||'empty'}}</span>\n                                    <ng-container *ngTemplateOutlet=\"groupTemplate; context: {$implicit: optgroup}\"></ng-container>\n                                </li>\n                                <ng-container *ngTemplateOutlet=\"itemslist; context: {$implicit: getOptionGroupChildren(optgroup), selectedOption: selectedOption}\"></ng-container>\n                            </ng-template>\n                        </ng-container>\n                        <ng-container *ngIf=\"!group\">\n                            <ng-container *ngTemplateOutlet=\"itemslist; context: {$implicit: optionsToDisplay, selectedOption: selectedOption}\"></ng-container>\n                        </ng-container>\n                        <ng-template #itemslist let-options let-selectedOption=\"selectedOption\">\n                            <ng-container *ngIf=\"!virtualScroll; else virtualScrollList\">\n                                <ng-template ngFor let-option let-i=\"index\" [ngForOf]=\"options\">\n                                    <p-dropdownItem [option]=\"option\" [selected]=\"selectedOption == option\" [label]=\"getOptionLabel(option)\" [disabled]=\"isOptionDisabled(option)\"\n                                                    (onClick)=\"onItemClick($event)\"\n                                                    [template]=\"itemTemplate\"></p-dropdownItem>\n                                </ng-template>\n                            </ng-container>\n                            <ng-template #virtualScrollList>\n                                <cdk-virtual-scroll-viewport (scrolledIndexChange)=\"scrollToSelectedVirtualScrollElement()\" #viewport [ngStyle]=\"{'height': scrollHeight}\" [itemSize]=\"itemSize\" *ngIf=\"virtualScroll && optionsToDisplay && optionsToDisplay.length\">\n                                    <ng-container *cdkVirtualFor=\"let option of options; let i = index; let c = count; let f = first; let l = last; let e = even; let o = odd\">\n                                        <p-dropdownItem [option]=\"option\" [selected]=\"selectedOption == option\" [label]=\"getOptionLabel(option)\" [disabled]=\"isOptionDisabled(option)\"\n                                                                   (onClick)=\"onItemClick($event)\"\n                                                                   [template]=\"itemTemplate\"></p-dropdownItem>\n                                    </ng-container>\n                                </cdk-virtual-scroll-viewport>\n                            </ng-template>\n                        </ng-template>\n                        <li *ngIf=\"filterValue && isEmpty()\" class=\"p-dropdown-empty-message\">\n                            <ng-container *ngIf=\"!emptyFilterTemplate && !emptyTemplate; else emptyFilter\">\n                                {{emptyFilterMessageLabel}}\n                            </ng-container>\n                            <ng-container #emptyFilter *ngTemplateOutlet=\"emptyFilterTemplate || emptyTemplate\"></ng-container>\n                        </li>\n                        <li *ngIf=\"!filterValue && isEmpty()\" class=\"p-dropdown-empty-message\">\n                            <ng-container *ngIf=\"!emptyTemplate; else empty\">\n                                {{emptyMessageLabel}}\n                            </ng-container>\n                            <ng-container #empty *ngTemplateOutlet=\"emptyTemplate\"></ng-container>\n                        </li>\n                    </ul>\n                </div>\n                <ng-container *ngTemplateOutlet=\"footerTemplate\"></ng-container>\n            </div>\n        </div>\n    `,\n    animations: [\n        trigger('overlayAnimation', [\n            transition(':enter', [\n                style({opacity: 0, transform: 'scaleY(0.8)'}),\n                animate('{{showTransitionParams}}')\n            ]),\n            transition(':leave', [\n                animate('{{hideTransitionParams}}', style({ opacity: 0 }))\n            ])\n        ])\n    ],\n    host: {\n        'class': 'p-element p-inputwrapper',\n        '[class.p-inputwrapper-filled]': 'filled',\n        '[class.p-inputwrapper-focus]': 'focused || overlayVisible'\n    },\n    providers: [DROPDOWN_VALUE_ACCESSOR],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    encapsulation: ViewEncapsulation.None,\n    styleUrls: ['./dropdown.css']\n})\nexport class Dropdown implements OnInit,AfterViewInit,AfterContentInit,AfterViewChecked,OnDestroy,ControlValueAccessor {\n\n    @Input() scrollHeight: string = '200px';\n\n    @Input() filter: boolean;\n\n    @Input() name: string;\n\n    @Input() style: any;\n\n    @Input() panelStyle: any;\n\n    @Input() styleClass: string;\n\n    @Input() panelStyleClass: string;\n\n    @Input() readonly: boolean;\n\n    @Input() required: boolean;\n\n    @Input() editable: boolean;\n\n    @Input() appendTo: any;\n\n    @Input() tabindex: number;\n\n    @Input() placeholder: string;\n\n    @Input() filterPlaceholder: string;\n\n    @Input() filterLocale: string;\n\n    @Input() inputId: string;\n\n    @Input() selectId: string;\n\n    @Input() dataKey: string;\n\n    @Input() filterBy: string;\n\n    @Input() autofocus: boolean;\n\n    @Input() resetFilterOnHide: boolean = false;\n\n    @Input() dropdownIcon: string = 'pi pi-chevron-down';\n\n    @Input() optionLabel: string;\n\n    @Input() optionValue: string;\n\n    @Input() optionDisabled: string;\n\n    @Input() optionGroupLabel: string;\n\n    @Input() optionGroupChildren: string = \"items\";\n\n    @Input() autoDisplayFirst: boolean = true;\n\n    @Input() group: boolean;\n\n    @Input() showClear: boolean;\n\n    @Input() emptyFilterMessage: string = '';\n\n    @Input() emptyMessage: string = '';\n\n    @Input() virtualScroll: boolean;\n\n    @Input() itemSize: number;\n\n    @Input() autoZIndex: boolean = true;\n\n    @Input() baseZIndex: number = 0;\n\n    @Input() showTransitionOptions: string = '.12s cubic-bezier(0, 0, 0.2, 1)';\n\n    @Input() hideTransitionOptions: string = '.1s linear';\n\n    @Input() ariaFilterLabel: string;\n\n    @Input() ariaLabelledBy: string;\n\n    @Input() filterMatchMode: string = \"contains\";\n\n    @Input() maxlength: number;\n\n    @Input() tooltip: string = '';\n\n    @Input() tooltipPosition: string = 'right';\n\n    @Input() tooltipPositionStyle: string = 'absolute';\n\n    @Input() tooltipStyleClass: string;\n\n    @Input() autofocusFilter: boolean = true;\n\n    @Output() onChange: EventEmitter<any> = new EventEmitter();\n\n    @Output() onFilter: EventEmitter<any> = new EventEmitter();\n\n    @Output() onFocus: EventEmitter<any> = new EventEmitter();\n\n    @Output() onBlur: EventEmitter<any> = new EventEmitter();\n\n    @Output() onClick: EventEmitter<any> = new EventEmitter();\n\n    @Output() onShow: EventEmitter<any> = new EventEmitter();\n\n    @Output() onHide: EventEmitter<any> = new EventEmitter();\n\n    @Output() onClear: EventEmitter<any> = new EventEmitter();\n\n    @ViewChild('container') containerViewChild: ElementRef;\n\n    @ViewChild('filter') filterViewChild: ElementRef;\n\n    @ViewChild('in') accessibleViewChild: ElementRef;\n\n    @ViewChild(CdkVirtualScrollViewport) viewPort: CdkVirtualScrollViewport;\n\n    @ViewChild('editableInput') editableInputViewChild: ElementRef;\n\n    @ContentChildren(PrimeTemplate) templates: QueryList<any>;\n\n    private _disabled: boolean;\n\n    @Input() get disabled(): boolean {\n        return this._disabled;\n    };\n\n    set disabled(_disabled: boolean) {\n        if (_disabled) {\n            this.focused = false;\n\n            if (this.overlayVisible)\n                this.hide();\n        }\n\n        this._disabled = _disabled;\n        if (!(this.cd as ViewRef).destroyed) {\n            this.cd.detectChanges();\n        }\n    }\n\n    overlay: HTMLDivElement;\n\n    itemsWrapper: HTMLDivElement;\n\n    itemTemplate: TemplateRef<any>;\n\n    groupTemplate: TemplateRef<any>;\n\n    selectedItemTemplate: TemplateRef<any>;\n\n    headerTemplate: TemplateRef<any>;\n\n    footerTemplate: TemplateRef<any>;\n\n    emptyFilterTemplate: TemplateRef<any>;\n\n    emptyTemplate: TemplateRef<any>;\n\n    selectedOption: any;\n\n    _options: any[];\n\n    value: any;\n\n    onModelChange: Function = () => {};\n\n    onModelTouched: Function = () => {};\n\n    optionsToDisplay: any[];\n\n    hover: boolean;\n\n    focused: boolean;\n\n    overlayVisible: boolean;\n\n    documentClickListener: any;\n\n    scrollHandler: any;\n\n    optionsChanged: boolean;\n\n    panel: HTMLDivElement;\n\n    dimensionsUpdated: boolean;\n\n    hoveredItem: any;\n\n    selectedOptionUpdated: boolean;\n\n    _filterValue: string;\n\n    searchValue: string;\n\n    searchIndex: number;\n\n    searchTimeout: any;\n\n    previousSearchChar: string;\n\n    currentSearchChar: string;\n\n    documentResizeListener: any;\n\n    virtualAutoScrolled: boolean;\n\n    virtualScrollSelectedIndex: number;\n\n    viewPortOffsetTop: number = 0;\n\n    preventModelTouched: boolean;\n\n    id: string = UniqueComponentId();\n\n    labelId: string;\n\n    listId: string;\n\n    constructor(public el: ElementRef, public renderer: Renderer2, public cd: ChangeDetectorRef, public zone: NgZone, public filterService: FilterService, public config: PrimeNGConfig, public overlayService: OverlayService) {}\n\n    ngAfterContentInit() {\n        this.templates.forEach((item) => {\n            switch(item.getType()) {\n                case 'item':\n                    this.itemTemplate = item.template;\n                break;\n\n                case 'selectedItem':\n                    this.selectedItemTemplate = item.template;\n                break;\n\n                case 'header':\n                    this.headerTemplate = item.template;\n                break;\n\n                case 'footer':\n                    this.footerTemplate = item.template;\n                break;\n\n                case 'emptyfilter':\n                    this.emptyFilterTemplate = item.template;\n                break;\n\n                case 'empty':\n                    this.emptyTemplate = item.template;\n                break;\n\n                case 'group':\n                    this.groupTemplate = item.template;\n                break;\n\n                default:\n                    this.itemTemplate = item.template;\n                break;\n            }\n        });\n    }\n\n    ngOnInit() {\n        this.optionsToDisplay = this.options;\n        this.updateSelectedOption(null);\n        this.labelId = this.id + '_label';\n        this.listId = this.id + '_list';\n    }\n\n    @Input() get options(): any[] {\n        return this._options;\n    }\n\n    set options(val: any[]) {\n        this._options = val;\n        this.optionsToDisplay = this._options;\n        this.updateSelectedOption(this.value);\n        this.optionsChanged = true;\n\n        if (this._filterValue && this._filterValue.length) {\n            this.activateFilter();\n        }\n    }\n\n    @Input() get filterValue(): string {\n        return this._filterValue;\n    }\n\n    set filterValue(val: string) {\n        this._filterValue = val;\n        this.activateFilter();\n    }\n\n    ngAfterViewInit() {\n        if (this.editable) {\n            this.updateEditableLabel();\n        }\n    }\n\n    get label(): string {\n        return this.selectedOption ? this.getOptionLabel(this.selectedOption) : null;\n    }\n\n    get emptyMessageLabel(): string {\n        return this.emptyMessage || this.config.getTranslation(TranslationKeys.EMPTY_MESSAGE);\n    }\n\n    get emptyFilterMessageLabel(): string {\n        return this.emptyFilterMessage || this.config.getTranslation(TranslationKeys.EMPTY_FILTER_MESSAGE);\n    }\n\n    get filled() {\n        return this.value || this.value != null || this.value != undefined;\n    }\n\n    updateEditableLabel(): void {\n        if (this.editableInputViewChild && this.editableInputViewChild.nativeElement) {\n            this.editableInputViewChild.nativeElement.value = (this.selectedOption ? this.getOptionLabel(this.selectedOption) : this.value||'');\n        }\n    }\n\n    getOptionLabel(option: any) {\n        return this.optionLabel ? ObjectUtils.resolveFieldData(option, this.optionLabel) : (option.label != undefined ? option.label : option);\n    }\n\n    getOptionValue(option: any) {\n        return this.optionValue ? ObjectUtils.resolveFieldData(option, this.optionValue) : (this.optionLabel || option.value === undefined ? option : option.value);\n    }\n\n    isOptionDisabled(option: any) {\n        return this.optionDisabled ? ObjectUtils.resolveFieldData(option, this.optionDisabled) : (option.disabled !== undefined ? option.disabled : false);\n    }\n\n    getOptionGroupLabel(optionGroup: any) {\n        return this.optionGroupLabel ? ObjectUtils.resolveFieldData(optionGroup, this.optionGroupLabel) : (optionGroup.label != undefined ? optionGroup.label : optionGroup);\n    }\n\n    getOptionGroupChildren(optionGroup: any) {\n        return this.optionGroupChildren ? ObjectUtils.resolveFieldData(optionGroup, this.optionGroupChildren) : optionGroup.items;\n    }\n\n    onItemClick(event) {\n        const option = event.option;\n\n        if (!this.isOptionDisabled(option)) {\n            this.selectItem(event, option);\n            this.accessibleViewChild.nativeElement.focus();\n        }\n\n        setTimeout(() => {\n            this.hide();\n        }, 150);\n    }\n\n    selectItem(event, option) {\n        if (this.selectedOption != option) {\n            this.selectedOption = option;\n            this.value = this.getOptionValue(option);\n\n            this.onModelChange(this.value);\n            this.updateEditableLabel();\n            this.onChange.emit({\n                originalEvent: event.originalEvent,\n                value: this.value\n            });\n\n            if (this.virtualScroll) {\n                setTimeout(() => {\n                    this.viewPortOffsetTop = this.viewPort ? this.viewPort.measureScrollOffset() : 0;\n                }, 1);\n            }\n        }\n    }\n\n    ngAfterViewChecked() {\n        if (this.optionsChanged && this.overlayVisible) {\n            this.optionsChanged = false;\n\n            if (this.virtualScroll) {\n                this.updateVirtualScrollSelectedIndex(true);\n            }\n\n            this.zone.runOutsideAngular(() => {\n                setTimeout(() => {\n                    this.alignOverlay();\n                }, 1);\n            });\n        }\n\n        if (this.selectedOptionUpdated && this.itemsWrapper) {\n            if (this.virtualScroll && this.viewPort) {\n                let range = this.viewPort.getRenderedRange();\n                this.updateVirtualScrollSelectedIndex(false);\n\n                if (range.start > this.virtualScrollSelectedIndex || range.end < this.virtualScrollSelectedIndex) {\n                    this.viewPort.scrollToIndex(this.virtualScrollSelectedIndex);\n                }\n            }\n\n            let selectedItem = DomHandler.findSingle(this.overlay, 'li.p-highlight');\n            if (selectedItem) {\n                DomHandler.scrollInView(this.itemsWrapper, DomHandler.findSingle(this.overlay, 'li.p-highlight'));\n            }\n            this.selectedOptionUpdated = false;\n        }\n    }\n\n    writeValue(value: any): void {\n        if (this.filter) {\n            this.resetFilter();\n        }\n\n        this.value = value;\n        this.updateSelectedOption(value);\n        this.updateEditableLabel();\n        this.cd.markForCheck();\n    }\n\n    resetFilter(): void {\n        this._filterValue = null;\n\n        if (this.filterViewChild && this.filterViewChild.nativeElement) {\n            this.filterViewChild.nativeElement.value = '';\n        }\n\n        this.optionsToDisplay = this.options;\n    }\n\n    updateSelectedOption(val: any): void {\n        this.selectedOption = this.findOption(val, this.optionsToDisplay);\n\n        if (this.autoDisplayFirst && !this.placeholder && !this.selectedOption && this.optionsToDisplay && this.optionsToDisplay.length && !this.editable) {\n            this.selectedOption = this.optionsToDisplay[0];\n            this.value = this.getOptionValue(this.selectedOption);\n            this.onModelChange(this.value);\n        }\n\n        this.selectedOptionUpdated = true;\n    }\n\n    registerOnChange(fn: Function): void {\n        this.onModelChange = fn;\n    }\n\n    registerOnTouched(fn: Function): void {\n        this.onModelTouched = fn;\n    }\n\n    setDisabledState(val: boolean): void {\n        this.disabled = val;\n        this.cd.markForCheck();\n    }\n\n    onMouseclick(event) {\n        if (this.disabled || this.readonly || this.isInputClick(event)) {\n            return;\n        }\n\n        this.onClick.emit(event);\n        this.accessibleViewChild.nativeElement.focus();\n\n        if (this.overlayVisible)\n            this.hide();\n        else\n            this.show();\n\n        this.cd.detectChanges();\n    }\n\n    onOverlayClick(event) {\n        this.overlayService.add({\n            originalEvent: event,\n            target: this.el.nativeElement\n        });\n    }\n\n    isInputClick(event): boolean {\n        return DomHandler.hasClass(event.target, 'p-dropdown-clear-icon') ||\n            event.target.isSameNode(this.accessibleViewChild.nativeElement) ||\n            (this.editableInputViewChild && event.target.isSameNode(this.editableInputViewChild.nativeElement));\n    }\n\n    isOutsideClicked(event: Event): boolean {\n        return !(this.el.nativeElement.isSameNode(event.target) || this.el.nativeElement.contains(event.target) || (this.overlay && this.overlay.contains(<Node> event.target)));\n    }\n\n    isEmpty() {\n        return !this.optionsToDisplay || (this.optionsToDisplay && this.optionsToDisplay.length === 0);\n    }\n\n    onEditableInputClick() {\n        this.bindDocumentClickListener();\n    }\n\n    onEditableInputFocus(event) {\n        this.focused = true;\n        this.hide();\n        this.onFocus.emit(event);\n    }\n\n    onEditableInputChange(event) {\n        this.value = event.target.value;\n        this.updateSelectedOption(this.value);\n        this.onModelChange(this.value);\n        this.onChange.emit({\n            originalEvent: event,\n            value: this.value\n        });\n    }\n\n    show() {\n        this.overlayVisible = true;\n    }\n\n    onOverlayAnimationStart(event: AnimationEvent) {\n        switch (event.toState) {\n            case 'visible':\n                this.overlay = event.element;\n                let itemsWrapperSelector = this.virtualScroll ? '.cdk-virtual-scroll-viewport' : '.p-dropdown-items-wrapper';\n                this.itemsWrapper = DomHandler.findSingle(this.overlay, itemsWrapperSelector);\n                this.appendOverlay();\n                if (this.autoZIndex) {\n                    ZIndexUtils.set('overlay', this.overlay, this.baseZIndex + this.config.zIndex.overlay);\n                }\n                this.alignOverlay();\n                this.bindDocumentClickListener();\n                this.bindDocumentResizeListener();\n                this.bindScrollListener();\n\n                if (this.options && this.options.length) {\n                    if (!this.virtualScroll) {\n                        let selectedListItem = DomHandler.findSingle(this.itemsWrapper, '.p-dropdown-item.p-highlight');\n\n                        if (selectedListItem) {\n                            selectedListItem.scrollIntoView({ block: 'nearest', inline: 'start' });\n                        }\n                    }\n                }\n\n                if (this.filterViewChild && this.filterViewChild.nativeElement) {\n                    this.preventModelTouched = true;\n\n                    if (this.autofocusFilter) {\n                        this.filterViewChild.nativeElement.focus();\n                    }\n                }\n\n                this.onShow.emit(event);\n            break;\n\n            case 'void':\n                this.onOverlayHide();\n                this.onHide.emit(event);\n            break;\n        }\n    }\n\n    onOverlayAnimationEnd(event: AnimationEvent) {\n        switch (event.toState) {\n            case 'void':\n                ZIndexUtils.clear(event.element);\n            break;\n        }\n    }\n\n    scrollToSelectedVirtualScrollElement() {\n        if (!this.virtualAutoScrolled) {\n            if (this.viewPortOffsetTop) {\n                this.viewPort.scrollToOffset(this.viewPortOffsetTop);\n            }\n            else if (this.virtualScrollSelectedIndex > -1) {\n                this.viewPort.scrollToIndex(this.virtualScrollSelectedIndex);\n            }\n        }\n\n        this.virtualAutoScrolled = true;\n    }\n\n    updateVirtualScrollSelectedIndex(resetOffset) {\n        if (this.selectedOption && this.optionsToDisplay && this.optionsToDisplay.length) {\n            if (resetOffset) {\n                this.viewPortOffsetTop = 0;\n            }\n\n            this.virtualScrollSelectedIndex = this.findOptionIndex(this.getOptionValue(this.selectedOption), this.optionsToDisplay);\n        }\n    }\n\n    appendOverlay() {\n        if (this.appendTo) {\n            if (this.appendTo === 'body')\n                document.body.appendChild(this.overlay);\n            else\n                DomHandler.appendChild(this.overlay, this.appendTo);\n\n            if (!this.overlay.style.minWidth) {\n                this.overlay.style.minWidth = DomHandler.getWidth(this.containerViewChild.nativeElement) + 'px';\n            }\n        }\n    }\n\n    restoreOverlayAppend() {\n        if (this.overlay && this.appendTo) {\n            this.el.nativeElement.appendChild(this.overlay);\n        }\n    }\n\n    hide() {\n        this.overlayVisible = false;\n\n        if (this.filter && this.resetFilterOnHide) {\n            this.resetFilter();\n        }\n\n        if (this.virtualScroll) {\n            this.virtualAutoScrolled = false;\n        }\n\n        this.cd.markForCheck();\n    }\n\n    alignOverlay() {\n        if (this.overlay) {\n            if (this.appendTo)\n                DomHandler.absolutePosition(this.overlay, this.containerViewChild.nativeElement);\n            else\n                DomHandler.relativePosition(this.overlay, this.containerViewChild.nativeElement);\n        }\n    }\n\n    onInputFocus(event) {\n        this.focused = true;\n        this.onFocus.emit(event);\n    }\n\n    onInputBlur(event) {\n        this.focused = false;\n        this.onBlur.emit(event);\n\n        if (!this.preventModelTouched) {\n            this.onModelTouched();\n        }\n        this.preventModelTouched = false;\n    }\n\n    findPrevEnabledOption(index) {\n        let prevEnabledOption;\n\n        if (this.optionsToDisplay && this.optionsToDisplay.length) {\n            for (let i = (index - 1); 0 <= i; i--) {\n                let option = this.optionsToDisplay[i];\n                if (option.disabled) {\n                    continue;\n                }\n                else {\n                    prevEnabledOption = option;\n                    break;\n                }\n            }\n\n            if (!prevEnabledOption) {\n                for (let i = this.optionsToDisplay.length - 1; i >= index ; i--) {\n                    let option = this.optionsToDisplay[i];\n                    if (this.isOptionDisabled(option)) {\n                        continue;\n                    }\n                    else {\n                        prevEnabledOption = option;\n                        break;\n                    }\n                }\n            }\n        }\n\n        return prevEnabledOption;\n    }\n\n    findNextEnabledOption(index) {\n        let nextEnabledOption;\n\n        if (this.optionsToDisplay && this.optionsToDisplay.length) {\n            for (let i = (index + 1); i < this.optionsToDisplay.length; i++) {\n                let option = this.optionsToDisplay[i];\n                if (this.isOptionDisabled(option)) {\n                    continue;\n                }\n                else {\n                    nextEnabledOption = option;\n                    break;\n                }\n            }\n\n            if (!nextEnabledOption) {\n                for (let i = 0; i < index; i++) {\n                    let option = this.optionsToDisplay[i];\n                    if (this.isOptionDisabled(option)) {\n                        continue;\n                    }\n                    else {\n                        nextEnabledOption = option;\n                        break;\n                    }\n                }\n            }\n        }\n\n        return nextEnabledOption;\n    }\n\n    onKeydown(event: KeyboardEvent, search: boolean) {\n        if (this.readonly || !this.optionsToDisplay || this.optionsToDisplay.length === null) {\n            return;\n        }\n\n        switch(event.which) {\n            //down\n            case 40:\n                if (!this.overlayVisible && event.altKey) {\n                    this.show();\n                }\n                else {\n                    if (this.group) {\n                        let selectedItemIndex = this.selectedOption ? this.findOptionGroupIndex(this.getOptionValue(this.selectedOption), this.optionsToDisplay) : -1;\n\n                        if (selectedItemIndex !== -1) {\n                            let nextItemIndex = selectedItemIndex.itemIndex + 1;\n                            if (nextItemIndex < (this.getOptionGroupChildren(this.optionsToDisplay[selectedItemIndex.groupIndex]).length)) {\n                                this.selectItem(event, this.getOptionGroupChildren(this.optionsToDisplay[selectedItemIndex.groupIndex])[nextItemIndex]);\n                                this.selectedOptionUpdated = true;\n                            }\n                            else if (this.optionsToDisplay[selectedItemIndex.groupIndex + 1]) {\n                                this.selectItem(event, this.getOptionGroupChildren(this.optionsToDisplay[selectedItemIndex.groupIndex + 1])[0]);\n                                this.selectedOptionUpdated = true;\n                            }\n                        }\n                        else {\n                            if (this.optionsToDisplay && this.optionsToDisplay.length > 0) {\n                                this.selectItem(event, this.getOptionGroupChildren(this.optionsToDisplay[0])[0]);\n                            }\n                        }\n                    }\n                    else {\n                        let selectedItemIndex = this.selectedOption ? this.findOptionIndex(this.getOptionValue(this.selectedOption), this.optionsToDisplay) : -1;\n                        let nextEnabledOption = this.findNextEnabledOption(selectedItemIndex);\n                        if (nextEnabledOption) {\n                            this.selectItem(event, nextEnabledOption);\n                            this.selectedOptionUpdated = true;\n                        }\n                    }\n                }\n\n                event.preventDefault();\n\n            break;\n\n            //up\n            case 38:\n                if (this.group) {\n                    let selectedItemIndex = this.selectedOption ? this.findOptionGroupIndex(this.getOptionValue(this.selectedOption), this.optionsToDisplay) : -1;\n                    if (selectedItemIndex !== -1) {\n                        let prevItemIndex = selectedItemIndex.itemIndex - 1;\n                        if (prevItemIndex >= 0) {\n                            this.selectItem(event, this.getOptionGroupChildren(this.optionsToDisplay[selectedItemIndex.groupIndex])[prevItemIndex]);\n                            this.selectedOptionUpdated = true;\n                        }\n                        else if (prevItemIndex < 0) {\n                            let prevGroup = this.optionsToDisplay[selectedItemIndex.groupIndex - 1];\n                            if (prevGroup) {\n                                this.selectItem(event, this.getOptionGroupChildren(prevGroup)[this.getOptionGroupChildren(prevGroup).length - 1]);\n                                this.selectedOptionUpdated = true;\n                            }\n                        }\n                    }\n                }\n                else {\n                    let selectedItemIndex = this.selectedOption ? this.findOptionIndex(this.getOptionValue(this.selectedOption), this.optionsToDisplay) : -1;\n                    let prevEnabledOption = this.findPrevEnabledOption(selectedItemIndex);\n                    if (prevEnabledOption) {\n                        this.selectItem(event, prevEnabledOption);\n                        this.selectedOptionUpdated = true;\n                    }\n                }\n\n                event.preventDefault();\n            break;\n\n            //space\n            case 32:\n                if (search) {\n                    if (!this.overlayVisible){\n                        this.show();\n                    }\n                    else {\n                        this.hide();\n                    }\n\n                    event.preventDefault();\n                }\n            break;\n\n            //enter\n            case 13:\n                if (this.overlayVisible && (!this.filter || (this.optionsToDisplay && this.optionsToDisplay.length > 0))) {\n                    this.hide();\n                }\n\n                else if (!this.overlayVisible) {\n                    this.show();\n                }\n\n                event.preventDefault();\n            break;\n\n            //escape and tab\n            case 27:\n            case 9:\n                this.hide();\n            break;\n\n            //search item based on keyboard input\n            default:\n                if (search && !event.metaKey) {\n                    this.search(event);\n                }\n            break;\n        }\n    }\n\n    search(event: KeyboardEvent) {\n        if (this.searchTimeout) {\n            clearTimeout(this.searchTimeout);\n        }\n\n        const char = event.key;\n        this.previousSearchChar = this.currentSearchChar;\n        this.currentSearchChar = char;\n\n        if (this.previousSearchChar === this.currentSearchChar)\n            this.searchValue = this.currentSearchChar;\n        else\n            this.searchValue = this.searchValue ? this.searchValue + char : char;\n\n        let newOption;\n        if (this.group) {\n            let searchIndex = this.selectedOption ? this.findOptionGroupIndex(this.getOptionValue(this.selectedOption), this.optionsToDisplay) : {groupIndex: 0, itemIndex: 0};\n            newOption = this.searchOptionWithinGroup(searchIndex);\n        }\n        else {\n            let searchIndex = this.selectedOption ? this.findOptionIndex(this.getOptionValue(this.selectedOption), this.optionsToDisplay) : -1;\n            newOption = this.searchOption(++searchIndex);\n        }\n\n        if (newOption && !this.isOptionDisabled(newOption)) {\n            this.selectItem(event, newOption);\n            this.selectedOptionUpdated = true;\n        }\n\n        this.searchTimeout = setTimeout(() => {\n            this.searchValue = null;\n        }, 250);\n    }\n\n    searchOption(index) {\n        let option;\n\n        if (this.searchValue) {\n            option = this.searchOptionInRange(index, this.optionsToDisplay.length);\n\n            if (!option) {\n                option = this.searchOptionInRange(0, index);\n            }\n        }\n\n        return option;\n    }\n\n    searchOptionInRange(start, end) {\n        for (let i = start; i < end; i++) {\n            let opt = this.optionsToDisplay[i];\n            if (this.getOptionLabel(opt).toLocaleLowerCase(this.filterLocale).startsWith((this.searchValue as any).toLocaleLowerCase(this.filterLocale)) && !this.isOptionDisabled(opt)) {\n                return opt;\n            }\n        }\n\n        return null;\n    }\n\n    searchOptionWithinGroup(index) {\n        let option;\n\n        if (this.searchValue) {\n            for (let i = index.groupIndex; i < this.optionsToDisplay.length; i++) {\n                for (let j = (index.groupIndex === i) ? (index.itemIndex + 1) : 0; j < this.getOptionGroupChildren(this.optionsToDisplay[i]).length; j++) {\n                    let opt = this.getOptionGroupChildren(this.optionsToDisplay[i])[j];\n                    if (this.getOptionLabel(opt).toLocaleLowerCase(this.filterLocale).startsWith((this.searchValue as any).toLocaleLowerCase(this.filterLocale)) && !this.isOptionDisabled(opt)) {\n                        return opt;\n                    }\n                }\n            }\n\n            if (!option) {\n                for (let i = 0; i <= index.groupIndex; i++) {\n                    for (let j = 0; j < ((index.groupIndex === i) ? index.itemIndex : this.getOptionGroupChildren(this.optionsToDisplay[i]).length); j++) {\n                        let opt = this.getOptionGroupChildren(this.optionsToDisplay[i])[j];\n                        if (this.getOptionLabel(opt).toLocaleLowerCase(this.filterLocale).startsWith((this.searchValue as any).toLocaleLowerCase(this.filterLocale)) && !this.isOptionDisabled(opt)) {\n                            return opt;\n                        }\n                    }\n                }\n            }\n        }\n\n        return null;\n    }\n\n    findOptionIndex(val: any, opts: any[]): number {\n        let index: number = -1;\n        if (opts) {\n            for (let i = 0; i < opts.length; i++) {\n                if ((val == null && this.getOptionValue(opts[i]) == null) || ObjectUtils.equals(val, this.getOptionValue(opts[i]), this.dataKey)) {\n                    index = i;\n                    break;\n                }\n            }\n        }\n\n        return index;\n    }\n\n    findOptionGroupIndex(val: any, opts: any[]): any {\n        let groupIndex, itemIndex;\n\n        if (opts) {\n            for (let i = 0; i < opts.length; i++) {\n                groupIndex = i;\n                itemIndex = this.findOptionIndex(val, this.getOptionGroupChildren(opts[i]));\n\n                if (itemIndex !== -1) {\n                    break;\n                }\n            }\n        }\n\n        if (itemIndex !== -1) {\n            return {groupIndex: groupIndex, itemIndex: itemIndex};\n        }\n        else {\n            return -1;\n        }\n    }\n\n    findOption(val: any, opts: any[], inGroup?: boolean): SelectItem {\n        if (this.group && !inGroup) {\n            let opt: SelectItem;\n            if (opts && opts.length) {\n                for (let optgroup of opts) {\n                    opt = this.findOption(val, this.getOptionGroupChildren(optgroup), true);\n                    if (opt) {\n                        break;\n                    }\n                }\n            }\n            return opt;\n        }\n        else {\n            let index: number = this.findOptionIndex(val, opts);\n            return (index != -1) ? opts[index] : null;\n        }\n    }\n\n    onFilterInputChange(event): void {\n        let inputValue = event.target.value;\n        if (inputValue && inputValue.length) {\n            this._filterValue = inputValue;\n            this.activateFilter();\n        }\n        else {\n            this._filterValue = null;\n            this.optionsToDisplay = this.options;\n        }\n\n        this.optionsChanged = true;\n        this.onFilter.emit({originalEvent: event, filter: this._filterValue});\n    }\n\n    activateFilter() {\n        let searchFields: string[] = (this.filterBy || this.optionLabel || 'label').split(',');\n\n        if (this.options && this.options.length) {\n            if (this.group) {\n                let filteredGroups = [];\n                for (let optgroup of this.options) {\n                    let filteredSubOptions = this.filterService.filter(this.getOptionGroupChildren(optgroup), searchFields, this.filterValue, this.filterMatchMode, this.filterLocale);\n                    if (filteredSubOptions && filteredSubOptions.length) {\n                        filteredGroups.push({...optgroup, ...{[this.optionGroupChildren]: filteredSubOptions}});\n                    }\n                }\n\n                this.optionsToDisplay = filteredGroups;\n            }\n            else {\n                this.optionsToDisplay = this.filterService.filter(this.options, searchFields, this.filterValue, this.filterMatchMode, this.filterLocale);\n            }\n\n            this.optionsChanged = true;\n        }\n    }\n\n    applyFocus(): void {\n        if (this.editable)\n            DomHandler.findSingle(this.el.nativeElement, '.p-dropdown-label.p-inputtext').focus();\n        else\n            DomHandler.findSingle(this.el.nativeElement, 'input[readonly]').focus();\n    }\n\n    focus(): void {\n        this.applyFocus();\n    }\n\n    bindDocumentClickListener() {\n        if (!this.documentClickListener) {\n            const documentTarget: any = this.el ? this.el.nativeElement.ownerDocument : 'document';\n\n            this.documentClickListener = this.renderer.listen(documentTarget, 'click', (event) => {\n                if (this.isOutsideClicked(event)) {\n                    this.hide();\n                    this.unbindDocumentClickListener();\n                }\n\n                this.cd.markForCheck();\n            });\n        }\n    }\n\n    unbindDocumentClickListener() {\n        if (this.documentClickListener) {\n            this.documentClickListener();\n            this.documentClickListener = null;\n        }\n    }\n\n    bindDocumentResizeListener() {\n        this.documentResizeListener = this.onWindowResize.bind(this);\n        window.addEventListener('resize', this.documentResizeListener);\n    }\n\n    unbindDocumentResizeListener() {\n        if (this.documentResizeListener) {\n            window.removeEventListener('resize', this.documentResizeListener);\n            this.documentResizeListener = null;\n        }\n    }\n\n    onWindowResize() {\n        if (this.overlayVisible && !DomHandler.isTouchDevice()) {\n            this.hide();\n        }\n    }\n\n    bindScrollListener() {\n        if (!this.scrollHandler) {\n            this.scrollHandler = new ConnectedOverlayScrollHandler(this.containerViewChild.nativeElement, (event: any) => {\n                if (this.overlayVisible) {\n                    this.hide();\n                }\n            });\n        }\n\n        this.scrollHandler.bindScrollListener();\n    }\n\n    unbindScrollListener() {\n        if (this.scrollHandler) {\n            this.scrollHandler.unbindScrollListener();\n        }\n    }\n\n    clear(event: Event) {\n        this.value = null;\n        this.onModelChange(this.value);\n        this.onChange.emit({\n            originalEvent: event,\n            value: this.value\n        });\n        this.updateSelectedOption(this.value);\n        this.updateEditableLabel();\n        this.onClear.emit(event);\n    }\n\n    onOverlayHide() {\n        this.unbindDocumentClickListener();\n        this.unbindDocumentResizeListener();\n        this.unbindScrollListener();\n        this.overlay = null;\n        this.itemsWrapper = null;\n        this.onModelTouched();\n    }\n\n    ngOnDestroy() {\n        if (this.scrollHandler) {\n            this.scrollHandler.destroy();\n            this.scrollHandler = null;\n        }\n\n        if (this.overlay) {\n            ZIndexUtils.clear(this.overlay);\n        }\n\n        this.restoreOverlayAppend();\n        this.onOverlayHide();\n    }\n}\n\n@NgModule({\n    imports: [CommonModule,SharedModule,ScrollingModule,TooltipModule,RippleModule],\n    exports: [Dropdown,SharedModule,ScrollingModule],\n    declarations: [Dropdown,DropdownItem]\n})\nexport class DropdownModule { }\n"]}
Index: trip-planner-front/node_modules/primeng/esm2020/dropdown/primeng-dropdown.mjs
===================================================================
--- trip-planner-front/node_modules/primeng/esm2020/dropdown/primeng-dropdown.mjs	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ trip-planner-front/node_modules/primeng/esm2020/dropdown/primeng-dropdown.mjs	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpbWVuZy1kcm9wZG93bi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcHAvY29tcG9uZW50cy9kcm9wZG93bi9wcmltZW5nLWRyb3Bkb3duLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljX2FwaSc7XG4iXX0=
Index: trip-planner-front/node_modules/primeng/esm2020/dropdown/public_api.mjs
===================================================================
--- trip-planner-front/node_modules/primeng/esm2020/dropdown/public_api.mjs	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ trip-planner-front/node_modules/primeng/esm2020/dropdown/public_api.mjs	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
@@ -0,0 +1,2 @@
+export * from './dropdown';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcHAvY29tcG9uZW50cy9kcm9wZG93bi9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsWUFBWSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kcm9wZG93bic7Il19
