Index: trip-planner-front/node_modules/primeng/esm2020/treeselect/primeng-treeselect.mjs
===================================================================
--- trip-planner-front/node_modules/primeng/esm2020/treeselect/primeng-treeselect.mjs	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ trip-planner-front/node_modules/primeng/esm2020/treeselect/primeng-treeselect.mjs	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpbWVuZy10cmVlc2VsZWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcC9jb21wb25lbnRzL3RyZWVzZWxlY3QvcHJpbWVuZy10cmVlc2VsZWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljX2FwaSc7XG4iXX0=
Index: trip-planner-front/node_modules/primeng/esm2020/treeselect/public_api.mjs
===================================================================
--- trip-planner-front/node_modules/primeng/esm2020/treeselect/public_api.mjs	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ trip-planner-front/node_modules/primeng/esm2020/treeselect/public_api.mjs	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
@@ -0,0 +1,2 @@
+export * from './treeselect';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcHAvY29tcG9uZW50cy90cmVlc2VsZWN0L3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3RyZWVzZWxlY3QnO1xuIl19
Index: trip-planner-front/node_modules/primeng/esm2020/treeselect/treeselect.mjs
===================================================================
--- trip-planner-front/node_modules/primeng/esm2020/treeselect/treeselect.mjs	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ trip-planner-front/node_modules/primeng/esm2020/treeselect/treeselect.mjs	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
@@ -0,0 +1,598 @@
+import { NgModule, Component, EventEmitter, Output, Input, ChangeDetectionStrategy, ViewEncapsulation, ContentChildren, forwardRef, ViewChild } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { RippleModule } from 'primeng/ripple';
+import { PrimeTemplate, SharedModule, TranslationKeys } from 'primeng/api';
+import { animate, style, transition, trigger } from '@angular/animations';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { ConnectedOverlayScrollHandler, DomHandler } from 'primeng/dom';
+import { TreeModule } from 'primeng/tree';
+import { ZIndexUtils } from 'primeng/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/api";
+import * as i2 from "primeng/tree";
+import * as i3 from "@angular/common";
+export const TREESELECT_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => TreeSelect),
+    multi: true
+};
+export class TreeSelect {
+    constructor(config, cd, el, overlayService) {
+        this.config = config;
+        this.cd = cd;
+        this.el = el;
+        this.overlayService = overlayService;
+        this.type = "button";
+        this.scrollHeight = "400px";
+        this.metaKeySelection = true;
+        this.display = "comma";
+        this.selectionMode = "single";
+        this.propagateSelectionDown = true;
+        this.propagateSelectionUp = true;
+        this.showTransitionOptions = '.12s cubic-bezier(0, 0, 0.2, 1)';
+        this.hideTransitionOptions = '.1s linear';
+        this.onNodeExpand = new EventEmitter();
+        this.onNodeCollapse = new EventEmitter();
+        this.onShow = new EventEmitter();
+        this.onHide = new EventEmitter();
+        this.onNodeUnselect = new EventEmitter();
+        this.onNodeSelect = new EventEmitter();
+        this.expandedNodes = [];
+        this.onModelChange = () => { };
+        this.onModelTouched = () => { };
+    }
+    get options() {
+        return this._options;
+    }
+    ;
+    set options(options) {
+        this._options = options;
+        this.updateTreeState();
+    }
+    ngOnInit() {
+        this.updateTreeState();
+    }
+    ngAfterContentInit() {
+        this.templates.forEach((item) => {
+            switch (item.getType()) {
+                case 'value':
+                    this.valueTemplate = item.template;
+                    break;
+                case 'header':
+                    this.headerTemplate = item.template;
+                    break;
+                case 'empty':
+                    this.emptyTemplate = item.template;
+                    break;
+                case 'footer':
+                    this.footerTemplate = item.template;
+                    break;
+                default:
+                    this.valueTemplate = item.template;
+                    break;
+            }
+        });
+    }
+    onOverlayAnimationStart(event) {
+        switch (event.toState) {
+            case 'visible':
+                this.overlayEl = event.element;
+                this.onOverlayEnter();
+                break;
+        }
+    }
+    onOverlayAnimationDone(event) {
+        switch (event.toState) {
+            case 'void':
+                this.onOverlayLeave();
+                break;
+        }
+    }
+    onSelectionChange(event) {
+        this.value = event;
+        this.onModelChange(this.value);
+        this.cd.markForCheck();
+    }
+    onClick(event) {
+        if (!this.disabled && (!this.overlayEl || !this.overlayEl.contains(event.target)) && !DomHandler.hasClass(event.target, 'p-treeselect-close')) {
+            if (this.overlayVisible) {
+                this.hide();
+            }
+            else
+                this.show();
+            this.focusInput.nativeElement.focus();
+        }
+    }
+    onKeyDown(event) {
+        switch (event.which) {
+            //down
+            case 40:
+                if (!this.overlayVisible && event.altKey) {
+                    this.show();
+                    event.preventDefault();
+                }
+                else if (this.overlayVisible && this.overlayEl) {
+                    let focusableElements = DomHandler.getFocusableElements(this.overlayEl);
+                    if (focusableElements && focusableElements.length > 0) {
+                        focusableElements[0].focus();
+                    }
+                    event.preventDefault();
+                }
+                break;
+            //space
+            case 32:
+                if (!this.overlayVisible) {
+                    this.show();
+                    event.preventDefault();
+                }
+                break;
+            //enter and escape
+            case 13:
+            case 27:
+                if (this.overlayVisible) {
+                    this.hide();
+                    event.preventDefault();
+                }
+                break;
+            //tab
+            case 9:
+                this.hide();
+                break;
+            default:
+                break;
+        }
+    }
+    show() {
+        this.overlayVisible = true;
+    }
+    hide() {
+        this.overlayVisible = false;
+        this.cd.markForCheck();
+    }
+    onOverlayClick(event) {
+        this.overlayService.add({
+            originalEvent: event,
+            target: this.el.nativeElement
+        });
+    }
+    updateTreeState() {
+        if (this.value) {
+            let selectedNodes = this.selectionMode === "single" ? [this.value] : [...this.value];
+            this.resetExpandedNodes();
+            if (selectedNodes && this.options) {
+                this.updateTreeBranchState(null, null, selectedNodes);
+            }
+        }
+    }
+    updateTreeBranchState(node, path, selectedNodes) {
+        if (node) {
+            if (this.isSelected(node)) {
+                this.expandPath(path);
+                selectedNodes.splice(selectedNodes.indexOf(node), 1);
+            }
+            if (selectedNodes.length > 0 && node.children) {
+                for (let childNode of node.children) {
+                    path.push(node);
+                    this.updateTreeBranchState(childNode, path, selectedNodes);
+                }
+            }
+        }
+        else {
+            for (let childNode of this.options) {
+                this.updateTreeBranchState(childNode, [], selectedNodes);
+            }
+        }
+    }
+    expandPath(expandedNodes) {
+        for (let node of expandedNodes) {
+            node.expanded = true;
+        }
+        this.expandedNodes = [...expandedNodes];
+    }
+    nodeExpand(event) {
+        this.onNodeExpand.emit(event);
+        this.expandedNodes.push(event.node);
+    }
+    nodeCollapse(event) {
+        this.onNodeCollapse.emit(event);
+        this.expandedNodes.splice(this.expandedNodes.indexOf(event.node), 1);
+    }
+    resetExpandedNodes() {
+        for (let node of this.expandedNodes) {
+            node.expanded = false;
+        }
+        this.expandedNodes = [];
+    }
+    findSelectedNodes(node, keys, selectedNodes) {
+        if (node) {
+            if (this.isSelected(node)) {
+                selectedNodes.push(node);
+                delete keys[node.key];
+            }
+            if (Object.keys(keys).length && node.children) {
+                for (let childNode of node.children) {
+                    this.findSelectedNodes(childNode, keys, selectedNodes);
+                }
+            }
+        }
+        else {
+            for (let childNode of this.options) {
+                this.findSelectedNodes(childNode, keys, selectedNodes);
+            }
+        }
+    }
+    isSelected(node) {
+        return this.findIndexInSelection(node) != -1;
+    }
+    findIndexInSelection(node) {
+        let index = -1;
+        if (this.value) {
+            if (this.selectionMode === "single") {
+                let areNodesEqual = (this.value.key && this.value.key === node.key) || this.value == node;
+                index = areNodesEqual ? 0 : -1;
+            }
+            else {
+                for (let i = 0; i < this.value.length; i++) {
+                    let selectedNode = this.value[i];
+                    let areNodesEqual = (selectedNode.key && selectedNode.key === node.key) || selectedNode == node;
+                    if (areNodesEqual) {
+                        index = i;
+                        break;
+                    }
+                }
+            }
+        }
+        return index;
+    }
+    onSelect(node) {
+        this.onNodeSelect.emit(node);
+        if (this.selectionMode === 'single') {
+            this.hide();
+        }
+    }
+    onUnselect(node) {
+        this.onNodeUnselect.emit(node);
+    }
+    onOverlayEnter() {
+        ZIndexUtils.set('overlay', this.overlayEl, this.config.zIndex.overlay);
+        this.appendContainer();
+        this.alignOverlay();
+        this.bindOutsideClickListener();
+        this.bindScrollListener();
+        this.bindResizeListener();
+        this.onShow.emit();
+    }
+    onOverlayLeave() {
+        this.unbindOutsideClickListener();
+        this.unbindScrollListener();
+        this.unbindResizeListener();
+        ZIndexUtils.clear(this.overlayEl);
+        this.overlayEl = null;
+        this.onHide.emit();
+    }
+    onFocus() {
+        this.focused = true;
+    }
+    onBlur() {
+        this.focused = false;
+    }
+    writeValue(value) {
+        this.value = value;
+        this.updateTreeState();
+        this.cd.markForCheck();
+    }
+    registerOnChange(fn) {
+        this.onModelChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onModelTouched = fn;
+    }
+    setDisabledState(val) {
+        this.disabled = val;
+        this.cd.markForCheck();
+    }
+    appendContainer() {
+        if (this.appendTo) {
+            if (this.appendTo === 'body')
+                document.body.appendChild(this.overlayEl);
+            else
+                document.getElementById(this.appendTo).appendChild(this.overlayEl);
+        }
+    }
+    restoreAppend() {
+        if (this.overlayEl && this.appendTo) {
+            if (this.appendTo === 'body')
+                document.body.removeChild(this.overlayEl);
+            else
+                document.getElementById(this.appendTo).removeChild(this.overlayEl);
+        }
+    }
+    alignOverlay() {
+        if (this.appendTo) {
+            DomHandler.absolutePosition(this.overlayEl, this.containerEl.nativeElement);
+            this.overlayEl.style.minWidth = DomHandler.getOuterWidth(this.containerEl.nativeElement) + 'px';
+        }
+        else {
+            DomHandler.relativePosition(this.overlayEl, this.containerEl.nativeElement);
+        }
+    }
+    bindOutsideClickListener() {
+        if (!this.outsideClickListener) {
+            this.outsideClickListener = (event) => {
+                if (this.overlayVisible && this.overlayEl && !this.containerEl.nativeElement.contains(event.target) && !this.overlayEl.contains(event.target)) {
+                    this.hide();
+                }
+            };
+            document.addEventListener('click', this.outsideClickListener);
+        }
+    }
+    unbindOutsideClickListener() {
+        if (this.outsideClickListener) {
+            document.removeEventListener('click', this.outsideClickListener);
+            this.outsideClickListener = null;
+        }
+    }
+    bindScrollListener() {
+        if (!this.scrollHandler) {
+            this.scrollHandler = new ConnectedOverlayScrollHandler(this.containerEl.nativeElement, () => {
+                if (this.overlayVisible) {
+                    this.hide();
+                }
+            });
+        }
+        this.scrollHandler.bindScrollListener();
+    }
+    unbindScrollListener() {
+        if (this.scrollHandler) {
+            this.scrollHandler.unbindScrollListener();
+        }
+    }
+    bindResizeListener() {
+        if (!this.resizeListener) {
+            this.resizeListener = () => {
+                if (this.overlayVisible) {
+                    this.hide();
+                }
+            };
+            window.addEventListener('resize', this.resizeListener);
+        }
+    }
+    unbindResizeListener() {
+        if (this.resizeListener) {
+            window.removeEventListener('resize', this.resizeListener);
+            this.resizeListener = null;
+        }
+    }
+    ngOnDestroy() {
+        this.restoreAppend();
+        this.unbindOutsideClickListener();
+        this.unbindResizeListener();
+        if (this.scrollHandler) {
+            this.scrollHandler.destroy();
+            this.scrollHandler = null;
+        }
+        if (this.overlayEl) {
+            ZIndexUtils.clear(this.overlayEl);
+            this.overlayEl = null;
+        }
+    }
+    containerClass() {
+        return {
+            'p-treeselect p-component p-inputwrapper': true,
+            'p-treeselect-chip': this.display === 'chip',
+            'p-disabled': this.disabled,
+            'p-focus': this.focused
+        };
+    }
+    labelClass() {
+        return {
+            'p-treeselect-label': true,
+            'p-placeholder': this.label === this.placeholder,
+            'p-treeselect-label-empty': !this.placeholder && this.emptyValue
+        };
+    }
+    get emptyMessageText() {
+        return this.emptyMessage || this.config.getTranslation(TranslationKeys.EMPTY_MESSAGE);
+    }
+    get emptyValue() {
+        return !this.value || Object.keys(this.value).length === 0;
+    }
+    get emptyOptions() {
+        return !this.options || this.options.length === 0;
+    }
+    get label() {
+        let value = this.value || [];
+        return value.length ? value.map(node => node.label).join(', ') : (this.selectionMode === "single" && this.value) ? value.label : this.placeholder;
+    }
+}
+TreeSelect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: TreeSelect, deps: [{ token: i1.PrimeNGConfig }, { token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i1.OverlayService }], target: i0.ɵɵFactoryTarget.Component });
+TreeSelect.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: TreeSelect, selector: "p-treeSelect", inputs: { type: "type", inputId: "inputId", scrollHeight: "scrollHeight", disabled: "disabled", metaKeySelection: "metaKeySelection", display: "display", selectionMode: "selectionMode", tabindex: "tabindex", ariaLabelledBy: "ariaLabelledBy", placeholder: "placeholder", panelClass: "panelClass", emptyMessage: "emptyMessage", appendTo: "appendTo", propagateSelectionDown: "propagateSelectionDown", propagateSelectionUp: "propagateSelectionUp", options: "options", showTransitionOptions: "showTransitionOptions", hideTransitionOptions: "hideTransitionOptions" }, outputs: { onNodeExpand: "onNodeExpand", onNodeCollapse: "onNodeCollapse", onShow: "onShow", onHide: "onHide", onNodeUnselect: "onNodeUnselect", onNodeSelect: "onNodeSelect" }, host: { properties: { "class.p-inputwrapper-filled": "!emptyValue", "class.p-inputwrapper-focus": "focused || overlayVisible" }, classAttribute: "p-element p-inputwrapper" }, providers: [TREESELECT_VALUE_ACCESSOR], queries: [{ propertyName: "templates", predicate: PrimeTemplate }], viewQueries: [{ propertyName: "containerEl", first: true, predicate: ["container"], descendants: true }, { propertyName: "focusInput", first: true, predicate: ["focusInput"], descendants: true }], ngImport: i0, template: `
+    <div #container [ngClass]="containerClass()" (click)="onClick($event)">
+        <div class="p-hidden-accessible">
+            <input #focusInput type="text" role="listbox" [attr.id]="inputId" readonly [disabled]="disabled" (focus)="onFocus()" (blur)="onBlur()" (keydown)="onKeyDown($event)" [attr.tabindex]="tabindex"
+            aria-haspopup="true" [attr.aria-expanded]="overlayVisible" [attr.aria-labelledby]="ariaLabelledBy"/>
+        </div>
+        <div class="p-treeselect-label-container">
+            <div [ngClass]="labelClass()">
+                <ng-container *ngIf="valueTemplate;else defaultValueTemplate">
+                        <ng-container *ngTemplateOutlet="valueTemplate; context: {$implicit: value, placeholder: placeholder}"></ng-container>
+                </ng-container>
+                <ng-template #defaultValueTemplate>
+                    <ng-container *ngIf="display === 'comma';else chipsValueTemplate">
+                        {{label || 'empty'}}
+                    </ng-container>
+                    <ng-template #chipsValueTemplate>
+                        <div *ngFor="let node of value" class="p-treeselect-token">
+                            <span class="p-treeselect-token-label">{{node.label}}</span>
+                        </div>
+                        <ng-container *ngIf="emptyValue">{{placeholder || 'empty'}}</ng-container>
+                    </ng-template>
+                </ng-template>
+            </div>
+        </div>
+        <div class="p-treeselect-trigger">
+            <span class="p-treeselect-trigger-icon pi pi-chevron-down"></span>
+        </div>
+
+        <div #overlayRef class="p-treeselect-panel p-component" *ngIf="overlayVisible" (click)="onOverlayClick($event)"
+            [@overlayAnimation]="{value: 'visible', params: {showTransitionParams: showTransitionOptions, hideTransitionParams: hideTransitionOptions}}" (@overlayAnimation.start)="onOverlayAnimationStart($event)" (@overlayAnimation.done)="onOverlayAnimationDone($event)">
+            <ng-container *ngTemplateOutlet="headerTemplate; context: {$implicit: value, options: options}"></ng-container>
+            <div class="p-treeselect-items-wrapper" [ngStyle]="{'max-height': scrollHeight}">
+                <p-tree [value]="options" [propagateSelectionDown]="propagateSelectionDown" [propagateSelectionUp]="propagateSelectionUp" [selectionMode]="selectionMode" (selectionChange)="onSelectionChange($event)" [selection]="value"
+                    [metaKeySelection]="metaKeySelection" (onNodeExpand)="nodeExpand($event)" (onNodeCollapse)="nodeCollapse($event)"
+                    (onNodeSelect)="onSelect($event)" (onNodeUnselect)="onUnselect($event)"></p-tree>
+                <div *ngIf="emptyOptions" class="p-treeselect-empty-message">
+                    <ng-container *ngIf="!emptyTemplate; else empty">
+                        {{emptyMessageText}}
+                    </ng-container>
+                    <ng-container *ngTemplateOutlet="emptyTemplate;"></ng-container>
+                </div>
+            </div>
+            <ng-container *ngTemplateOutlet="footerTemplate; context: {$implicit: value, options: options}"></ng-container>
+        </div>
+    </div>
+    `, isInline: true, styles: [".p-treeselect{display:inline-flex;cursor:pointer;position:relative;-webkit-user-select:none;-ms-user-select:none;user-select:none}.p-treeselect-trigger{display:flex;align-items:center;justify-content:center;flex-shrink:0}.p-treeselect-label-container{overflow:hidden;flex:1 1 auto;cursor:pointer}.p-treeselect-label{display:block;white-space:nowrap;cursor:pointer;overflow:hidden;text-overflow:ellipsis}.p-treeselect-label-empty{overflow:hidden;visibility:hidden}.p-treeselect-token{cursor:default;display:inline-flex;align-items:center;flex:0 0 auto}.p-treeselect .p-treeselect-panel{min-width:100%}.p-treeselect-panel{position:absolute;top:0;left:0}.p-treeselect-items-wrapper{overflow:auto}.p-fluid .p-treeselect{display:flex}\n"], components: [{ type: i2.Tree, selector: "p-tree", inputs: ["value", "selectionMode", "selection", "style", "styleClass", "contextMenu", "layout", "draggableScope", "droppableScope", "draggableNodes", "droppableNodes", "metaKeySelection", "propagateSelectionUp", "propagateSelectionDown", "loading", "loadingIcon", "emptyMessage", "ariaLabel", "togglerAriaLabel", "ariaLabelledBy", "validateDrop", "filter", "filterBy", "filterMode", "filterPlaceholder", "filterLocale", "scrollHeight", "virtualScroll", "virtualNodeHeight", "minBufferPx", "maxBufferPx", "indentation", "trackBy"], outputs: ["selectionChange", "onNodeSelect", "onNodeUnselect", "onNodeExpand", "onNodeCollapse", "onNodeContextMenuSelect", "onNodeDrop", "onFilter"] }], directives: [{ type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }], 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: TreeSelect, decorators: [{
+            type: Component,
+            args: [{ selector: 'p-treeSelect', template: `
+    <div #container [ngClass]="containerClass()" (click)="onClick($event)">
+        <div class="p-hidden-accessible">
+            <input #focusInput type="text" role="listbox" [attr.id]="inputId" readonly [disabled]="disabled" (focus)="onFocus()" (blur)="onBlur()" (keydown)="onKeyDown($event)" [attr.tabindex]="tabindex"
+            aria-haspopup="true" [attr.aria-expanded]="overlayVisible" [attr.aria-labelledby]="ariaLabelledBy"/>
+        </div>
+        <div class="p-treeselect-label-container">
+            <div [ngClass]="labelClass()">
+                <ng-container *ngIf="valueTemplate;else defaultValueTemplate">
+                        <ng-container *ngTemplateOutlet="valueTemplate; context: {$implicit: value, placeholder: placeholder}"></ng-container>
+                </ng-container>
+                <ng-template #defaultValueTemplate>
+                    <ng-container *ngIf="display === 'comma';else chipsValueTemplate">
+                        {{label || 'empty'}}
+                    </ng-container>
+                    <ng-template #chipsValueTemplate>
+                        <div *ngFor="let node of value" class="p-treeselect-token">
+                            <span class="p-treeselect-token-label">{{node.label}}</span>
+                        </div>
+                        <ng-container *ngIf="emptyValue">{{placeholder || 'empty'}}</ng-container>
+                    </ng-template>
+                </ng-template>
+            </div>
+        </div>
+        <div class="p-treeselect-trigger">
+            <span class="p-treeselect-trigger-icon pi pi-chevron-down"></span>
+        </div>
+
+        <div #overlayRef class="p-treeselect-panel p-component" *ngIf="overlayVisible" (click)="onOverlayClick($event)"
+            [@overlayAnimation]="{value: 'visible', params: {showTransitionParams: showTransitionOptions, hideTransitionParams: hideTransitionOptions}}" (@overlayAnimation.start)="onOverlayAnimationStart($event)" (@overlayAnimation.done)="onOverlayAnimationDone($event)">
+            <ng-container *ngTemplateOutlet="headerTemplate; context: {$implicit: value, options: options}"></ng-container>
+            <div class="p-treeselect-items-wrapper" [ngStyle]="{'max-height': scrollHeight}">
+                <p-tree [value]="options" [propagateSelectionDown]="propagateSelectionDown" [propagateSelectionUp]="propagateSelectionUp" [selectionMode]="selectionMode" (selectionChange)="onSelectionChange($event)" [selection]="value"
+                    [metaKeySelection]="metaKeySelection" (onNodeExpand)="nodeExpand($event)" (onNodeCollapse)="nodeCollapse($event)"
+                    (onNodeSelect)="onSelect($event)" (onNodeUnselect)="onUnselect($event)"></p-tree>
+                <div *ngIf="emptyOptions" class="p-treeselect-empty-message">
+                    <ng-container *ngIf="!emptyTemplate; else empty">
+                        {{emptyMessageText}}
+                    </ng-container>
+                    <ng-container *ngTemplateOutlet="emptyTemplate;"></ng-container>
+                </div>
+            </div>
+            <ng-container *ngTemplateOutlet="footerTemplate; context: {$implicit: value, options: options}"></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]': '!emptyValue',
+                        '[class.p-inputwrapper-focus]': 'focused || overlayVisible'
+                    }, changeDetection: ChangeDetectionStrategy.OnPush, providers: [TREESELECT_VALUE_ACCESSOR], encapsulation: ViewEncapsulation.None, styles: [".p-treeselect{display:inline-flex;cursor:pointer;position:relative;-webkit-user-select:none;-ms-user-select:none;user-select:none}.p-treeselect-trigger{display:flex;align-items:center;justify-content:center;flex-shrink:0}.p-treeselect-label-container{overflow:hidden;flex:1 1 auto;cursor:pointer}.p-treeselect-label{display:block;white-space:nowrap;cursor:pointer;overflow:hidden;text-overflow:ellipsis}.p-treeselect-label-empty{overflow:hidden;visibility:hidden}.p-treeselect-token{cursor:default;display:inline-flex;align-items:center;flex:0 0 auto}.p-treeselect .p-treeselect-panel{min-width:100%}.p-treeselect-panel{position:absolute;top:0;left:0}.p-treeselect-items-wrapper{overflow:auto}.p-fluid .p-treeselect{display:flex}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.PrimeNGConfig }, { type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i1.OverlayService }]; }, propDecorators: { type: [{
+                type: Input
+            }], inputId: [{
+                type: Input
+            }], scrollHeight: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], metaKeySelection: [{
+                type: Input
+            }], display: [{
+                type: Input
+            }], selectionMode: [{
+                type: Input
+            }], tabindex: [{
+                type: Input
+            }], ariaLabelledBy: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], panelClass: [{
+                type: Input
+            }], emptyMessage: [{
+                type: Input
+            }], appendTo: [{
+                type: Input
+            }], propagateSelectionDown: [{
+                type: Input
+            }], propagateSelectionUp: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], showTransitionOptions: [{
+                type: Input
+            }], hideTransitionOptions: [{
+                type: Input
+            }], templates: [{
+                type: ContentChildren,
+                args: [PrimeTemplate]
+            }], containerEl: [{
+                type: ViewChild,
+                args: ['container']
+            }], focusInput: [{
+                type: ViewChild,
+                args: ['focusInput']
+            }], onNodeExpand: [{
+                type: Output
+            }], onNodeCollapse: [{
+                type: Output
+            }], onShow: [{
+                type: Output
+            }], onHide: [{
+                type: Output
+            }], onNodeUnselect: [{
+                type: Output
+            }], onNodeSelect: [{
+                type: Output
+            }] } });
+export class TreeSelectModule {
+}
+TreeSelectModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: TreeSelectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TreeSelectModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: TreeSelectModule, declarations: [TreeSelect], imports: [CommonModule, RippleModule, SharedModule, TreeModule], exports: [TreeSelect, SharedModule, TreeModule] });
+TreeSelectModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: TreeSelectModule, imports: [[CommonModule, RippleModule, SharedModule, TreeModule], SharedModule, TreeModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: TreeSelectModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, RippleModule, SharedModule, TreeModule],
+                    exports: [TreeSelect, SharedModule, TreeModule],
+                    declarations: [TreeSelect]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"treeselect.js","sourceRoot":"","sources":["../../../src/app/components/treeselect/treeselect.ts"],"names":[],"mappings":"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","sourcesContent":["import {NgModule,Component,EventEmitter,Output,Input,ChangeDetectionStrategy, ViewEncapsulation, ContentChildren, AfterContentInit, TemplateRef, QueryList, forwardRef, ChangeDetectorRef, ViewChild, ElementRef} from '@angular/core';\nimport {CommonModule} from '@angular/common';\nimport {RippleModule} from 'primeng/ripple';\nimport {OverlayService, PrimeNGConfig, PrimeTemplate, SharedModule, TranslationKeys, TreeNode} from 'primeng/api';\nimport {animate, style, transition, trigger, AnimationEvent} from '@angular/animations';\nimport {NG_VALUE_ACCESSOR} from '@angular/forms';\nimport {ConnectedOverlayScrollHandler, DomHandler} from 'primeng/dom';\nimport {TreeModule} from 'primeng/tree';\nimport {ZIndexUtils} from 'primeng/utils'\n\n\nexport const TREESELECT_VALUE_ACCESSOR: any = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => TreeSelect),\n    multi: true\n};\n\n@Component({\n    selector: 'p-treeSelect',\n    template: `\n    <div #container [ngClass]=\"containerClass()\" (click)=\"onClick($event)\">\n        <div class=\"p-hidden-accessible\">\n            <input #focusInput type=\"text\" role=\"listbox\" [attr.id]=\"inputId\" readonly [disabled]=\"disabled\" (focus)=\"onFocus()\" (blur)=\"onBlur()\" (keydown)=\"onKeyDown($event)\" [attr.tabindex]=\"tabindex\"\n            aria-haspopup=\"true\" [attr.aria-expanded]=\"overlayVisible\" [attr.aria-labelledby]=\"ariaLabelledBy\"/>\n        </div>\n        <div class=\"p-treeselect-label-container\">\n            <div [ngClass]=\"labelClass()\">\n                <ng-container *ngIf=\"valueTemplate;else defaultValueTemplate\">\n                        <ng-container *ngTemplateOutlet=\"valueTemplate; context: {$implicit: value, placeholder: placeholder}\"></ng-container>\n                </ng-container>\n                <ng-template #defaultValueTemplate>\n                    <ng-container *ngIf=\"display === 'comma';else chipsValueTemplate\">\n                        {{label || 'empty'}}\n                    </ng-container>\n                    <ng-template #chipsValueTemplate>\n                        <div *ngFor=\"let node of value\" class=\"p-treeselect-token\">\n                            <span class=\"p-treeselect-token-label\">{{node.label}}</span>\n                        </div>\n                        <ng-container *ngIf=\"emptyValue\">{{placeholder || 'empty'}}</ng-container>\n                    </ng-template>\n                </ng-template>\n            </div>\n        </div>\n        <div class=\"p-treeselect-trigger\">\n            <span class=\"p-treeselect-trigger-icon pi pi-chevron-down\"></span>\n        </div>\n\n        <div #overlayRef class=\"p-treeselect-panel p-component\" *ngIf=\"overlayVisible\" (click)=\"onOverlayClick($event)\"\n            [@overlayAnimation]=\"{value: 'visible', params: {showTransitionParams: showTransitionOptions, hideTransitionParams: hideTransitionOptions}}\" (@overlayAnimation.start)=\"onOverlayAnimationStart($event)\" (@overlayAnimation.done)=\"onOverlayAnimationDone($event)\">\n            <ng-container *ngTemplateOutlet=\"headerTemplate; context: {$implicit: value, options: options}\"></ng-container>\n            <div class=\"p-treeselect-items-wrapper\" [ngStyle]=\"{'max-height': scrollHeight}\">\n                <p-tree [value]=\"options\" [propagateSelectionDown]=\"propagateSelectionDown\" [propagateSelectionUp]=\"propagateSelectionUp\" [selectionMode]=\"selectionMode\" (selectionChange)=\"onSelectionChange($event)\" [selection]=\"value\"\n                    [metaKeySelection]=\"metaKeySelection\" (onNodeExpand)=\"nodeExpand($event)\" (onNodeCollapse)=\"nodeCollapse($event)\"\n                    (onNodeSelect)=\"onSelect($event)\" (onNodeUnselect)=\"onUnselect($event)\"></p-tree>\n                <div *ngIf=\"emptyOptions\" class=\"p-treeselect-empty-message\">\n                    <ng-container *ngIf=\"!emptyTemplate; else empty\">\n                        {{emptyMessageText}}\n                    </ng-container>\n                    <ng-container *ngTemplateOutlet=\"emptyTemplate;\"></ng-container>\n                </div>\n            </div>\n            <ng-container *ngTemplateOutlet=\"footerTemplate; context: {$implicit: value, options: options}\"></ng-container>\n        </div>\n    </div>\n    `,\n    styleUrls: ['./treeselect.css'],\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]': '!emptyValue',\n        '[class.p-inputwrapper-focus]': 'focused || overlayVisible'\n    },\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    providers: [TREESELECT_VALUE_ACCESSOR],\n    encapsulation: ViewEncapsulation.None\n})\nexport class TreeSelect implements AfterContentInit {\n\n    @Input() type: string = \"button\";\n\n    @Input() inputId: string;\n\n    @Input() scrollHeight: string = \"400px\";\n\n    @Input() disabled: boolean;\n\n    @Input() metaKeySelection: boolean = true;\n\n    @Input() display: string = \"comma\";\n\n    @Input() selectionMode: string = \"single\";\n\n    @Input() tabindex: string;\n\n    @Input() ariaLabelledBy: string;\n\n    @Input() placeholder: string;\n\n    @Input() panelClass: string;\n\n    @Input() emptyMessage: string;\n\n    @Input() appendTo: any;\n\n    @Input() propagateSelectionDown: boolean = true;\n\n    @Input() propagateSelectionUp: boolean = true;\n\n    @Input() get options(): any[] {\n        return this._options;\n    };\n    set options(options) {\n        this._options = options;\n        this.updateTreeState();\n    }\n\n    @Input() showTransitionOptions: string = '.12s cubic-bezier(0, 0, 0.2, 1)';\n\n    @Input() hideTransitionOptions: string = '.1s linear';\n\n    @ContentChildren(PrimeTemplate) templates: QueryList<any>;\n\n    @ViewChild('container') containerEl: ElementRef;\n\n    @ViewChild('focusInput') focusInput: ElementRef;\n\n    @Output() onNodeExpand: EventEmitter<any> = new EventEmitter();\n\n    @Output() onNodeCollapse: EventEmitter<any> = new EventEmitter();\n\n    @Output() onShow: EventEmitter<any> = new EventEmitter();\n\n    @Output() onHide: EventEmitter<any> = new EventEmitter();\n\n    @Output() onNodeUnselect: EventEmitter<any> = new EventEmitter();\n\n    @Output() onNodeSelect: EventEmitter<any> = new EventEmitter();\n\n    valueTemplate: TemplateRef<any>;\n\n    headerTemplate: TemplateRef<any>;\n\n    emptyTemplate: TemplateRef<any>;\n\n    footerTemplate: TemplateRef<any>;\n\n    focused: boolean;\n\n    overlayVisible: boolean;\n\n    selfChange: boolean;\n\n    value;\n\n    expandedNodes: any[] = [];\n\n    _options: any[];\n\n    outsideClickListener: any;\n\n    scrollHandler: any;\n\n    resizeListener: any;\n\n    overlayEl: any;\n\n    onModelChange: Function = () => {};\n\n    onModelTouched: Function = () => {};\n\n    constructor(public config: PrimeNGConfig, public cd: ChangeDetectorRef, public el: ElementRef, public overlayService: OverlayService) { }\n\n    ngOnInit() {\n        this.updateTreeState();\n    }\n\n    ngAfterContentInit() {\n        this.templates.forEach((item) => {\n            switch(item.getType()) {\n                case 'value':\n                    this.valueTemplate = item.template;\n                break;\n\n                case 'header':\n                    this.headerTemplate = item.template;\n                break;\n\n                case 'empty':\n                    this.emptyTemplate = item.template;\n                break;\n\n                case 'footer':\n                    this.footerTemplate = item.template;\n                break;\n\n                default:\n                    this.valueTemplate = item.template;\n                break;\n            }\n        });\n    }\n\n    onOverlayAnimationStart(event: AnimationEvent) {\n        switch (event.toState) {\n            case 'visible':\n                this.overlayEl = event.element;\n                this.onOverlayEnter();\n            break;\n        }\n    }\n\n    onOverlayAnimationDone(event: AnimationEvent) {\n        switch (event.toState) {\n            case 'void':\n                this.onOverlayLeave();\n            break;\n        }\n    }\n\n    onSelectionChange(event) {\n        this.value = event;\n        this.onModelChange(this.value);\n        this.cd.markForCheck();\n    }\n\n    onClick(event) {\n        if (!this.disabled && (!this.overlayEl || !this.overlayEl.contains(event.target)) && !DomHandler.hasClass(event.target, 'p-treeselect-close')) {\n            if (this.overlayVisible){\n                this.hide();\n            }\n            else\n                this.show();\n\n            this.focusInput.nativeElement.focus();\n        }\n    }\n\n    onKeyDown(event) {\n        switch(event.which) {\n            //down\n            case 40:\n                if (!this.overlayVisible && event.altKey) {\n                    this.show();\n                    event.preventDefault();\n                }\n                else if (this.overlayVisible && this.overlayEl) {\n                    let focusableElements = DomHandler.getFocusableElements(this.overlayEl);\n\n                    if (focusableElements && focusableElements.length > 0) {\n                        focusableElements[0].focus();\n                    }\n\n                    event.preventDefault();\n                }\n            break;\n\n            //space\n            case 32:\n                if (!this.overlayVisible) {\n                    this.show();\n                    event.preventDefault();\n                }\n            break;\n\n            //enter and escape\n            case 13:\n            case 27:\n                if (this.overlayVisible) {\n                    this.hide();\n                    event.preventDefault();\n                }\n            break;\n\n            //tab\n            case 9:\n                this.hide();\n            break;\n\n            default:\n            break;\n        }\n    }\n\n    show() {\n        this.overlayVisible = true;\n    }\n\n    hide() {\n        this.overlayVisible = false;\n        this.cd.markForCheck();\n    }\n\n    onOverlayClick(event) {\n        this.overlayService.add({\n            originalEvent: event,\n            target: this.el.nativeElement\n        });\n    }\n\n    updateTreeState() {\n        if (this.value) {\n            let selectedNodes = this.selectionMode === \"single\" ? [this.value] : [...this.value];\n            this.resetExpandedNodes();\n            if (selectedNodes && this.options) {\n                this.updateTreeBranchState(null, null, selectedNodes);\n            }\n        }\n    }\n\n    updateTreeBranchState(node, path, selectedNodes) {\n        if (node) {\n            if (this.isSelected(node)) {\n                this.expandPath(path);\n                selectedNodes.splice(selectedNodes.indexOf(node), 1);\n            }\n\n            if (selectedNodes.length > 0 && node.children) {\n                for (let childNode of node.children) {\n                    path.push(node);\n                    this.updateTreeBranchState(childNode, path, selectedNodes);\n                }\n            }\n        }\n        else {\n            for (let childNode of this.options) {\n                this.updateTreeBranchState(childNode, [], selectedNodes);\n            }\n        }\n    }\n\n    expandPath(expandedNodes) {\n        for (let node of expandedNodes) {\n            node.expanded = true;\n        }\n\n        this.expandedNodes = [...expandedNodes];\n    }\n\n    nodeExpand(event) {\n        this.onNodeExpand.emit(event);\n        this.expandedNodes.push(event.node);\n    }\n\n    nodeCollapse(event) {\n        this.onNodeCollapse.emit(event);\n        this.expandedNodes.splice(this.expandedNodes.indexOf(event.node), 1);\n    }\n\n    resetExpandedNodes() {\n        for (let node of this.expandedNodes) {\n            node.expanded = false;\n        }\n\n        this.expandedNodes = [];\n    }\n\n    findSelectedNodes(node, keys, selectedNodes) {\n        if (node) {\n            if (this.isSelected(node)) {\n                selectedNodes.push(node);\n                delete keys[node.key];\n            }\n\n            if (Object.keys(keys).length && node.children) {\n                for (let childNode of node.children) {\n                    this.findSelectedNodes(childNode, keys, selectedNodes);\n                }\n            }\n        }\n        else {\n            for (let childNode of this.options) {\n                this.findSelectedNodes(childNode, keys, selectedNodes);\n            }\n        }\n    }\n\n    isSelected(node: TreeNode) {\n        return this.findIndexInSelection(node) != -1;\n    }\n\n    findIndexInSelection(node: TreeNode) {\n        let index: number = -1;\n\n        if (this.value) {\n            if (this.selectionMode === \"single\") {\n                let areNodesEqual = (this.value.key && this.value.key === node.key) || this.value == node;\n                index = areNodesEqual ? 0 : - 1;\n            }\n            else {\n                for(let i = 0; i  < this.value.length; i++) {\n                    let selectedNode = this.value[i];\n                    let areNodesEqual = (selectedNode.key && selectedNode.key === node.key) || selectedNode == node;\n                    if (areNodesEqual) {\n                        index = i;\n                        break;\n                    }\n                }\n            }\n        }\n\n        return index;\n    }\n\n    onSelect(node) {\n        this.onNodeSelect.emit(node);\n\n        if (this.selectionMode === 'single') {\n            this.hide();\n        }\n    }\n\n    onUnselect(node) {\n        this.onNodeUnselect.emit(node);\n    }\n\n    onOverlayEnter() {\n        ZIndexUtils.set('overlay', this.overlayEl, this.config.zIndex.overlay);\n        this.appendContainer();\n        this.alignOverlay();\n        this.bindOutsideClickListener();\n        this.bindScrollListener();\n        this.bindResizeListener();\n        this.onShow.emit();\n    }\n\n    onOverlayLeave() {\n        this.unbindOutsideClickListener();\n        this.unbindScrollListener();\n        this.unbindResizeListener();\n        ZIndexUtils.clear(this.overlayEl);\n        this.overlayEl = null;\n        this.onHide.emit();\n    }\n\n    onFocus() {\n        this.focused = true;\n    }\n\n    onBlur() {\n        this.focused = false;\n    }\n\n    writeValue(value: any) : void {\n        this.value = value;\n        this.updateTreeState();\n        this.cd.markForCheck();\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    appendContainer() {\n        if (this.appendTo) {\n            if (this.appendTo === 'body')\n                document.body.appendChild(this.overlayEl);\n            else\n                document.getElementById(this.appendTo).appendChild(this.overlayEl);\n        }\n    }\n\n    restoreAppend() {\n        if (this.overlayEl && this.appendTo) {\n            if (this.appendTo === 'body')\n                document.body.removeChild(this.overlayEl);\n            else\n                document.getElementById(this.appendTo).removeChild(this.overlayEl);\n        }\n    }\n\n    alignOverlay() {\n        if (this.appendTo) {\n            DomHandler.absolutePosition(this.overlayEl, this.containerEl.nativeElement);\n            this.overlayEl.style.minWidth = DomHandler.getOuterWidth(this.containerEl.nativeElement) + 'px';\n        } else {\n            DomHandler.relativePosition(this.overlayEl, this.containerEl.nativeElement);\n        }\n    }\n\n    bindOutsideClickListener() {\n        if (!this.outsideClickListener) {\n            this.outsideClickListener = (event) => {\n                if (this.overlayVisible && this.overlayEl && !this.containerEl.nativeElement.contains(event.target) && !this.overlayEl.contains(event.target)) {\n                    this.hide();\n                }\n            };\n            document.addEventListener('click', this.outsideClickListener);\n        }\n    }\n\n    unbindOutsideClickListener() {\n        if (this.outsideClickListener) {\n            document.removeEventListener('click', this.outsideClickListener);\n            this.outsideClickListener = null;\n        }\n    }\n\n    bindScrollListener() {\n        if (!this.scrollHandler) {\n            this.scrollHandler = new ConnectedOverlayScrollHandler(this.containerEl.nativeElement, () => {\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    bindResizeListener() {\n        if (!this.resizeListener) {\n            this.resizeListener = () => {\n                if (this.overlayVisible) {\n                    this.hide();\n                }\n            };\n            window.addEventListener('resize', this.resizeListener);\n        }\n    }\n\n    unbindResizeListener() {\n        if (this.resizeListener) {\n            window.removeEventListener('resize', this.resizeListener);\n            this.resizeListener = null;\n        }\n    }\n\n    ngOnDestroy() {\n        this.restoreAppend();\n        this.unbindOutsideClickListener();\n        this.unbindResizeListener();\n\n        if (this.scrollHandler) {\n            this.scrollHandler.destroy();\n            this.scrollHandler = null;\n        }\n\n        if (this.overlayEl) {\n            ZIndexUtils.clear(this.overlayEl);\n            this.overlayEl = null;\n        }\n    }\n\n    containerClass() {\n        return {\n            'p-treeselect p-component p-inputwrapper': true,\n            'p-treeselect-chip': this.display === 'chip',\n            'p-disabled': this.disabled,\n            'p-focus': this.focused\n        }\n    }\n\n    labelClass() {\n        return {\n            'p-treeselect-label': true,\n            'p-placeholder': this.label === this.placeholder,\n            'p-treeselect-label-empty': !this.placeholder && this.emptyValue\n        }\n    }\n\n    get emptyMessageText() {\n        return this.emptyMessage || this.config.getTranslation(TranslationKeys.EMPTY_MESSAGE);\n    }\n\n    get emptyValue() {\n        return !this.value || Object.keys(this.value).length === 0;\n    }\n\n    get emptyOptions() {\n        return !this.options || this.options.length === 0;\n    }\n\n    get label() {\n        let value = this.value||[];\n        return value.length ? value.map(node => node.label).join(', ') : (this.selectionMode === \"single\" && this.value) ? value.label : this.placeholder;\n    }\n}\n\n@NgModule({\n    imports: [CommonModule,RippleModule,SharedModule,TreeModule],\n    exports: [TreeSelect,SharedModule,TreeModule],\n    declarations: [TreeSelect]\n})\nexport class TreeSelectModule { }\n"]}
