cmat 0.0.3

package/esm2022/components/select-search/select-search.component.mjs

@@ -0,0 +1,488 @@
+import { ChangeDetectionStrategy, Component, ElementRef, EventEmitter, forwardRef, Inject, Input, ViewChild, ContentChild, Optional, HostBinding, Output, ViewEncapsulation } from '@angular/core';
+import { FormControl, NG_VALUE_ACCESSOR, FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MatSelect } from '@angular/material/select';
+import { BehaviorSubject, combineLatest, of, Subject } from 'rxjs';
+import { delay, filter, map, startWith, switchMap, take, takeUntil, tap } from 'rxjs/operators';
+import { CmatSelectSearchClearDirective } from './select-search-clear.directive';
+import { MatOption, _countGroupLabelsBeforeOption } from '@angular/material/core';
+import { MatFormField, MatFormFieldModule } from '@angular/material/form-field';
+import { CmatSelectNoEntriesFoundDirective } from './select-no-entries-found.directive';
+import { configurableDefaultOptions, MAT_SELECTSEARCH_DEFAULT_OPTIONS } from './default-options';
+import { MatButtonModule } from '@angular/material/button';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { MatIconModule } from '@angular/material/icon';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { NgClass, NgIf, AsyncPipe } from '@angular/common';
+import { MatInputModule } from '@angular/material/input';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/scrolling";
+import * as i2 from "@angular/material/input";
+import * as i3 from "@angular/material/form-field";
+import * as i4 from "@angular/material/checkbox";
+import * as i5 from "@angular/material/tooltip";
+import * as i6 from "@angular/material/icon";
+import * as i7 from "@angular/forms";
+import * as i8 from "@angular/material/progress-spinner";
+import * as i9 from "@angular/material/button";
+import * as i10 from "@angular/material/select";
+import * as i11 from "@angular/material/core";
+const SELECT_PANEL_MAX_HEIGHT = 256;
+export class CmatSelectSearchComponent {
+    constructor(matSelect, _changeDetectorRef, _viewportRuler, _matOption = null, matFormField = null, _defaultOptions) {
+        this.matSelect = matSelect;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._viewportRuler = _viewportRuler;
+        this._matOption = _matOption;
+        this.matFormField = matFormField;
+        this._defaultOptions = _defaultOptions;
+        this.placeholderLabel = '查询';
+        this.type = 'text';
+        this.noEntriesFoundLabel = '无结果';
+        this.showNoFoundLabel = true;
+        this.indexAndLengthScreenReaderText = ' of ';
+        this.clearSearchInput = true;
+        this.searching = false;
+        this.disableInitialFocus = false;
+        this.enableClearOnEscapePressed = false;
+        this.preventHomeEndKeyPropagation = false;
+        this.disableScrollToActiveOnOptionsChanged = false;
+        this.ariaLabel = '下拉查询';
+        /** Whether to show Select All Checkbox (for mat-select[multi=true]) */
+        this.showToggleAllCheckbox = false;
+        /** select all checkbox checked state */
+        this.toggleAllCheckboxChecked = false;
+        /** select all checkbox indeterminate state */
+        this.toggleAllCheckboxIndeterminate = false;
+        this.toggleAllCheckboxTooltipMessage = '';
+        this.toggleAllCheckboxTooltipPosition = 'below';
+        this.hideClearSearchButton = false;
+        this.alwaysRestoreSelectedOptionsMulti = false;
+        /** Output emitter to send to parent component with the toggle all boolean */
+        this.toggleAll = new EventEmitter();
+        this.formControl = new FormControl('');
+        this._options$ = new BehaviorSubject(null);
+        this._optionsList$ = this._options$.pipe(switchMap(_options => _options ?
+            _options.changes.pipe(map(options => options.toArray()), startWith(_options.toArray())) : of(null)));
+        this._optionsLength$ = this._optionsList$.pipe(map(options => options ? options.length : 0));
+        this._onDestroy = new Subject();
+        /** whether to show the no entries found message */
+        // eslint-disable-next-line @typescript-eslint/member-ordering
+        this.showNoEntriesFound$ = combineLatest([
+            this.formControl.valueChanges,
+            this._optionsLength$
+        ]).pipe(map(([value, optionsLength]) => this.noEntriesFoundLabel && value
+            && optionsLength === this._getOptionsLengthOffset()));
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        this.onTouched = () => { };
+        this._applyDefaultOptions(this._defaultOptions);
+    }
+    get isInsideMatOption() {
+        return !!this._matOption;
+    }
+    get value() {
+        return this.formControl.value;
+    }
+    get _options() {
+        return this._options$.getValue();
+    }
+    set _options(_options) {
+        this._options$.next(_options);
+    }
+    ngOnInit() {
+        const panelClass = 'cmat-select-search-panel';
+        if (this.matSelect.panelClass) {
+            if (Array.isArray(this.matSelect.panelClass)) {
+                this.matSelect.panelClass.push(panelClass);
+            }
+            else if (typeof this.matSelect.panelClass === 'string') {
+                this.matSelect.panelClass = [this.matSelect.panelClass, panelClass];
+            }
+            else if (typeof this.matSelect.panelClass === 'object') {
+                this.matSelect.panelClass.entries[panelClass] = true;
+            }
+        }
+        else {
+            this.matSelect.panelClass = panelClass;
+        }
+        if (this._matOption) {
+            this._matOption.disabled = true;
+            this._matOption._getHostElement().classList.add('contains-cmat-select-search');
+            this._matOption._getHostElement().setAttribute('aria-hidden', 'true');
+        }
+        else {
+            console.error('<cmat-select-search> must be placed inside a <mat-option> element');
+        }
+        this.matSelect.openedChange
+            .pipe(delay(1), takeUntil(this._onDestroy))
+            .subscribe((opened) => {
+            if (opened) {
+                this.updateInputWidth();
+                if (!this.disableInitialFocus) {
+                    this.focus();
+                }
+            }
+            else {
+                if (this.clearSearchInput) {
+                    this.reset();
+                }
+            }
+        });
+        this.matSelect.openedChange
+            .pipe(take(1))
+            .pipe(takeUntil(this._onDestroy))
+            .subscribe(() => {
+            if (this.matSelect._keyManager) {
+                this.matSelect._keyManager.change.pipe(takeUntil(this._onDestroy))
+                    .subscribe(() => this._adjustScrollTopToFitActiveOptionIntoView());
+            }
+            else {
+                console.log('_keyManager was not initialized.');
+            }
+            this._options = this.matSelect.options;
+            let previousFirstOption = this._options.toArray()[this._getOptionsLengthOffset()];
+            this._options.changes
+                .pipe(takeUntil(this._onDestroy))
+                .subscribe(() => {
+                // avoid "expression has been changed" error
+                setTimeout(() => {
+                    if (this._options) {
+                        // Convert the QueryList to an array
+                        const options = this._options.toArray();
+                        // The true first item is offset by 1
+                        const currentFirstOption = options[this._getOptionsLengthOffset()];
+                        const keyManager = this.matSelect._keyManager;
+                        if (keyManager && this.matSelect.panelOpen) {
+                            // set first item active and input width
+                            // Check to see if the first option in these changes is different from the previous.
+                            const firstOptionIsChanged = !this.matSelect.compareWith(previousFirstOption, currentFirstOption);
+                            if (firstOptionIsChanged
+                                || !keyManager.activeItem
+                                || !options.find(option => this.matSelect.compareWith(option, keyManager.activeItem))) {
+                                keyManager.setFirstItemActive();
+                            }
+                            // wait for panel width changes
+                            setTimeout(() => {
+                                this.updateInputWidth();
+                            });
+                            if (!this.disableScrollToActiveOnOptionsChanged) {
+                                this._adjustScrollTopToFitActiveOptionIntoView();
+                            }
+                        }
+                        // Update our reference
+                        previousFirstOption = currentFirstOption;
+                    }
+                });
+            });
+        });
+        // add or remove css class depending on whether to show the no entries found message
+        // note: this is hacky
+        this.showNoEntriesFound$.pipe(takeUntil(this._onDestroy)).subscribe((showNoEntriesFound) => {
+            // set no entries found class on mat option
+            if (this._matOption) {
+                if (showNoEntriesFound) {
+                    this._matOption._getHostElement().classList.add('cmat-select-search-no-entries-found');
+                }
+                else {
+                    this._matOption._getHostElement().classList.remove('cmat-select-search-no-entries-found');
+                }
+            }
+        });
+        // resize the input width when the viewport is resized, i.e. the trigger width could potentially be resized
+        this._viewportRuler.change()
+            .pipe(takeUntil(this._onDestroy))
+            .subscribe(() => {
+            if (this.matSelect.panelOpen) {
+                this.updateInputWidth();
+            }
+        });
+        this._initMultipleHandling();
+        this._optionsList$.pipe(takeUntil(this._onDestroy)).subscribe(() => {
+            // update view when available options change
+            this._changeDetectorRef.markForCheck();
+        });
+    }
+    emitSelectAllBooleanToParent(state) {
+        this.toggleAll.emit(state);
+    }
+    ngOnDestroy() {
+        this._onDestroy.next(void 0);
+        this._onDestroy.complete();
+    }
+    isToggleAllCheckboxVisible() {
+        return this.matSelect.multiple && this.showToggleAllCheckbox;
+    }
+    handleKeydown(event) {
+        if ((event.key && event.key.length === 1) ||
+            (event.code === 'KeyA') || (event.code === 'KeyB') || (event.code === 'KeyC') || (event.code === 'KeyD') || (event.code === 'KeyE') || (event.code === 'KeyF')
+            || (event.code === 'KeyG') || (event.code === 'KeyH') || (event.code === 'KeyI') || (event.code === 'KeyJ') || (event.code === 'KeyK') || (event.code === 'KeyL')
+            || (event.code === 'KeyM') || (event.code === 'KeyN') || (event.code === 'KeyO') || (event.code === 'KeyP') || (event.code === 'KeyQ') || (event.code === 'KeyR')
+            || (event.code === 'KeyS') || (event.code === 'KeyT') || (event.code === 'KeyU') || (event.code === 'KeyV') || (event.code === 'KeyW')
+            || (event.code === 'KeyX') || (event.code === 'KeyY') || (event.code === 'KeyZ') || (event.code === 'Digit0') || (event.code === 'Digit1')
+            || (event.code === 'Digit2') || (event.code === 'Digit3') || (event.code === 'Digit4') || (event.code === 'Digit5') || (event.code === 'Digit6')
+            || (event.code === 'Digit7') || (event.code === 'Digit8') || (event.code === 'Digit9')
+            || (event.code === 'Space')
+            || (this.preventHomeEndKeyPropagation && (event.code === 'Home' || event.code === 'End'))) {
+            event.stopPropagation();
+        }
+        if (this.matSelect.multiple && event.key && event.code === 'Enter') {
+            // Regain focus after multiselect, so we can further type
+            setTimeout(() => this.focus());
+        }
+        // Special case if click Escape, if input is empty, close the dropdown, if not, empty out the search field
+        if (this.enableClearOnEscapePressed === true && event.code === 'Escape' && this.value) {
+            this.reset(true);
+            event.stopPropagation();
+        }
+    }
+    /**
+     * Handles the key up event with MatSelect.
+     * Allows e.g. the announcing of the currently activeDescendant by screen readers.
+     */
+    handleKeyup(event) {
+        if (event.code === 'ArrowUp' || event.code === 'ArrowDown') {
+            const ariaActiveDescendantId = this.matSelect._getAriaActiveDescendant();
+            const index = this._options?.toArray().findIndex(item => item.id === ariaActiveDescendantId);
+            if (index && index !== -1) {
+                this._unselectActiveDescendant();
+                this._activeDescendant = this._options?.toArray()[index]._getHostElement();
+                this._activeDescendant?.setAttribute('aria-selected', 'true');
+                this.searchSelectInput.nativeElement.setAttribute('aria-activedescendant', ariaActiveDescendantId);
+            }
+        }
+    }
+    writeValue(value) {
+        this._lastExternalInputValue = value;
+        this.formControl.setValue(value);
+        this._changeDetectorRef.markForCheck();
+    }
+    onBlur() {
+        this._unselectActiveDescendant();
+        this.onTouched();
+    }
+    registerOnChange(fn) {
+        this.formControl.valueChanges.pipe(filter(value => value !== this._lastExternalInputValue), tap(() => this._lastExternalInputValue = undefined), takeUntil(this._onDestroy)).subscribe(fn);
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    focus() {
+        if (!this.searchSelectInput || !this.matSelect.panel) {
+            return;
+        }
+        const panel = this.matSelect.panel.nativeElement;
+        const scrollTop = panel.scrollTop;
+        this.searchSelectInput.nativeElement.focus();
+        panel.scrollTop = scrollTop;
+    }
+    reset(focus) {
+        this.formControl.setValue('');
+        if (focus) {
+            this.focus();
+        }
+    }
+    updateInputWidth() {
+        if (!this.innerSelectSearch || !this.innerSelectSearch.nativeElement) {
+            return;
+        }
+        const element = this.innerSelectSearch.nativeElement;
+        let panelElement = void 0;
+        while (element === element.parentElement) {
+            if (element.classList.contains('mat-select-panel')) {
+                panelElement = element;
+                break;
+            }
+        }
+        if (panelElement) {
+            this.innerSelectSearch.nativeElement.style.width = panelElement.clientWidth + 'px';
+        }
+    }
+    _getMatOptionHeight() {
+        if (this.matSelect.options.length > 0) {
+            return this.matSelect.options.first._getHostElement().getBoundingClientRect().height;
+        }
+        return 0;
+    }
+    _getOptionsLengthOffset() {
+        if (this._matOption) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    }
+    _unselectActiveDescendant() {
+        this._activeDescendant?.removeAttribute('aria-selected');
+        this.searchSelectInput.nativeElement.removeAttribute('aria-activedescendant');
+    }
+    _applyDefaultOptions(defaultOptions) {
+        if (!defaultOptions) {
+            return;
+        }
+        for (const key of configurableDefaultOptions) {
+            if (Object.prototype.hasOwnProperty.call(defaultOptions, key)) {
+                this[key] = defaultOptions[key];
+            }
+        }
+    }
+    /*
+   * Initializes handling <mat-select [multiple]="true">
+   * Note: to improve this code, mat-select should be extended to allow disabling resetting the selection while filtering.
+   */
+    _initMultipleHandling() {
+        if (!this.matSelect.ngControl) {
+            if (this.matSelect.multiple) {
+                // note: the access to matSelect.ngControl (instead of matSelect.value / matSelect.valueChanges)
+                // is necessary to properly work in multi-selection mode.
+                console.error('the mat-select containing cmat-select-search must have a ngModel or formControl directive when multiple=true');
+            }
+            return;
+        }
+        // if <mat-select [multiple]="true">
+        // store previously selected values and restore them when they are deselected
+        // because the option is not available while we are currently filtering
+        this._previousSelectedValues = this.matSelect.ngControl.value;
+        this.matSelect.ngControl.valueChanges?.pipe(takeUntil(this._onDestroy))
+            .subscribe((values) => {
+            let restoreSelectedValues = false;
+            if (this.matSelect.multiple) {
+                if ((this.alwaysRestoreSelectedOptionsMulti || (this.formControl.value && this.formControl.value.length))
+                    && this._previousSelectedValues && Array.isArray(this._previousSelectedValues)) {
+                    if (!values || !Array.isArray(values)) {
+                        values = [];
+                    }
+                    const optionValues = this.matSelect.options.map(option => option.value);
+                    this._previousSelectedValues.forEach((previousValue) => {
+                        if (!values.some((v) => this.matSelect.compareWith(v, previousValue))
+                            && !optionValues.some(v => this.matSelect.compareWith(v, previousValue))) {
+                            // if a value that was selected before is deselected and not found in the options, it was deselected
+                            // due to the filtering, so we restore it.
+                            values.push(previousValue);
+                            restoreSelectedValues = true;
+                        }
+                    });
+                }
+            }
+            this._previousSelectedValues = values;
+            if (restoreSelectedValues) {
+                this.matSelect._onChange(values);
+            }
+        });
+    }
+    /**
+     * Scrolls the currently active option into the view if it is not yet visible.
+     */
+    _adjustScrollTopToFitActiveOptionIntoView() {
+        if (this.matSelect.panel && this.matSelect.options.length > 0) {
+            const matOptionHeight = this._getMatOptionHeight();
+            const activeOptionIndex = this.matSelect._keyManager.activeItemIndex || 0;
+            const labelCount = _countGroupLabelsBeforeOption(activeOptionIndex, this.matSelect.options, this.matSelect.optionGroups);
+            // If the component is in a MatOption, the activeItemIndex will be offset by one.
+            const indexOfOptionToFitIntoView = (this._matOption ? -1 : 0) + labelCount + activeOptionIndex;
+            const currentScrollTop = this.matSelect.panel.nativeElement.scrollTop;
+            const searchInputHeight = this.innerSelectSearch.nativeElement.offsetHeight;
+            const amountOfVisibleOptions = Math.floor((SELECT_PANEL_MAX_HEIGHT - searchInputHeight) / matOptionHeight);
+            const indexOfFirstVisibleOption = Math.round((currentScrollTop + searchInputHeight) / matOptionHeight) - 1;
+            if (indexOfFirstVisibleOption >= indexOfOptionToFitIntoView) {
+                this.matSelect.panel.nativeElement.scrollTop = indexOfOptionToFitIntoView * matOptionHeight;
+            }
+            else if (indexOfFirstVisibleOption + amountOfVisibleOptions <= indexOfOptionToFitIntoView) {
+                this.matSelect.panel.nativeElement.scrollTop = (indexOfOptionToFitIntoView + 1) * matOptionHeight
+                    - (SELECT_PANEL_MAX_HEIGHT - searchInputHeight);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatSelectSearchComponent, deps: [{ token: MatSelect }, { token: i0.ChangeDetectorRef }, { token: i1.ViewportRuler }, { token: MatOption, optional: true }, { token: MatFormField, optional: true }, { token: MAT_SELECTSEARCH_DEFAULT_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.0", type: CmatSelectSearchComponent, isStandalone: true, selector: "cmat-select-search", inputs: { placeholderLabel: "placeholderLabel", type: "type", noEntriesFoundLabel: "noEntriesFoundLabel", showNoFoundLabel: "showNoFoundLabel", indexAndLengthScreenReaderText: "indexAndLengthScreenReaderText", clearSearchInput: "clearSearchInput", searching: "searching", disableInitialFocus: "disableInitialFocus", enableClearOnEscapePressed: "enableClearOnEscapePressed", preventHomeEndKeyPropagation: "preventHomeEndKeyPropagation", disableScrollToActiveOnOptionsChanged: "disableScrollToActiveOnOptionsChanged", ariaLabel: "ariaLabel", showToggleAllCheckbox: "showToggleAllCheckbox", toggleAllCheckboxChecked: "toggleAllCheckboxChecked", toggleAllCheckboxIndeterminate: "toggleAllCheckboxIndeterminate", toggleAllCheckboxTooltipMessage: "toggleAllCheckboxTooltipMessage", toggleAllCheckboxTooltipPosition: "toggleAllCheckboxTooltipPosition", hideClearSearchButton: "hideClearSearchButton", alwaysRestoreSelectedOptionsMulti: "alwaysRestoreSelectedOptionsMulti" }, outputs: { toggleAll: "toggleAll" }, host: { properties: { "class.cmat-select-search-inside-mat-option": "this.isInsideMatOption" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => CmatSelectSearchComponent),
+                multi: true
+            }
+        ], queries: [{ propertyName: "clearIcon", first: true, predicate: CmatSelectSearchClearDirective, descendants: true }, { propertyName: "noEntriesFound", first: true, predicate: CmatSelectNoEntriesFoundDirective, descendants: true }], viewQueries: [{ propertyName: "searchSelectInput", first: true, predicate: ["searchSelectInput"], descendants: true, read: ElementRef, static: true }, { propertyName: "innerSelectSearch", first: true, predicate: ["innerSelectSearch"], descendants: true, read: ElementRef, static: true }], exportAs: ["cmatSelectSearch"], ngImport: i0, template: "<input matInput class=\"cmat-select-search-input cmat-select-search-hidden\" />\r\n\r\n<div #innerSelectSearch class=\"cmat-select-search-inner mat-typography mat-tab-header\"\r\n  [ngClass]=\"{'cmat-select-search-inner-multiple': matSelect.multiple, 'cmat-select-search-inner-toggle-all': isToggleAllCheckboxVisible() }\">\r\n\r\n  <mat-checkbox *ngIf=\"isToggleAllCheckboxVisible()\" [color]=\"matFormField?.color\"\r\n    class=\"cmat-select-search-toggle-all-checkbox\" [checked]=\"toggleAllCheckboxChecked\"\r\n    [indeterminate]=\"toggleAllCheckboxIndeterminate\" [matTooltip]=\"toggleAllCheckboxTooltipMessage\"\r\n    matTooltipClass=\"cmat-select-search-toggle-all-tooltip\" [matTooltipPosition]=\"toggleAllCheckboxTooltipPosition\"\r\n    (change)=\"emitSelectAllBooleanToParent($event.checked)\">\r\n  </mat-checkbox>\r\n  <span matPrefix class=\"flex flex-col justify-center pl-2\">\r\n    <mat-icon class=\"cmat-select-search-icon\" color=\"primary\" svgIcon=\"heroicons_solid:magnifying-glass\"></mat-icon>\r\n  </span>\r\n  <input matInput class=\"cmat-select-search-input cmat-input-element\" autocomplete=\"off\" [type]=\"type\"\r\n    [formControl]=\"formControl\" #searchSelectInput (keydown)=\"handleKeydown($event)\" (keyup)=\"handleKeyup($event)\"\r\n    (blur)=\"onBlur()\" [placeholder]=\"placeholderLabel\" [attr.aria-label]=\"ariaLabel\" />\r\n  <mat-spinner *ngIf=\"searching\" class=\"cmat-select-search-spinner\" diameter=\"16\"></mat-spinner>\r\n\r\n  <button type=\"button\" *ngIf=\"!hideClearSearchButton && value && !searching\" mat-icon-button aria-label=\"Clear\"\r\n    (click)=\"reset(true)\" class=\"cmat-select-search-clear\">\r\n    <ng-content *ngIf=\"clearIcon; else defaultIcon\" select=\"[cmatSelectSearchClear]\"></ng-content>\r\n    <ng-template #defaultIcon>\r\n      <mat-icon svgIcon=\"mat_outline:close\"></mat-icon>\r\n    </ng-template>\r\n  </button>\r\n\r\n  <ng-content select=\".cmat-select-search-custom-header-content\"></ng-content>\r\n</div>\r\n\r\n<div *ngIf=\"showNoEntriesFound$ | async\" class=\"cmat-select-search-no-entries-found\">\r\n  <ng-content *ngIf=\"noEntriesFound; else defaultNoEntriesFound\" select=\"[cmatSelectNoEntriesFound]\"></ng-content>\r\n  <ng-template #defaultNoEntriesFound>{{noEntriesFoundLabel}}</ng-template>\r\n</div>", styles: ["cmat-select-search .cmat-select-search-hidden{visibility:hidden}cmat-select-search .cmat-select-search-inner{position:absolute;top:0;left:0;width:100%;z-index:100;font-size:inherit;box-shadow:none;display:flex;border-bottom-width:1px;border-bottom-style:solid}cmat-select-search .cmat-select-search-inner.cmat-select-search-inner-multiple.cmat-select-search-inner-toggle-all{display:flex;align-items:center}cmat-select-search .cmat-select-search-inner .cmat-input-element{flex-basis:auto;vertical-align:middle!important}cmat-select-search .cmat-select-search-input{box-sizing:border-box;width:100%;border:none;font-family:inherit;font-size:inherit;color:currentColor;outline:none;background:none;padding:0 44px 0 16px;height:47px;line-height:47px}:host-context([dir=rtl]) cmat-select-search .cmat-select-search-input{padding-right:16px;padding-left:44px}cmat-select-search .cmat-select-search-no-entries-found{padding-top:8px}cmat-select-search .cmat-select-search-clear{position:absolute;right:4px;top:5px}:host-context([dir=rtl]) cmat-select-search .cmat-select-search-clear{right:auto;left:4px}cmat-select-search .cmat-select-search-spinner{position:absolute;right:16px;top:calc(50% - 8px)}:host-context([dir=rtl]) cmat-select-search .cmat-select-search-spinner{right:auto;left:16px}cmat-select-search .cmat-select-search-toggle-all-checkbox{padding-left:5px;padding-bottom:2px}:host-context([dir=rtl]) cmat-select-search .cmat-select-search-toggle-all-checkbox{padding-left:0;padding-right:5px}.mat-mdc-option[aria-disabled=true].contains-cmat-select-search{position:sticky;top:0;z-index:1;opacity:1;pointer-events:all;background:var(--mat-select-panel-background-color)}.mat-mdc-option[aria-disabled=true].contains-cmat-select-search .mat-icon{margin-right:0;margin-left:0}.mat-mdc-option[aria-disabled=true].contains-cmat-select-search mat-pseudo-checkbox{display:none}.mat-mdc-option[aria-disabled=true].contains-cmat-select-search .mdc-list-item__primary-text{opacity:1}.mat-mdc-option[aria-disabled=true].contains-cmat-select-search.cmat-select-search-no-entries-found{height:96px}.cmat-select-search-panel{transform:none!important;overflow-x:hidden;position:relative;padding:0!important}\n"], dependencies: [{ kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i2.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "directive", type: i3.MatPrefix, selector: "[matPrefix], [matIconPrefix], [matTextPrefix]", inputs: ["matTextPrefix"] }, { kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatCheckboxModule }, { kind: "component", type: i4.MatCheckbox, selector: "mat-checkbox", inputs: ["aria-label", "aria-labelledby", "aria-describedby", "id", "required", "labelPosition", "name", "value", "disableRipple", "tabIndex", "color", "checked", "disabled", "indeterminate"], outputs: ["change", "indeterminateChange"], exportAs: ["matCheckbox"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i5.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i6.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i7.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i7.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i7.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: MatProgressSpinnerModule }, { kind: "component", type: i8.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "mode", "value", "diameter", "strokeWidth"], exportAs: ["matProgressSpinner"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i9.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "pipe", type: AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatSelectSearchComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cmat-select-search', providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => CmatSelectSearchComponent),
+                            multi: true
+                        }
+                    ], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, exportAs: 'cmatSelectSearch', imports: [MatInputModule, NgClass, NgIf, MatCheckboxModule, MatTooltipModule, MatFormFieldModule,
+                        MatIconModule, FormsModule, ReactiveFormsModule, MatProgressSpinnerModule, MatButtonModule, AsyncPipe], template: "<input matInput class=\"cmat-select-search-input cmat-select-search-hidden\" />\r\n\r\n<div #innerSelectSearch class=\"cmat-select-search-inner mat-typography mat-tab-header\"\r\n  [ngClass]=\"{'cmat-select-search-inner-multiple': matSelect.multiple, 'cmat-select-search-inner-toggle-all': isToggleAllCheckboxVisible() }\">\r\n\r\n  <mat-checkbox *ngIf=\"isToggleAllCheckboxVisible()\" [color]=\"matFormField?.color\"\r\n    class=\"cmat-select-search-toggle-all-checkbox\" [checked]=\"toggleAllCheckboxChecked\"\r\n    [indeterminate]=\"toggleAllCheckboxIndeterminate\" [matTooltip]=\"toggleAllCheckboxTooltipMessage\"\r\n    matTooltipClass=\"cmat-select-search-toggle-all-tooltip\" [matTooltipPosition]=\"toggleAllCheckboxTooltipPosition\"\r\n    (change)=\"emitSelectAllBooleanToParent($event.checked)\">\r\n  </mat-checkbox>\r\n  <span matPrefix class=\"flex flex-col justify-center pl-2\">\r\n    <mat-icon class=\"cmat-select-search-icon\" color=\"primary\" svgIcon=\"heroicons_solid:magnifying-glass\"></mat-icon>\r\n  </span>\r\n  <input matInput class=\"cmat-select-search-input cmat-input-element\" autocomplete=\"off\" [type]=\"type\"\r\n    [formControl]=\"formControl\" #searchSelectInput (keydown)=\"handleKeydown($event)\" (keyup)=\"handleKeyup($event)\"\r\n    (blur)=\"onBlur()\" [placeholder]=\"placeholderLabel\" [attr.aria-label]=\"ariaLabel\" />\r\n  <mat-spinner *ngIf=\"searching\" class=\"cmat-select-search-spinner\" diameter=\"16\"></mat-spinner>\r\n\r\n  <button type=\"button\" *ngIf=\"!hideClearSearchButton && value && !searching\" mat-icon-button aria-label=\"Clear\"\r\n    (click)=\"reset(true)\" class=\"cmat-select-search-clear\">\r\n    <ng-content *ngIf=\"clearIcon; else defaultIcon\" select=\"[cmatSelectSearchClear]\"></ng-content>\r\n    <ng-template #defaultIcon>\r\n      <mat-icon svgIcon=\"mat_outline:close\"></mat-icon>\r\n    </ng-template>\r\n  </button>\r\n\r\n  <ng-content select=\".cmat-select-search-custom-header-content\"></ng-content>\r\n</div>\r\n\r\n<div *ngIf=\"showNoEntriesFound$ | async\" class=\"cmat-select-search-no-entries-found\">\r\n  <ng-content *ngIf=\"noEntriesFound; else defaultNoEntriesFound\" select=\"[cmatSelectNoEntriesFound]\"></ng-content>\r\n  <ng-template #defaultNoEntriesFound>{{noEntriesFoundLabel}}</ng-template>\r\n</div>", styles: ["cmat-select-search .cmat-select-search-hidden{visibility:hidden}cmat-select-search .cmat-select-search-inner{position:absolute;top:0;left:0;width:100%;z-index:100;font-size:inherit;box-shadow:none;display:flex;border-bottom-width:1px;border-bottom-style:solid}cmat-select-search .cmat-select-search-inner.cmat-select-search-inner-multiple.cmat-select-search-inner-toggle-all{display:flex;align-items:center}cmat-select-search .cmat-select-search-inner .cmat-input-element{flex-basis:auto;vertical-align:middle!important}cmat-select-search .cmat-select-search-input{box-sizing:border-box;width:100%;border:none;font-family:inherit;font-size:inherit;color:currentColor;outline:none;background:none;padding:0 44px 0 16px;height:47px;line-height:47px}:host-context([dir=rtl]) cmat-select-search .cmat-select-search-input{padding-right:16px;padding-left:44px}cmat-select-search .cmat-select-search-no-entries-found{padding-top:8px}cmat-select-search .cmat-select-search-clear{position:absolute;right:4px;top:5px}:host-context([dir=rtl]) cmat-select-search .cmat-select-search-clear{right:auto;left:4px}cmat-select-search .cmat-select-search-spinner{position:absolute;right:16px;top:calc(50% - 8px)}:host-context([dir=rtl]) cmat-select-search .cmat-select-search-spinner{right:auto;left:16px}cmat-select-search .cmat-select-search-toggle-all-checkbox{padding-left:5px;padding-bottom:2px}:host-context([dir=rtl]) cmat-select-search .cmat-select-search-toggle-all-checkbox{padding-left:0;padding-right:5px}.mat-mdc-option[aria-disabled=true].contains-cmat-select-search{position:sticky;top:0;z-index:1;opacity:1;pointer-events:all;background:var(--mat-select-panel-background-color)}.mat-mdc-option[aria-disabled=true].contains-cmat-select-search .mat-icon{margin-right:0;margin-left:0}.mat-mdc-option[aria-disabled=true].contains-cmat-select-search mat-pseudo-checkbox{display:none}.mat-mdc-option[aria-disabled=true].contains-cmat-select-search .mdc-list-item__primary-text{opacity:1}.mat-mdc-option[aria-disabled=true].contains-cmat-select-search.cmat-select-search-no-entries-found{height:96px}.cmat-select-search-panel{transform:none!important;overflow-x:hidden;position:relative;padding:0!important}\n"] }]
+        }], ctorParameters: () => [{ type: i10.MatSelect, decorators: [{
+                    type: Inject,
+                    args: [MatSelect]
+                }] }, { type: i0.ChangeDetectorRef }, { type: i1.ViewportRuler }, { type: i11.MatOption, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MatOption]
+                }] }, { type: i3.MatFormField, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MatFormField]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MAT_SELECTSEARCH_DEFAULT_OPTIONS]
+                }] }], propDecorators: { placeholderLabel: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], noEntriesFoundLabel: [{
+                type: Input
+            }], showNoFoundLabel: [{
+                type: Input
+            }], indexAndLengthScreenReaderText: [{
+                type: Input
+            }], clearSearchInput: [{
+                type: Input
+            }], searching: [{
+                type: Input
+            }], disableInitialFocus: [{
+                type: Input
+            }], enableClearOnEscapePressed: [{
+                type: Input
+            }], preventHomeEndKeyPropagation: [{
+                type: Input
+            }], disableScrollToActiveOnOptionsChanged: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], showToggleAllCheckbox: [{
+                type: Input
+            }], toggleAllCheckboxChecked: [{
+                type: Input
+            }], toggleAllCheckboxIndeterminate: [{
+                type: Input
+            }], toggleAllCheckboxTooltipMessage: [{
+                type: Input
+            }], toggleAllCheckboxTooltipPosition: [{
+                type: Input
+            }], hideClearSearchButton: [{
+                type: Input
+            }], alwaysRestoreSelectedOptionsMulti: [{
+                type: Input
+            }], toggleAll: [{
+                type: Output
+            }], searchSelectInput: [{
+                type: ViewChild,
+                args: ['searchSelectInput', { read: ElementRef, static: true }]
+            }], innerSelectSearch: [{
+                type: ViewChild,
+                args: ['innerSelectSearch', { read: ElementRef, static: true }]
+            }], clearIcon: [{
+                type: ContentChild,
+                args: [CmatSelectSearchClearDirective, { static: false }]
+            }], noEntriesFound: [{
+                type: ContentChild,
+                args: [CmatSelectNoEntriesFoundDirective]
+            }], isInsideMatOption: [{
+                type: HostBinding,
+                args: ['class.cmat-select-search-inside-mat-option']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select-search.component.js","sourceRoot":"","sources":["../../../../../projects/cmat/components/select-search/select-search.component.ts","../../../../../projects/cmat/components/select-search/select-search.component.html"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAC9D,SAAS,EACT,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,EAAE,iBAAiB,EAC/D,MAAM,eAAe,CAAC;AACvB,OAAO,EAAwB,WAAW,EAAE,iBAAiB,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACxH,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAErD,OAAO,EAAE,eAAe,EAAE,aAAa,EAAc,EAAE,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/E,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAEhG,OAAO,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAE,SAAS,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAClF,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAChF,OAAO,EAAE,iCAAiC,EAAE,MAAM,qCAAqC,CAAC;AACxF,OAAO,EAAE,0BAA0B,EAA0B,gCAAgC,EAAE,MAAM,mBAAmB,CAAC;AACzH,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,wBAAwB,EAAE,MAAM,oCAAoC,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;;;;;;;;;;;;;AAEzD,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAoBpC,MAAM,OAAO,yBAAyB;IA0EpC,YAAyC,SAAoB,EACnD,kBAAqC,EACrC,cAA6B,EACE,aAA+B,IAAI,EAC9B,eAAoC,IAAI,EACtB,eAAwC;QAL/D,cAAS,GAAT,SAAS,CAAW;QACnD,uBAAkB,GAAlB,kBAAkB,CAAmB;QACrC,mBAAc,GAAd,cAAc,CAAe;QACE,eAAU,GAAV,UAAU,CAAyB;QAC9B,iBAAY,GAAZ,YAAY,CAA4B;QACtB,oBAAe,GAAf,eAAe,CAAyB;QA7E/F,qBAAgB,GAAG,IAAI,CAAC;QAExB,SAAI,GAAG,MAAM,CAAC;QAEd,wBAAmB,GAAG,KAAK,CAAC;QAE5B,qBAAgB,GAAG,IAAI,CAAC;QAExB,mCAA8B,GAAG,MAAM,CAAC;QAExC,qBAAgB,GAAG,IAAI,CAAC;QAExB,cAAS,GAAG,KAAK,CAAC;QAElB,wBAAmB,GAAG,KAAK,CAAC;QAE5B,+BAA0B,GAAG,KAAK,CAAC;QAEnC,iCAA4B,GAAG,KAAK,CAAC;QAErC,0CAAqC,GAAG,KAAK,CAAC;QAE9C,cAAS,GAAG,MAAM,CAAC;QAE5B,uEAAuE;QAC9D,0BAAqB,GAAG,KAAK,CAAC;QAEvC,wCAAwC;QAC/B,6BAAwB,GAAG,KAAK,CAAC;QAE1C,8CAA8C;QACrC,mCAA8B,GAAG,KAAK,CAAC;QAEvC,oCAA+B,GAAG,EAAE,CAAC;QAErC,qCAAgC,GAA8D,OAAO,CAAC;QAEtG,0BAAqB,GAAG,KAAK,CAAC;QAE9B,sCAAiC,GAAG,KAAK,CAAC;QAEnD,6EAA6E;QACnE,cAAS,GAAG,IAAI,YAAY,EAAW,CAAC;QAOlD,gBAAW,GAAgB,IAAI,WAAW,CAAC,EAAE,CAAC,CAAC;QAEvC,cAAS,GAAiD,IAAI,eAAe,CAA8B,IAAI,CAAC,CAAC;QAGjH,kBAAa,GAAmC,IAAI,CAAC,SAAS,CAAC,IAAI,CACzE,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;YAC9B,QAAQ,CAAC,OAAO,CAAC,IAAI,CACnB,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,EACjC,SAAS,CAAc,QAAQ,CAAC,OAAO,EAAE,CAAC,CAC3C,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CACb,CACF,CAAC;QAEM,oBAAe,GAAuB,IAAI,CAAC,aAAa,CAAC,IAAI,CACnE,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAC7C,CAAC;QAGM,eAAU,GAAG,IAAI,OAAO,EAAQ,CAAC;QAczC,mDAAmD;QACnD,8DAA8D;QAC9D,wBAAmB,GAAwB,aAAa,CAAC;YACvD,IAAI,CAAC,WAAW,CAAC,YAAY;YAC7B,IAAI,CAAC,eAAe;SACrB,CAAC,CAAC,IAAI,CACL,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,aAAa,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,mBAAmB,IAAI,KAAK;eAC5D,aAAa,KAAK,IAAI,CAAC,uBAAuB,EAAE,CAAC,CACvD,CAAC;QAkBF,gEAAgE;QAChE,cAAS,GAAc,GAAG,EAAE,GAAG,CAAC,CAAC;QA9B/B,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IAClD,CAAC;IAYD,IACI,iBAAiB;QACnB,OAAO,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC;IAChC,CAAC;IAED,IAAW,QAAQ;QACjB,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IACnC,CAAC;IACD,IAAW,QAAQ,CAAC,QAA8B;QAChD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAChC,CAAC;IAKD,QAAQ;QACN,MAAM,UAAU,GAAG,0BAA0B,CAAC;QAC9C,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE;YAC7B,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE;gBAC3C,IAAI,CAAC,SAAS,CAAC,UAAuB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAC1D;iBAAM,IAAI,OAAO,IAAI,CAAC,SAAS,CAAC,UAAU,KAAK,QAAQ,EAAE;gBACxD,IAAI,CAAC,SAAS,CAAC,UAAU,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;aACrE;iBAAM,IAAI,OAAO,IAAI,CAAC,SAAS,CAAC,UAAU,KAAK,QAAQ,EAAE;gBACxD,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;aACtD;SACF;aAAM;YACL,IAAI,CAAC,SAAS,CAAC,UAAU,GAAG,UAAU,CAAC;SACxC;QAED,IAAI,IAAI,CAAC,UAAU,EAAE;YACnB,IAAI,CAAC,UAAU,CAAC,QAAQ,GAAG,IAAI,CAAC;YAChC,IAAI,CAAC,UAAU,CAAC,eAAe,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,6BAA6B,CAAC,CAAC;YAC/E,IAAI,CAAC,UAAU,CAAC,eAAe,EAAE,CAAC,YAAY,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;SACvE;aAAM;YACL,OAAO,CAAC,KAAK,CAAC,mEAAmE,CAAC,CAAC;SACpF;QAGD,IAAI,CAAC,SAAS,CAAC,YAAY;aACxB,IAAI,CACH,KAAK,CAAC,CAAC,CAAC,EACR,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAC3B;aACA,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;YACpB,IAAI,MAAM,EAAE;gBACV,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBACxB,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE;oBAC7B,IAAI,CAAC,KAAK,EAAE,CAAC;iBACd;aACF;iBAAM;gBACL,IAAI,IAAI,CAAC,gBAAgB,EAAE;oBACzB,IAAI,CAAC,KAAK,EAAE,CAAC;iBACd;aACF;QACH,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,SAAS,CAAC,YAAY;aACxB,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACb,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAChC,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE;gBAC9B,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;qBAC/D,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,yCAAyC,EAAE,CAAC,CAAC;aACtE;iBAAM;gBACL,OAAO,CAAC,GAAG,CAAC,kCAAkC,CAAC,CAAC;aACjD;YAED,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;YACvC,IAAI,mBAAmB,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;YAElF,IAAI,CAAC,QAAQ,CAAC,OAAO;iBAClB,IAAI,CACH,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAC3B;iBACA,SAAS,CAAC,GAAG,EAAE;gBACd,4CAA4C;gBAC5C,UAAU,CAAC,GAAG,EAAE;oBACd,IAAI,IAAI,CAAC,QAAQ,EAAE;wBACjB,oCAAoC;wBACpC,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;wBAExC,qCAAqC;wBACrC,MAAM,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;wBAEnE,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC;wBAC9C,IAAI,UAAU,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE;4BAE1C,wCAAwC;4BAExC,oFAAoF;4BACpF,MAAM,oBAAoB,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,mBAAmB,EAAE,kBAAkB,CAAC,CAAC;4BAElG,IAAI,oBAAoB;mCACnB,CAAC,UAAU,CAAC,UAAU;mCACtB,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC,EAAE;gCACvF,UAAU,CAAC,kBAAkB,EAAE,CAAC;6BACjC;4BAED,+BAA+B;4BAC/B,UAAU,CAAC,GAAG,EAAE;gCACd,IAAI,CAAC,gBAAgB,EAAE,CAAC;4BAC1B,CAAC,CAAC,CAAC;4BAEH,IAAI,CAAC,IAAI,CAAC,qCAAqC,EAAE;gCAC/C,IAAI,CAAC,yCAAyC,EAAE,CAAC;6BAClD;yBACF;wBAED,uBAAuB;wBACvB,mBAAmB,GAAG,kBAAkB,CAAC;qBAC1C;gBACH,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;QAEL,oFAAoF;QACpF,sBAAsB;QACtB,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAC3B,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAC3B,CAAC,SAAS,CAAC,CAAC,kBAAkB,EAAE,EAAE;YACjC,2CAA2C;YAC3C,IAAI,IAAI,CAAC,UAAU,EAAE;gBACnB,IAAI,kBAAkB,EAAE;oBACtB,IAAI,CAAC,UAAU,CAAC,eAAe,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,qCAAqC,CAAC,CAAC;iBACxF;qBAAM;oBACL,IAAI,CAAC,UAAU,CAAC,eAAe,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,qCAAqC,CAAC,CAAC;iBAC3F;aACF;QACH,CAAC,CAAC,CAAC;QAEH,2GAA2G;QAC3G,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE;aACzB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAChC,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE;gBAC5B,IAAI,CAAC,gBAAgB,EAAE,CAAC;aACzB;QACH,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAE7B,IAAI,CAAC,aAAa,CAAC,IAAI,CACrB,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAC3B,CAAC,SAAS,CAAC,GAAG,EAAE;YACf,4CAA4C;YAC5C,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC;QACzC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,4BAA4B,CAAC,KAAc;QACzC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;IAED,WAAW;QACT,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAC7B,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;IAED,0BAA0B;QACxB,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,IAAI,IAAI,CAAC,qBAAqB,CAAC;IAC/D,CAAC;IAED,aAAa,CAAC,KAAoB;QAChC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,MAAM,KAAK,CAAC,CAAC;YACvC,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC;eAC3J,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC;eAC9J,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC;eAC9J,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC;eACnI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC;eACvI,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC;eAC7I,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC;eACnF,CAAC,KAAK,CAAC,IAAI,KAAK,OAAO,CAAC;eACxB,CAAC,IAAI,CAAC,4BAA4B,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,EACzF;YACA,KAAK,CAAC,eAAe,EAAE,CAAC;SACzB;QAED,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,EAAE;YAClE,yDAAyD;YACzD,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;SAChC;QAED,0GAA0G;QAC1G,IAAI,IAAI,CAAC,0BAA0B,KAAK,IAAI,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,KAAK,EAAE;YACrF,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACjB,KAAK,CAAC,eAAe,EAAE,CAAC;SACzB;IACH,CAAC;IAED;;;OAGG;IACH,WAAW,CAAC,KAAoB;QAC9B,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,WAAW,EAAE;YAC1D,MAAM,sBAAsB,GAAG,IAAI,CAAC,SAAS,CAAC,wBAAwB,EAAE,CAAC;YACzE,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,sBAAsB,CAAC,CAAC;YAC7F,IAAI,KAAK,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE;gBACzB,IAAI,CAAC,yBAAyB,EAAE,CAAC;gBACjC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC,eAAe,EAAE,CAAC;gBAC3E,IAAI,CAAC,iBAAiB,EAAE,YAAY,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;gBAC9D,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,YAAY,CAAC,uBAAuB,EAAE,sBAAsB,CAAC,CAAC;aACpG;SACF;IACH,CAAC;IAED,UAAU,CAAC,KAAa;QACtB,IAAI,CAAC,uBAAuB,GAAG,KAAK,CAAC;QACrC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC;IACzC,CAAC;IAED,MAAM;QACJ,IAAI,CAAC,yBAAyB,EAAE,CAAC;QACjC,IAAI,CAAC,SAAS,EAAE,CAAC;IACnB,CAAC;IAED,gBAAgB,CAAC,EAA2B;QAC1C,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,IAAI,CAChC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,uBAAuB,CAAC,EACvD,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,uBAAuB,GAAG,SAAS,CAAC,EACnD,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAC3B,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;IAClB,CAAC;IAED,iBAAiB,CAAC,EAAO;QACvB,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACtB,CAAC;IAEM,KAAK;QACV,IAAI,CAAC,IAAI,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE;YACpD,OAAO;SACR;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,aAAa,CAAC;QACjD,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;QAElC,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAE7C,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC;IAC9B,CAAC;IAEM,KAAK,CAAC,KAAe;QAC1B,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAC9B,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,KAAK,EAAE,CAAC;SACd;IACH,CAAC;IAEM,gBAAgB;QACrB,IAAI,CAAC,IAAI,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE;YACpE,OAAO;SACR;QACD,MAAM,OAAO,GAAgB,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC;QAClE,IAAI,YAAY,GAAuB,KAAK,CAAC,CAAC;QAC9C,OAAO,OAAO,KAAK,OAAO,CAAC,aAAa,EAAE;YACxC,IAAI,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE;gBAClD,YAAY,GAAG,OAAO,CAAC;gBACvB,MAAM;aACP;SACF;QACD,IAAI,YAAY,EAAE;YAChB,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,KAAK,CAAC,KAAK,GAAG,YAAY,CAAC,WAAW,GAAG,IAAI,CAAC;SACpF;IACH,CAAC;IAEO,mBAAmB;QACzB,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;YACrC,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,eAAe,EAAE,CAAC,qBAAqB,EAAE,CAAC,MAAM,CAAC;SACtF;QAED,OAAO,CAAC,CAAC;IACX,CAAC;IAEO,uBAAuB;QAC7B,IAAI,IAAI,CAAC,UAAU,EAAE;YACnB,OAAO,CAAC,CAAC;SACV;aAAM;YACL,OAAO,CAAC,CAAC;SACV;IACH,CAAC;IAEO,yBAAyB;QAC/B,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,eAAe,CAAC,CAAC;QACzD,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,eAAe,CAAC,uBAAuB,CAAC,CAAC;IAChF,CAAC;IACO,oBAAoB,CAAC,cAAuC;QAClE,IAAI,CAAC,cAAc,EAAE;YACnB,OAAO;SACR;QACD,KAAK,MAAM,GAAG,IAAI,0BAA0B,EAAE;YAC5C,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,cAAc,EAAE,GAAG,CAAC,EAAE;gBAC5D,IAAI,CAAC,GAAG,CAAS,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC;aAC1C;SACF;IACH,CAAC;IACD;;;KAGC;IACO,qBAAqB;QAC3B,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE;YAC7B,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE;gBAC3B,gGAAgG;gBAChG,yDAAyD;gBACzD,OAAO,CAAC,KAAK,CAAC,8GAA8G,CAAC,CAAC;aAC/H;YACD,OAAO;SACR;QACD,oCAAoC;QACpC,6EAA6E;QAC7E,uEAAuE;QACvE,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC;QAE9D,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aACpE,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;YACpB,IAAI,qBAAqB,GAAG,KAAK,CAAC;YAClC,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE;gBAC3B,IAAI,CAAC,IAAI,CAAC,iCAAiC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,IAAI,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;uBACpG,IAAI,CAAC,uBAAuB,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,uBAAuB,CAAC,EAAE;oBAChF,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;wBACrC,MAAM,GAAG,EAAE,CAAC;qBACb;oBACD,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;oBACxE,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC,aAAa,EAAE,EAAE;wBACrD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;+BACrE,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,EAAE;4BAC1E,oGAAoG;4BACpG,0CAA0C;4BAC1C,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;4BAC3B,qBAAqB,GAAG,IAAI,CAAC;yBAC9B;oBACH,CAAC,CAAC,CAAC;iBACJ;aACF;YACD,IAAI,CAAC,uBAAuB,GAAG,MAAM,CAAC;YAEtC,IAAI,qBAAqB,EAAE;gBACzB,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;aAClC;QACH,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACK,yCAAyC;QAC/C,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;YAC7D,MAAM,eAAe,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;YACnD,MAAM,iBAAiB,GAAG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,eAAe,IAAI,CAAC,CAAC;YAC1E,MAAM,UAAU,GAAG,6BAA6B,CAAC,iBAAiB,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;YACzH,iFAAiF;YACjF,MAAM,0BAA0B,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,GAAG,iBAAiB,CAAC;YAC/F,MAAM,gBAAgB,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,aAAa,CAAC,SAAS,CAAC;YAEtE,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,YAAY,CAAC;YAC5E,MAAM,sBAAsB,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,uBAAuB,GAAG,iBAAiB,CAAC,GAAG,eAAe,CAAC,CAAC;YAE3G,MAAM,yBAAyB,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,gBAAgB,GAAG,iBAAiB,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC;YAE3G,IAAI,yBAAyB,IAAI,0BAA0B,EAAE;gBAC3D,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,aAAa,CAAC,SAAS,GAAG,0BAA0B,GAAG,eAAe,CAAC;aAC7F;iBAAM,IAAI,yBAAyB,GAAG,sBAAsB,IAAI,0BAA0B,EAAE;gBAC3F,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,aAAa,CAAC,SAAS,GAAG,CAAC,0BAA0B,GAAG,CAAC,CAAC,GAAG,eAAe;sBAC7F,CAAC,uBAAuB,GAAG,iBAAiB,CAAC,CAAC;aACnD;SACF;IACH,CAAC;8GAhdU,yBAAyB,kBA0EhB,SAAS,2EAGP,SAAS,6BACT,YAAY,6BACZ,gCAAgC;kGA/E3C,yBAAyB,gpCAdzB;YACT;gBACE,OAAO,EAAE,iBAAiB;gBAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,yBAAyB,CAAC;gBACxD,KAAK,EAAE,IAAI;aACZ;SACF,iEAyDa,8BAA8B,iFAC9B,iCAAiC,mJAJP,UAAU,+HAEV,UAAU,2EC7FpD,wwEAiCM,gtEDSM,cAAc,4eAAE,OAAO,oFAAE,IAAI,4FAAE,iBAAiB,6WAAE,gBAAgB,4TAAE,kBAAkB,8BAC9F,aAAa,mLAAE,WAAW,sZAAE,mBAAmB,iNAAE,wBAAwB,kOAAE,eAAe,uIAAE,SAAS;;2FAE5F,yBAAyB;kBAlBrC,SAAS;+BACE,oBAAoB,aAGnB;wBACT;4BACE,OAAO,EAAE,iBAAiB;4BAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,0BAA0B,CAAC;4BACxD,KAAK,EAAE,IAAI;yBACZ;qBACF,iBACc,iBAAiB,CAAC,IAAI,mBACpB,uBAAuB,CAAC,MAAM,cACnC,IAAI,YACN,kBAAkB,WACnB,CAAC,cAAc,EAAE,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,kBAAkB;wBAC9F,aAAa,EAAE,WAAW,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,eAAe,EAAE,SAAS,CAAC;;0BA4E3F,MAAM;2BAAC,SAAS;;0BAG1B,QAAQ;;0BAAI,MAAM;2BAAC,SAAS;;0BAC5B,QAAQ;;0BAAI,MAAM;2BAAC,YAAY;;0BAC/B,QAAQ;;0BAAI,MAAM;2BAAC,gCAAgC;yCA7E7C,gBAAgB;sBAAxB,KAAK;gBAEG,IAAI;sBAAZ,KAAK;gBAEG,mBAAmB;sBAA3B,KAAK;gBAEG,gBAAgB;sBAAxB,KAAK;gBAEG,8BAA8B;sBAAtC,KAAK;gBAEG,gBAAgB;sBAAxB,KAAK;gBAEG,SAAS;sBAAjB,KAAK;gBAEG,mBAAmB;sBAA3B,KAAK;gBAEG,0BAA0B;sBAAlC,KAAK;gBAEG,4BAA4B;sBAApC,KAAK;gBAEG,qCAAqC;sBAA7C,KAAK;gBAEG,SAAS;sBAAjB,KAAK;gBAGG,qBAAqB;sBAA7B,KAAK;gBAGG,wBAAwB;sBAAhC,KAAK;gBAGG,8BAA8B;sBAAtC,KAAK;gBAEG,+BAA+B;sBAAvC,KAAK;gBAEG,gCAAgC;sBAAxC,KAAK;gBAEG,qBAAqB;sBAA7B,KAAK;gBAEG,iCAAiC;sBAAzC,KAAK;gBAGI,SAAS;sBAAlB,MAAM;gBAE6D,iBAAiB;sBAApF,SAAS;uBAAC,mBAAmB,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE;gBAEE,iBAAiB;sBAApF,SAAS;uBAAC,mBAAmB,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE;gBACD,SAAS;sBAAzE,YAAY;uBAAC,8BAA8B,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE;gBACd,cAAc;sBAA9D,YAAY;uBAAC,iCAAiC;gBA6C3C,iBAAiB;sBADpB,WAAW;uBAAC,4CAA4C","sourcesContent":["import {\r\n  ChangeDetectionStrategy, ChangeDetectorRef,\r\n  Component, ElementRef, EventEmitter, forwardRef, Inject, Input, OnDestroy, OnInit, QueryList,\r\n  ViewChild,\r\n  ContentChild, Optional, HostBinding, Output, ViewEncapsulation\r\n} from '@angular/core';\r\nimport { ControlValueAccessor, FormControl, NG_VALUE_ACCESSOR, FormsModule, ReactiveFormsModule } from '@angular/forms';\r\nimport { MatSelect } from '@angular/material/select';\r\nimport { ViewportRuler } from '@angular/cdk/scrolling';\r\nimport { BehaviorSubject, combineLatest, Observable, of, Subject } from 'rxjs';\r\nimport { delay, filter, map, startWith, switchMap, take, takeUntil, tap } from 'rxjs/operators';\r\n\r\nimport { CmatSelectSearchClearDirective } from './select-search-clear.directive';\r\nimport { MatOption, _countGroupLabelsBeforeOption } from '@angular/material/core';\r\nimport { MatFormField, MatFormFieldModule } from '@angular/material/form-field';\r\nimport { CmatSelectNoEntriesFoundDirective } from './select-no-entries-found.directive';\r\nimport { configurableDefaultOptions, MatSelectSearchOptions, MAT_SELECTSEARCH_DEFAULT_OPTIONS } from './default-options';\r\nimport { MatButtonModule } from '@angular/material/button';\r\nimport { MatProgressSpinnerModule } from '@angular/material/progress-spinner';\r\nimport { MatIconModule } from '@angular/material/icon';\r\nimport { MatTooltipModule } from '@angular/material/tooltip';\r\nimport { MatCheckboxModule } from '@angular/material/checkbox';\r\nimport { NgClass, NgIf, AsyncPipe } from '@angular/common';\r\nimport { MatInputModule } from '@angular/material/input';\r\n\r\nconst SELECT_PANEL_MAX_HEIGHT = 256;\r\n\r\n@Component({\r\n  selector: 'cmat-select-search',\r\n  templateUrl: './select-search.component.html',\r\n  styleUrls: ['./select-search.component.scss'],\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      useExisting: forwardRef(() => CmatSelectSearchComponent),\r\n      multi: true\r\n    }\r\n  ],\r\n  encapsulation: ViewEncapsulation.None,\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  standalone: true,\r\n  exportAs: 'cmatSelectSearch',\r\n  imports: [MatInputModule, NgClass, NgIf, MatCheckboxModule, MatTooltipModule, MatFormFieldModule,\r\n    MatIconModule, FormsModule, ReactiveFormsModule, MatProgressSpinnerModule, MatButtonModule, AsyncPipe]\r\n})\r\nexport class CmatSelectSearchComponent implements OnInit, OnDestroy, ControlValueAccessor {\r\n\r\n  @Input() placeholderLabel = '查询';\r\n\r\n  @Input() type = 'text';\r\n\r\n  @Input() noEntriesFoundLabel = '无结果';\r\n\r\n  @Input() showNoFoundLabel = true;\r\n\r\n  @Input() indexAndLengthScreenReaderText = ' of ';\r\n\r\n  @Input() clearSearchInput = true;\r\n\r\n  @Input() searching = false;\r\n\r\n  @Input() disableInitialFocus = false;\r\n\r\n  @Input() enableClearOnEscapePressed = false;\r\n\r\n  @Input() preventHomeEndKeyPropagation = false;\r\n\r\n  @Input() disableScrollToActiveOnOptionsChanged = false;\r\n\r\n  @Input() ariaLabel = '下拉查询';\r\n\r\n  /** Whether to show Select All Checkbox (for mat-select[multi=true]) */\r\n  @Input() showToggleAllCheckbox = false;\r\n\r\n  /** select all checkbox checked state */\r\n  @Input() toggleAllCheckboxChecked = false;\r\n\r\n  /** select all checkbox indeterminate state */\r\n  @Input() toggleAllCheckboxIndeterminate = false;\r\n\r\n  @Input() toggleAllCheckboxTooltipMessage = '';\r\n\r\n  @Input() toggleAllCheckboxTooltipPosition: 'left' | 'right' | 'above' | 'below' | 'before' | 'after' = 'below';\r\n\r\n  @Input() hideClearSearchButton = false;\r\n\r\n  @Input() alwaysRestoreSelectedOptionsMulti = false;\r\n\r\n  /** Output emitter to send to parent component with the toggle all boolean */\r\n  @Output() toggleAll = new EventEmitter<boolean>();\r\n\r\n  @ViewChild('searchSelectInput', { read: ElementRef, static: true }) searchSelectInput: ElementRef;\r\n\r\n  @ViewChild('innerSelectSearch', { read: ElementRef, static: true }) innerSelectSearch: ElementRef;\r\n  @ContentChild(CmatSelectSearchClearDirective, { static: false }) clearIcon: CmatSelectSearchClearDirective;\r\n  @ContentChild(CmatSelectNoEntriesFoundDirective) noEntriesFound: CmatSelectNoEntriesFoundDirective;\r\n  formControl: FormControl = new FormControl('');\r\n\r\n  private _options$: BehaviorSubject<QueryList<MatOption> | null> = new BehaviorSubject<QueryList<MatOption> | null>(null);\r\n  private _lastExternalInputValue?: string;\r\n\r\n  private _optionsList$: Observable<MatOption[] | null> = this._options$.pipe(\r\n    switchMap(_options => _options ?\r\n      _options.changes.pipe(\r\n        map(options => options.toArray()),\r\n        startWith<MatOption[]>(_options.toArray()),\r\n      ) : of(null)\r\n    )\r\n  );\r\n\r\n  private _optionsLength$: Observable<number> = this._optionsList$.pipe(\r\n    map(options => options ? options.length : 0)\r\n  );\r\n\r\n  private _previousSelectedValues: any[];\r\n  private _onDestroy = new Subject<void>();\r\n  /** Reference to active descendant for ARIA Support. */\r\n  private _activeDescendant?: HTMLElement;\r\n\r\n  constructor(@Inject(MatSelect) protected matSelect: MatSelect,\r\n    private _changeDetectorRef: ChangeDetectorRef,\r\n    private _viewportRuler: ViewportRuler,\r\n    @Optional() @Inject(MatOption) private _matOption: MatOption | null = null,\r\n    @Optional() @Inject(MatFormField) protected matFormField: MatFormField | null = null,\r\n    @Optional() @Inject(MAT_SELECTSEARCH_DEFAULT_OPTIONS) private _defaultOptions?: MatSelectSearchOptions\r\n  ) {\r\n    this._applyDefaultOptions(this._defaultOptions);\r\n  }\r\n\r\n  /** whether to show the no entries found message */\r\n  // eslint-disable-next-line @typescript-eslint/member-ordering\r\n  showNoEntriesFound$: Observable<boolean> = combineLatest([\r\n    this.formControl.valueChanges,\r\n    this._optionsLength$\r\n  ]).pipe(\r\n    map(([value, optionsLength]) => this.noEntriesFoundLabel && value\r\n      && optionsLength === this._getOptionsLengthOffset())\r\n  );\r\n\r\n  @HostBinding('class.cmat-select-search-inside-mat-option')\r\n  get isInsideMatOption(): boolean {\r\n    return !!this._matOption;\r\n  }\r\n\r\n  get value(): string {\r\n    return this.formControl.value;\r\n  }\r\n\r\n  public get _options(): QueryList<MatOption> | null {\r\n    return this._options$.getValue();\r\n  }\r\n  public set _options(_options: QueryList<MatOption>) {\r\n    this._options$.next(_options);\r\n  }\r\n\r\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\r\n  onTouched: () => any = () => { };\r\n\r\n  ngOnInit(): void {\r\n    const panelClass = 'cmat-select-search-panel';\r\n    if (this.matSelect.panelClass) {\r\n      if (Array.isArray(this.matSelect.panelClass)) {\r\n        (this.matSelect.panelClass as string[]).push(panelClass);\r\n      } else if (typeof this.matSelect.panelClass === 'string') {\r\n        this.matSelect.panelClass = [this.matSelect.panelClass, panelClass];\r\n      } else if (typeof this.matSelect.panelClass === 'object') {\r\n        this.matSelect.panelClass.entries[panelClass] = true;\r\n      }\r\n    } else {\r\n      this.matSelect.panelClass = panelClass;\r\n    }\r\n\r\n    if (this._matOption) {\r\n      this._matOption.disabled = true;\r\n      this._matOption._getHostElement().classList.add('contains-cmat-select-search');\r\n      this._matOption._getHostElement().setAttribute('aria-hidden', 'true');\r\n    } else {\r\n      console.error('<cmat-select-search> must be placed inside a <mat-option> element');\r\n    }\r\n\r\n\r\n    this.matSelect.openedChange\r\n      .pipe(\r\n        delay(1),\r\n        takeUntil(this._onDestroy)\r\n      )\r\n      .subscribe((opened) => {\r\n        if (opened) {\r\n          this.updateInputWidth();\r\n          if (!this.disableInitialFocus) {\r\n            this.focus();\r\n          }\r\n        } else {\r\n          if (this.clearSearchInput) {\r\n            this.reset();\r\n          }\r\n        }\r\n      });\r\n\r\n    this.matSelect.openedChange\r\n      .pipe(take(1))\r\n      .pipe(takeUntil(this._onDestroy))\r\n      .subscribe(() => {\r\n        if (this.matSelect._keyManager) {\r\n          this.matSelect._keyManager.change.pipe(takeUntil(this._onDestroy))\r\n            .subscribe(() => this._adjustScrollTopToFitActiveOptionIntoView());\r\n        } else {\r\n          console.log('_keyManager was not initialized.');\r\n        }\r\n\r\n        this._options = this.matSelect.options;\r\n        let previousFirstOption = this._options.toArray()[this._getOptionsLengthOffset()];\r\n\r\n        this._options.changes\r\n          .pipe(\r\n            takeUntil(this._onDestroy)\r\n          )\r\n          .subscribe(() => {\r\n            // avoid \"expression has been changed\" error\r\n            setTimeout(() => {\r\n              if (this._options) {\r\n                // Convert the QueryList to an array\r\n                const options = this._options.toArray();\r\n\r\n                // The true first item is offset by 1\r\n                const currentFirstOption = options[this._getOptionsLengthOffset()];\r\n\r\n                const keyManager = this.matSelect._keyManager;\r\n                if (keyManager && this.matSelect.panelOpen) {\r\n\r\n                  // set first item active and input width\r\n\r\n                  // Check to see if the first option in these changes is different from the previous.\r\n                  const firstOptionIsChanged = !this.matSelect.compareWith(previousFirstOption, currentFirstOption);\r\n\r\n                  if (firstOptionIsChanged\r\n                    || !keyManager.activeItem\r\n                    || !options.find(option => this.matSelect.compareWith(option, keyManager.activeItem))) {\r\n                    keyManager.setFirstItemActive();\r\n                  }\r\n\r\n                  // wait for panel width changes\r\n                  setTimeout(() => {\r\n                    this.updateInputWidth();\r\n                  });\r\n\r\n                  if (!this.disableScrollToActiveOnOptionsChanged) {\r\n                    this._adjustScrollTopToFitActiveOptionIntoView();\r\n                  }\r\n                }\r\n\r\n                // Update our reference\r\n                previousFirstOption = currentFirstOption;\r\n              }\r\n            });\r\n          });\r\n      });\r\n\r\n    // add or remove css class depending on whether to show the no entries found message\r\n    // note: this is hacky\r\n    this.showNoEntriesFound$.pipe(\r\n      takeUntil(this._onDestroy)\r\n    ).subscribe((showNoEntriesFound) => {\r\n      // set no entries found class on mat option\r\n      if (this._matOption) {\r\n        if (showNoEntriesFound) {\r\n          this._matOption._getHostElement().classList.add('cmat-select-search-no-entries-found');\r\n        } else {\r\n          this._matOption._getHostElement().classList.remove('cmat-select-search-no-entries-found');\r\n        }\r\n      }\r\n    });\r\n\r\n    // resize the input width when the viewport is resized, i.e. the trigger width could potentially be resized\r\n    this._viewportRuler.change()\r\n      .pipe(takeUntil(this._onDestroy))\r\n      .subscribe(() => {\r\n        if (this.matSelect.panelOpen) {\r\n          this.updateInputWidth();\r\n        }\r\n      });\r\n\r\n    this._initMultipleHandling();\r\n\r\n    this._optionsList$.pipe(\r\n      takeUntil(this._onDestroy)\r\n    ).subscribe(() => {\r\n      // update view when available options change\r\n      this._changeDetectorRef.markForCheck();\r\n    });\r\n  }\r\n\r\n  emitSelectAllBooleanToParent(state: boolean): void {\r\n    this.toggleAll.emit(state);\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._onDestroy.next(void 0);\r\n    this._onDestroy.complete();\r\n  }\r\n\r\n  isToggleAllCheckboxVisible(): boolean {\r\n    return this.matSelect.multiple && this.showToggleAllCheckbox;\r\n  }\r\n\r\n  handleKeydown(event: KeyboardEvent): void {\r\n    if ((event.key && event.key.length === 1) ||\r\n      (event.code === 'KeyA') || (event.code === 'KeyB') || (event.code === 'KeyC') || (event.code === 'KeyD') || (event.code === 'KeyE') || (event.code === 'KeyF')\r\n      || (event.code === 'KeyG') || (event.code === 'KeyH') || (event.code === 'KeyI') || (event.code === 'KeyJ') || (event.code === 'KeyK') || (event.code === 'KeyL')\r\n      || (event.code === 'KeyM') || (event.code === 'KeyN') || (event.code === 'KeyO') || (event.code === 'KeyP') || (event.code === 'KeyQ') || (event.code === 'KeyR')\r\n      || (event.code === 'KeyS') || (event.code === 'KeyT') || (event.code === 'KeyU') || (event.code === 'KeyV') || (event.code === 'KeyW')\r\n      || (event.code === 'KeyX') || (event.code === 'KeyY') || (event.code === 'KeyZ') || (event.code === 'Digit0') || (event.code === 'Digit1')\r\n      || (event.code === 'Digit2') || (event.code === 'Digit3') || (event.code === 'Digit4') || (event.code === 'Digit5') || (event.code === 'Digit6')\r\n      || (event.code === 'Digit7') || (event.code === 'Digit8') || (event.code === 'Digit9')\r\n      || (event.code === 'Space')\r\n      || (this.preventHomeEndKeyPropagation && (event.code === 'Home' || event.code === 'End'))\r\n    ) {\r\n      event.stopPropagation();\r\n    }\r\n\r\n    if (this.matSelect.multiple && event.key && event.code === 'Enter') {\r\n      // Regain focus after multiselect, so we can further type\r\n      setTimeout(() => this.focus());\r\n    }\r\n\r\n    // Special case if click Escape, if input is empty, close the dropdown, if not, empty out the search field\r\n    if (this.enableClearOnEscapePressed === true && event.code === 'Escape' && this.value) {\r\n      this.reset(true);\r\n      event.stopPropagation();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handles the key up event with MatSelect.\r\n   * Allows e.g. the announcing of the currently activeDescendant by screen readers.\r\n   */\r\n  handleKeyup(event: KeyboardEvent): void {\r\n    if (event.code === 'ArrowUp' || event.code === 'ArrowDown') {\r\n      const ariaActiveDescendantId = this.matSelect._getAriaActiveDescendant();\r\n      const index = this._options?.toArray().findIndex(item => item.id === ariaActiveDescendantId);\r\n      if (index && index !== -1) {\r\n        this._unselectActiveDescendant();\r\n        this._activeDescendant = this._options?.toArray()[index]._getHostElement();\r\n        this._activeDescendant?.setAttribute('aria-selected', 'true');\r\n        this.searchSelectInput.nativeElement.setAttribute('aria-activedescendant', ariaActiveDescendantId);\r\n      }\r\n    }\r\n  }\r\n\r\n  writeValue(value: string): void {\r\n    this._lastExternalInputValue = value;\r\n    this.formControl.setValue(value);\r\n    this._changeDetectorRef.markForCheck();\r\n  }\r\n\r\n  onBlur(): void {\r\n    this._unselectActiveDescendant();\r\n    this.onTouched();\r\n  }\r\n\r\n  registerOnChange(fn: (value: string) => void): void {\r\n    this.formControl.valueChanges.pipe(\r\n      filter(value => value !== this._lastExternalInputValue),\r\n      tap(() => this._lastExternalInputValue = undefined),\r\n      takeUntil(this._onDestroy)\r\n    ).subscribe(fn);\r\n  }\r\n\r\n  registerOnTouched(fn: any): void {\r\n    this.onTouched = fn;\r\n  }\r\n\r\n  public focus(): void {\r\n    if (!this.searchSelectInput || !this.matSelect.panel) {\r\n      return;\r\n    }\r\n    const panel = this.matSelect.panel.nativeElement;\r\n    const scrollTop = panel.scrollTop;\r\n\r\n    this.searchSelectInput.nativeElement.focus();\r\n\r\n    panel.scrollTop = scrollTop;\r\n  }\r\n\r\n  public reset(focus?: boolean): void {\r\n    this.formControl.setValue('');\r\n    if (focus) {\r\n      this.focus();\r\n    }\r\n  }\r\n\r\n  public updateInputWidth(): void {\r\n    if (!this.innerSelectSearch || !this.innerSelectSearch.nativeElement) {\r\n      return;\r\n    }\r\n    const element: HTMLElement = this.innerSelectSearch.nativeElement;\r\n    let panelElement: HTMLElement | void = void 0;\r\n    while (element === element.parentElement) {\r\n      if (element.classList.contains('mat-select-panel')) {\r\n        panelElement = element;\r\n        break;\r\n      }\r\n    }\r\n    if (panelElement) {\r\n      this.innerSelectSearch.nativeElement.style.width = panelElement.clientWidth + 'px';\r\n    }\r\n  }\r\n\r\n  private _getMatOptionHeight(): number {\r\n    if (this.matSelect.options.length > 0) {\r\n      return this.matSelect.options.first._getHostElement().getBoundingClientRect().height;\r\n    }\r\n\r\n    return 0;\r\n  }\r\n\r\n  private _getOptionsLengthOffset(): number {\r\n    if (this._matOption) {\r\n      return 1;\r\n    } else {\r\n      return 0;\r\n    }\r\n  }\r\n\r\n  private _unselectActiveDescendant(): void {\r\n    this._activeDescendant?.removeAttribute('aria-selected');\r\n    this.searchSelectInput.nativeElement.removeAttribute('aria-activedescendant');\r\n  }\r\n  private _applyDefaultOptions(defaultOptions?: MatSelectSearchOptions): void {\r\n    if (!defaultOptions) {\r\n      return;\r\n    }\r\n    for (const key of configurableDefaultOptions) {\r\n      if (Object.prototype.hasOwnProperty.call(defaultOptions, key)) {\r\n        (this[key] as any) = defaultOptions[key];\r\n      }\r\n    }\r\n  }\r\n  /*\r\n * Initializes handling <mat-select [multiple]=\"true\">\r\n * Note: to improve this code, mat-select should be extended to allow disabling resetting the selection while filtering.\r\n */\r\n  private _initMultipleHandling(): void {\r\n    if (!this.matSelect.ngControl) {\r\n      if (this.matSelect.multiple) {\r\n        // note: the access to matSelect.ngControl (instead of matSelect.value / matSelect.valueChanges)\r\n        // is necessary to properly work in multi-selection mode.\r\n        console.error('the mat-select containing cmat-select-search must have a ngModel or formControl directive when multiple=true');\r\n      }\r\n      return;\r\n    }\r\n    // if <mat-select [multiple]=\"true\">\r\n    // store previously selected values and restore them when they are deselected\r\n    // because the option is not available while we are currently filtering\r\n    this._previousSelectedValues = this.matSelect.ngControl.value;\r\n\r\n    this.matSelect.ngControl.valueChanges?.pipe(takeUntil(this._onDestroy))\r\n      .subscribe((values) => {\r\n        let restoreSelectedValues = false;\r\n        if (this.matSelect.multiple) {\r\n          if ((this.alwaysRestoreSelectedOptionsMulti || (this.formControl.value && this.formControl.value.length))\r\n            && this._previousSelectedValues && Array.isArray(this._previousSelectedValues)) {\r\n            if (!values || !Array.isArray(values)) {\r\n              values = [];\r\n            }\r\n            const optionValues = this.matSelect.options.map(option => option.value);\r\n            this._previousSelectedValues.forEach((previousValue) => {\r\n              if (!values.some((v: any) => this.matSelect.compareWith(v, previousValue))\r\n                && !optionValues.some(v => this.matSelect.compareWith(v, previousValue))) {\r\n                // if a value that was selected before is deselected and not found in the options, it was deselected\r\n                // due to the filtering, so we restore it.\r\n                values.push(previousValue);\r\n                restoreSelectedValues = true;\r\n              }\r\n            });\r\n          }\r\n        }\r\n        this._previousSelectedValues = values;\r\n\r\n        if (restoreSelectedValues) {\r\n          this.matSelect._onChange(values);\r\n        }\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Scrolls the currently active option into the view if it is not yet visible.\r\n   */\r\n  private _adjustScrollTopToFitActiveOptionIntoView(): void {\r\n    if (this.matSelect.panel && this.matSelect.options.length > 0) {\r\n      const matOptionHeight = this._getMatOptionHeight();\r\n      const activeOptionIndex = this.matSelect._keyManager.activeItemIndex || 0;\r\n      const labelCount = _countGroupLabelsBeforeOption(activeOptionIndex, this.matSelect.options, this.matSelect.optionGroups);\r\n      // If the component is in a MatOption, the activeItemIndex will be offset by one.\r\n      const indexOfOptionToFitIntoView = (this._matOption ? -1 : 0) + labelCount + activeOptionIndex;\r\n      const currentScrollTop = this.matSelect.panel.nativeElement.scrollTop;\r\n\r\n      const searchInputHeight = this.innerSelectSearch.nativeElement.offsetHeight;\r\n      const amountOfVisibleOptions = Math.floor((SELECT_PANEL_MAX_HEIGHT - searchInputHeight) / matOptionHeight);\r\n\r\n      const indexOfFirstVisibleOption = Math.round((currentScrollTop + searchInputHeight) / matOptionHeight) - 1;\r\n\r\n      if (indexOfFirstVisibleOption >= indexOfOptionToFitIntoView) {\r\n        this.matSelect.panel.nativeElement.scrollTop = indexOfOptionToFitIntoView * matOptionHeight;\r\n      } else if (indexOfFirstVisibleOption + amountOfVisibleOptions <= indexOfOptionToFitIntoView) {\r\n        this.matSelect.panel.nativeElement.scrollTop = (indexOfOptionToFitIntoView + 1) * matOptionHeight\r\n          - (SELECT_PANEL_MAX_HEIGHT - searchInputHeight);\r\n      }\r\n    }\r\n  }\r\n}\r\n","<input matInput class=\"cmat-select-search-input cmat-select-search-hidden\" />\r\n\r\n<div #innerSelectSearch class=\"cmat-select-search-inner mat-typography mat-tab-header\"\r\n  [ngClass]=\"{'cmat-select-search-inner-multiple': matSelect.multiple, 'cmat-select-search-inner-toggle-all': isToggleAllCheckboxVisible() }\">\r\n\r\n  <mat-checkbox *ngIf=\"isToggleAllCheckboxVisible()\" [color]=\"matFormField?.color\"\r\n    class=\"cmat-select-search-toggle-all-checkbox\" [checked]=\"toggleAllCheckboxChecked\"\r\n    [indeterminate]=\"toggleAllCheckboxIndeterminate\" [matTooltip]=\"toggleAllCheckboxTooltipMessage\"\r\n    matTooltipClass=\"cmat-select-search-toggle-all-tooltip\" [matTooltipPosition]=\"toggleAllCheckboxTooltipPosition\"\r\n    (change)=\"emitSelectAllBooleanToParent($event.checked)\">\r\n  </mat-checkbox>\r\n  <span matPrefix class=\"flex flex-col justify-center pl-2\">\r\n    <mat-icon class=\"cmat-select-search-icon\" color=\"primary\" svgIcon=\"heroicons_solid:magnifying-glass\"></mat-icon>\r\n  </span>\r\n  <input matInput class=\"cmat-select-search-input cmat-input-element\" autocomplete=\"off\" [type]=\"type\"\r\n    [formControl]=\"formControl\" #searchSelectInput (keydown)=\"handleKeydown($event)\" (keyup)=\"handleKeyup($event)\"\r\n    (blur)=\"onBlur()\" [placeholder]=\"placeholderLabel\" [attr.aria-label]=\"ariaLabel\" />\r\n  <mat-spinner *ngIf=\"searching\" class=\"cmat-select-search-spinner\" diameter=\"16\"></mat-spinner>\r\n\r\n  <button type=\"button\" *ngIf=\"!hideClearSearchButton && value && !searching\" mat-icon-button aria-label=\"Clear\"\r\n    (click)=\"reset(true)\" class=\"cmat-select-search-clear\">\r\n    <ng-content *ngIf=\"clearIcon; else defaultIcon\" select=\"[cmatSelectSearchClear]\"></ng-content>\r\n    <ng-template #defaultIcon>\r\n      <mat-icon svgIcon=\"mat_outline:close\"></mat-icon>\r\n    </ng-template>\r\n  </button>\r\n\r\n  <ng-content select=\".cmat-select-search-custom-header-content\"></ng-content>\r\n</div>\r\n\r\n<div *ngIf=\"showNoEntriesFound$ | async\" class=\"cmat-select-search-no-entries-found\">\r\n  <ng-content *ngIf=\"noEntriesFound; else defaultNoEntriesFound\" select=\"[cmatSelectNoEntriesFound]\"></ng-content>\r\n  <ng-template #defaultNoEntriesFound>{{noEntriesFoundLabel}}</ng-template>\r\n</div>"]}

package/esm2022/components/select-tree/cmat-components-select-tree.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1jb21wb25lbnRzLXNlbGVjdC10cmVlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY21hdC9jb21wb25lbnRzL3NlbGVjdC10cmVlL2NtYXQtY29tcG9uZW50cy1zZWxlY3QtdHJlZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19