@ardium-ui/ui 1.0.0

package/esm2022/lib/select/select.component.mjs

@@ -0,0 +1,1160 @@
+import { OverlayConfig } from '@angular/cdk/overlay';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { ChangeDetectionStrategy, Component, ContentChild, ContentChildren, ElementRef, EventEmitter, HostBinding, HostListener, Input, Output, TemplateRef, ViewChild, ViewEncapsulation, forwardRef, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { coerceArrayProperty, coerceBooleanProperty, coerceNumberProperty } from '@ardium-ui/devkit';
+import { Subject, merge, startWith, takeUntil } from 'rxjs';
+import { isAnyString, isArray, isFunction } from 'simple-bool';
+import { ItemStorage } from '../_internal/item-storages/dropdown-item-storage';
+import { _NgModelComponentBase } from '../_internal/ngmodel-component';
+import { ArdiumDropdownPanelComponent } from '../dropdown-panel/dropdown-panel.component';
+import { DropdownPanelAppearance, DropdownPanelVariant } from '../dropdown-panel/dropdown-panel.types';
+import { ArdiumOptionComponent } from '../option/option.component';
+import { searchFunctions } from '../search-functions';
+import { ArdPanelPosition } from '../types/item-storage.types';
+import { FormElementAppearance } from '../types/theming.types';
+import { FormElementVariant } from './../types/theming.types';
+import { ArdAddCustomTemplateDirective, ArdDropdownFooterTemplateDirective, ArdDropdownHeaderTemplateDirective, ArdItemDisplayLimitTemplateDirective, ArdItemLimitReachedTemplateDirective, ArdLoadingPlaceholderTemplateDirective, ArdLoadingSpinnerTemplateDirective, ArdNoItemsFoundTemplateDirective, ArdOptgroupTemplateDirective, ArdOptionTemplateDirective, ArdSelectPlaceholderTemplateDirective, ArdSelectPrefixTemplateDirective, ArdSelectSuffixTemplateDirective, ArdValueTemplateDirective, } from './select.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@angular/common";
+import * as i3 from "../form-field-frame/form-field-frame.component";
+import * as i4 from "../dropdown-panel/dropdown-panel.component";
+import * as i5 from "../chip/deletable-chip/deletable-chip.component";
+import * as i6 from "@ardium-ui/devkit";
+import * as i7 from "../_internal/clear-button/clear-button.component";
+export class ArdiumSelectComponent extends _NgModelComponentBase {
+    get itemsAlreadyGrouped() {
+        return this._itemsAlreadyGrouped;
+    }
+    set itemsAlreadyGrouped(v) {
+        this._itemsAlreadyGrouped = coerceBooleanProperty(v);
+    }
+    get invertDisabled() {
+        return this._invertDisabled;
+    }
+    set invertDisabled(v) {
+        this._invertDisabled = coerceBooleanProperty(v);
+    }
+    get noGroupActions() {
+        return this._noGroupActions;
+    }
+    set noGroupActions(v) {
+        this._noGroupActions = coerceBooleanProperty(v);
+    }
+    get autoHighlightFirst() {
+        return this._autoHighlightFirst;
+    }
+    set autoHighlightFirst(v) {
+        this._autoHighlightFirst = coerceBooleanProperty(v);
+    }
+    get autoFocus() {
+        return this._autoFocus;
+    }
+    set autoFocus(v) {
+        this._autoFocus = coerceBooleanProperty(v);
+    }
+    get keepOpen() {
+        return this._keepOpen;
+    }
+    set keepOpen(v) {
+        this._keepOpen = coerceBooleanProperty(v);
+    }
+    get hideSelected() {
+        return this._hideSelected;
+    }
+    set hideSelected(v) {
+        this._hideSelected = coerceBooleanProperty(v);
+    }
+    get noBackspaceClear() {
+        return this._clearOnBackspace;
+    }
+    set noBackspaceClear(v) {
+        this._clearOnBackspace = coerceBooleanProperty(v);
+    }
+    get sortMultipleValues() {
+        return this._sortMultipleValues;
+    }
+    set sortMultipleValues(v) {
+        this._sortMultipleValues = coerceBooleanProperty(v);
+    }
+    get searchCaseSensitive() {
+        return this._searchCaseSensitive;
+    }
+    set searchCaseSensitive(v) {
+        this._searchCaseSensitive = coerceBooleanProperty(v);
+    }
+    get keepSearchAfterSelect() {
+        return this._keepSearchAfterSelect;
+    }
+    set keepSearchAfterSelect(v) {
+        this._keepSearchAfterSelect = coerceBooleanProperty(v);
+    }
+    get maxSelectedItems() {
+        return this._maxSelectedItems;
+    }
+    set maxSelectedItems(v) {
+        this._maxSelectedItems = coerceNumberProperty(v, undefined);
+    }
+    get itemDisplayLimit() {
+        return this._itemDisplayLimit;
+    }
+    set itemDisplayLimit(v) {
+        this._itemDisplayLimit = coerceNumberProperty(v, Infinity);
+    }
+    get searchFn() {
+        return this._searchFn;
+    }
+    set searchFn(fn) {
+        if (fn !== undefined && fn !== null && !isFunction(fn)) {
+            throw Error('`searchFn` must be a function.');
+        }
+        this._searchFn = fn;
+    }
+    get compareWith() {
+        return this._compareWith;
+    }
+    set compareWith(fn) {
+        if (fn !== undefined && fn !== null && !isFunction(fn)) {
+            throw Error('`compareWith` must be a function.');
+        }
+        this._compareWith = fn;
+    }
+    get compact() {
+        return this._compact;
+    }
+    set compact(v) {
+        this._compact = coerceBooleanProperty(v);
+    }
+    get ngClasses() {
+        return [
+            //appearance, variant handled in ard-form-field-frame component
+            this.compact ? 'ard-compact' : '',
+            this.multiselectable ? 'ard-multiselect' : 'ard-singleselect',
+            this.clearable ? 'ard-clearable' : '',
+            this.searchable ? 'ard-searchable' : '',
+            this.filtered ? 'ard-filtered' : '',
+            this.touched ? 'ard-touched' : '',
+            this.isDropdownOpen ? 'ard-dropdown-open' : '',
+            this._searchBarFocused ? 'ard-select-focused' : '',
+            this._searchBarFocused ? 'ard-select-focused' : '',
+        ].join(' ');
+    }
+    set dropdowonAppearance(v) {
+        this._dropdownAppearance = v;
+    }
+    get dropdownAppearance() {
+        if (this._dropdownAppearance)
+            return this._dropdownAppearance;
+        if (this.appearance == FormElementAppearance.Outlined)
+            return DropdownPanelAppearance.Outlined;
+        return DropdownPanelAppearance.Raised;
+    }
+    set dropdowonVariant(v) {
+        this._dropdownVariant = v;
+    }
+    get dropdownVariant() {
+        if (this._dropdownVariant)
+            return this._dropdownVariant;
+        if (this.variant == FormElementVariant.Pill)
+            return DropdownPanelVariant.Rounded;
+        return this.variant;
+    }
+    //! items setter/getter
+    get items() {
+        return this._items;
+    }
+    set items(value) {
+        this.isItemsInputUsed = true;
+        if (value === null) {
+            value = [];
+            this.isItemsInputUsed = false;
+        }
+        else if (isAnyString(value)) {
+            value = coerceArrayProperty(value);
+        }
+        let printErrors = this.itemStorage.setItems(value);
+        if (printErrors) {
+            this._printPrimitiveWarnings();
+        }
+    }
+    _setItemsFromComponents() {
+        const handleOptionChange = () => {
+            const changedOrDestroyed = merge(this.optionComponents.changes, this._destroy$);
+            merge(...this.optionComponents.map(option => option.stateChange$))
+                .pipe(takeUntil(changedOrDestroyed))
+                .subscribe(option => {
+                setTimeout(() => {
+                    const item = this.itemStorage.findItemByValue(option.oldValue ?? option.value);
+                    if (item) {
+                        item.disabled = option.disabled;
+                        item.label = option.label || item.label;
+                        item.value = option.value;
+                        item.itemData.disabled = option.disabled;
+                        item.itemData.label = option.label || item.label;
+                        item.itemData.value = option.value;
+                    }
+                    this.detectChanges();
+                }, 0);
+            });
+        };
+        this.optionComponents.changes
+            .pipe(startWith(this.optionComponents), takeUntil(this._destroy$))
+            .subscribe((options) => {
+            if (options.length == 0)
+                return;
+            setTimeout(() => {
+                this.items = options.map(option => ({
+                    value: option.value,
+                    label: option.label,
+                    disabled: option.disabled,
+                }));
+                handleOptionChange();
+                this.detectChanges();
+            }, 0);
+        });
+    }
+    get multiselectable() {
+        return this._multiselectable;
+    }
+    set multiselectable(v) {
+        this._multiselectable = coerceBooleanProperty(v);
+    }
+    get singleselectable() {
+        return !this._multiselectable;
+    }
+    get clearable() {
+        return this._clearable;
+    }
+    set clearable(v) {
+        this._clearable = coerceBooleanProperty(v);
+    }
+    get searchable() {
+        return this._searchable;
+    }
+    set searchable(v) {
+        this._searchable = coerceBooleanProperty(v);
+    }
+    get filtered() {
+        return this._searchable && this.searchTerm != '';
+    }
+    get touched() {
+        return this._touched;
+    }
+    set touched(state) {
+        this._touched = state;
+    }
+    get addCustom() {
+        return this._addCustom;
+    }
+    set addCustom(v) {
+        if (isFunction(v)) {
+            this._addCustom = v;
+            return;
+        }
+        //coerce the value into a boolean
+        //if "true", use the default function. Otherwise, just set to "false".
+        this._addCustom = coerceBooleanProperty(v) && this._defaultAddCustomFn;
+    }
+    get shouldShowAddCustom() {
+        return this.addCustom != false && this.searchTerm.length > 0 && this.itemStorage.isNoItemsFound;
+    }
+    async addCustomOption(value) {
+        if (!this.addCustom)
+            return;
+        const newOptionObj = await this.itemStorage.addCustomOption(value, this.addCustom);
+        this.selectItem(newOptionObj);
+    }
+    //! control value accessor
+    //override the writeValue and setDisabledState defined in _NgModelComponent
+    setDisabledState(state) {
+        this._disabled = state;
+        this._cd.markForCheck();
+    }
+    writeValue(ngModel) {
+        this.itemStorage.handleWriteValue(ngModel);
+        this._cd.markForCheck();
+    }
+    //* change & touch event emitters
+    _emitChange() {
+        let value = this.itemStorage.value;
+        this._onChangeRegistered?.(value);
+        this.changeEvent.emit(value);
+        this.valueChange.emit(value);
+    }
+    _onTouched() {
+        this.touched = true;
+        this._onTouchedRegistered?.();
+    }
+    //! value input & output
+    set value(newValue) {
+        //if is a string, coerce it into array of strings
+        if (isAnyString(newValue))
+            newValue = coerceArrayProperty(newValue);
+        //if it is not a string and not an array, just put it in an array
+        else if (!isArray(newValue))
+            newValue = [newValue];
+        this.writeValue(newValue);
+    }
+    get value() {
+        return this.itemStorage.value;
+    }
+    //! context providers
+    getValueContext(item) {
+        const $this = this;
+        return {
+            $implicit: item,
+            item,
+            itemData: item.itemData,
+            unselect() {
+                $this.unselectItem(item);
+            },
+        };
+    }
+    getStatsContext() {
+        return {
+            totalItems: this.totalItems,
+            foundItems: this.foundItems,
+        };
+    }
+    getSearchContext() {
+        return {
+            $implicit: this.searchTerm,
+            searchTerm: this.searchTerm,
+            totalItems: this.totalItems,
+            foundItems: this.foundItems,
+        };
+    }
+    getPlaceholderContext() {
+        const placeholder = this.placeholderForCurrentContext;
+        return {
+            placeholder,
+            $implicit: placeholder,
+        };
+    }
+    getCustomOptionContext() {
+        return {
+            $implicit: this.searchTerm,
+            searchTerm: this.searchTerm,
+        };
+    }
+    getGroupContext(group) {
+        return {
+            $implicit: group,
+            group,
+            selectedChildren: group.children.filter(v => v.selected).length,
+            totalChildren: group.children.length,
+        };
+    }
+    getOptionContext(item) {
+        return {
+            $implicit: item,
+            item,
+            itemData: item.itemData,
+        };
+    }
+    getItemLimitContext() {
+        return {
+            totalItems: this.totalItems,
+            selectedItems: this.itemStorage.selectedItems.length,
+            itemLimit: this.maxSelectedItems,
+        };
+    }
+    getItemDisplayLimitContext() {
+        let selectedItems = this.itemStorage.selectedItems.length;
+        return {
+            totalItems: this.totalItems,
+            selectedItems,
+            itemLimit: this.maxSelectedItems,
+            overflowCount: selectedItems - (this.itemDisplayLimit ?? 0),
+        };
+    }
+    constructor(_elementRef, _cd, overlay, viewContainerRef, scrollStrategyOpts) {
+        super();
+        this._cd = _cd;
+        this.overlay = overlay;
+        this.viewContainerRef = viewContainerRef;
+        this.scrollStrategyOpts = scrollStrategyOpts;
+        //! public constants
+        this.itemStorage = new ItemStorage(this);
+        this.DEFAULTS = {
+            valueFrom: 'value',
+            labelFrom: 'label',
+            disabledFrom: 'disabled',
+            groupLabelFrom: 'group',
+            groupDisabledFrom: 'disabled',
+            childrenFrom: 'children',
+            searchFn: searchFunctions.byLabel,
+            clearButtonTitle: 'Clear',
+            noItemsFoundText: 'No items found.',
+            loadingPlaceholderText: 'Loading...',
+        };
+        //! privates
+        this._items = [];
+        this._isMouseBeingUsed = false;
+        this._searchBarFocused = false;
+        this._destroy$ = new Subject();
+        //! publics
+        this.searchTerm = '';
+        this.isItemsInputUsed = false;
+        //! settings
+        this.placeholder = 'Select item';
+        this.searchPlaceholder = 'Search...';
+        this.dropdownPosition = ArdPanelPosition.Auto;
+        this.clearButtonTitle = this.DEFAULTS.clearButtonTitle;
+        //! template-related settings
+        this.noItemsFoundText = this.DEFAULTS.noItemsFoundText;
+        this.loadingPlaceholderText = this.DEFAULTS.loadingPlaceholderText;
+        //! other inputs
+        this.isLoading = false;
+        this.inputAttrs = {};
+        this.htmlId = crypto.randomUUID();
+        //! boolean settings
+        this._itemsAlreadyGrouped = false;
+        //should the value that the "disabledFrom" path lead to be inverted?
+        //useful when the property is e.g. "active", which is the oposite of "disabled"
+        this._invertDisabled = false;
+        this._noGroupActions = false;
+        this._autoHighlightFirst = true;
+        this._autoFocus = false;
+        this._keepOpen = false;
+        this._hideSelected = false;
+        this._clearOnBackspace = false;
+        this._sortMultipleValues = false;
+        this._searchCaseSensitive = false;
+        this._keepSearchAfterSelect = false;
+        //! number inputs
+        this._maxSelectedItems = undefined;
+        this._itemDisplayLimit = Infinity;
+        //! function inputs
+        this._searchFn = this.DEFAULTS.searchFn;
+        //! appearance
+        this.appearance = FormElementAppearance.Outlined;
+        this.variant = FormElementVariant.Rounded;
+        this._compact = false;
+        this._dropdownAppearance = undefined;
+        this._dropdownVariant = undefined;
+        //! class-based inputs
+        this.groupItems = false; //default value may be changed to "true" in ngOnChanges if this.groupBy is defined or this.itemsAlreadyGrouped is set to "true"
+        //! attribute and/or class setters/getters
+        this._multiselectable = false;
+        this._clearable = true;
+        this._searchable = false;
+        this._touched = false;
+        //! custom options
+        this._defaultAddCustomFn = (value) => value;
+        this._addCustom = false;
+        this.valueChange = new EventEmitter();
+        //! output events
+        this.changeEvent = new EventEmitter();
+        this.addEvent = new EventEmitter();
+        this.failedToAddEvent = new EventEmitter();
+        this.removeEvent = new EventEmitter();
+        this.clearEvent = new EventEmitter();
+        this.openEvent = new EventEmitter();
+        this.closeEvent = new EventEmitter();
+        this.scrollEvent = new EventEmitter();
+        this.scrollToEndEvent = new EventEmitter();
+        this.searchEvent = new EventEmitter();
+        this.isDropdownOpenChange = new EventEmitter();
+        //! click handlers
+        this._isClickedWithin = false;
+        this.element = _elementRef.nativeElement;
+    }
+    _createOverlay() {
+        const strategy = this.overlay
+            .position()
+            .flexibleConnectedTo(this.dropdownHost)
+            .withPositions([
+            {
+                originX: 'start',
+                originY: 'bottom',
+                overlayX: 'start',
+                overlayY: 'top',
+            },
+            {
+                originX: 'start',
+                originY: 'top',
+                overlayX: 'start',
+                overlayY: 'bottom',
+            },
+        ]);
+        const config = new OverlayConfig({
+            positionStrategy: strategy,
+            scrollStrategy: this.scrollStrategyOpts.block(),
+            hasBackdrop: false,
+        });
+        this.dropdownOverlay = this.overlay.create(config);
+        const portal = new TemplatePortal(this.dropdownTemplate, this.viewContainerRef);
+        this.dropdownOverlay.attach(portal);
+        this.setOverlaySize();
+    }
+    _destroyOverlay() {
+        if (!this.dropdownOverlay)
+            return;
+        this.dropdownOverlay.dispose();
+        delete this.dropdownOverlay;
+    }
+    setOverlaySize() {
+        if (!this.dropdownOverlay)
+            return;
+        const rect = this.dropdownHost.nativeElement.getBoundingClientRect();
+        this.dropdownOverlay.updateSize({ width: rect.width });
+    }
+    onWindowResize() {
+        this.setOverlaySize();
+    }
+    //! hooks
+    ngOnInit() {
+        this._setSearchInputAttributes();
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    ngAfterViewInit() {
+        if (this.autoFocus) {
+            this.focus();
+        }
+    }
+    ngAfterContentInit() {
+        if (!this.isItemsInputUsed) {
+            this._setItemsFromComponents();
+        }
+    }
+    ngOnChanges(changes) {
+        //fire items load handler when loading is set to false
+        if (changes['loading']) {
+            if (changes['loading'].currentValue == false) {
+                this._onItemsLoad();
+            }
+        }
+        //set groupItems to true by default if groupLabelFrom or itemsAlreadyGrouped is set to true as the first change
+        if ((changes['groupLabelFrom']?.firstChange || changes['itemsAlreadyGrouped']?.firstChange) && !changes['groupItems']) {
+            this.groupItems = true;
+        }
+    }
+    _onItemsLoad() {
+        if (!this._searchBarFocused)
+            return;
+        this.open();
+    }
+    _printPrimitiveWarnings() {
+        function makeWarning(str) {
+            console.warn(`Skipped using [${str}] property bound to <ard-select>, as some provided items are of primitive type`);
+        }
+        if (this.valueFrom) {
+            makeWarning('valueFrom');
+        }
+        if (this.labelFrom) {
+            makeWarning('labelFrom');
+        }
+        if (this.disabledFrom) {
+            makeWarning('disabledFrom');
+        }
+        if (this.groupLabelFrom) {
+            makeWarning('groupLabelFrom');
+        }
+        if (this.groupDisabledFrom) {
+            makeWarning('groupDisabledFrom');
+        }
+        if (this.childrenFrom) {
+            makeWarning('childrenFrom');
+        }
+        if (this.invertDisabled) {
+            makeWarning('invertDisabled');
+        }
+    }
+    //! getters
+    get firstHighlightedItem() {
+        return this.itemStorage.highlightedItems?.first();
+    }
+    get shouldDisplayPlaceholder() {
+        return !this.itemStorage.isAnyItemSelected && !this.searchTerm;
+    }
+    get shouldDisplayValue() {
+        return this.itemStorage.isAnyItemSelected && (!this.searchTerm || this.multiselectable);
+    }
+    get shouldShowClearButton() {
+        return this._clearable && !this._disabled && (this.itemStorage.isAnyItemSelected || this.searchTerm != '');
+    }
+    get itemsToDisplay() {
+        return this.itemStorage.groups.values();
+    }
+    get shouldShowNoItemsFound() {
+        return this.itemStorage.isNoItemsFound && !this.isLoading && !this.shouldShowAddCustom;
+    }
+    get totalItems() {
+        return this.itemStorage.items.length;
+    }
+    get foundItems() {
+        if (!this.searchable)
+            return undefined;
+        return this.itemStorage.filteredItems.length;
+    }
+    get shouldShowItemDisplayLimit() {
+        return this.multiselectable && this.itemDisplayLimit != Infinity && this.itemStorage.selectedItems.length > this.itemDisplayLimit;
+    }
+    get isInputElementReadonly() {
+        return !this.addCustom && (!this.searchable || this.itemStorage.isItemLimitReached);
+    }
+    isValueWithinDisplayLimit(i) {
+        return !this.multiselectable || this.itemDisplayLimit == Infinity || i < this.itemDisplayLimit;
+    }
+    get placeholderForCurrentContext() {
+        if (this.searchPlaceholder && this.searchable && (this._searchBarFocused || this._isClickedWithin))
+            return this.searchPlaceholder;
+        return this.placeholder;
+    }
+    //! search input event handlers
+    filter(filterTerm, suppressSearchEvent = false) {
+        this.searchTerm = filterTerm;
+        let matching = this.itemStorage.filter(filterTerm);
+        if (!suppressSearchEvent)
+            this.searchEvent.emit({ search: filterTerm, matching });
+        this.open();
+    }
+    onSearchInputFocus(event) {
+        this._searchBarFocused = true;
+    }
+    onSearchInputBlur(event) {
+        if (!this._searchBarFocused)
+            return;
+        this._onTouched();
+        this._searchBarFocused = false;
+    }
+    //! item selection handlers
+    toggleItem(item) {
+        if (item.selected) {
+            this.unselectItem(item);
+            return;
+        }
+        this.selectItem(item);
+    }
+    selectItem(...items) {
+        let [selected, unselected, failedToSelect] = this.itemStorage.selectItem(...items);
+        if (unselected.length > 0)
+            this.removeEvent.emit(unselected);
+        if (failedToSelect.length > 0) {
+            this.failedToAddEvent.emit(failedToSelect);
+        }
+        if (selected.length > 0) {
+            this.addEvent.emit(selected);
+            this._emitChange();
+            this.focus();
+            if (!this.keepSearchAfterSelect)
+                this._clearSearch(true);
+            if (!this.keepOpen || this.itemStorage.isNoItemsToSelect) {
+                this.close();
+            }
+        }
+    }
+    unselectItem(...items) {
+        let unselected = this.itemStorage.unselectItem(...items);
+        this.removeEvent.emit(unselected);
+        this._emitChange();
+        if (!this.keepSearchAfterSelect)
+            this._clearSearch();
+        this.focus();
+        if (!this.keepOpen || this.itemStorage.isNoItemsToSelect) {
+            this.close();
+        }
+    }
+    _clearAllItems() {
+        let cleared = this.itemStorage.clearAllSelected(true);
+        this.focus();
+        this.clearEvent.emit();
+        this.removeEvent.emit(cleared);
+        this._emitChange();
+    }
+    _clearLastItem() {
+        let clearedValue = this.itemStorage.clearLastSelected().value;
+        this.focus();
+        this.removeEvent.emit([clearedValue]);
+        this._emitChange();
+    }
+    //! highligh-related
+    onMouseMove() {
+        this._isMouseBeingUsed = true;
+    }
+    onGroupMouseover(group) {
+        if (!this.multiselectable || this.noGroupActions)
+            return;
+        this.itemStorage.highlightGroup(group);
+    }
+    onItemMouseOver(event) {
+        event.stopPropagation();
+    }
+    onItemMouseEnter(option, event) {
+        if (!this._isMouseBeingUsed)
+            return;
+        this.itemStorage.highlightSingleItem(option);
+        event.stopPropagation();
+    }
+    onItemMouseLeave(option, event) {
+        if (!this._isMouseBeingUsed)
+            return;
+        this.itemStorage.unhighlightItem(option);
+        event.stopPropagation();
+    }
+    onItemClick(option, event) {
+        event.stopPropagation();
+        if (this.clearable)
+            this.toggleItem(option);
+        else
+            this.selectItem(option);
+        this._isClickedWithin = true;
+    }
+    onGroupClick(group) {
+        if (!this.multiselectable || this.noGroupActions)
+            return;
+        if (group.children.every(o => o.selected)) {
+            this.unselectItem(...group.children);
+            return;
+        }
+        this.selectItem(...group.children);
+        this._isClickedWithin = true;
+    }
+    handleClearButtonClick(event) {
+        event.stopPropagation();
+        if (this.searchTerm) {
+            this._clearSearch();
+            return;
+        }
+        this._clearAllItems();
+    }
+    handleDropdownArrowClick(event) {
+        event.stopPropagation();
+        this._isClickedWithin = true;
+        this.toggle();
+    }
+    handleOutsideClick(event) {
+        if (!this.isDropdownOpen)
+            return;
+        const target = event.target;
+        if (this.element.contains(target))
+            return;
+        this.close();
+    }
+    handleAnywhereClick(event) {
+        const target = event.target;
+        if (target.tagName != 'INPUT') {
+            event.preventDefault();
+        }
+        this._isClickedWithin = true;
+        if (!this._searchBarFocused) {
+            this.focus();
+        }
+        if (this._searchable) {
+            this.open();
+        }
+        else {
+            this.toggle();
+        }
+    }
+    onMouseup() {
+        this._isClickedWithin = false;
+    }
+    //! dropdown state handlers
+    toggle() {
+        if (this.isDropdownOpen) {
+            this.close();
+            return;
+        }
+        this.open();
+    }
+    open() {
+        if (this.disabled || this.isDropdownOpen)
+            return;
+        this.isDropdownOpen = true;
+        if (this.autoHighlightFirst)
+            this.itemStorage.highlightFirstItem();
+        this._createOverlay();
+        this.focus();
+        this.openEvent.emit();
+        this.isDropdownOpenChange.emit(this.isDropdownOpen);
+        this.detectChanges();
+    }
+    close() {
+        if (!this.isDropdownOpen)
+            return;
+        this.isDropdownOpen = false;
+        this._destroyOverlay();
+        this._onTouched();
+        this.closeEvent.emit();
+        this.isDropdownOpenChange.emit(this.isDropdownOpen);
+        this._cd.markForCheck();
+    }
+    //! ChangeDetectorRef
+    detectChanges() {
+        if (!this._cd.destroyed) {
+            this._cd.detectChanges();
+        }
+    }
+    //! search
+    _clearSearch(suppressSearchEvent = false) {
+        this._setSearch('', suppressSearchEvent);
+    }
+    _setSearch(searchTerm, suppressSearchEvent = false) {
+        this.searchTerm = searchTerm;
+        this.filter(searchTerm, suppressSearchEvent);
+    }
+    _setSearchInputAttributes() {
+        const input = this.searchInput.nativeElement;
+        const attributes = {
+            type: 'text',
+            autocorrect: 'off',
+            autocapitalize: 'off',
+            autocomplete: 'off',
+            ...this.inputAttrs,
+        };
+        for (const key of Object.keys(attributes)) {
+            input.setAttribute(key, attributes[key]);
+        }
+    }
+    //! key press handlers
+    onKeyPress(event) {
+        switch (event.code) {
+            case 'Enter': {
+                this._onEnterPress(event);
+                return;
+            }
+            case 'Space': {
+                this._onSpacePress(event);
+                return;
+            }
+            case 'ArrowDown': {
+                this._onArrowDownPress(event);
+                return;
+            }
+            case 'ArrowUp': {
+                this._onArrowUpPress(event);
+                return;
+            }
+            case 'Home': {
+                this._onHomePress(event);
+                return;
+            }
+            case 'End': {
+                this._onEndPress(event);
+                return;
+            }
+            case 'Backspace':
+            case 'Delete': {
+                this._onBackspaceOrDeletePress(event);
+                return;
+            }
+            case 'KeyA': {
+                if (event.ctrlKey) {
+                    this._onCtrlAPress(event);
+                    return;
+                }
+            }
+        }
+    }
+    async _onEnterPress(event) {
+        event.preventDefault();
+        let shouldClose = true;
+        //select the currently highlighted option
+        if (this.isDropdownOpen && this.firstHighlightedItem) {
+            if (this.clearable && this.itemStorage.highlightedItems.every(item => item.selected)) {
+                this.unselectItem(...this.itemStorage.highlightedItems);
+            }
+            else {
+                this.selectItem(...this.itemStorage.highlightedItems);
+            }
+        }
+        //add a custom option
+        else if (this.isDropdownOpen && this.shouldShowAddCustom) {
+            await this.addCustomOption(this.searchTerm);
+        }
+        //in case of no action, open the dropdown (or keep it open)
+        else
+            shouldClose = false;
+        if (!this.keepOpen && shouldClose) {
+            this.itemStorage.clearAllHighlights();
+            this.close();
+        }
+        else {
+            this.open();
+        }
+    }
+    _onSpacePress(event) {
+        if (this.isDropdownOpen)
+            return;
+        event.preventDefault();
+        this.open();
+    }
+    _onArrowDownPress(event) {
+        event.preventDefault();
+        this.open();
+        this._isMouseBeingUsed = false;
+        const recentlyHighlighted = this.itemStorage.highlightNextItem(+1, event.shiftKey);
+        if (recentlyHighlighted) {
+            this.itemStorage.setRecentlyHighlighted(recentlyHighlighted);
+        }
+        this.dropdownPanel.scrollToRecentlyHighlighted('bottom');
+    }
+    _onArrowUpPress(event) {
+        if (!this.isDropdownOpen)
+            return;
+        event.preventDefault();
+        this._isMouseBeingUsed = false;
+        const recentlyHighlighted = this.itemStorage.highlightNextItem(-1, event.shiftKey);
+        if (recentlyHighlighted) {
+            this.itemStorage.setRecentlyHighlighted(recentlyHighlighted);
+        }
+        this.dropdownPanel.scrollToRecentlyHighlighted('top');
+    }
+    _onHomePress(event) {
+        if (!this.isDropdownOpen || (this.searchInput.nativeElement.selectionEnd != 0 && this.searchInput.nativeElement.selectionStart != 0))
+            return;
+        event.preventDefault();
+        this._isMouseBeingUsed = false;
+        const recentlyHighlighted = this.itemStorage.highlightFirstItem();
+        if (!recentlyHighlighted)
+            return;
+        this.itemStorage.setRecentlyHighlighted(recentlyHighlighted);
+        this.dropdownPanel.scrollToRecentlyHighlighted('top');
+    }
+    _onEndPress(event) {
+        if (!this.isDropdownOpen ||
+            (this.searchInput.nativeElement.selectionEnd != this.searchTerm.length && this.searchInput.nativeElement.selectionStart != this.searchTerm.length))
+            return;
+        event.preventDefault();
+        this._isMouseBeingUsed = false;
+        const recentlyHighlighted = this.itemStorage.highlightLastItem();
+        if (!recentlyHighlighted)
+            return;
+        this.itemStorage.setRecentlyHighlighted(recentlyHighlighted);
+        this.dropdownPanel.scrollToRecentlyHighlighted('bottom');
+    }
+    _onBackspaceOrDeletePress(event) {
+        if (this.searchTerm || !this._clearable || this.noBackspaceClear || !this.itemStorage.isAnyItemSelected)
+            return;
+        event.preventDefault();
+        if (this.multiselectable && this.itemStorage.selectedItems.length > 1) {
+            this._clearLastItem();
+            return;
+        }
+        this._clearAllItems();
+    }
+    _onCtrlAPress(event) {
+        this.itemStorage.highlightAllItems();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumSelectComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i1.Overlay }, { token: i0.ViewContainerRef }, { token: i1.ScrollStrategyOptions }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.7", type: ArdiumSelectComponent, selector: "ard-select", inputs: { valueFrom: "valueFrom", labelFrom: "labelFrom", disabledFrom: "disabledFrom", groupLabelFrom: "groupLabelFrom", groupDisabledFrom: "groupDisabledFrom", childrenFrom: "childrenFrom", placeholder: "placeholder", searchPlaceholder: "searchPlaceholder", dropdownPosition: "dropdownPosition", clearButtonTitle: "clearButtonTitle", noItemsFoundText: "noItemsFoundText", loadingPlaceholderText: "loadingPlaceholderText", searchInputId: "searchInputId", isLoading: "isLoading", inputAttrs: "inputAttrs", htmlId: "htmlId", itemsAlreadyGrouped: "itemsAlreadyGrouped", invertDisabled: "invertDisabled", noGroupActions: "noGroupActions", autoHighlightFirst: "autoHighlightFirst", autoFocus: "autoFocus", keepOpen: "keepOpen", hideSelected: "hideSelected", noBackspaceClear: "noBackspaceClear", sortMultipleValues: "sortMultipleValues", searchCaseSensitive: "searchCaseSensitive", keepSearchAfterSelect: "keepSearchAfterSelect", maxSelectedItems: "maxSelectedItems", itemDisplayLimit: "itemDisplayLimit", searchFn: "searchFn", compareWith: "compareWith", appearance: "appearance", variant: "variant", compact: "compact", dropdowonAppearance: "dropdowonAppearance", dropdowonVariant: "dropdowonVariant", groupItems: "groupItems", items: "items", multiselectable: "multiselectable", clearable: "clearable", searchable: "searchable", addCustom: "addCustom", value: "value", isDropdownOpen: ["isOpen", "isDropdownOpen"] }, outputs: { valueChange: "valueChange", changeEvent: "change", addEvent: "add", failedToAddEvent: "failedToAdd", removeEvent: "remove", clearEvent: "clear", openEvent: "open", closeEvent: "close", scrollEvent: "scroll", scrollToEndEvent: "scrollToEnd", searchEvent: "search", isDropdownOpenChange: "isOpenChange" }, host: { listeners: { "window:resize": "onWindowResize()", "mouseup": "onMouseup()", "keydown": "onKeyPress($event)" }, properties: { "class.ard-group-items": "this.groupItems", "attr.multiple": "this.multiselectable" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => ArdiumSelectComponent),
+                multi: true,
+            },
+        ], queries: [{ propertyName: "optionTemplate", first: true, predicate: ArdOptionTemplateDirective, descendants: true, read: TemplateRef }, { propertyName: "optgroupTemplate", first: true, predicate: ArdOptgroupTemplateDirective, descendants: true, read: TemplateRef }, { propertyName: "valueTemplate", first: true, predicate: ArdValueTemplateDirective, descendants: true, read: TemplateRef }, { propertyName: "placeholderTemplate", first: true, predicate: ArdSelectPlaceholderTemplateDirective, descendants: true, read: TemplateRef }, { propertyName: "loadingSpinnerTemplate", first: true, predicate: ArdLoadingSpinnerTemplateDirective, descendants: true, read: TemplateRef }, { propertyName: "loadingPlaceholderTemplate", first: true, predicate: ArdLoadingPlaceholderTemplateDirective, descendants: true, read: TemplateRef }, { propertyName: "dropdownHeaderTemplate", first: true, predicate: ArdDropdownHeaderTemplateDirective, descendants: true, read: TemplateRef }, { propertyName: "dropdownFooterTemplate", first: true, predicate: ArdDropdownFooterTemplateDirective, descendants: true, read: TemplateRef }, { propertyName: "noItemsFoundTemplate", first: true, predicate: ArdNoItemsFoundTemplateDirective, descendants: true, read: TemplateRef }, { propertyName: "addCustomTemplate", first: true, predicate: ArdAddCustomTemplateDirective, descendants: true, read: TemplateRef }, { propertyName: "itemLimitReachedTemplate", first: true, predicate: ArdItemLimitReachedTemplateDirective, descendants: true, read: TemplateRef }, { propertyName: "itemDisplayLimitTemplate", first: true, predicate: ArdItemDisplayLimitTemplateDirective, descendants: true, read: TemplateRef }, { propertyName: "prefixTemplate", first: true, predicate: ArdSelectPrefixTemplateDirective, descendants: true, read: TemplateRef }, { propertyName: "suffixTemplate", first: true, predicate: ArdSelectSuffixTemplateDirective, descendants: true, read: TemplateRef }, { propertyName: "optionComponents", predicate: ArdiumOptionComponent }], viewQueries: [{ propertyName: "searchInput", first: true, predicate: ["searchInput"], descendants: true, static: true }, { propertyName: "dropdownPanel", first: true, predicate: i0.forwardRef(() => ArdiumDropdownPanelComponent), descendants: true }, { propertyName: "dropdownHost", first: true, predicate: ["dropdownHost"], descendants: true, read: ElementRef }, { propertyName: "dropdownTemplate", first: true, predicate: ["dropdownTemplate"], descendants: true, read: TemplateRef }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<ard-form-field-frame\r\n    [appearance]=\"appearance\"\r\n    [variant]=\"variant\"\r\n    [compact]=\"compact\"\r\n    [isFocused]=\"isFocused\"\r\n    [prefixTemplate]=\"prefixTemplate\"\r\n    [suffixTemplate]=\"suffixTemplate\"\r\n>\r\n    <div class=\"ard-select\"\r\n        #dropdownHost\r\n        (click)=\"handleAnywhereClick($event)\"\r\n        [class.ard-has-value]=\"itemStorage.isAnyItemSelected\"\r\n        [ngClass]=\"ngClasses\"\r\n    >\r\n        <div class=\"ard-select-value-container\">\r\n            <ng-container *ngIf=\"shouldDisplayPlaceholder\">\r\n                <ng-template #defaultPlaceholderTemplate let-plhldr>\r\n                    <div class=\"ard-placeholder\">{{ plhldr }}</div>\r\n                </ng-template>\r\n\r\n                <ng-template\r\n                    [ngTemplateOutlet]=\"placeholderTemplate || defaultPlaceholderTemplate\"\r\n                    [ngTemplateOutletContext]=\"getPlaceholderContext()\"\r\n                ></ng-template>\r\n            </ng-container>\r\n\r\n            <ng-container *ngIf=\"shouldDisplayValue\">\r\n                <div class=\"ard-select-value\"\r\n                    *ngFor=\"let item of itemStorage.selectedItems; let i = index\"\r\n                    [class.ard-value-disabled]=\"item.disabled\"\r\n                    [attr.hidden]=\"!isValueWithinDisplayLimit(i) ? true : null\"\r\n                >\r\n                    <ng-template *ngIf=\"isValueWithinDisplayLimit(i)\"\r\n                        [ngTemplateOutlet]=\"valueTemplate || (multiselectable ? defaultMultiValueTemplate :  defaultValueTemplate)\"\r\n                        [ngTemplateOutletContext]=\"getValueContext(item)\"\r\n                    ></ng-template>\r\n                </div>\r\n\r\n                <ng-template #defaultValueTemplate let-item>\r\n                    <div [ardInnerHTML]=\"item.label\" [ardEscapeInnerHTML]=\"isItemsInputUsed\"></div>\r\n                </ng-template>\r\n                <ng-template #defaultMultiValueTemplate let-item let-unselect=\"unselect\">\r\n                    <ard-deletable-chip\r\n                        (delete)=\"unselect(item)\"\r\n                        [variant]=\"variant\"\r\n                        compact\r\n                        appearance=\"outlined-strong\"\r\n                    >\r\n                        <div [ardInnerHTML]=\"item.label\" [ardEscapeInnerHTML]=\"isItemsInputUsed\"></div>\r\n                    </ard-deletable-chip>\r\n                </ng-template>\r\n            </ng-container>\r\n\r\n            <ng-container *ngIf=\"itemStorage.isAnyItemSelected && shouldShowItemDisplayLimit\">\r\n                <div class=\"ard-overflow-indicator\">\r\n                    <ng-template\r\n                        [ngTemplateOutlet]=\"itemDisplayLimitTemplate || defaultItemDisplayLimitTemplate\"\r\n                        [ngTemplateOutletContext]=\"getItemDisplayLimitContext()\"\r\n                    ></ng-template>\r\n\r\n                    <ng-template #defaultItemDisplayLimitTemplate let-count=\"overflowCount\">\r\n                        <div>{{count}} more...</div>\r\n                    </ng-template>\r\n                </div>\r\n            </ng-container>\r\n            \r\n            <div class=\"ard-search-input\"\r\n                role=\"combobox\"\r\n                aria-haspopup=\"listbox\"\r\n                [attr.aria-expanded]=\"isDropdownOpen\"\r\n                [attr.aria-owns]=\"isDropdownOpen ? htmlId : null\"\r\n            >\r\n                <input #searchInput\r\n                    #focusableElement\r\n                    type=\"text\"\r\n                    [attr.id]=\"searchInputId\"\r\n                    [attr.tabindex]=\"tabIndex\"\r\n                    [readonly]=\"isInputElementReadonly\"\r\n                    [disabled]=\"disabled\"\r\n                    [value]=\"searchTerm\"\r\n                    aria-autocomplete=\"list\"\r\n                    [attr.aria-controls]=\"isDropdownOpen ? htmlId : null\"\r\n                    (input)=\"filter(searchInput.value)\"\r\n                    (change)=\"$event.stopPropagation()\"\r\n                    (focus)=\"onFocus($event)\"\r\n                    (focus)=\"onSearchInputFocus($event)\"\r\n                    (blur)=\"onBlur($event)\"\r\n                    (blur)=\"onSearchInputBlur($event)\"\r\n                >\r\n            </div>\r\n        </div>\r\n\r\n        <div class=\"ard-select-controls\">\r\n            <ng-container *ngIf=\"isLoading\">\r\n                <ng-template #defaultLoadingSpinnerTemplate>\r\n                    <div class=\"ard-simple-spinner\"></div>\r\n                </ng-template>\r\n\r\n                <ng-template [ngTemplateOutlet]=\"loadingSpinnerTemplate || defaultLoadingSpinnerTemplate\">\r\n                </ng-template>\r\n            </ng-container>\r\n\r\n            <ard-_clear-button *ngIf=\"shouldShowClearButton\"\r\n                [title]=\"clearButtonTitle\"\r\n                (click)=\"handleClearButtonClick($event)\"\r\n            ></ard-_clear-button>\r\n\r\n            <div class=\"ard-dropdown-arrow-wrapper\"\r\n                role=\"button\"\r\n                (click)=\"handleDropdownArrowClick($event)\"\r\n            >\r\n                <span class=\"ard-dropdown-arrow\"></span>\r\n                <div class=\"ard-hitbox\"></div>\r\n            </div>\r\n        </div>\r\n    </div>\r\n</ard-form-field-frame>\r\n\r\n\r\n<ng-template #dropdownTemplate>\r\n    <ard-dropdown-panel\r\n        class=\"ard-dropdown-panel ard-select-dropdown-panel\"\r\n        role=\"listbox\"\r\n        aria-label=\"Options list\"\r\n        [headerTemplate]=\"dropdownHeaderTemplate\"\r\n        [footerTemplate]=\"dropdownFooterTemplate\"\r\n        [appearance]=\"dropdownAppearance\"\r\n        [variant]=\"dropdownVariant\"\r\n        [isOpen]=\"true\"\r\n        [filterValue]=\"searchTerm\"\r\n        [panelId]=\"htmlId\"\r\n        [compact]=\"compact\"\r\n        (ardClickOutside)=\"handleOutsideClick($event)\"\r\n        (mousemove)=\"onMouseMove()\"\r\n        (scroll)=\"scrollEvent.emit($event)\"\r\n        (scrollToEnd)=\"scrollToEndEvent.emit($event)\"\r\n    >\r\n        <ng-container *ngIf=\"!shouldShowNoItemsFound\">\r\n            <div\r\n                class=\"ard-optgroup\"\r\n                role=\"group\"\r\n                *ngFor=\"let group of itemStorage.groups\"\r\n                [class.ard-group-disabled]=\"group.disabled\"\r\n                [class.ard-group-selected]=\"group.selected\"\r\n                [class.ard-group-highlighted]=\"group.highlighted\"\r\n                (mouseover)=\"onGroupMouseover(group)\"\r\n                (click)=\"onGroupClick(group)\"\r\n            >\r\n                <ng-container *ngIf=\"group.label !== '' && group.label !== undefined\">\r\n                    <ng-template #defaultOptgroupTemplate>\r\n                        <span class=\"ard-optgroup-label\" [ardInnerHTML]=\"group.label\" [ardEscapeInnerHTML]=\"isItemsInputUsed\"></span>\r\n                    </ng-template>\r\n\r\n                    <ng-template\r\n                        [ngTemplateOutlet]=\"optgroupTemplate || defaultOptgroupTemplate\"\r\n                        [ngTemplateOutletContext]=\"getGroupContext(group)\"\r\n                    ></ng-template>\r\n                </ng-container>\r\n\r\n                <div class=\"ard-optgroup-children\">\r\n                    <div\r\n                        class=\"ard-option\"\r\n                        role=\"option\"\r\n                        *ngFor=\"let option of group.children\"\r\n                        [class.ard-option-disabled]=\"option.disabled\"\r\n                        [class.ard-option-selected]=\"option.selected\"\r\n                        [class.ard-option-highlighted]=\"option.highlighted\"\r\n                        [class.ard-option-highlighted-recent]=\"option.highlighted_recently\"\r\n                        [attr.aria-selected]=\"option.selected\"\r\n                        [attr.id]=\"htmlId + '-' + option.index\"\r\n                        (click)=\"onItemClick(option, $event)\"\r\n                        (mouseover)=\"onItemMouseOver($event)\"\r\n                        (mouseenter)=\"onItemMouseEnter(option, $event)\"\r\n                        (mouseleave)=\"onItemMouseLeave(option, $event)\"\r\n                    >\r\n                        <div class=\"ard-option-label\">\r\n                            <ng-template #defaultOptionTemplate>\r\n                                <span [ardInnerHTML]=\"option.label\" [ardEscapeInnerHTML]=\"isItemsInputUsed\"></span>\r\n                            </ng-template>\r\n\r\n                            <ng-template\r\n                                [ngTemplateOutlet]=\"optionTemplate || defaultOptionTemplate\"\r\n                                [ngTemplateOutletContext]=\"getOptionContext(option)\"\r\n                            ></ng-template>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </ng-container>\r\n\r\n        <ng-container *ngIf=\"shouldShowNoItemsFound\">\r\n            <ng-template #defaultNoItemsFoundTemplate>\r\n                <div class=\"ard-option ard-option-disabled\">{{noItemsFoundText}}</div>\r\n            </ng-template>\r\n\r\n            <ng-template [ngTemplateOutlet]=\"noItemsFoundTemplate || defaultNoItemsFoundTemplate\"\r\n                [ngTemplateOutletContext]=\"getSearchContext()\">\r\n            </ng-template>\r\n        </ng-container>\r\n\r\n        <ng-container *ngIf=\"shouldShowAddCustom\">\r\n            <ng-template #defaultAddCustomTemplate let-searchTerm>\r\n                <div class=\"ard-option ard-option-highlighted ard-add-custom\" (click)=\"addCustomOption(searchTerm)\">\r\n                    <span class=\"ard-add-custom-label\">Add option</span>\r\n                    <span class=\"ard-add-custom-value\">\"{{searchTerm}}\"</span>\r\n                </div>\r\n            </ng-template>\r\n\r\n            <ng-template [ngTemplateOutlet]=\"addCustomTemplate || defaultAddCustomTemplate\"\r\n                [ngTemplateOutletContext]=\"getCustomOptionContext()\">\r\n            </ng-template>\r\n        </ng-container>\r\n\r\n        <ng-container *ngIf=\"isLoading\">\r\n            <ng-template #defaultLoadingPlaceholderTemplate>\r\n                <div class=\"ard-option ard-option-disabled\">{{loadingPlaceholderText}}</div>\r\n            </ng-template>\r\n\r\n            <ng-template [ngTemplateOutlet]=\"loadingPlaceholderTemplate || defaultLoadingPlaceholderTemplate\"\r\n                [ngTemplateOutletContext]=\"getSearchContext()\">\r\n            </ng-template>\r\n        </ng-container>\r\n    </ard-dropdown-panel>\r\n</ng-template>", styles: ["@import\"@angular/cdk/overlay-prebuilt.css\";.ard-select .ard-select-container{display:flex;cursor:pointer}.ard-select .ard-placeholder,.ard-select .ard-value,.ard-select .ard-dropdown-arrow-wrapper,.ard-select .ard-clear-btn-wrapper{-webkit-user-select:none;user-select:none}.ard-select .ard-clear-btn,.ard-select .ard-dropdown-arrow{border:none;background:transparent;padding:0;box-sizing:content-box}.ard-select .ard-option-disabled{pointer-events:none}.ard-select .ard-value[hidden]{display:none}.ard-select .ard-searchable .ard-select-value-container{cursor:text}.ard-select .ard-dropdown-arrow-wrapper{position:relative}.ard-select .ard-dropdown-arrow-wrapper .ard-hitbox{position:absolute;left:-4px;right:-4px;aspect-ratio:1}.ard-select-dropdown-panel .ard-optgroup,.ard-select-dropdown-panel .ard-option{-webkit-user-select:none;user-select:none}\n"], dependencies: [{ kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i3.ArdiumFormFieldFrameComponent, selector: "ard-form-field-frame", inputs: ["isFocused", "appearance", "variant", "compact", "prefixTemplate", "suffixTemplate"] }, { kind: "component", type: i4.ArdiumDropdownPanelComponent, selector: "ard-dropdown-panel", inputs: ["panelId", "headerTemplate", "footerTemplate", "filterValue", "appearance", "variant", "compact", "isOpen"], outputs: ["scroll", "scrollToEnd"] }, { kind: "component", type: i5.ArdiumDeletableChipComponent, selector: "ard-deletable-chip", inputs: ["deleteButtonTitle", "contentAlignment", "appearance", "variant", "color", "compact", "wrapperClasses"], outputs: ["delete"] }, { kind: "directive", type: i6.ClickOutsideDirective, selector: "[ardClickOutside]", outputs: ["ardClickOutside"] }, { kind: "component", type: i7._ClearButtonComponent, selector: "ard-_clear-button" }, { kind: "directive", type: i6.ArdiumInnerHTMLDirective, selector: "[ardInnerHTML]", inputs: ["ardInnerHTML", "ardEscapeInnerHTML"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumSelectComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ard-select', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => ArdiumSelectComponent),
+                            multi: true,
+                        },
+                    ], template: "<ard-form-field-frame\r\n    [appearance]=\"appearance\"\r\n    [variant]=\"variant\"\r\n    [compact]=\"compact\"\r\n    [isFocused]=\"isFocused\"\r\n    [prefixTemplate]=\"prefixTemplate\"\r\n    [suffixTemplate]=\"suffixTemplate\"\r\n>\r\n    <div class=\"ard-select\"\r\n        #dropdownHost\r\n        (click)=\"handleAnywhereClick($event)\"\r\n        [class.ard-has-value]=\"itemStorage.isAnyItemSelected\"\r\n        [ngClass]=\"ngClasses\"\r\n    >\r\n        <div class=\"ard-select-value-container\">\r\n            <ng-container *ngIf=\"shouldDisplayPlaceholder\">\r\n                <ng-template #defaultPlaceholderTemplate let-plhldr>\r\n                    <div class=\"ard-placeholder\">{{ plhldr }}</div>\r\n                </ng-template>\r\n\r\n                <ng-template\r\n                    [ngTemplateOutlet]=\"placeholderTemplate || defaultPlaceholderTemplate\"\r\n                    [ngTemplateOutletContext]=\"getPlaceholderContext()\"\r\n                ></ng-template>\r\n            </ng-container>\r\n\r\n            <ng-container *ngIf=\"shouldDisplayValue\">\r\n                <div class=\"ard-select-value\"\r\n                    *ngFor=\"let item of itemStorage.selectedItems; let i = index\"\r\n                    [class.ard-value-disabled]=\"item.disabled\"\r\n                    [attr.hidden]=\"!isValueWithinDisplayLimit(i) ? true : null\"\r\n                >\r\n                    <ng-template *ngIf=\"isValueWithinDisplayLimit(i)\"\r\n                        [ngTemplateOutlet]=\"valueTemplate || (multiselectable ? defaultMultiValueTemplate :  defaultValueTemplate)\"\r\n                        [ngTemplateOutletContext]=\"getValueContext(item)\"\r\n                    ></ng-template>\r\n                </div>\r\n\r\n                <ng-template #defaultValueTemplate let-item>\r\n                    <div [ardInnerHTML]=\"item.label\" [ardEscapeInnerHTML]=\"isItemsInputUsed\"></div>\r\n                </ng-template>\r\n                <ng-template #defaultMultiValueTemplate let-item let-unselect=\"unselect\">\r\n                    <ard-deletable-chip\r\n                        (delete)=\"unselect(item)\"\r\n                        [variant]=\"variant\"\r\n                        compact\r\n                        appearance=\"outlined-strong\"\r\n                    >\r\n                        <div [ardInnerHTML]=\"item.label\" [ardEscapeInnerHTML]=\"isItemsInputUsed\"></div>\r\n                    </ard-deletable-chip>\r\n                </ng-template>\r\n            </ng-container>\r\n\r\n            <ng-container *ngIf=\"itemStorage.isAnyItemSelected && shouldShowItemDisplayLimit\">\r\n                <div class=\"ard-overflow-indicator\">\r\n                    <ng-template\r\n                        [ngTemplateOutlet]=\"itemDisplayLimitTemplate || defaultItemDisplayLimitTemplate\"\r\n                        [ngTemplateOutletContext]=\"getItemDisplayLimitContext()\"\r\n                    ></ng-template>\r\n\r\n                    <ng-template #defaultItemDisplayLimitTemplate let-count=\"overflowCount\">\r\n                        <div>{{count}} more...</div>\r\n                    </ng-template>\r\n                </div>\r\n            </ng-container>\r\n            \r\n            <div class=\"ard-search-input\"\r\n                role=\"combobox\"\r\n                aria-haspopup=\"listbox\"\r\n                [attr.aria-expanded]=\"isDropdownOpen\"\r\n                [attr.aria-owns]=\"isDropdownOpen ? htmlId : null\"\r\n            >\r\n                <input #searchInput\r\n                    #focusableElement\r\n                    type=\"text\"\r\n                    [attr.id]=\"searchInputId\"\r\n                    [attr.tabindex]=\"tabIndex\"\r\n                    [readonly]=\"isInputElementReadonly\"\r\n                    [disabled]=\"disabled\"\r\n                    [value]=\"searchTerm\"\r\n                    aria-autocomplete=\"list\"\r\n                    [attr.aria-controls]=\"isDropdownOpen ? htmlId : null\"\r\n                    (input)=\"filter(searchInput.value)\"\r\n                    (change)=\"$event.stopPropagation()\"\r\n                    (focus)=\"onFocus($event)\"\r\n                    (focus)=\"onSearchInputFocus($event)\"\r\n                    (blur)=\"onBlur($event)\"\r\n                    (blur)=\"onSearchInputBlur($event)\"\r\n                >\r\n            </div>\r\n        </div>\r\n\r\n        <div class=\"ard-select-controls\">\r\n            <ng-container *ngIf=\"isLoading\">\r\n                <ng-template #defaultLoadingSpinnerTemplate>\r\n                    <div class=\"ard-simple-spinner\"></div>\r\n                </ng-template>\r\n\r\n                <ng-template [ngTemplateOutlet]=\"loadingSpinnerTemplate || defaultLoadingSpinnerTemplate\">\r\n                </ng-template>\r\n            </ng-container>\r\n\r\n            <ard-_clear-button *ngIf=\"shouldShowClearButton\"\r\n                [title]=\"clearButtonTitle\"\r\n                (click)=\"handleClearButtonClick($event)\"\r\n            ></ard-_clear-button>\r\n\r\n            <div class=\"ard-dropdown-arrow-wrapper\"\r\n                role=\"button\"\r\n                (click)=\"handleDropdownArrowClick($event)\"\r\n            >\r\n                <span class=\"ard-dropdown-arrow\"></span>\r\n                <div class=\"ard-hitbox\"></div>\r\n            </div>\r\n        </div>\r\n    </div>\r\n</ard-form-field-frame>\r\n\r\n\r\n<ng-template #dropdownTemplate>\r\n    <ard-dropdown-panel\r\n        class=\"ard-dropdown-panel ard-select-dropdown-panel\"\r\n        role=\"listbox\"\r\n        aria-label=\"Options list\"\r\n        [headerTemplate]=\"dropdownHeaderTemplate\"\r\n        [footerTemplate]=\"dropdownFooterTemplate\"\r\n        [appearance]=\"dropdownAppearance\"\r\n        [variant]=\"dropdownVariant\"\r\n        [isOpen]=\"true\"\r\n        [filterValue]=\"searchTerm\"\r\n        [panelId]=\"htmlId\"\r\n        [compact]=\"compact\"\r\n        (ardClickOutside)=\"handleOutsideClick($event)\"\r\n        (mousemove)=\"onMouseMove()\"\r\n        (scroll)=\"scrollEvent.emit($event)\"\r\n        (scrollToEnd)=\"scrollToEndEvent.emit($event)\"\r\n    >\r\n        <ng-container *ngIf=\"!shouldShowNoItemsFound\">\r\n            <div\r\n                class=\"ard-optgroup\"\r\n                role=\"group\"\r\n                *ngFor=\"let group of itemStorage.groups\"\r\n                [class.ard-group-disabled]=\"group.disabled\"\r\n                [class.ard-group-selected]=\"group.selected\"\r\n                [class.ard-group-highlighted]=\"group.highlighted\"\r\n                (mouseover)=\"onGroupMouseover(group)\"\r\n                (click)=\"onGroupClick(group)\"\r\n            >\r\n                <ng-container *ngIf=\"group.label !== '' && group.label !== undefined\">\r\n                    <ng-template #defaultOptgroupTemplate>\r\n                        <span class=\"ard-optgroup-label\" [ardInnerHTML]=\"group.label\" [ardEscapeInnerHTML]=\"isItemsInputUsed\"></span>\r\n                    </ng-template>\r\n\r\n                    <ng-template\r\n                        [ngTemplateOutlet]=\"optgroupTemplate || defaultOptgroupTemplate\"\r\n                        [ngTemplateOutletContext]=\"getGroupContext(group)\"\r\n                    ></ng-template>\r\n                </ng-container>\r\n\r\n                <div class=\"ard-optgroup-children\">\r\n                    <div\r\n                        class=\"ard-option\"\r\n                        role=\"option\"\r\n                        *ngFor=\"let option of group.children\"\r\n                        [class.ard-option-disabled]=\"option.disabled\"\r\n                        [class.ard-option-selected]=\"option.selected\"\r\n                        [class.ard-option-highlighted]=\"option.highlighted\"\r\n                        [class.ard-option-highlighted-recent]=\"option.highlighted_recently\"\r\n                        [attr.aria-selected]=\"option.selected\"\r\n                        [attr.id]=\"htmlId + '-' + option.index\"\r\n                        (click)=\"onItemClick(option, $event)\"\r\n                        (mouseover)=\"onItemMouseOver($event)\"\r\n                        (mouseenter)=\"onItemMouseEnter(option, $event)\"\r\n                        (mouseleave)=\"onItemMouseLeave(option, $event)\"\r\n                    >\r\n                        <div class=\"ard-option-label\">\r\n                            <ng-template #defaultOptionTemplate>\r\n                                <span [ardInnerHTML]=\"option.label\" [ardEscapeInnerHTML]=\"isItemsInputUsed\"></span>\r\n                            </ng-template>\r\n\r\n                            <ng-template\r\n                                [ngTemplateOutlet]=\"optionTemplate || defaultOptionTemplate\"\r\n                                [ngTemplateOutletContext]=\"getOptionContext(option)\"\r\n                            ></ng-template>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </ng-container>\r\n\r\n        <ng-container *ngIf=\"shouldShowNoItemsFound\">\r\n            <ng-template #defaultNoItemsFoundTemplate>\r\n                <div class=\"ard-option ard-option-disabled\">{{noItemsFoundText}}</div>\r\n            </ng-template>\r\n\r\n            <ng-template [ngTemplateOutlet]=\"noItemsFoundTemplate || defaultNoItemsFoundTemplate\"\r\n                [ngTemplateOutletContext]=\"getSearchContext()\">\r\n            </ng-template>\r\n        </ng-container>\r\n\r\n        <ng-container *ngIf=\"shouldShowAddCustom\">\r\n            <ng-template #defaultAddCustomTemplate let-searchTerm>\r\n                <div class=\"ard-option ard-option-highlighted ard-add-custom\" (click)=\"addCustomOption(searchTerm)\">\r\n                    <span class=\"ard-add-custom-label\">Add option</span>\r\n                    <span class=\"ard-add-custom-value\">\"{{searchTerm}}\"</span>\r\n                </div>\r\n            </ng-template>\r\n\r\n            <ng-template [ngTemplateOutlet]=\"addCustomTemplate || defaultAddCustomTemplate\"\r\n                [ngTemplateOutletContext]=\"getCustomOptionContext()\">\r\n            </ng-template>\r\n        </ng-container>\r\n\r\n        <ng-container *ngIf=\"isLoading\">\r\n            <ng-template #defaultLoadingPlaceholderTemplate>\r\n                <div class=\"ard-option ard-option-disabled\">{{loadingPlaceholderText}}</div>\r\n            </ng-template>\r\n\r\n            <ng-template [ngTemplateOutlet]=\"loadingPlaceholderTemplate || defaultLoadingPlaceholderTemplate\"\r\n                [ngTemplateOutletContext]=\"getSearchContext()\">\r\n            </ng-template>\r\n        </ng-container>\r\n    </ard-dropdown-panel>\r\n</ng-template>", styles: ["@import\"@angular/cdk/overlay-prebuilt.css\";.ard-select .ard-select-container{display:flex;cursor:pointer}.ard-select .ard-placeholder,.ard-select .ard-value,.ard-select .ard-dropdown-arrow-wrapper,.ard-select .ard-clear-btn-wrapper{-webkit-user-select:none;user-select:none}.ard-select .ard-clear-btn,.ard-select .ard-dropdown-arrow{border:none;background:transparent;padding:0;box-sizing:content-box}.ard-select .ard-option-disabled{pointer-events:none}.ard-select .ard-value[hidden]{display:none}.ard-select .ard-searchable .ard-select-value-container{cursor:text}.ard-select .ard-dropdown-arrow-wrapper{position:relative}.ard-select .ard-dropdown-arrow-wrapper .ard-hitbox{position:absolute;left:-4px;right:-4px;aspect-ratio:1}.ard-select-dropdown-panel .ard-optgroup,.ard-select-dropdown-panel .ard-option{-webkit-user-select:none;user-select:none}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i1.Overlay }, { type: i0.ViewContainerRef }, { type: i1.ScrollStrategyOptions }], propDecorators: { valueFrom: [{
+                type: Input
+            }], labelFrom: [{
+                type: Input
+            }], disabledFrom: [{
+                type: Input
+            }], groupLabelFrom: [{
+                type: Input
+            }], groupDisabledFrom: [{
+                type: Input
+            }], childrenFrom: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], searchPlaceholder: [{
+                type: Input
+            }], dropdownPosition: [{
+                type: Input
+            }], clearButtonTitle: [{
+                type: Input
+            }], noItemsFoundText: [{
+                type: Input
+            }], loadingPlaceholderText: [{
+                type: Input
+            }], searchInputId: [{
+                type: Input
+            }], isLoading: [{
+                type: Input
+            }], inputAttrs: [{
+                type: Input
+            }], htmlId: [{
+                type: Input
+            }], itemsAlreadyGrouped: [{
+                type: Input
+            }], invertDisabled: [{
+                type: Input
+            }], noGroupActions: [{
+                type: Input
+            }], autoHighlightFirst: [{
+                type: Input
+            }], autoFocus: [{
+                type: Input
+            }], keepOpen: [{
+                type: Input
+            }], hideSelected: [{
+                type: Input
+            }], noBackspaceClear: [{
+                type: Input
+            }], sortMultipleValues: [{
+                type: Input
+            }], searchCaseSensitive: [{
+                type: Input
+            }], keepSearchAfterSelect: [{
+                type: Input
+            }], maxSelectedItems: [{
+                type: Input
+            }], itemDisplayLimit: [{
+                type: Input
+            }], searchFn: [{
+                type: Input
+            }], compareWith: [{
+                type: Input
+            }], appearance: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], compact: [{
+                type: Input
+            }], dropdowonAppearance: [{
+                type: Input
+            }], dropdowonVariant: [{
+                type: Input
+            }], groupItems: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['class.ard-group-items']
+            }], items: [{
+                type: Input
+            }], optionComponents: [{
+                type: ContentChildren,
+                args: [ArdiumOptionComponent]
+            }], multiselectable: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['attr.multiple']
+            }], clearable: [{
+                type: Input
+            }], searchable: [{
+                type: Input
+            }], addCustom: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], changeEvent: [{
+                type: Output,
+                args: ['change']
+            }], addEvent: [{
+                type: Output,
+                args: ['add']
+            }], failedToAddEvent: [{
+                type: Output,
+                args: ['failedToAdd']
+            }], removeEvent: [{
+                type: Output,
+                args: ['remove']
+            }], clearEvent: [{
+                type: Output,
+                args: ['clear']
+            }], openEvent: [{
+                type: Output,
+                args: ['open']
+            }], closeEvent: [{
+                type: Output,
+                args: ['close']
+            }], scrollEvent: [{
+                type: Output,
+                args: ['scroll']
+            }], scrollToEndEvent: [{
+                type: Output,
+                args: ['scrollToEnd']
+            }], searchEvent: [{
+                type: Output,
+                args: ['search']
+            }], isDropdownOpen: [{
+                type: Input,
+                args: ['isOpen']
+            }], isDropdownOpenChange: [{
+                type: Output,
+                args: ['isOpenChange']
+            }], searchInput: [{
+                type: ViewChild,
+                args: ['searchInput', { static: true }]
+            }], dropdownPanel: [{
+                type: ViewChild,
+                args: [forwardRef(() => ArdiumDropdownPanelComponent)]
+            }], optionTemplate: [{
+                type: ContentChild,
+                args: [ArdOptionTemplateDirective, { read: TemplateRef }]
+            }], optgroupTemplate: [{
+                type: ContentChild,
+                args: [ArdOptgroupTemplateDirective, { read: TemplateRef }]
+            }], valueTemplate: [{
+                type: ContentChild,
+                args: [ArdValueTemplateDirective, { read: TemplateRef }]
+            }], placeholderTemplate: [{
+                type: ContentChild,
+                args: [ArdSelectPlaceholderTemplateDirective, { read: TemplateRef }]
+            }], loadingSpinnerTemplate: [{
+                type: ContentChild,
+                args: [ArdLoadingSpinnerTemplateDirective, { read: TemplateRef }]
+            }], loadingPlaceholderTemplate: [{
+                type: ContentChild,
+                args: [ArdLoadingPlaceholderTemplateDirective, { read: TemplateRef }]
+            }], dropdownHeaderTemplate: [{
+                type: ContentChild,
+                args: [ArdDropdownHeaderTemplateDirective, { read: TemplateRef }]
+            }], dropdownFooterTemplate: [{
+                type: ContentChild,
+                args: [ArdDropdownFooterTemplateDirective, { read: TemplateRef }]
+            }], noItemsFoundTemplate: [{
+                type: ContentChild,
+                args: [ArdNoItemsFoundTemplateDirective, { read: TemplateRef }]
+            }], addCustomTemplate: [{
+                type: ContentChild,
+                args: [ArdAddCustomTemplateDirective, { read: TemplateRef }]
+            }], itemLimitReachedTemplate: [{
+                type: ContentChild,
+                args: [ArdItemLimitReachedTemplateDirective, { read: TemplateRef }]
+            }], itemDisplayLimitTemplate: [{
+                type: ContentChild,
+                args: [ArdItemDisplayLimitTemplateDirective, { read: TemplateRef }]
+            }], prefixTemplate: [{
+                type: ContentChild,
+                args: [ArdSelectPrefixTemplateDirective, { read: TemplateRef }]
+            }], suffixTemplate: [{
+                type: ContentChild,
+                args: [ArdSelectSuffixTemplateDirective, { read: TemplateRef }]
+            }], dropdownHost: [{
+                type: ViewChild,
+                args: ['dropdownHost', { read: ElementRef }]
+            }], dropdownTemplate: [{
+                type: ViewChild,
+                args: ['dropdownTemplate', { read: TemplateRef }]
+            }], onWindowResize: [{
+                type: HostListener,
+                args: ['window:resize']
+            }], onMouseup: [{
+                type: HostListener,
+                args: ['mouseup']
+            }], onKeyPress: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select.component.js","sourceRoot":"","sources":["../../../../../projects/ui/src/lib/select/select.component.ts","../../../../../projects/ui/src/lib/select/select.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Overlay, OverlayConfig, OverlayRef, ScrollStrategyOptions } from '@angular/cdk/overlay';\nimport { TemplatePortal } from '@angular/cdk/portal';\nimport {\n    AfterContentInit,\n    AfterViewInit,\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ContentChild,\n    ContentChildren,\n    ElementRef,\n    EventEmitter,\n    HostBinding,\n    HostListener,\n    Input,\n    OnChanges,\n    OnDestroy,\n    OnInit,\n    Output,\n    QueryList,\n    SimpleChanges,\n    TemplateRef,\n    ViewChild,\n    ViewContainerRef,\n    ViewEncapsulation,\n    forwardRef,\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { coerceArrayProperty, coerceBooleanProperty, coerceNumberProperty } from '@ardium-ui/devkit';\nimport { Subject, merge, startWith, takeUntil } from 'rxjs';\nimport { isAnyString, isArray, isFunction } from 'simple-bool';\nimport { ItemStorage } from '../_internal/item-storages/dropdown-item-storage';\nimport { _NgModelComponentBase } from '../_internal/ngmodel-component';\nimport { ArdiumDropdownPanelComponent } from '../dropdown-panel/dropdown-panel.component';\nimport { DropdownPanelAppearance, DropdownPanelVariant } from '../dropdown-panel/dropdown-panel.types';\nimport { ArdiumOptionComponent } from '../option/option.component';\nimport { searchFunctions } from '../search-functions';\nimport { ArdOption, ArdOptionGroup, ArdPanelPosition, CompareWithFn, GroupByFn, OptionContext, SearchFn } from '../types/item-storage.types';\nimport { FormElementAppearance } from '../types/theming.types';\nimport { FormElementVariant } from './../types/theming.types';\nimport {\n    ArdAddCustomTemplateDirective,\n    ArdDropdownFooterTemplateDirective,\n    ArdDropdownHeaderTemplateDirective,\n    ArdItemDisplayLimitTemplateDirective,\n    ArdItemLimitReachedTemplateDirective,\n    ArdLoadingPlaceholderTemplateDirective,\n    ArdLoadingSpinnerTemplateDirective,\n    ArdNoItemsFoundTemplateDirective,\n    ArdOptgroupTemplateDirective,\n    ArdOptionTemplateDirective,\n    ArdSelectPlaceholderTemplateDirective,\n    ArdSelectPrefixTemplateDirective,\n    ArdSelectSuffixTemplateDirective,\n    ArdValueTemplateDirective,\n} from './select.directive';\nimport {\n    AddCustomFn,\n    CustomOptionContext,\n    GroupContext,\n    ItemDisplayLimitContext,\n    ItemLimitContext,\n    PlaceholderContext,\n    SearchContext,\n    StatsContext,\n    ValueContext,\n} from './select.types';\n\n@Component({\n    selector: 'ard-select',\n    templateUrl: './select.component.html',\n    styleUrls: ['./select.component.scss'],\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef(() => ArdiumSelectComponent),\n            multi: true,\n        },\n    ],\n})\nexport class ArdiumSelectComponent\n    extends _NgModelComponentBase\n    implements OnChanges, AfterViewInit, AfterContentInit, OnInit, OnDestroy, ControlValueAccessor\n{\n    //! public constants\n    readonly itemStorage = new ItemStorage(this);\n    readonly element!: HTMLElement;\n    readonly DEFAULTS = {\n        valueFrom: 'value',\n        labelFrom: 'label',\n        disabledFrom: 'disabled',\n        groupLabelFrom: 'group',\n        groupDisabledFrom: 'disabled',\n        childrenFrom: 'children',\n        searchFn: searchFunctions.byLabel,\n        clearButtonTitle: 'Clear',\n        noItemsFoundText: 'No items found.',\n        loadingPlaceholderText: 'Loading...',\n    };\n\n    //! privates\n    private _items: any[] | null = [];\n    private _isMouseBeingUsed = false;\n    private _searchBarFocused = false;\n    private readonly _destroy$ = new Subject<void>();\n\n    //! publics\n    public searchTerm: string = '';\n    isItemsInputUsed: boolean = false;\n\n    //! binding-related inputs\n    //value/label/disabled/group/pre-grouped children paths\n    @Input() valueFrom?: string;\n    @Input() labelFrom?: string;\n    @Input() disabledFrom?: string;\n    //! group-related inputs\n    @Input() groupLabelFrom?: string | GroupByFn;\n    @Input() groupDisabledFrom?: string;\n    @Input() childrenFrom?: string;\n    //! settings\n    @Input() placeholder: string = 'Select item';\n    @Input() searchPlaceholder: string = 'Search...';\n    @Input() dropdownPosition: ArdPanelPosition = ArdPanelPosition.Auto;\n    @Input() clearButtonTitle: string = this.DEFAULTS.clearButtonTitle;\n    //! template-related settings\n    @Input() noItemsFoundText: string = this.DEFAULTS.noItemsFoundText;\n    @Input() loadingPlaceholderText: string = this.DEFAULTS.loadingPlaceholderText;\n    //! search-related options\n    @Input() searchInputId?: string;\n    //! other inputs\n    @Input() isLoading: boolean = false;\n    @Input() inputAttrs: { [key: string]: any } = {};\n    @Input() htmlId: string = crypto.randomUUID();\n\n    //! boolean settings\n    private _itemsAlreadyGrouped: boolean = false;\n    @Input()\n    get itemsAlreadyGrouped(): boolean {\n        return this._itemsAlreadyGrouped;\n    }\n    set itemsAlreadyGrouped(v: any) {\n        this._itemsAlreadyGrouped = coerceBooleanProperty(v);\n    }\n\n    //should the value that the \"disabledFrom\" path lead to be inverted?\n    //useful when the property is e.g. \"active\", which is the oposite of \"disabled\"\n    private _invertDisabled: boolean = false;\n    @Input()\n    get invertDisabled(): boolean {\n        return this._invertDisabled;\n    }\n    set invertDisabled(v: any) {\n        this._invertDisabled = coerceBooleanProperty(v);\n    }\n\n    private _noGroupActions: boolean = false;\n    @Input()\n    get noGroupActions(): boolean {\n        return this._noGroupActions;\n    }\n    set noGroupActions(v: any) {\n        this._noGroupActions = coerceBooleanProperty(v);\n    }\n\n    private _autoHighlightFirst: boolean = true;\n    @Input()\n    get autoHighlightFirst(): boolean {\n        return this._autoHighlightFirst;\n    }\n    set autoHighlightFirst(v: any) {\n        this._autoHighlightFirst = coerceBooleanProperty(v);\n    }\n\n    private _autoFocus: boolean = false;\n    @Input()\n    get autoFocus(): boolean {\n        return this._autoFocus;\n    }\n    set autoFocus(v: any) {\n        this._autoFocus = coerceBooleanProperty(v);\n    }\n\n    private _keepOpen: boolean = false;\n    @Input()\n    get keepOpen(): boolean {\n        return this._keepOpen;\n    }\n    set keepOpen(v: any) {\n        this._keepOpen = coerceBooleanProperty(v);\n    }\n\n    private _hideSelected: boolean = false;\n    @Input()\n    get hideSelected(): boolean {\n        return this._hideSelected;\n    }\n    set hideSelected(v: any) {\n        this._hideSelected = coerceBooleanProperty(v);\n    }\n\n    private _clearOnBackspace: boolean = false;\n    @Input()\n    get noBackspaceClear(): boolean {\n        return this._clearOnBackspace;\n    }\n    set noBackspaceClear(v: any) {\n        this._clearOnBackspace = coerceBooleanProperty(v);\n    }\n\n    private _sortMultipleValues: boolean = false;\n    @Input()\n    get sortMultipleValues(): boolean {\n        return this._sortMultipleValues;\n    }\n    set sortMultipleValues(v: any) {\n        this._sortMultipleValues = coerceBooleanProperty(v);\n    }\n\n    private _searchCaseSensitive: boolean = false;\n    @Input()\n    get searchCaseSensitive(): boolean {\n        return this._searchCaseSensitive;\n    }\n    set searchCaseSensitive(v: any) {\n        this._searchCaseSensitive = coerceBooleanProperty(v);\n    }\n\n    private _keepSearchAfterSelect: boolean = false;\n    @Input()\n    get keepSearchAfterSelect(): boolean {\n        return this._keepSearchAfterSelect;\n    }\n    set keepSearchAfterSelect(v: any) {\n        this._keepSearchAfterSelect = coerceBooleanProperty(v);\n    }\n\n    //! number inputs\n    private _maxSelectedItems: number | undefined = undefined;\n    @Input()\n    get maxSelectedItems(): number | undefined {\n        return this._maxSelectedItems;\n    }\n    set maxSelectedItems(v: any) {\n        this._maxSelectedItems = coerceNumberProperty(v, undefined);\n    }\n\n    private _itemDisplayLimit: number = Infinity;\n    @Input()\n    get itemDisplayLimit(): number {\n        return this._itemDisplayLimit;\n    }\n    set itemDisplayLimit(v: any) {\n        this._itemDisplayLimit = coerceNumberProperty(v, Infinity);\n    }\n\n    //! function inputs\n    private _searchFn: SearchFn = this.DEFAULTS.searchFn;\n    @Input()\n    get searchFn(): SearchFn {\n        return this._searchFn;\n    }\n    set searchFn(fn: SearchFn) {\n        if (fn !== undefined && fn !== null && !isFunction(fn)) {\n            throw Error('`searchFn` must be a function.');\n        }\n        this._searchFn = fn;\n    }\n    private _compareWith?: CompareWithFn;\n    @Input()\n    get compareWith(): CompareWithFn | undefined {\n        return this._compareWith;\n    }\n    set compareWith(fn: CompareWithFn | undefined) {\n        if (fn !== undefined && fn !== null && !isFunction(fn)) {\n            throw Error('`compareWith` must be a function.');\n        }\n        this._compareWith = fn;\n    }\n\n    //! appearance\n    @Input() appearance: FormElementAppearance = FormElementAppearance.Outlined;\n    @Input() variant: FormElementVariant = FormElementVariant.Rounded;\n\n    private _compact: boolean = false;\n    @Input()\n    get compact(): boolean {\n        return this._compact;\n    }\n    set compact(v: any) {\n        this._compact = coerceBooleanProperty(v);\n    }\n\n    get ngClasses(): string {\n        return [\n            //appearance, variant handled in ard-form-field-frame component\n            this.compact ? 'ard-compact' : '',\n            this.multiselectable ? 'ard-multiselect' : 'ard-singleselect',\n            this.clearable ? 'ard-clearable' : '',\n            this.searchable ? 'ard-searchable' : '',\n            this.filtered ? 'ard-filtered' : '',\n            this.touched ? 'ard-touched' : '',\n            this.isDropdownOpen ? 'ard-dropdown-open' : '',\n            this._searchBarFocused ? 'ard-select-focused' : '',\n            this._searchBarFocused ? 'ard-select-focused' : '',\n        ].join(' ');\n    }\n\n    private _dropdownAppearance?: DropdownPanelAppearance = undefined;\n    @Input()\n    set dropdowonAppearance(v: DropdownPanelAppearance) {\n        this._dropdownAppearance = v;\n    }\n    get dropdownAppearance(): DropdownPanelAppearance {\n        if (this._dropdownAppearance) return this._dropdownAppearance;\n        if (this.appearance == FormElementAppearance.Outlined) return DropdownPanelAppearance.Outlined;\n        return DropdownPanelAppearance.Raised;\n    }\n    private _dropdownVariant?: DropdownPanelVariant = undefined;\n    @Input()\n    set dropdowonVariant(v: DropdownPanelVariant) {\n        this._dropdownVariant = v;\n    }\n    get dropdownVariant(): DropdownPanelVariant {\n        if (this._dropdownVariant) return this._dropdownVariant;\n        if (this.variant == FormElementVariant.Pill) return DropdownPanelVariant.Rounded;\n        return this.variant;\n    }\n\n    //! class-based inputs\n    @Input() @HostBinding('class.ard-group-items') groupItems: boolean = false; //default value may be changed to \"true\" in ngOnChanges if this.groupBy is defined or this.itemsAlreadyGrouped is set to \"true\"\n\n    //! items setter/getter\n    @Input()\n    get items() {\n        return this._items;\n    }\n    set items(value: string | any[] | null) {\n        this.isItemsInputUsed = true;\n        if (value === null) {\n            value = [];\n            this.isItemsInputUsed = false;\n        } else if (isAnyString(value)) {\n            value = coerceArrayProperty(value);\n        }\n        let printErrors = this.itemStorage.setItems(value);\n        if (printErrors) {\n            this._printPrimitiveWarnings();\n        }\n    }\n\n    @ContentChildren(ArdiumOptionComponent)\n    optionComponents!: QueryList<ArdiumOptionComponent>;\n\n    private _setItemsFromComponents() {\n        const handleOptionChange = () => {\n            const changedOrDestroyed = merge(this.optionComponents.changes, this._destroy$);\n            merge(...this.optionComponents.map(option => option.stateChange$))\n                .pipe(takeUntil(changedOrDestroyed))\n                .subscribe(option => {\n                    setTimeout(() => {\n                        const item = this.itemStorage.findItemByValue(option.oldValue ?? option.value);\n                        if (item) {\n                            item.disabled = option.disabled;\n                            item.label = option.label || item.label;\n                            item.value = option.value;\n                            item.itemData.disabled = option.disabled;\n                            item.itemData.label = option.label || item.label;\n                            item.itemData.value = option.value;\n                        }\n                        this.detectChanges();\n                    }, 0);\n                });\n        };\n        this.optionComponents.changes\n            .pipe(startWith(this.optionComponents), takeUntil(this._destroy$))\n            .subscribe((options: QueryList<ArdiumOptionComponent>) => {\n                if (options.length == 0) return;\n                setTimeout(() => {\n                    this.items = options.map(option => ({\n                        value: option.value,\n                        label: option.label,\n                        disabled: option.disabled,\n                    }));\n                    handleOptionChange();\n                    this.detectChanges();\n                }, 0);\n            });\n    }\n\n    //! attribute and/or class setters/getters\n    private _multiselectable: boolean = false;\n    @Input()\n    @HostBinding('attr.multiple')\n    get multiselectable(): boolean {\n        return this._multiselectable;\n    }\n    set multiselectable(v: any) {\n        this._multiselectable = coerceBooleanProperty(v);\n    }\n    get singleselectable(): boolean {\n        return !this._multiselectable;\n    }\n\n    private _clearable: boolean = true;\n    @Input()\n    get clearable(): boolean {\n        return this._clearable;\n    }\n    set clearable(v: any) {\n        this._clearable = coerceBooleanProperty(v);\n    }\n\n    private _searchable: boolean = false;\n    @Input()\n    get searchable(): boolean {\n        return this._searchable;\n    }\n    set searchable(v: any) {\n        this._searchable = coerceBooleanProperty(v);\n    }\n\n    get filtered(): boolean {\n        return this._searchable && this.searchTerm != '';\n    }\n\n    private _touched: boolean = false;\n    get touched(): boolean {\n        return this._touched;\n    }\n    private set touched(state: boolean) {\n        this._touched = state;\n    }\n\n    //! custom options\n    private _defaultAddCustomFn: AddCustomFn<any> = (value: string) => value;\n    private _addCustom: false | AddCustomFn<any> | AddCustomFn<Promise<any>> = false;\n    @Input()\n    get addCustom(): false | AddCustomFn<any> | AddCustomFn<Promise<any>> {\n        return this._addCustom;\n    }\n    set addCustom(v: string | boolean | AddCustomFn<any> | AddCustomFn<Promise<any>>) {\n        if (isFunction(v)) {\n            this._addCustom = v;\n            return;\n        }\n        //coerce the value into a boolean\n        //if \"true\", use the default function. Otherwise, just set to \"false\".\n        this._addCustom = coerceBooleanProperty(v) && this._defaultAddCustomFn;\n    }\n\n    get shouldShowAddCustom(): boolean {\n        return this.addCustom != false && this.searchTerm.length > 0 && this.itemStorage.isNoItemsFound;\n    }\n\n    async addCustomOption(value: string) {\n        if (!this.addCustom) return;\n\n        const newOptionObj = await this.itemStorage.addCustomOption(value, this.addCustom);\n\n        this.selectItem(newOptionObj);\n    }\n\n    //! control value accessor\n    //override the writeValue and setDisabledState defined in _NgModelComponent\n    override setDisabledState(state: boolean): void {\n        this._disabled = state;\n        this._cd.markForCheck();\n    }\n    writeValue(ngModel: any[]): void {\n        this.itemStorage.handleWriteValue(ngModel);\n        this._cd.markForCheck();\n    }\n    //* change & touch event emitters\n    protected _emitChange(): void {\n        let value = this.itemStorage.value;\n        this._onChangeRegistered?.(value);\n        this.changeEvent.emit(value);\n        this.valueChange.emit(value);\n    }\n    private _onTouched(): void {\n        this.touched = true;\n        this._onTouchedRegistered?.();\n    }\n\n    //! value input & output\n    @Input()\n    set value(newValue: any) {\n        //if is a string, coerce it into array of strings\n        if (isAnyString(newValue)) newValue = coerceArrayProperty(newValue);\n        //if it is not a string and not an array, just put it in an array\n        else if (!isArray(newValue)) newValue = [newValue];\n\n        this.writeValue(newValue);\n    }\n    get value(): any[] {\n        return this.itemStorage.value;\n    }\n    @Output() valueChange = new EventEmitter<any[]>();\n\n    //! output events\n    @Output('change') changeEvent = new EventEmitter<any[]>();\n    @Output('add') addEvent = new EventEmitter<any[]>();\n    @Output('failedToAdd') failedToAddEvent = new EventEmitter<any[]>();\n    @Output('remove') removeEvent = new EventEmitter<any[]>();\n    @Output('clear') clearEvent = new EventEmitter<null>();\n    @Output('open') openEvent = new EventEmitter<null>();\n    @Output('close') closeEvent = new EventEmitter<null>();\n    @Output('scroll') scrollEvent = new EventEmitter<{\n        start: number;\n        end: number;\n    }>();\n    @Output('scrollToEnd') scrollToEndEvent = new EventEmitter();\n    @Output('search') searchEvent = new EventEmitter<{\n        search: string;\n        matching: any[];\n    }>();\n\n    @Input('isOpen')\n    isDropdownOpen!: boolean;\n    @Output('isOpenChange') isDropdownOpenChange = new EventEmitter<boolean>();\n\n    //! view children\n    @ViewChild('searchInput', { static: true })\n    searchInput!: ElementRef<HTMLInputElement>;\n    @ViewChild(forwardRef(() => ArdiumDropdownPanelComponent))\n    dropdownPanel!: ArdiumDropdownPanelComponent;\n\n    //! templates\n    @ContentChild(ArdOptionTemplateDirective, { read: TemplateRef })\n    optionTemplate?: TemplateRef<any>;\n    @ContentChild(ArdOptgroupTemplateDirective, { read: TemplateRef })\n    optgroupTemplate?: TemplateRef<any>;\n    @ContentChild(ArdValueTemplateDirective, { read: TemplateRef })\n    valueTemplate?: TemplateRef<any>;\n    @ContentChild(ArdSelectPlaceholderTemplateDirective, { read: TemplateRef })\n    placeholderTemplate?: TemplateRef<any>;\n    @ContentChild(ArdLoadingSpinnerTemplateDirective, { read: TemplateRef })\n    loadingSpinnerTemplate?: TemplateRef<any>;\n    @ContentChild(ArdLoadingPlaceholderTemplateDirective, { read: TemplateRef })\n    loadingPlaceholderTemplate?: TemplateRef<any>;\n    @ContentChild(ArdDropdownHeaderTemplateDirective, { read: TemplateRef })\n    dropdownHeaderTemplate?: TemplateRef<any>;\n    @ContentChild(ArdDropdownFooterTemplateDirective, { read: TemplateRef })\n    dropdownFooterTemplate?: TemplateRef<any>;\n    @ContentChild(ArdNoItemsFoundTemplateDirective, { read: TemplateRef })\n    noItemsFoundTemplate?: TemplateRef<any>;\n    @ContentChild(ArdAddCustomTemplateDirective, { read: TemplateRef })\n    addCustomTemplate?: TemplateRef<any>;\n    @ContentChild(ArdItemLimitReachedTemplateDirective, { read: TemplateRef })\n    itemLimitReachedTemplate?: TemplateRef<any>;\n    @ContentChild(ArdItemDisplayLimitTemplateDirective, { read: TemplateRef })\n    itemDisplayLimitTemplate?: TemplateRef<any>;\n\n    @ContentChild(ArdSelectPrefixTemplateDirective, { read: TemplateRef })\n    prefixTemplate?: TemplateRef<any>;\n    @ContentChild(ArdSelectSuffixTemplateDirective, { read: TemplateRef })\n    suffixTemplate?: TemplateRef<any>;\n\n    //! context providers\n    getValueContext(item: ArdOption): ValueContext {\n        const $this = this;\n        return {\n            $implicit: item,\n            item,\n            itemData: item.itemData,\n            unselect() {\n                $this.unselectItem(item);\n            },\n        };\n    }\n    getStatsContext(): StatsContext {\n        return {\n            totalItems: this.totalItems,\n            foundItems: this.foundItems,\n        };\n    }\n    getSearchContext(): SearchContext {\n        return {\n            $implicit: this.searchTerm,\n            searchTerm: this.searchTerm,\n            totalItems: this.totalItems,\n            foundItems: this.foundItems,\n        };\n    }\n    getPlaceholderContext(): PlaceholderContext {\n        const placeholder = this.placeholderForCurrentContext;\n        return {\n            placeholder,\n            $implicit: placeholder,\n        };\n    }\n    getCustomOptionContext(): CustomOptionContext {\n        return {\n            $implicit: this.searchTerm,\n            searchTerm: this.searchTerm,\n        };\n    }\n    getGroupContext(group: ArdOptionGroup): GroupContext {\n        return {\n            $implicit: group,\n            group,\n            selectedChildren: group.children.filter(v => v.selected).length,\n            totalChildren: group.children.length,\n        };\n    }\n    getOptionContext(item: ArdOption): OptionContext {\n        return {\n            $implicit: item,\n            item,\n            itemData: item.itemData,\n        };\n    }\n    getItemLimitContext(): ItemLimitContext {\n        return {\n            totalItems: this.totalItems,\n            selectedItems: this.itemStorage.selectedItems.length,\n            itemLimit: this.maxSelectedItems,\n        };\n    }\n    getItemDisplayLimitContext(): ItemDisplayLimitContext {\n        let selectedItems = this.itemStorage.selectedItems.length;\n        return {\n            totalItems: this.totalItems,\n            selectedItems,\n            itemLimit: this.maxSelectedItems,\n            overflowCount: selectedItems - (this.itemDisplayLimit ?? 0),\n        };\n    }\n\n    constructor(\n        _elementRef: ElementRef<HTMLElement>,\n        private _cd: ChangeDetectorRef,\n        private overlay: Overlay,\n        private viewContainerRef: ViewContainerRef,\n        private scrollStrategyOpts: ScrollStrategyOptions\n    ) {\n        super();\n        this.element = _elementRef.nativeElement;\n    }\n\n    //! dropdown overlay\n    @ViewChild('dropdownHost', { read: ElementRef })\n    dropdownHost!: ElementRef<HTMLDivElement>;\n    @ViewChild('dropdownTemplate', { read: TemplateRef })\n    dropdownTemplate!: TemplateRef<any>;\n\n    private dropdownOverlay?: OverlayRef;\n\n    private _createOverlay(): void {\n        const strategy = this.overlay\n            .position()\n            .flexibleConnectedTo(this.dropdownHost)\n            .withPositions([\n                {\n                    originX: 'start',\n                    originY: 'bottom',\n                    overlayX: 'start',\n                    overlayY: 'top',\n                },\n                {\n                    originX: 'start',\n                    originY: 'top',\n                    overlayX: 'start',\n                    overlayY: 'bottom',\n                },\n            ]);\n\n        const config = new OverlayConfig({\n            positionStrategy: strategy,\n            scrollStrategy: this.scrollStrategyOpts.block(),\n            hasBackdrop: false,\n        });\n\n        this.dropdownOverlay = this.overlay.create(config);\n\n        const portal = new TemplatePortal(this.dropdownTemplate, this.viewContainerRef);\n        this.dropdownOverlay.attach(portal);\n        this.setOverlaySize();\n    }\n    private _destroyOverlay(): void {\n        if (!this.dropdownOverlay) return;\n\n        this.dropdownOverlay.dispose();\n        delete this.dropdownOverlay;\n    }\n\n    setOverlaySize(): void {\n        if (!this.dropdownOverlay) return;\n\n        const rect = this.dropdownHost.nativeElement.getBoundingClientRect();\n        this.dropdownOverlay.updateSize({ width: rect.width });\n    }\n\n    @HostListener('window:resize')\n    onWindowResize(): void {\n        this.setOverlaySize();\n    }\n\n    //! hooks\n    ngOnInit(): void {\n        this._setSearchInputAttributes();\n    }\n    ngOnDestroy() {\n        this._destroy$.next();\n        this._destroy$.complete();\n    }\n    ngAfterViewInit(): void {\n        if (this.autoFocus) {\n            this.focus();\n        }\n    }\n    ngAfterContentInit(): void {\n        if (!this.isItemsInputUsed) {\n            this._setItemsFromComponents();\n        }\n    }\n    ngOnChanges(changes: SimpleChanges): void {\n        //fire items load handler when loading is set to false\n        if (changes['loading']) {\n            if (changes['loading'].currentValue == false) {\n                this._onItemsLoad();\n            }\n        }\n        //set groupItems to true by default if groupLabelFrom or itemsAlreadyGrouped is set to true as the first change\n        if ((changes['groupLabelFrom']?.firstChange || changes['itemsAlreadyGrouped']?.firstChange) && !changes['groupItems']) {\n            this.groupItems = true;\n        }\n    }\n    private _onItemsLoad() {\n        if (!this._searchBarFocused) return;\n        this.open();\n    }\n    private _printPrimitiveWarnings() {\n        function makeWarning(str: string): void {\n            console.warn(`Skipped using [${str}] property bound to <ard-select>, as some provided items are of primitive type`);\n        }\n        if (this.valueFrom) {\n            makeWarning('valueFrom');\n        }\n        if (this.labelFrom) {\n            makeWarning('labelFrom');\n        }\n        if (this.disabledFrom) {\n            makeWarning('disabledFrom');\n        }\n        if (this.groupLabelFrom) {\n            makeWarning('groupLabelFrom');\n        }\n        if (this.groupDisabledFrom) {\n            makeWarning('groupDisabledFrom');\n        }\n        if (this.childrenFrom) {\n            makeWarning('childrenFrom');\n        }\n        if (this.invertDisabled) {\n            makeWarning('invertDisabled');\n        }\n    }\n\n    //! getters\n    get firstHighlightedItem(): ArdOption | undefined {\n        return this.itemStorage.highlightedItems?.first();\n    }\n    get shouldDisplayPlaceholder(): boolean {\n        return !this.itemStorage.isAnyItemSelected && !this.searchTerm;\n    }\n    get shouldDisplayValue(): boolean {\n        return this.itemStorage.isAnyItemSelected && (!this.searchTerm || this.multiselectable);\n    }\n    get shouldShowClearButton(): boolean {\n        return this._clearable && !this._disabled && (this.itemStorage.isAnyItemSelected || this.searchTerm != '');\n    }\n    get itemsToDisplay(): IterableIterator<ArdOptionGroup> {\n        return this.itemStorage.groups.values();\n    }\n    get shouldShowNoItemsFound(): boolean {\n        return this.itemStorage.isNoItemsFound && !this.isLoading && !this.shouldShowAddCustom;\n    }\n    get totalItems(): number {\n        return this.itemStorage.items.length;\n    }\n    get foundItems(): number | undefined {\n        if (!this.searchable) return undefined;\n        return this.itemStorage.filteredItems.length;\n    }\n    get shouldShowItemDisplayLimit(): boolean {\n        return this.multiselectable && this.itemDisplayLimit != Infinity && this.itemStorage.selectedItems.length > this.itemDisplayLimit;\n    }\n    get isInputElementReadonly(): boolean {\n        return !this.addCustom && (!this.searchable || this.itemStorage.isItemLimitReached);\n    }\n    isValueWithinDisplayLimit(i: number): boolean {\n        return !this.multiselectable || this.itemDisplayLimit == Infinity || i < this.itemDisplayLimit;\n    }\n    get placeholderForCurrentContext(): string {\n        if (this.searchPlaceholder && this.searchable && (this._searchBarFocused || this._isClickedWithin)) return this.searchPlaceholder;\n        return this.placeholder;\n    }\n\n    //! search input event handlers\n    filter(filterTerm: string, suppressSearchEvent: boolean = false): void {\n        this.searchTerm = filterTerm;\n        let matching = this.itemStorage.filter(filterTerm);\n        if (!suppressSearchEvent) this.searchEvent.emit({ search: filterTerm, matching });\n        this.open();\n    }\n    onSearchInputFocus(event: FocusEvent): void {\n        this._searchBarFocused = true;\n    }\n    onSearchInputBlur(event: FocusEvent): void {\n        if (!this._searchBarFocused) return;\n\n        this._onTouched();\n\n        this._searchBarFocused = false;\n    }\n    //! item selection handlers\n    toggleItem(item: ArdOption): void {\n        if (item.selected) {\n            this.unselectItem(item);\n            return;\n        }\n        this.selectItem(item);\n    }\n    selectItem(...items: ArdOption[]): void {\n        let [selected, unselected, failedToSelect] = this.itemStorage.selectItem(...items);\n\n        if (unselected.length > 0) this.removeEvent.emit(unselected);\n\n        if (failedToSelect.length > 0) {\n            this.failedToAddEvent.emit(failedToSelect);\n        }\n\n        if (selected.length > 0) {\n            this.addEvent.emit(selected);\n            this._emitChange();\n\n            this.focus();\n            if (!this.keepSearchAfterSelect) this._clearSearch(true);\n\n            if (!this.keepOpen || this.itemStorage.isNoItemsToSelect) {\n                this.close();\n            }\n        }\n    }\n    unselectItem(...items: ArdOption[]): void {\n        let unselected = this.itemStorage.unselectItem(...items);\n\n        this.removeEvent.emit(unselected);\n        this._emitChange();\n        if (!this.keepSearchAfterSelect) this._clearSearch();\n\n        this.focus();\n\n        if (!this.keepOpen || this.itemStorage.isNoItemsToSelect) {\n            this.close();\n        }\n    }\n    private _clearAllItems(): void {\n        let cleared = this.itemStorage.clearAllSelected(true);\n\n        this.focus();\n\n        this.clearEvent.emit();\n        this.removeEvent.emit(cleared);\n        this._emitChange();\n    }\n    private _clearLastItem(): void {\n        let clearedValue = this.itemStorage.clearLastSelected().value;\n\n        this.focus();\n\n        this.removeEvent.emit([clearedValue]);\n        this._emitChange();\n    }\n    //! highligh-related\n    onMouseMove() {\n        this._isMouseBeingUsed = true;\n    }\n    onGroupMouseover(group: ArdOptionGroup): void {\n        if (!this.multiselectable || this.noGroupActions) return;\n        this.itemStorage.highlightGroup(group);\n    }\n    onItemMouseOver(event: MouseEvent): void {\n        event.stopPropagation();\n    }\n    onItemMouseEnter(option: ArdOption, event: MouseEvent): void {\n        if (!this._isMouseBeingUsed) return;\n        this.itemStorage.highlightSingleItem(option);\n        event.stopPropagation();\n    }\n    onItemMouseLeave(option: ArdOption, event: MouseEvent): void {\n        if (!this._isMouseBeingUsed) return;\n        this.itemStorage.unhighlightItem(option);\n        event.stopPropagation();\n    }\n    //! click handlers\n    private _isClickedWithin: boolean = false;\n    onItemClick(option: ArdOption, event: MouseEvent): void {\n        event.stopPropagation();\n        if (this.clearable) this.toggleItem(option);\n        else this.selectItem(option);\n\n        this._isClickedWithin = true;\n    }\n    onGroupClick(group: ArdOptionGroup): void {\n        if (!this.multiselectable || this.noGroupActions) return;\n        if (group.children.every(o => o.selected)) {\n            this.unselectItem(...group.children);\n            return;\n        }\n        this.selectItem(...group.children);\n\n        this._isClickedWithin = true;\n    }\n    handleClearButtonClick(event: MouseEvent): void {\n        event.stopPropagation();\n        if (this.searchTerm) {\n            this._clearSearch();\n            return;\n        }\n        this._clearAllItems();\n    }\n    handleDropdownArrowClick(event: MouseEvent): void {\n        event.stopPropagation();\n\n        this._isClickedWithin = true;\n\n        this.toggle();\n    }\n    handleOutsideClick(event: MouseEvent): void {\n        if (!this.isDropdownOpen) return;\n        const target = event.target as HTMLElement;\n        if (this.element.contains(target)) return;\n\n        this.close();\n    }\n    handleAnywhereClick(event: MouseEvent): void {\n        const target = event.target as HTMLElement;\n        if (target.tagName != 'INPUT') {\n            event.preventDefault();\n        }\n\n        this._isClickedWithin = true;\n\n        if (!this._searchBarFocused) {\n            this.focus();\n        }\n\n        if (this._searchable) {\n            this.open();\n        } else {\n            this.toggle();\n        }\n    }\n    @HostListener('mouseup')\n    onMouseup(): void {\n        this._isClickedWithin = false;\n    }\n    //! dropdown state handlers\n    toggle(): void {\n        if (this.isDropdownOpen) {\n            this.close();\n            return;\n        }\n        this.open();\n    }\n    open(): void {\n        if (this.disabled || this.isDropdownOpen) return;\n\n        this.isDropdownOpen = true;\n        if (this.autoHighlightFirst) this.itemStorage.highlightFirstItem();\n\n        this._createOverlay();\n        this.focus();\n\n        this.openEvent.emit();\n        this.isDropdownOpenChange.emit(this.isDropdownOpen);\n        this.detectChanges();\n    }\n    close(): void {\n        if (!this.isDropdownOpen) return;\n\n        this.isDropdownOpen = false;\n\n        this._destroyOverlay();\n\n        this._onTouched();\n        this.closeEvent.emit();\n        this.isDropdownOpenChange.emit(this.isDropdownOpen);\n        this._cd.markForCheck();\n    }\n    //! ChangeDetectorRef\n    detectChanges(): void {\n        if (!(<any>this._cd).destroyed) {\n            this._cd.detectChanges();\n        }\n    }\n    //! search\n    private _clearSearch(suppressSearchEvent: boolean = false): void {\n        this._setSearch('', suppressSearchEvent);\n    }\n    private _setSearch(searchTerm: string, suppressSearchEvent: boolean = false): void {\n        this.searchTerm = searchTerm;\n        this.filter(searchTerm, suppressSearchEvent);\n    }\n    private _setSearchInputAttributes() {\n        const input = this.searchInput.nativeElement;\n        const attributes: { [key: string]: string } = {\n            type: 'text',\n            autocorrect: 'off',\n            autocapitalize: 'off',\n            autocomplete: 'off',\n            ...this.inputAttrs,\n        };\n\n        for (const key of Object.keys(attributes)) {\n            input.setAttribute(key, attributes[key]);\n        }\n    }\n\n    //! key press handlers\n    @HostListener('keydown', ['$event'])\n    onKeyPress(event: KeyboardEvent): void {\n        switch (event.code) {\n            case 'Enter': {\n                this._onEnterPress(event);\n                return;\n            }\n            case 'Space': {\n                this._onSpacePress(event);\n                return;\n            }\n            case 'ArrowDown': {\n                this._onArrowDownPress(event);\n                return;\n            }\n            case 'ArrowUp': {\n                this._onArrowUpPress(event);\n                return;\n            }\n            case 'Home': {\n                this._onHomePress(event);\n                return;\n            }\n            case 'End': {\n                this._onEndPress(event);\n                return;\n            }\n            case 'Backspace':\n            case 'Delete': {\n                this._onBackspaceOrDeletePress(event);\n                return;\n            }\n            case 'KeyA': {\n                if (event.ctrlKey) {\n                    this._onCtrlAPress(event);\n                    return;\n                }\n            }\n        }\n    }\n    private async _onEnterPress(event: KeyboardEvent) {\n        event.preventDefault();\n        let shouldClose = true;\n\n        //select the currently highlighted option\n        if (this.isDropdownOpen && this.firstHighlightedItem) {\n            if (this.clearable && this.itemStorage.highlightedItems.every(item => item.selected)) {\n                this.unselectItem(...this.itemStorage.highlightedItems);\n            } else {\n                this.selectItem(...this.itemStorage.highlightedItems);\n            }\n        }\n        //add a custom option\n        else if (this.isDropdownOpen && this.shouldShowAddCustom) {\n            await this.addCustomOption(this.searchTerm);\n        }\n        //in case of no action, open the dropdown (or keep it open)\n        else shouldClose = false;\n\n        if (!this.keepOpen && shouldClose) {\n            this.itemStorage.clearAllHighlights();\n            this.close();\n        } else {\n            this.open();\n        }\n    }\n    private _onSpacePress(event: KeyboardEvent): void {\n        if (this.isDropdownOpen) return;\n\n        event.preventDefault();\n        this.open();\n    }\n    private _onArrowDownPress(event: KeyboardEvent): void {\n        event.preventDefault();\n        this.open();\n\n        this._isMouseBeingUsed = false;\n\n        const recentlyHighlighted = this.itemStorage.highlightNextItem(+1, event.shiftKey);\n        if (recentlyHighlighted) {\n            this.itemStorage.setRecentlyHighlighted(recentlyHighlighted);\n        }\n\n        this.dropdownPanel.scrollToRecentlyHighlighted('bottom');\n    }\n    private _onArrowUpPress(event: KeyboardEvent): void {\n        if (!this.isDropdownOpen) return;\n        event.preventDefault();\n\n        this._isMouseBeingUsed = false;\n\n        const recentlyHighlighted = this.itemStorage.highlightNextItem(-1, event.shiftKey);\n        if (recentlyHighlighted) {\n            this.itemStorage.setRecentlyHighlighted(recentlyHighlighted);\n        }\n\n        this.dropdownPanel.scrollToRecentlyHighlighted('top');\n    }\n    private _onHomePress(event: KeyboardEvent): void {\n        if (!this.isDropdownOpen || (this.searchInput.nativeElement.selectionEnd != 0 && this.searchInput.nativeElement.selectionStart != 0)) return;\n        event.preventDefault();\n\n        this._isMouseBeingUsed = false;\n\n        const recentlyHighlighted = this.itemStorage.highlightFirstItem();\n        if (!recentlyHighlighted) return;\n\n        this.itemStorage.setRecentlyHighlighted(recentlyHighlighted);\n        this.dropdownPanel.scrollToRecentlyHighlighted('top');\n    }\n    private _onEndPress(event: KeyboardEvent): void {\n        if (\n            !this.isDropdownOpen ||\n            (this.searchInput.nativeElement.selectionEnd != this.searchTerm.length && this.searchInput.nativeElement.selectionStart != this.searchTerm.length)\n        )\n            return;\n        event.preventDefault();\n\n        this._isMouseBeingUsed = false;\n\n        const recentlyHighlighted = this.itemStorage.highlightLastItem();\n        if (!recentlyHighlighted) return;\n\n        this.itemStorage.setRecentlyHighlighted(recentlyHighlighted);\n        this.dropdownPanel.scrollToRecentlyHighlighted('bottom');\n    }\n    private _onBackspaceOrDeletePress(event: KeyboardEvent): void {\n        if (this.searchTerm || !this._clearable || this.noBackspaceClear || !this.itemStorage.isAnyItemSelected) return;\n\n        event.preventDefault();\n        if (this.multiselectable && this.itemStorage.selectedItems.length > 1) {\n            this._clearLastItem();\n            return;\n        }\n        this._clearAllItems();\n    }\n    private _onCtrlAPress(event: KeyboardEvent): void {\n        this.itemStorage.highlightAllItems();\n    }\n}\n","<ard-form-field-frame\r\n    [appearance]=\"appearance\"\r\n    [variant]=\"variant\"\r\n    [compact]=\"compact\"\r\n    [isFocused]=\"isFocused\"\r\n    [prefixTemplate]=\"prefixTemplate\"\r\n    [suffixTemplate]=\"suffixTemplate\"\r\n>\r\n    <div class=\"ard-select\"\r\n        #dropdownHost\r\n        (click)=\"handleAnywhereClick($event)\"\r\n        [class.ard-has-value]=\"itemStorage.isAnyItemSelected\"\r\n        [ngClass]=\"ngClasses\"\r\n    >\r\n        <div class=\"ard-select-value-container\">\r\n            <ng-container *ngIf=\"shouldDisplayPlaceholder\">\r\n                <ng-template #defaultPlaceholderTemplate let-plhldr>\r\n                    <div class=\"ard-placeholder\">{{ plhldr }}</div>\r\n                </ng-template>\r\n\r\n                <ng-template\r\n                    [ngTemplateOutlet]=\"placeholderTemplate || defaultPlaceholderTemplate\"\r\n                    [ngTemplateOutletContext]=\"getPlaceholderContext()\"\r\n                ></ng-template>\r\n            </ng-container>\r\n\r\n            <ng-container *ngIf=\"shouldDisplayValue\">\r\n                <div class=\"ard-select-value\"\r\n                    *ngFor=\"let item of itemStorage.selectedItems; let i = index\"\r\n                    [class.ard-value-disabled]=\"item.disabled\"\r\n                    [attr.hidden]=\"!isValueWithinDisplayLimit(i) ? true : null\"\r\n                >\r\n                    <ng-template *ngIf=\"isValueWithinDisplayLimit(i)\"\r\n                        [ngTemplateOutlet]=\"valueTemplate || (multiselectable ? defaultMultiValueTemplate :  defaultValueTemplate)\"\r\n                        [ngTemplateOutletContext]=\"getValueContext(item)\"\r\n                    ></ng-template>\r\n                </div>\r\n\r\n                <ng-template #defaultValueTemplate let-item>\r\n                    <div [ardInnerHTML]=\"item.label\" [ardEscapeInnerHTML]=\"isItemsInputUsed\"></div>\r\n                </ng-template>\r\n                <ng-template #defaultMultiValueTemplate let-item let-unselect=\"unselect\">\r\n                    <ard-deletable-chip\r\n                        (delete)=\"unselect(item)\"\r\n                        [variant]=\"variant\"\r\n                        compact\r\n                        appearance=\"outlined-strong\"\r\n                    >\r\n                        <div [ardInnerHTML]=\"item.label\" [ardEscapeInnerHTML]=\"isItemsInputUsed\"></div>\r\n                    </ard-deletable-chip>\r\n                </ng-template>\r\n            </ng-container>\r\n\r\n            <ng-container *ngIf=\"itemStorage.isAnyItemSelected && shouldShowItemDisplayLimit\">\r\n                <div class=\"ard-overflow-indicator\">\r\n                    <ng-template\r\n                        [ngTemplateOutlet]=\"itemDisplayLimitTemplate || defaultItemDisplayLimitTemplate\"\r\n                        [ngTemplateOutletContext]=\"getItemDisplayLimitContext()\"\r\n                    ></ng-template>\r\n\r\n                    <ng-template #defaultItemDisplayLimitTemplate let-count=\"overflowCount\">\r\n                        <div>{{count}} more...</div>\r\n                    </ng-template>\r\n                </div>\r\n            </ng-container>\r\n            \r\n            <div class=\"ard-search-input\"\r\n                role=\"combobox\"\r\n                aria-haspopup=\"listbox\"\r\n                [attr.aria-expanded]=\"isDropdownOpen\"\r\n                [attr.aria-owns]=\"isDropdownOpen ? htmlId : null\"\r\n            >\r\n                <input #searchInput\r\n                    #focusableElement\r\n                    type=\"text\"\r\n                    [attr.id]=\"searchInputId\"\r\n                    [attr.tabindex]=\"tabIndex\"\r\n                    [readonly]=\"isInputElementReadonly\"\r\n                    [disabled]=\"disabled\"\r\n                    [value]=\"searchTerm\"\r\n                    aria-autocomplete=\"list\"\r\n                    [attr.aria-controls]=\"isDropdownOpen ? htmlId : null\"\r\n                    (input)=\"filter(searchInput.value)\"\r\n                    (change)=\"$event.stopPropagation()\"\r\n                    (focus)=\"onFocus($event)\"\r\n                    (focus)=\"onSearchInputFocus($event)\"\r\n                    (blur)=\"onBlur($event)\"\r\n                    (blur)=\"onSearchInputBlur($event)\"\r\n                >\r\n            </div>\r\n        </div>\r\n\r\n        <div class=\"ard-select-controls\">\r\n            <ng-container *ngIf=\"isLoading\">\r\n                <ng-template #defaultLoadingSpinnerTemplate>\r\n                    <div class=\"ard-simple-spinner\"></div>\r\n                </ng-template>\r\n\r\n                <ng-template [ngTemplateOutlet]=\"loadingSpinnerTemplate || defaultLoadingSpinnerTemplate\">\r\n                </ng-template>\r\n            </ng-container>\r\n\r\n            <ard-_clear-button *ngIf=\"shouldShowClearButton\"\r\n                [title]=\"clearButtonTitle\"\r\n                (click)=\"handleClearButtonClick($event)\"\r\n            ></ard-_clear-button>\r\n\r\n            <div class=\"ard-dropdown-arrow-wrapper\"\r\n                role=\"button\"\r\n                (click)=\"handleDropdownArrowClick($event)\"\r\n            >\r\n                <span class=\"ard-dropdown-arrow\"></span>\r\n                <div class=\"ard-hitbox\"></div>\r\n            </div>\r\n        </div>\r\n    </div>\r\n</ard-form-field-frame>\r\n\r\n\r\n<ng-template #dropdownTemplate>\r\n    <ard-dropdown-panel\r\n        class=\"ard-dropdown-panel ard-select-dropdown-panel\"\r\n        role=\"listbox\"\r\n        aria-label=\"Options list\"\r\n        [headerTemplate]=\"dropdownHeaderTemplate\"\r\n        [footerTemplate]=\"dropdownFooterTemplate\"\r\n        [appearance]=\"dropdownAppearance\"\r\n        [variant]=\"dropdownVariant\"\r\n        [isOpen]=\"true\"\r\n        [filterValue]=\"searchTerm\"\r\n        [panelId]=\"htmlId\"\r\n        [compact]=\"compact\"\r\n        (ardClickOutside)=\"handleOutsideClick($event)\"\r\n        (mousemove)=\"onMouseMove()\"\r\n        (scroll)=\"scrollEvent.emit($event)\"\r\n        (scrollToEnd)=\"scrollToEndEvent.emit($event)\"\r\n    >\r\n        <ng-container *ngIf=\"!shouldShowNoItemsFound\">\r\n            <div\r\n                class=\"ard-optgroup\"\r\n                role=\"group\"\r\n                *ngFor=\"let group of itemStorage.groups\"\r\n                [class.ard-group-disabled]=\"group.disabled\"\r\n                [class.ard-group-selected]=\"group.selected\"\r\n                [class.ard-group-highlighted]=\"group.highlighted\"\r\n                (mouseover)=\"onGroupMouseover(group)\"\r\n                (click)=\"onGroupClick(group)\"\r\n            >\r\n                <ng-container *ngIf=\"group.label !== '' && group.label !== undefined\">\r\n                    <ng-template #defaultOptgroupTemplate>\r\n                        <span class=\"ard-optgroup-label\" [ardInnerHTML]=\"group.label\" [ardEscapeInnerHTML]=\"isItemsInputUsed\"></span>\r\n                    </ng-template>\r\n\r\n                    <ng-template\r\n                        [ngTemplateOutlet]=\"optgroupTemplate || defaultOptgroupTemplate\"\r\n                        [ngTemplateOutletContext]=\"getGroupContext(group)\"\r\n                    ></ng-template>\r\n                </ng-container>\r\n\r\n                <div class=\"ard-optgroup-children\">\r\n                    <div\r\n                        class=\"ard-option\"\r\n                        role=\"option\"\r\n                        *ngFor=\"let option of group.children\"\r\n                        [class.ard-option-disabled]=\"option.disabled\"\r\n                        [class.ard-option-selected]=\"option.selected\"\r\n                        [class.ard-option-highlighted]=\"option.highlighted\"\r\n                        [class.ard-option-highlighted-recent]=\"option.highlighted_recently\"\r\n                        [attr.aria-selected]=\"option.selected\"\r\n                        [attr.id]=\"htmlId + '-' + option.index\"\r\n                        (click)=\"onItemClick(option, $event)\"\r\n                        (mouseover)=\"onItemMouseOver($event)\"\r\n                        (mouseenter)=\"onItemMouseEnter(option, $event)\"\r\n                        (mouseleave)=\"onItemMouseLeave(option, $event)\"\r\n                    >\r\n                        <div class=\"ard-option-label\">\r\n                            <ng-template #defaultOptionTemplate>\r\n                                <span [ardInnerHTML]=\"option.label\" [ardEscapeInnerHTML]=\"isItemsInputUsed\"></span>\r\n                            </ng-template>\r\n\r\n                            <ng-template\r\n                                [ngTemplateOutlet]=\"optionTemplate || defaultOptionTemplate\"\r\n                                [ngTemplateOutletContext]=\"getOptionContext(option)\"\r\n                            ></ng-template>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </ng-container>\r\n\r\n        <ng-container *ngIf=\"shouldShowNoItemsFound\">\r\n            <ng-template #defaultNoItemsFoundTemplate>\r\n                <div class=\"ard-option ard-option-disabled\">{{noItemsFoundText}}</div>\r\n            </ng-template>\r\n\r\n            <ng-template [ngTemplateOutlet]=\"noItemsFoundTemplate || defaultNoItemsFoundTemplate\"\r\n                [ngTemplateOutletContext]=\"getSearchContext()\">\r\n            </ng-template>\r\n        </ng-container>\r\n\r\n        <ng-container *ngIf=\"shouldShowAddCustom\">\r\n            <ng-template #defaultAddCustomTemplate let-searchTerm>\r\n                <div class=\"ard-option ard-option-highlighted ard-add-custom\" (click)=\"addCustomOption(searchTerm)\">\r\n                    <span class=\"ard-add-custom-label\">Add option</span>\r\n                    <span class=\"ard-add-custom-value\">\"{{searchTerm}}\"</span>\r\n                </div>\r\n            </ng-template>\r\n\r\n            <ng-template [ngTemplateOutlet]=\"addCustomTemplate || defaultAddCustomTemplate\"\r\n                [ngTemplateOutletContext]=\"getCustomOptionContext()\">\r\n            </ng-template>\r\n        </ng-container>\r\n\r\n        <ng-container *ngIf=\"isLoading\">\r\n            <ng-template #defaultLoadingPlaceholderTemplate>\r\n                <div class=\"ard-option ard-option-disabled\">{{loadingPlaceholderText}}</div>\r\n            </ng-template>\r\n\r\n            <ng-template [ngTemplateOutlet]=\"loadingPlaceholderTemplate || defaultLoadingPlaceholderTemplate\"\r\n                [ngTemplateOutletContext]=\"getSearchContext()\">\r\n            </ng-template>\r\n        </ng-container>\r\n    </ard-dropdown-panel>\r\n</ng-template>"]}