primevue 3.15.0 → 3.16.2

package/multiselect/multiselect.js

@@ -11,7 +11,7 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
 
     var script = {
         name: 'MultiSelect',
-        emits: ['update:modelValue', 'before-show', 'before-hide', 'change', 'show', 'hide', 'filter', 'selectall-change'],
+        emits: ['update:modelValue', 'change', 'focus', 'blur' , 'before-show', 'before-hide', 'show', 'hide', 'filter', 'selectall-change'],
         props: {
             modelValue: null,
             options: Array,
@@ -26,8 +26,13 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
     		},
     		placeholder: String,
     		disabled: Boolean,
-            tabindex: String,
             inputId: String,
+            inputProps: null,
+            panelStyle: null,
+            panelClass: null,
+            panelProps: null,
+            filterInputProps: null,
+            closeButtonProps: null,
             dataKey: null,
             filter: Boolean,
             filterPlaceholder: String,
@@ -40,24 +45,14 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
                 type: Array,
                 default: null
             },
-            ariaLabelledBy: null,
             appendTo: {
                 type: String,
                 default: 'body'
             },
-            emptyFilterMessage: {
-                type: String,
-                default: null
-            },
-            emptyMessage: {
-                type: String,
-                default: null
-            },
             display: {
                 type: String,
                 default: 'comma'
             },
-            panelClass: null,
             selectedItemsLabel: {
                 type: String,
                 default: '{0} items selected'
@@ -93,21 +88,75 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
             virtualScrollerOptions: {
                 type: Object,
                 default: null
+            },
+            autoOptionFocus: {
+                type: Boolean,
+                default: true
+            },
+            filterMessage: {
+                type: String,
+                default: null
+            },
+            selectionMessage: {
+                type: String,
+                default: null
+            },
+            emptySelectionMessage: {
+                type: String,
+                default: null
+            },
+            emptyFilterMessage: {
+                type: String,
+                default: null
+            },
+            emptyMessage: {
+                type: String,
+                default: null
+            },
+            tabindex: {
+                type: Number,
+                default: 0
+            },
+            'aria-label': {
+                type: String,
+                default: null
+            },
+            'aria-labelledby': {
+                type: String,
+                default: null
             }
         },
+        outsideClickListener: null,
+        scrollHandler: null,
+        resizeListener: null,
+        overlay: null,
+        list: null,
+        virtualScroller: null,
+        startRangeIndex: -1,
+        searchTimeout: null,
+        searchValue: '',
+        selectOnFocus: false,
+        focusOnHover: false,
         data() {
             return {
+                id: utils.UniqueComponentId(),
                 focused: false,
+                focusedOptionIndex: -1,
                 headerCheckboxFocused: false,
                 filterValue: null,
                 overlayVisible: false
-            };
+            }
+        },
+        watch: {
+            options() {
+                this.autoUpdateModel();
+            }
+        },
+        mounted() {
+            this.id = this.$attrs.id || this.id;
+
+            this.autoUpdateModel();
         },
-        outsideClickListener: null,
-        resizeListener: null,
-        scrollHandler: null,
-        overlay: null,
-        virtualScroller: null,
         beforeUnmount() {
             this.unbindOutsideClickListener();
             this.unbindResizeListener();
@@ -135,15 +184,6 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
             getOptionRenderKey(option) {
                 return this.dataKey ? utils.ObjectUtils.resolveFieldData(option, this.dataKey) : this.getOptionLabel(option);
             },
-            getOptionGroupRenderKey(optionGroup) {
-                return utils.ObjectUtils.resolveFieldData(optionGroup, this.optionGroupLabel);
-            },
-            getOptionGroupLabel(optionGroup) {
-                return utils.ObjectUtils.resolveFieldData(optionGroup, this.optionGroupLabel);
-            },
-            getOptionGroupChildren(optionGroup) {
-                return utils.ObjectUtils.resolveFieldData(optionGroup, this.optionGroupChildren);
-            },
             isOptionDisabled(option) {
                 if (this.maxSelectionLimitReached && !this.isSelected(option)) {
                     return true;
@@ -151,109 +191,141 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
 
                 return this.optionDisabled ? utils.ObjectUtils.resolveFieldData(option, this.optionDisabled) : false;
             },
-            getSelectedOptionIndex() {
-                if (this.modelValue != null && this.options) {
-                    if (this.optionGroupLabel) {
-                        for (let i = 0; i < this.options.length; i++) {
-                            let selectedOptionIndex = this.findOptionIndexInList(this.modelValue, this.getOptionGroupChildren(this.options[i]));
-                            if (selectedOptionIndex !== -1) {
-                                return {group: i, option: selectedOptionIndex};
-                            }
-                        }
-                    }
-                    else {
-                        return this.findOptionIndexInList(this.modelValue, this.options);
-                    }
-                }
-
-                return -1;
+            isOptionGroup(option) {
+                return this.optionGroupLabel && option.optionGroup && option.group;
+            },
+            getOptionGroupLabel(optionGroup) {
+                return utils.ObjectUtils.resolveFieldData(optionGroup, this.optionGroupLabel);
             },
-            findOptionIndexInList(value, list) {
-                return value ? list.findIndex(item => value.some(val => utils.ObjectUtils.equals(val, this.getOptionValue(item), this.equalityKey))) : -1;
+            getOptionGroupChildren(optionGroup) {
+                return utils.ObjectUtils.resolveFieldData(optionGroup, this.optionGroupChildren);
             },
-            isSelected(option) {
-                if (this.modelValue) {
-                    let optionValue = this.getOptionValue(option);
-                    let key = this.equalityKey;
-
-                    return this.modelValue.some(val => utils.ObjectUtils.equals(val, optionValue, key));
-                }
-
-                return false;
+            getAriaPosInset(index) {
+                return (this.optionGroupLabel ? index - this.visibleOptions.slice(0, index).filter(option => this.isOptionGroup(option)).length : index) + 1;
             },
-            show() {
+            show(isFocus) {
                 this.$emit('before-show');
                 this.overlayVisible = true;
+                this.focusedOptionIndex = this.focusedOptionIndex !== -1 ? this.focusedOptionIndex : (this.autoOptionFocus ? this.findFirstFocusedOptionIndex() : -1);
+
+                isFocus && this.$refs.focusInput.focus();
             },
-            hide() {
+            hide(isFocus) {
                 this.$emit('before-hide');
                 this.overlayVisible = false;
-                if (this.resetFilterOnHide) {
-                    this.filterValue = null;
-                }
+                this.focusedOptionIndex = -1;
+                this.searchValue = '';
+
+                this.resetFilterOnHide && (this.filterValue = null);
+                isFocus && this.$refs.focusInput.focus();
             },
-            onFocus() {
+            onFocus(event) {
                 this.focused = true;
+                this.focusedOptionIndex = this.overlayVisible && this.autoOptionFocus ? this.findFirstFocusedOptionIndex() : -1;
+                this.overlayVisible && this.scrollInView(this.focusedOptionIndex);
+                this.$emit('focus', event);
             },
-            onBlur() {
+            onBlur(event) {
                 this.focused = false;
+                this.focusedOptionIndex = -1;
+                this.searchValue = '';
+                this.$emit('blur', event);
             },
-            onHeaderCheckboxFocus() {
-                this.headerCheckboxFocused = true;
-            },
-            onHeaderCheckboxBlur() {
-                this.headerCheckboxFocused = false;
+            onKeyDown(event) {
+                switch (event.code) {
+                    case 'ArrowDown':
+                        this.onArrowDownKey(event);
+                        break;
+
+                    case 'ArrowUp':
+                        this.onArrowUpKey(event);
+                        break;
+
+                    case 'Home':
+                        this.onHomeKey(event);
+                        break;
+
+                    case 'End':
+                        this.onEndKey(event);
+                        break;
+
+                    case 'PageDown':
+                        this.onPageDownKey(event);
+                        break;
+
+                    case 'PageUp':
+                        this.onPageUpKey(event);
+                        break;
+
+                    case 'Enter':
+                    case 'Space':
+                        this.onEnterKey(event);
+                        break;
+
+                    case 'Escape':
+                        this.onEscapeKey(event);
+                        break;
+
+                    case 'Tab':
+                        this.onTabKey(event);
+                        break;
+
+                    case 'ShiftLeft':
+                    case 'ShiftRight':
+                        this.onShiftKey(event);
+                        break;
+
+                    default:
+                        if (event.code === 'KeyA' && (event.metaKey || event.ctrlKey)) {
+                            const value = this.visibleOptions.filter(option => this.isValidOption(option)).map(option => this.getOptionValue(option));
+                            this.updateModel(event, value);
+
+                            event.preventDefault();
+                            break;
+                        }
+
+                        if (utils.ObjectUtils.isPrintableCharacter(event.key)) {
+                            !this.overlayVisible && this.show();
+                            this.searchOptions(event);
+                            event.preventDefault();
+                        }
+
+                        break;
+                }
             },
-            onClick(event) {
+            onContainerClick(event) {
                 if (this.disabled || this.loading) {
                     return;
                 }
 
-                if ((!this.overlay || !this.overlay.contains(event.target)) && !utils.DomHandler.hasClass(event.target, 'p-multiselect-close')) {
-                    utils.DomHandler.hasClass(event.target, 'p-multiselect-close');
-                    if (this.overlayVisible)
-                        this.hide();
-                    else
-                        this.show();
+                if (!this.overlay || !this.overlay.contains(event.target)) {
+                    this.overlayVisible ? this.hide(true) : this.show(true);
+                }
+            },
+            onFirstHiddenFocus(event) {
+                const relatedTarget = event.relatedTarget;
 
+                if (relatedTarget === this.$refs.focusInput) {
+                    const firstFocusableEl = utils.DomHandler.getFirstFocusableElement(this.overlay, ':not(.p-hidden-focusable)');
+                    firstFocusableEl && firstFocusableEl.focus();
+                }
+                else {
                     this.$refs.focusInput.focus();
                 }
             },
+            onLastHiddenFocus() {
+                this.$refs.firstHiddenFocusableElementOnOverlay.focus();
+            },
             onCloseClick() {
-                this.hide();
+                this.hide(true);
             },
-            onKeyDown(event) {
-                switch(event.which) {
-                    //down
-                    case 40:
-                        if (this.visibleOptions && !this.overlayVisible && event.altKey) {
-                            this.show();
-                        }
-                    break;
-
-                    //space
-                    case 32:
-                        if (!this.overlayVisible) {
-                            this.show();
-                            event.preventDefault();
-                        }
-                    break;
-
-                    //escape
-                    case 27:
-                        if (this.overlayVisible) {
-                            this.hide();
-                            event.preventDefault();
-                        }
-                    break;
-
-                    //tab
-                    case 9:
-                        this.hide();
-                    break;
-                }
+            onHeaderCheckboxFocus() {
+                this.headerCheckboxFocused = true;
+            },
+            onHeaderCheckboxBlur() {
+                this.headerCheckboxFocused = false;
             },
-            onOptionSelect(event, option) {
+            onOptionSelect(event, option, index = -1, isFocus = false) {
                 if (this.disabled || this.isOptionDisabled(option)) {
                     return;
                 }
@@ -266,84 +338,235 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
                 else
                     value = [...(this.modelValue || []), this.getOptionValue(option)];
 
-                this.$emit('update:modelValue', value);
-                this.$emit('change', {originalEvent: event, value: value});
+                this.updateModel(event, value);
+                isFocus && this.$refs.focusInput.focus();
+                index !== -1 && (this.focusedOptionIndex = index);
             },
-            onOptionKeyDown(event, option) {
-                let listItem = event.target;
+            onOptionMouseMove(event, index) {
+                if (this.focusOnHover) {
+                    this.changeFocusedOptionIndex(event, index);
+                }
+            },
+            onOptionSelectRange(event, start = -1, end = -1) {
+                start === -1 && (start = this.findNearestSelectedOptionIndex(end, true));
+                end === -1 && (end = this.findNearestSelectedOptionIndex(start));
 
-                switch(event.which) {
-                    //down
-                    case 40:
-                        var nextItem = this.findNextItem(listItem);
-                        if (nextItem) {
-                            nextItem.focus();
-                        }
+                if (start !== -1 && end !== -1) {
+                    const rangeStart = Math.min(start, end);
+                    const rangeEnd = Math.max(start, end);
+                    const value = this.visibleOptions.slice(rangeStart, rangeEnd + 1).filter(option => this.isValidOption(option)).map(option => this.getOptionValue(option));
 
-                        event.preventDefault();
-                    break;
+                    this.updateModel(event, value);
+                }
+            },
+            onFilterChange(event) {
+                const value = event.target.value;
 
-                    //up
-                    case 38:
-                        var prevItem = this.findPrevItem(listItem);
-                        if (prevItem) {
-                            prevItem.focus();
-                        }
+                this.filterValue = value;
+                this.focusedOptionIndex = -1;
+                this.$emit('filter', { originalEvent: event, value });
 
-                        event.preventDefault();
-                    break;
+                !this.virtualScrollerDisabled && this.virtualScroller.scrollToIndex(0);
+            },
+            onFilterKeyDown(event) {
+                switch (event.code) {
+                    case 'ArrowDown':
+                        this.onArrowDownKey(event);
+                        break;
 
-                    //enter
-                    case 13:
-                        this.onOptionSelect(event, option);
-                        event.preventDefault();
-                    break;
+                    case 'ArrowUp':
+                        this.onArrowUpKey(event, true);
+                        break;
+
+                    case 'ArrowLeft':
+                    case 'ArrowRight':
+                        this.onArrowLeftKey(event, true);
+                        break;
+
+                    case 'Home':
+                        this.onHomeKey(event, true);
+                        break;
+
+                    case 'End':
+                        this.onEndKey(event, true);
+                        break;
+
+                    case 'Enter':
+                        this.onEnterKey(event);
+                        break;
+
+                    case 'Escape':
+                        this.onEscapeKey(event);
+                        break;
+
+                    case 'Tab':
+                        this.onTabKey(event, true);
+                        break;
                 }
             },
-            findNextItem(item) {
-                let nextItem = item.nextElementSibling;
+            onFilterBlur() {
+                this.focusedOptionIndex = -1;
+            },
+            onFilterUpdated() {
+                if (this.overlayVisible) {
+                    this.alignOverlay();
+                }
+            },
+            onOverlayClick(event) {
+                OverlayEventBus__default["default"].emit('overlay-click', {
+                    originalEvent: event,
+                    target: this.$el
+                });
+            },
+            onOverlayKeyDown(event) {
+                switch (event.code) {
+                    case 'Escape':
+                        this.onEscapeKey(event);
+                        break;
+                }
+            },
+            onArrowDownKey(event) {
+                const optionIndex = this.focusedOptionIndex !== -1 ? this.findNextOptionIndex(this.focusedOptionIndex) : this.findFirstFocusedOptionIndex();
 
-                if (nextItem)
-                    return utils.DomHandler.hasClass(nextItem, 'p-disabled') || utils.DomHandler.hasClass(nextItem, 'p-multiselect-item-group') ? this.findNextItem(nextItem) : nextItem;
-                else
-                    return null;
+                if (event.shiftKey) {
+                    this.onOptionSelectRange(event, this.startRangeIndex, optionIndex);
+                }
+
+                this.changeFocusedOptionIndex(event, optionIndex);
+
+                !this.overlayVisible && this.show();
+                event.preventDefault();
             },
-            findPrevItem(item) {
-                let prevItem = item.previousElementSibling;
+            onArrowUpKey(event, pressedInInputText = false) {
+                if (event.altKey && !pressedInInputText) {
+                    if (this.focusedOptionIndex !== -1) {
+                        this.onOptionSelect(event, this.visibleOptions[this.focusedOptionIndex]);
+                    }
 
-                if (prevItem)
-                    return utils.DomHandler.hasClass(prevItem, 'p-disabled') || utils.DomHandler.hasClass(prevItem, 'p-multiselect-item-group') ? this.findPrevItem(prevItem) : prevItem;
-                else
-                    return null;
+                    this.overlayVisible && this.hide();
+                    event.preventDefault();
+                }
+                else {
+                    const optionIndex = this.focusedOptionIndex !== -1 ? this.findPrevOptionIndex(this.focusedOptionIndex) : this.findLastFocusedOptionIndex();
+
+                    if (event.shiftKey) {
+                        this.onOptionSelectRange(event, optionIndex, this.startRangeIndex);
+                    }
+
+                    this.changeFocusedOptionIndex(event, optionIndex);
+
+                    !this.overlayVisible && this.show();
+                    event.preventDefault();
+                }
             },
-            onOverlayEnter(el) {
-                utils.ZIndexUtils.set('overlay', el, this.$primevue.config.zIndex.overlay);
-                this.alignOverlay();
+            onArrowLeftKey(event, pressedInInputText = false) {
+                pressedInInputText && (this.focusedOptionIndex = -1);
+            },
+            onHomeKey(event, pressedInInputText = false) {
+                if (pressedInInputText) {
+                    event.currentTarget.setSelectionRange(0, 0);
+                    this.focusedOptionIndex = -1;
+                }
+                else {
+                    let metaKey = event.metaKey || event.ctrlKey;
+                    let optionIndex = this.findFirstOptionIndex();
 
-                if (!this.virtualScrollerDisabled) {
-                    const selectedIndex = this.getSelectedOptionIndex();
-                    if (selectedIndex !== -1) {
-                        setTimeout(() => {
-                            this.virtualScroller && this.virtualScroller.scrollToIndex(selectedIndex);
-                        }, 0);
+                    if (event.shiftKey && metaKey) {
+                        this.onOptionSelectRange(event, optionIndex, this.startRangeIndex);
                     }
+
+                    this.changeFocusedOptionIndex(event, optionIndex);
+
+                    !this.overlayVisible && this.show();
                 }
+
+                event.preventDefault();
+            },
+            onEndKey(event, pressedInInputText = false) {
+                if (pressedInInputText) {
+                    const target = event.currentTarget;
+                    const len = target.value.length;
+                    target.setSelectionRange(len, len);
+                    this.focusedOptionIndex = -1;
+                }
+                else {
+                    let metaKey = event.metaKey || event.ctrlKey;
+                    let optionIndex = this.findLastOptionIndex();
+
+                    if (event.shiftKey && metaKey) {
+                        this.onOptionSelectRange(event, this.startRangeIndex, optionIndex);
+                    }
+
+                    this.changeFocusedOptionIndex(event, optionIndex);
+
+                    !this.overlayVisible && this.show();
+                }
+
+                event.preventDefault();
+            },
+            onPageUpKey(event) {
+                this.scrollInView(0);
+                event.preventDefault();
+            },
+            onPageDownKey(event) {
+                this.scrollInView(this.visibleOptions.length - 1);
+                event.preventDefault();
+            },
+            onEnterKey(event) {
+                if (!this.overlayVisible) {
+                    this.onArrowDownKey(event);
+                }
+                else {
+                    if (this.focusedOptionIndex !== -1) {
+                        if (event.shiftKey)
+                            this.onOptionSelectRange(event, this.focusedOptionIndex);
+                        else
+                            this.onOptionSelect(event, this.visibleOptions[this.focusedOptionIndex]);
+                    }
+                }
+
+                event.preventDefault();
+            },
+            onEscapeKey(event) {
+                this.overlayVisible && this.hide(true);
+                event.preventDefault();
+            },
+            onTabKey(event, pressedInInputText = false) {
+                if (!pressedInInputText) {
+                    if (this.overlayVisible && this.hasFocusableElements()) {
+                        this.$refs.firstHiddenFocusableElementOnOverlay.focus();
+
+                        event.preventDefault();
+                    }
+                    else {
+                        if (this.focusedOptionIndex !== -1) {
+                            this.onOptionSelect(event, this.visibleOptions[this.focusedOptionIndex]);
+                        }
+
+                        this.overlayVisible && this.hide(this.filter);
+                    }
+                }
+            },
+            onShiftKey() {
+                this.startRangeIndex = this.focusedOptionIndex;
+            },
+            onOverlayEnter(el) {
+                utils.ZIndexUtils.set('overlay', el, this.$primevue.config.zIndex.overlay);
+                this.alignOverlay();
+                this.scrollInView();
             },
             onOverlayAfterEnter() {
                 this.bindOutsideClickListener();
                 this.bindScrollListener();
                 this.bindResizeListener();
 
-                if (this.filter) {
-                    this.$refs.filterInput.focus();
-                }
-
                 this.$emit('show');
             },
             onOverlayLeave() {
                 this.unbindOutsideClickListener();
                 this.unbindScrollListener();
                 this.unbindResizeListener();
+
                 this.$emit('hide');
                 this.overlay = null;
             },
@@ -410,34 +633,9 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
             isOutsideClicked(event) {
                 return !(this.$el.isSameNode(event.target) || this.$el.contains(event.target) || (this.overlay && this.overlay.contains(event.target)));
             },
-            getLabelByValue(val) {
-                let option;
-                if (this.options) {
-                    if (this.optionGroupLabel) {
-                        for (let optionGroup of this.options) {
-                            option = this.findOptionByValue(val, this.getOptionGroupChildren(optionGroup));
-                            if (option) {
-                                break;
-                            }
-                        }
-                    }
-                    else {
-                        option = this.findOptionByValue(val, this.options);
-                    }
-                }
-
-                return option ? this.getOptionLabel(option): null;
-            },
-            findOptionByValue(val, list) {
-                for (let option of list) {
-                    let optionValue = this.getOptionValue(option);
-
-                    if(utils.ObjectUtils.equals(optionValue, val, this.equalityKey)) {
-                        return option;
-                    }
-                }
-
-                return null;
+            getLabelByValue(value) {
+                const matchedOption = this.visibleOptions.find(option => !this.isOptionGroup(option) && utils.ObjectUtils.equals(this.getOptionValue(option), value, this.equalityKey));
+                return matchedOption ? this.getOptionLabel(matchedOption): null;
             },
             getSelectedItemsLabel() {
                 let pattern = /{(.*?)}/;
@@ -452,85 +650,176 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
                     this.$emit('selectall-change', {originalEvent: event, checked: !this.allSelected});
                 }
                 else {
-                    let value = null;
+                    const value = this.allSelected ? [] : this.visibleOptions.filter(option => !this.isOptionGroup(option)).map(option => this.getOptionValue(option));
+
+                    this.updateModel(event, value);
+                }
+
+                this.headerCheckboxFocused = true;
+            },
+            removeOption(event, optionValue) {
+                let value = this.modelValue.filter(val => !utils.ObjectUtils.equals(val, optionValue, this.equalityKey));
 
-                    if (this.allSelected) {
-                        value = [];
+                this.updateModel(event, value);
+            },
+            clearFilter() {
+                this.filterValue = null;
+            },
+            hasFocusableElements() {
+                return utils.DomHandler.getFocusableElements(this.overlay, ':not(.p-hidden-focusable)').length > 0;
+            },
+            isOptionMatched(option) {
+                return this.isValidOption(option) && this.getOptionLabel(option).toLocaleLowerCase(this.filterLocale).startsWith(this.searchValue.toLocaleLowerCase(this.filterLocale));
+            },
+            isValidOption(option) {
+                return option && !(this.isOptionDisabled(option) || this.isOptionGroup(option));
+            },
+            isValidSelectedOption(option) {
+                return this.isValidOption(option) && this.isSelected(option);
+            },
+            isSelected(option) {
+                const optionValue = this.getOptionValue(option);
+                return (this.modelValue || []).some(value => utils.ObjectUtils.equals(value, optionValue, this.equalityKey));
+            },
+            findFirstOptionIndex() {
+                return this.visibleOptions.findIndex(option => this.isValidOption(option));
+            },
+            findLastOptionIndex() {
+                return utils.ObjectUtils.findLastIndex(this.visibleOptions, option => this.isValidOption(option));
+            },
+            findNextOptionIndex(index) {
+                const matchedOptionIndex = index < (this.visibleOptions.length - 1) ? this.visibleOptions.slice(index + 1).findIndex(option => this.isValidOption(option)) : -1;
+                return matchedOptionIndex > -1 ? matchedOptionIndex + index + 1 : index;
+            },
+            findPrevOptionIndex(index) {
+                const matchedOptionIndex = index > 0 ? utils.ObjectUtils.findLastIndex(this.visibleOptions.slice(0, index), option => this.isValidOption(option)) : -1;
+                return matchedOptionIndex > -1 ? matchedOptionIndex : index;
+            },
+            findFirstSelectedOptionIndex() {
+                return this.hasSelectedOption ? this.visibleOptions.findIndex(option => this.isValidSelectedOption(option)) : -1;
+            },
+            findLastSelectedOptionIndex() {
+                return this.hasSelectedOption ? utils.ObjectUtils.findLastIndex(this.visibleOptions, option => this.isValidSelectedOption(option)) : -1;
+            },
+            findNextSelectedOptionIndex(index) {
+                const matchedOptionIndex = this.hasSelectedOption && index < (this.visibleOptions.length - 1) ? this.visibleOptions.slice(index + 1).findIndex(option => this.isValidSelectedOption(option)) : -1;
+                return matchedOptionIndex > -1 ? matchedOptionIndex + index + 1 : -1;
+            },
+            findPrevSelectedOptionIndex(index) {
+                const matchedOptionIndex = this.hasSelectedOption && index > 0 ? utils.ObjectUtils.findLastIndex(this.visibleOptions.slice(0, index), option => this.isValidSelectedOption(option)) : -1;
+                return matchedOptionIndex > -1 ? matchedOptionIndex : -1;
+            },
+            findNearestSelectedOptionIndex(index, firstCheckUp = false) {
+                let matchedOptionIndex = -1;
+
+                if (this.hasSelectedOption) {
+                    if (firstCheckUp) {
+                        matchedOptionIndex = this.findPrevSelectedOptionIndex(index);
+                        matchedOptionIndex = matchedOptionIndex === -1 ? this.findNextSelectedOptionIndex(index) : matchedOptionIndex;
                     }
-                    else if (this.visibleOptions) {
-                        if (this.optionGroupLabel) {
-                            value = [];
-                            this.visibleOptions.forEach(optionGroup => {
-                                for (let option of this.getOptionGroupChildren(optionGroup)) {
-                                    value.push(this.getOptionValue(option));
-                                }
-                            });
-                        }
-                        else  {
-                            value = this.visibleOptions.map(option => this.getOptionValue(option));
-                        }
+                    else {
+                        matchedOptionIndex = this.findNextSelectedOptionIndex(index);
+                        matchedOptionIndex = matchedOptionIndex === -1 ? this.findPrevSelectedOptionIndex(index) : matchedOptionIndex;
                     }
+                }
 
-                    this.$emit('update:modelValue', value);
-                    this.$emit('change', {originalEvent: event, value: value});
+                return matchedOptionIndex > -1 ? matchedOptionIndex : index;
+            },
+            findFirstFocusedOptionIndex() {
+                const selectedIndex = this.findFirstSelectedOptionIndex();
+                return selectedIndex < 0 ? this.findFirstOptionIndex() : selectedIndex;
+            },
+            findLastFocusedOptionIndex() {
+                const selectedIndex = this.findLastSelectedOptionIndex();
+                return selectedIndex < 0 ? this.findLastOptionIndex() : selectedIndex;
+            },
+            searchOptions(event) {
+                this.searchValue = (this.searchValue || '') + event.key;
+
+                let optionIndex = -1;
+                if (this.focusedOptionIndex !== -1) {
+                    optionIndex = this.visibleOptions.slice(this.focusedOptionIndex).findIndex(option => this.isOptionMatched(option));
+                    optionIndex = optionIndex === -1 ? this.visibleOptions.slice(0, this.focusedOptionIndex).findIndex(option => this.isOptionMatched(option)) : optionIndex + this.focusedOptionIndex;
+                }
+                else {
+                    optionIndex = this.visibleOptions.findIndex(option => this.isOptionMatched(option));
+                }
+
+                if (optionIndex === -1 && this.focusedOptionIndex === -1) {
+                    const selectedIndex = this.findSelectedOptionIndex();
+                    optionIndex = selectedIndex < 0 ? this.findFirstOptionIndex() : selectedIndex;
+                }
+
+                if (optionIndex !== -1) {
+                    this.changeFocusedOptionIndex(event, optionIndex);
+                }
+
+                if (this.searchTimeout) {
+                    clearTimeout(this.searchTimeout);
+                }
+
+                this.searchTimeout = setTimeout(() => {
+                    this.searchValue = '';
+                    this.searchTimeout = null;
+                }, 500);
+            },
+            changeFocusedOptionIndex(event, index) {
+                if (this.focusedOptionIndex !== index) {
+                    this.focusedOptionIndex = index;
+                    this.scrollInView();
                 }
             },
-            onFilterChange(event) {
-                this.$emit('filter', {originalEvent: event, value: event.target.value});
-                if (this.overlayVisible) {
-                    this.alignOverlay();
+            scrollInView(index = -1) {
+                const id = index !== -1 ? `${this.id}_${index}` : this.focusedOptionId;
+                const element = utils.DomHandler.findSingle(this.list, `li[id="${id}"]`);
+                if (element) {
+                    element.scrollIntoView && element.scrollIntoView({ block: 'nearest', inline: 'nearest' });
+                }
+                else if (!this.virtualScrollerDisabled) {
+                    this.virtualScroller && this.virtualScroller.scrollToIndex(index !== -1 ? index : this.focusedOptionIndex);
                 }
             },
-            overlayRef(el) {
-                this.overlay = el;
+            autoUpdateModel() {
+                if (this.selectOnFocus && this.autoOptionFocus && !this.hasSelectedOption) {
+                    this.focusedOptionIndex = this.findFirstFocusedOptionIndex();
+                    const value = this.getOptionValue(this.visibleOptions[this.focusedOptionIndex]);
+                    this.updateModel(null, [value]);
+                }
             },
-            virtualScrollerRef(el) {
-                this.virtualScroller = el;
+            updateModel(event, value) {
+                this.$emit('update:modelValue', value);
+                this.$emit('change', { originalEvent: event, value });
             },
-            removeChip(item) {
-                let value = this.modelValue.filter(val => !utils.ObjectUtils.equals(val, item, this.equalityKey));
+            flatOptions(options) {
+                return (options || []).reduce((result, option, index) => {
+                    result.push({ optionGroup: option, group: true, index });
 
-                this.$emit('update:modelValue', value);
-                this.$emit('change', {originalEvent: event, value: value});
+                    const optionGroupChildren = this.getOptionGroupChildren(option);
+                    optionGroupChildren && optionGroupChildren.forEach(o => result.push(o));
+
+                    return result;
+                }, []);
             },
-            onOverlayClick(event) {
-                OverlayEventBus__default["default"].emit('overlay-click', {
-                    originalEvent: event,
-                    target: this.$el
-                });
+            overlayRef(el) {
+                this.overlay = el;
             },
-            clearFilter() {
-                this.filterValue = null;
+            listRef(el, contentRef) {
+                this.list = el;
+                contentRef && contentRef(el); // For VirtualScroller
+            },
+            virtualScrollerRef(el) {
+                this.virtualScroller = el;
             }
         },
         computed: {
-            visibleOptions() {
-                if (this.filterValue) {
-                    if (this.optionGroupLabel) {
-                        let filteredGroups = [];
-                        for (let optgroup of this.options) {
-                            let filteredSubOptions = api.FilterService.filter(this.getOptionGroupChildren(optgroup), this.searchFields, this.filterValue, this.filterMatchMode, this.filterLocale);
-                            if (filteredSubOptions && filteredSubOptions.length) {
-                                filteredGroups.push({...optgroup, ...{items: filteredSubOptions}});
-                            }
-                        }
-                        return filteredGroups
-                    }
-                    else {
-                        return api.FilterService.filter(this.options, this.searchFields, this.filterValue, this.filterMatchMode, this.filterLocale);
-                    }
-                }
-                else {
-                    return this.options;
-                }
-            },
             containerClass() {
                 return ['p-multiselect p-component p-inputwrapper', {
                     'p-multiselect-chip': this.display === 'chip',
                     'p-disabled': this.disabled,
                     'p-focus': this.focused,
                     'p-inputwrapper-filled': this.modelValue && this.modelValue.length,
-                    'p-inputwrapper-focus': this.focused || this.overlayVisible
+                    'p-inputwrapper-focus': this.focused || this.overlayVisible,
+                    'p-overlay-open': this.overlayVisible
                 }];
             },
             labelClass() {
@@ -539,13 +828,27 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
                     'p-multiselect-label-empty': !this.placeholder && (!this.modelValue || this.modelValue.length === 0)
                 }];
             },
+            dropdownIconClass() {
+                return ['p-multiselect-trigger-icon', this.loading ? this.loadingIcon : 'pi pi-chevron-down'];
+            },
             panelStyleClass() {
                 return ['p-multiselect-panel p-component', this.panelClass, {
                     'p-input-filled': this.$primevue.config.inputStyle === 'filled',
                     'p-ripple-disabled': this.$primevue.config.ripple === false
                 }];
             },
-            label() {
+            headerCheckboxClass() {
+                return ['p-checkbox p-component', {
+                    'p-checkbox-checked': this.allSelected,
+                    'p-checkbox-focused': this.headerCheckboxFocused
+                }];
+            },
+            visibleOptions() {
+                const options = this.optionGroupLabel ? this.flatOptions(this.options) : (this.options || []);
+
+                return this.filterValue ? api.FilterService.filter(options, this.searchFields, this.filterValue, this.filterMatchMode, this.filterLocale) : options;
+            },
+            label() { // TODO: Refactor
                 let label;
 
                 if (this.modelValue && this.modelValue.length) {
@@ -554,8 +857,8 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
                     }
                     else {
                         label = '';
-                        for(let i = 0; i < this.modelValue.length; i++) {
-                            if(i !== 0) {
+                        for (let i = 0; i < this.modelValue.length; i++) {
+                            if (i !== 0) {
                                 label += ', ';
                             }
 
@@ -570,48 +873,10 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
                 return label;
             },
             allSelected() {
-                if (this.selectAll !== null) {
-                    return this.selectAll;
-                }
-                else {
-                    if (this.filterValue && this.filterValue.trim().length > 0) {
-                        if (this.visibleOptions.length === 0) {
-                            return false;
-                        }
-
-                        if (this.optionGroupLabel) {
-                            for (let optionGroup of this.visibleOptions) {
-                                for (let option of this.getOptionGroupChildren(optionGroup)) {
-                                    if (!this.isSelected(option)) {
-                                        return false;
-                                    }
-                                }
-                            }
-                        }
-                        else {
-                            for (let option of this.visibleOptions) {
-                                if (!this.isSelected(option)) {
-                                    return false;
-                                }
-                            }
-                        }
-
-                        return true;
-                    }
-                    else {
-                        if (this.modelValue && this.options) {
-                            let optionCount = 0;
-                            if (this.optionGroupLabel)
-                                this.options.forEach(optionGroup => optionCount += this.getOptionGroupChildren(optionGroup).length);
-                            else
-                                optionCount = this.options.length;
-
-                            return optionCount > 0 && optionCount === this.modelValue.length;
-                        }
-
-                        return false;
-                    }
-                }
+                return (this.selectAll !== null) ? this.selectAll : (utils.ObjectUtils.isNotEmpty(this.visibleOptions) && this.visibleOptions.every(option => this.isOptionGroup(option) || this.isValidSelectedOption(option)));
+            },
+            hasSelectedOption() {
+                return utils.ObjectUtils.isNotEmpty(this.modelValue);
             },
             equalityKey() {
                 return this.optionValue ? null : this.dataKey;
@@ -619,20 +884,44 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
             searchFields() {
                 return this.filterFields || [this.optionLabel];
             },
+            maxSelectionLimitReached() {
+                return this.selectionLimit && (this.modelValue && this.modelValue.length === this.selectionLimit);
+            },
+            filterResultMessageText() {
+                return utils.ObjectUtils.isNotEmpty(this.visibleOptions) ? this.filterMessageText.replaceAll('{0}', this.visibleOptions.length) : this.emptyFilterMessageText;
+            },
+            filterMessageText() {
+                return this.filterMessage || this.$primevue.config.locale.searchMessage || '';
+            },
             emptyFilterMessageText() {
-                return this.emptyFilterMessage || this.$primevue.config.locale.emptyFilterMessage;
+                return this.emptyFilterMessage || this.$primevue.config.locale.emptySearchMessage || this.$primevue.config.locale.emptyFilterMessage || '';
             },
             emptyMessageText() {
-                return this.emptyMessage || this.$primevue.config.locale.emptyMessage;
+                return this.emptyMessage || this.$primevue.config.locale.emptyMessage || '';
             },
-            virtualScrollerDisabled() {
-                return !this.virtualScrollerOptions;
+            selectionMessageText() {
+                return this.selectionMessage || this.$primevue.config.locale.selectionMessage || '';
             },
-            maxSelectionLimitReached() {
-                return this.selectionLimit && (this.modelValue && this.modelValue.length === this.selectionLimit);
+            emptySelectionMessageText() {
+                return this.emptySelectionMessage || this.$primevue.config.locale.emptySelectionMessage || '';
             },
-            dropdownIconClass() {
-                return ['p-multiselect-trigger-icon', this.loading ? this.loadingIcon : 'pi pi-chevron-down'];
+            selectedMessageText() {
+                return this.hasSelectedOption ? this.selectionMessageText.replaceAll('{0}', this.modelValue.length) : this.emptySelectionMessageText;
+            },
+            focusedOptionId() {
+                return this.focusedOptionIndex !== -1 ? `${this.id}_${this.focusedOptionIndex}` : null;
+            },
+            ariaSetSize() {
+                return this.visibleOptions.filter(option => !this.isOptionGroup(option)).length;
+            },
+            toggleAllAriaLabel() {
+                return this.$primevue.config.locale.aria ? this.$primevue.config.locale.aria[this.allSelected ? 'selectAll' : 'unselectAll'] : undefined;
+            },
+            closeAriaLabel() {
+                return this.$primevue.config.locale.aria ? this.$primevue.config.locale.aria.close : undefined;
+            },
+            virtualScrollerDisabled() {
+                return !this.virtualScrollerOptions;
             }
         },
         directives: {
@@ -645,7 +934,7 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
     };
 
     const _hoisted_1 = { class: "p-hidden-accessible" };
-    const _hoisted_2 = ["id", "disabled", "tabindex", "aria-expanded", "aria-labelledby"];
+    const _hoisted_2 = ["id", "disabled", "placeholder", "tabindex", "aria-label", "aria-labelledby", "aria-expanded", "aria-controls", "aria-activedescendant"];
     const _hoisted_3 = { class: "p-multiselect-label-container" };
     const _hoisted_4 = { class: "p-multiselect-token-label" };
     const _hoisted_5 = ["onClick"];
@@ -654,31 +943,49 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
       key: 0,
       class: "p-multiselect-header"
     };
-    const _hoisted_8 = ["aria-checked"];
-    const _hoisted_9 = { class: "p-hidden-accessible" };
-    const _hoisted_10 = ["aria-checked"];
-    const _hoisted_11 = {
+    const _hoisted_8 = { class: "p-hidden-accessible" };
+    const _hoisted_9 = ["checked", "aria-label"];
+    const _hoisted_10 = {
       key: 1,
       class: "p-multiselect-filter-container"
     };
-    const _hoisted_12 = ["placeholder"];
-    const _hoisted_13 = /*#__PURE__*/vue.createElementVNode("span", { class: "p-multiselect-filter-icon pi pi-search" }, null, -1);
-    const _hoisted_14 = /*#__PURE__*/vue.createElementVNode("span", { class: "p-multiselect-close-icon pi pi-times" }, null, -1);
-    const _hoisted_15 = [
-      _hoisted_14
+    const _hoisted_11 = ["value", "placeholder", "aria-owns", "aria-activedescendant"];
+    const _hoisted_12 = /*#__PURE__*/vue.createElementVNode("span", { class: "p-multiselect-filter-icon pi pi-search" }, null, -1);
+    const _hoisted_13 = {
+      key: 2,
+      role: "status",
+      "aria-live": "polite",
+      class: "p-hidden-accessible"
+    };
+    const _hoisted_14 = ["aria-label"];
+    const _hoisted_15 = /*#__PURE__*/vue.createElementVNode("span", { class: "p-multiselect-close-icon pi pi-times" }, null, -1);
+    const _hoisted_16 = [
+      _hoisted_15
     ];
-    const _hoisted_16 = ["aria-selected", "onClick", "onKeydown", "tabindex", "aria-label"];
-    const _hoisted_17 = { class: "p-checkbox p-component" };
-    const _hoisted_18 = { class: "p-multiselect-item-group" };
-    const _hoisted_19 = ["aria-selected", "onClick", "onKeydown", "tabindex", "aria-label"];
+    const _hoisted_17 = ["id"];
+    const _hoisted_18 = ["id"];
+    const _hoisted_19 = ["id", "aria-label", "aria-selected", "aria-disabled", "aria-setsize", "aria-posinset", "onClick", "onMousemove"];
     const _hoisted_20 = { class: "p-checkbox p-component" };
     const _hoisted_21 = {
-      key: 2,
-      class: "p-multiselect-empty-message"
+      key: 0,
+      class: "p-multiselect-empty-message",
+      role: "option"
     };
     const _hoisted_22 = {
-      key: 3,
-      class: "p-multiselect-empty-message"
+      key: 1,
+      class: "p-multiselect-empty-message",
+      role: "option"
+    };
+    const _hoisted_23 = {
+      key: 0,
+      role: "status",
+      "aria-live": "polite",
+      class: "p-hidden-accessible"
+    };
+    const _hoisted_24 = {
+      role: "status",
+      "aria-live": "polite",
+      class: "p-hidden-accessible"
     };
 
     function render(_ctx, _cache, $props, $setup, $data, $options) {
@@ -689,24 +996,28 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
       return (vue.openBlock(), vue.createElementBlock("div", {
         ref: "container",
         class: vue.normalizeClass($options.containerClass),
-        onClick: _cache[10] || (_cache[10] = (...args) => ($options.onClick && $options.onClick(...args)))
+        onClick: _cache[15] || (_cache[15] = (...args) => ($options.onContainerClick && $options.onContainerClick(...args)))
       }, [
         vue.createElementVNode("div", _hoisted_1, [
-          vue.createElementVNode("input", {
+          vue.createElementVNode("input", vue.mergeProps({
             ref: "focusInput",
-            type: "text",
-            role: "listbox",
             id: $props.inputId,
+            type: "text",
             readonly: "",
             disabled: $props.disabled,
+            placeholder: $props.placeholder,
+            tabindex: !$props.disabled ? $props.tabindex : -1,
+            role: "combobox",
+            "aria-label": _ctx.ariaLabel,
+            "aria-labelledby": _ctx.ariaLabelledby,
+            "aria-haspopup": "listbox",
+            "aria-expanded": $data.overlayVisible,
+            "aria-controls": $data.id + '_list',
+            "aria-activedescendant": $data.focused ? $options.focusedOptionId : undefined,
             onFocus: _cache[0] || (_cache[0] = (...args) => ($options.onFocus && $options.onFocus(...args))),
             onBlur: _cache[1] || (_cache[1] = (...args) => ($options.onBlur && $options.onBlur(...args))),
-            onKeydown: _cache[2] || (_cache[2] = (...args) => ($options.onKeyDown && $options.onKeyDown(...args))),
-            tabindex: $props.tabindex,
-            "aria-haspopup": "true",
-            "aria-expanded": $data.overlayVisible,
-            "aria-labelledby": $props.ariaLabelledBy
-          }, null, 40, _hoisted_2)
+            onKeydown: _cache[2] || (_cache[2] = (...args) => ($options.onKeyDown && $options.onKeyDown(...args)))
+          }, $props.inputProps), null, 16, _hoisted_2)
         ]),
         vue.createElementVNode("div", _hoisted_3, [
           vue.createElementVNode("div", {
@@ -734,7 +1045,7 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
                             ? (vue.openBlock(), vue.createElementBlock("span", {
                                 key: 0,
                                 class: "p-multiselect-token-icon pi pi-times-circle",
-                                onClick: $event => ($options.removeChip(item))
+                                onClick: $event => ($options.removeOption($event, item))
                               }, null, 8, _hoisted_5))
                             : vue.createCommentVNode("", true)
                         ]))
@@ -752,7 +1063,8 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
         vue.createElementVNode("div", _hoisted_6, [
           vue.renderSlot(_ctx.$slots, "indicator", {}, () => [
             vue.createElementVNode("span", {
-              class: vue.normalizeClass($options.dropdownIconClass)
+              class: vue.normalizeClass($options.dropdownIconClass),
+              "aria-hidden": "true"
             }, null, 2)
           ])
         ]),
@@ -767,12 +1079,22 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
             }, {
               default: vue.withCtx(() => [
                 ($data.overlayVisible)
-                  ? (vue.openBlock(), vue.createElementBlock("div", {
+                  ? (vue.openBlock(), vue.createElementBlock("div", vue.mergeProps({
                       key: 0,
                       ref: $options.overlayRef,
-                      class: vue.normalizeClass($options.panelStyleClass),
-                      onClick: _cache[9] || (_cache[9] = (...args) => ($options.onOverlayClick && $options.onOverlayClick(...args)))
-                    }, [
+                      style: $props.panelStyle,
+                      class: $options.panelStyleClass,
+                      onClick: _cache[13] || (_cache[13] = (...args) => ($options.onOverlayClick && $options.onOverlayClick(...args))),
+                      onKeydown: _cache[14] || (_cache[14] = (...args) => ($options.onOverlayKeyDown && $options.onOverlayKeyDown(...args)))
+                    }, $props.panelProps), [
+                      vue.createElementVNode("span", {
+                        ref: "firstHiddenFocusableElementOnOverlay",
+                        role: "presentation",
+                        "aria-hidden": "true",
+                        class: "p-hidden-accessible p-hidden-focusable",
+                        tabindex: 0,
+                        onFocus: _cache[3] || (_cache[3] = (...args) => ($options.onFirstHiddenFocus && $options.onFirstHiddenFocus(...args)))
+                      }, null, 544),
                       vue.renderSlot(_ctx.$slots, "header", {
                         value: $props.modelValue,
                         options: $options.visibleOptions
@@ -782,51 +1104,57 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
                             ($props.showToggleAll && $props.selectionLimit == null)
                               ? (vue.openBlock(), vue.createElementBlock("div", {
                                   key: 0,
-                                  class: "p-checkbox p-component",
-                                  onClick: _cache[5] || (_cache[5] = (...args) => ($options.onToggleAll && $options.onToggleAll(...args))),
-                                  role: "checkbox",
-                                  "aria-checked": $options.allSelected
+                                  class: vue.normalizeClass($options.headerCheckboxClass),
+                                  onClick: _cache[6] || (_cache[6] = (...args) => ($options.onToggleAll && $options.onToggleAll(...args)))
                                 }, [
-                                  vue.createElementVNode("div", _hoisted_9, [
+                                  vue.createElementVNode("div", _hoisted_8, [
                                     vue.createElementVNode("input", {
                                       type: "checkbox",
                                       readonly: "",
-                                      onFocus: _cache[3] || (_cache[3] = (...args) => ($options.onHeaderCheckboxFocus && $options.onHeaderCheckboxFocus(...args))),
-                                      onBlur: _cache[4] || (_cache[4] = (...args) => ($options.onHeaderCheckboxBlur && $options.onHeaderCheckboxBlur(...args)))
-                                    }, null, 32)
+                                      checked: $options.allSelected,
+                                      "aria-label": $options.toggleAllAriaLabel,
+                                      onFocus: _cache[4] || (_cache[4] = (...args) => ($options.onHeaderCheckboxFocus && $options.onHeaderCheckboxFocus(...args))),
+                                      onBlur: _cache[5] || (_cache[5] = (...args) => ($options.onHeaderCheckboxBlur && $options.onHeaderCheckboxBlur(...args)))
+                                    }, null, 40, _hoisted_9)
                                   ]),
                                   vue.createElementVNode("div", {
-                                    class: vue.normalizeClass(['p-checkbox-box', {'p-highlight': $options.allSelected, 'p-focus': $data.headerCheckboxFocused}]),
-                                    role: "checkbox",
-                                    "aria-checked": $options.allSelected
+                                    class: vue.normalizeClass(['p-checkbox-box', {'p-highlight': $options.allSelected, 'p-focus': $data.headerCheckboxFocused}])
                                   }, [
                                     vue.createElementVNode("span", {
                                       class: vue.normalizeClass(['p-checkbox-icon', {'pi pi-check': $options.allSelected}])
                                     }, null, 2)
-                                  ], 10, _hoisted_10)
-                                ], 8, _hoisted_8))
+                                  ], 2)
+                                ], 2))
                               : vue.createCommentVNode("", true),
                             ($props.filter)
-                              ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_11, [
-                                  vue.withDirectives(vue.createElementVNode("input", {
+                              ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_10, [
+                                  vue.createElementVNode("input", vue.mergeProps({
                                     type: "text",
                                     ref: "filterInput",
-                                    "onUpdate:modelValue": _cache[6] || (_cache[6] = $event => (($data.filterValue) = $event)),
-                                    autoComplete: "on",
+                                    value: $data.filterValue,
+                                    onVnodeUpdated: _cache[7] || (_cache[7] = (...args) => ($options.onFilterUpdated && $options.onFilterUpdated(...args))),
                                     class: "p-multiselect-filter p-inputtext p-component",
                                     placeholder: $props.filterPlaceholder,
-                                    onInput: _cache[7] || (_cache[7] = (...args) => ($options.onFilterChange && $options.onFilterChange(...args)))
-                                  }, null, 40, _hoisted_12), [
-                                    [vue.vModelText, $data.filterValue]
-                                  ]),
-                                  _hoisted_13
+                                    role: "searchbox",
+                                    autocomplete: "off",
+                                    "aria-owns": $data.id + '_list',
+                                    "aria-activedescendant": $options.focusedOptionId,
+                                    onKeydown: _cache[8] || (_cache[8] = (...args) => ($options.onFilterKeyDown && $options.onFilterKeyDown(...args))),
+                                    onBlur: _cache[9] || (_cache[9] = (...args) => ($options.onFilterBlur && $options.onFilterBlur(...args))),
+                                    onInput: _cache[10] || (_cache[10] = (...args) => ($options.onFilterChange && $options.onFilterChange(...args)))
+                                  }, $props.filterInputProps), null, 16, _hoisted_11),
+                                  _hoisted_12
                                 ]))
                               : vue.createCommentVNode("", true),
-                            vue.withDirectives((vue.openBlock(), vue.createElementBlock("button", {
+                            ($props.filter)
+                              ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_13, vue.toDisplayString($options.filterResultMessageText), 1))
+                              : vue.createCommentVNode("", true),
+                            vue.withDirectives((vue.openBlock(), vue.createElementBlock("button", vue.mergeProps({
                               class: "p-multiselect-close p-link",
-                              onClick: _cache[8] || (_cache[8] = (...args) => ($options.onCloseClick && $options.onCloseClick(...args))),
+                              "aria-label": $options.closeAriaLabel,
+                              onClick: _cache[11] || (_cache[11] = (...args) => ($options.onCloseClick && $options.onCloseClick(...args))),
                               type: "button"
-                            }, _hoisted_15)), [
+                            }, $props.closeButtonProps), _hoisted_16, 16, _hoisted_14)), [
                               [_directive_ripple]
                             ])
                           ]))
@@ -838,91 +1166,71 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
                         vue.createVNode(_component_VirtualScroller, vue.mergeProps({ ref: $options.virtualScrollerRef }, $props.virtualScrollerOptions, {
                           items: $options.visibleOptions,
                           style: {'height': $props.scrollHeight},
+                          tabindex: -1,
                           disabled: $options.virtualScrollerDisabled
                         }), vue.createSlots({
-                          content: vue.withCtx(({ styleClass, contentRef, items, getItemOptions, contentStyle}) => [
+                          content: vue.withCtx(({ styleClass, contentRef, items, getItemOptions, contentStyle, itemSize }) => [
                             vue.createElementVNode("ul", {
-                              ref: contentRef,
+                              ref: (el) => $options.listRef(el, contentRef),
+                              id: $data.id + '_list',
                               class: vue.normalizeClass(['p-multiselect-items p-component', styleClass]),
                               style: vue.normalizeStyle(contentStyle),
                               role: "listbox",
                               "aria-multiselectable": "true"
                             }, [
-                              (!$props.optionGroupLabel)
-                                ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(items, (option, i) => {
-                                    return vue.withDirectives((vue.openBlock(), vue.createElementBlock("li", {
-                                      class: vue.normalizeClass(['p-multiselect-item', {'p-highlight': $options.isSelected(option), 'p-disabled': $options.isOptionDisabled(option)}]),
-                                      role: "option",
-                                      "aria-selected": $options.isSelected(option),
-                                      key: $options.getOptionRenderKey(option),
-                                      onClick: $event => ($options.onOptionSelect($event, option)),
-                                      onKeydown: $event => ($options.onOptionKeyDown($event, option)),
-                                      tabindex: $props.tabindex||'0',
-                                      "aria-label": $options.getOptionLabel(option)
-                                    }, [
-                                      vue.createElementVNode("div", _hoisted_17, [
-                                        vue.createElementVNode("div", {
-                                          class: vue.normalizeClass(['p-checkbox-box', {'p-highlight': $options.isSelected(option)}])
-                                        }, [
-                                          vue.createElementVNode("span", {
-                                            class: vue.normalizeClass(['p-checkbox-icon', {'pi pi-check': $options.isSelected(option)}])
-                                          }, null, 2)
-                                        ], 2)
-                                      ]),
-                                      vue.renderSlot(_ctx.$slots, "option", {
-                                        option: option,
-                                        index: $options.getOptionIndex(i, getItemOptions)
-                                      }, () => [
-                                        vue.createElementVNode("span", null, vue.toDisplayString($options.getOptionLabel(option)), 1)
-                                      ])
-                                    ], 42, _hoisted_16)), [
-                                      [_directive_ripple]
-                                    ])
-                                  }), 128))
-                                : (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 1 }, vue.renderList(items, (optionGroup, i) => {
-                                    return (vue.openBlock(), vue.createElementBlock(vue.Fragment, {
-                                      key: $options.getOptionGroupRenderKey(optionGroup)
-                                    }, [
-                                      vue.createElementVNode("li", _hoisted_18, [
+                              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(items, (option, i) => {
+                                return (vue.openBlock(), vue.createElementBlock(vue.Fragment, {
+                                  key: $options.getOptionRenderKey(option, $options.getOptionIndex(i, getItemOptions))
+                                }, [
+                                  ($options.isOptionGroup(option))
+                                    ? (vue.openBlock(), vue.createElementBlock("li", {
+                                        key: 0,
+                                        id: $data.id + '_' + $options.getOptionIndex(i, getItemOptions),
+                                        style: vue.normalizeStyle({height: itemSize ? itemSize + 'px' : undefined}),
+                                        class: "p-multiselect-item-group",
+                                        role: "option"
+                                      }, [
                                         vue.renderSlot(_ctx.$slots, "optiongroup", {
-                                          option: optionGroup,
+                                          option: option.optionGroup,
                                           index: $options.getOptionIndex(i, getItemOptions)
                                         }, () => [
-                                          vue.createTextVNode(vue.toDisplayString($options.getOptionGroupLabel(optionGroup)), 1)
+                                          vue.createTextVNode(vue.toDisplayString($options.getOptionGroupLabel(option.optionGroup)), 1)
                                         ])
-                                      ]),
-                                      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList($options.getOptionGroupChildren(optionGroup), (option, i) => {
-                                        return vue.withDirectives((vue.openBlock(), vue.createElementBlock("li", {
-                                          class: vue.normalizeClass(['p-multiselect-item', {'p-highlight': $options.isSelected(option), 'p-disabled': $options.isOptionDisabled(option)}]),
-                                          role: "option",
-                                          "aria-selected": $options.isSelected(option),
-                                          key: $options.getOptionRenderKey(option),
-                                          onClick: $event => ($options.onOptionSelect($event, option)),
-                                          onKeydown: $event => ($options.onOptionKeyDown($event, option)),
-                                          tabindex: $props.tabindex||'0',
-                                          "aria-label": $options.getOptionLabel(option)
-                                        }, [
-                                          vue.createElementVNode("div", _hoisted_20, [
-                                            vue.createElementVNode("div", {
-                                              class: vue.normalizeClass(['p-checkbox-box', {'p-highlight': $options.isSelected(option)}])
-                                            }, [
-                                              vue.createElementVNode("span", {
-                                                class: vue.normalizeClass(['p-checkbox-icon', {'pi pi-check': $options.isSelected(option)}])
-                                              }, null, 2)
-                                            ], 2)
-                                          ]),
-                                          vue.renderSlot(_ctx.$slots, "option", {
-                                            option: option,
-                                            index: $options.getOptionIndex(i, getItemOptions)
-                                          }, () => [
-                                            vue.createElementVNode("span", null, vue.toDisplayString($options.getOptionLabel(option)), 1)
-                                          ])
-                                        ], 42, _hoisted_19)), [
-                                          [_directive_ripple]
+                                      ], 12, _hoisted_18))
+                                    : vue.withDirectives((vue.openBlock(), vue.createElementBlock("li", {
+                                        key: 1,
+                                        id: $data.id + '_' + $options.getOptionIndex(i, getItemOptions),
+                                        style: vue.normalizeStyle({height: itemSize ? itemSize + 'px' : undefined}),
+                                        class: vue.normalizeClass(['p-multiselect-item', {'p-highlight': $options.isSelected(option), 'p-focus': $data.focusedOptionIndex === $options.getOptionIndex(i, getItemOptions), 'p-disabled': $options.isOptionDisabled(option)}]),
+                                        role: "option",
+                                        "aria-label": $options.getOptionLabel(option),
+                                        "aria-selected": $options.isSelected(option),
+                                        "aria-disabled": $options.isOptionDisabled(option),
+                                        "aria-setsize": $options.ariaSetSize,
+                                        "aria-posinset": $options.getAriaPosInset($options.getOptionIndex(i, getItemOptions)),
+                                        onClick: $event => ($options.onOptionSelect($event, option, $options.getOptionIndex(i, getItemOptions), true)),
+                                        onMousemove: $event => ($options.onOptionMouseMove($event, $options.getOptionIndex(i, getItemOptions)))
+                                      }, [
+                                        vue.createElementVNode("div", _hoisted_20, [
+                                          vue.createElementVNode("div", {
+                                            class: vue.normalizeClass(['p-checkbox-box', {'p-highlight': $options.isSelected(option)}])
+                                          }, [
+                                            vue.createElementVNode("span", {
+                                              class: vue.normalizeClass(['p-checkbox-icon', {'pi pi-check': $options.isSelected(option)}])
+                                            }, null, 2)
+                                          ], 2)
+                                        ]),
+                                        vue.renderSlot(_ctx.$slots, "option", {
+                                          option: option,
+                                          index: $options.getOptionIndex(i, getItemOptions)
+                                        }, () => [
+                                          vue.createElementVNode("span", null, vue.toDisplayString($options.getOptionLabel(option)), 1)
                                         ])
-                                      }), 128))
-                                    ], 64))
-                                  }), 128)),
+                                      ], 46, _hoisted_19)), [
+                                        [_directive_ripple]
+                                      ])
+                                ], 64))
+                              }), 128)),
                               ($data.filterValue && (!items || (items && items.length === 0)))
                                 ? (vue.openBlock(), vue.createElementBlock("li", _hoisted_21, [
                                     vue.renderSlot(_ctx.$slots, "emptyfilter", {}, () => [
@@ -936,7 +1244,11 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
                                       ])
                                     ]))
                                   : vue.createCommentVNode("", true)
-                            ], 6)
+                            ], 14, _hoisted_17),
+                            ((!$props.options || ($props.options && $props.options.length === 0)))
+                              ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_23, vue.toDisplayString($options.emptyMessageText), 1))
+                              : vue.createCommentVNode("", true),
+                            vue.createElementVNode("span", _hoisted_24, vue.toDisplayString($options.selectedMessageText), 1)
                           ]),
                           _: 2
                         }, [
@@ -953,8 +1265,16 @@ this.primevue.multiselect = (function (utils, OverlayEventBus, api, Ripple, Virt
                       vue.renderSlot(_ctx.$slots, "footer", {
                         value: $props.modelValue,
                         options: $options.visibleOptions
-                      })
-                    ], 2))
+                      }),
+                      vue.createElementVNode("span", {
+                        ref: "lastHiddenFocusableElementOnOverlay",
+                        role: "presentation",
+                        "aria-hidden": "true",
+                        class: "p-hidden-accessible p-hidden-focusable",
+                        tabindex: 0,
+                        onFocus: _cache[12] || (_cache[12] = (...args) => ($options.onLastHiddenFocus && $options.onLastHiddenFocus(...args)))
+                      }, null, 544)
+                    ], 16))
                   : vue.createCommentVNode("", true)
               ]),
               _: 3