@govbr-ds/webcomponents 2.1.0 → 2.1.2

package/dist/collection/components/select/select.js

@@ -0,0 +1,2692 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+import { Host, h, } from "@stencil/core";
+import { dispatchNativeFormEvent } from "../../shared/utils/event";
+import { listenForExternalBlockingSurface } from "../../shared/utils/floating-surface-dismiss";
+import { getFormValidationState, isFormControlDisabled, safeSetFormValue, syncNativeFormValidity, } from "../../shared/utils/form";
+import { hasAssignedSlotContent, hasNamedLightDomSlot } from "../../shared/utils/slot";
+import { resolveFormValidator } from "../../shared/utils/validator";
+import { transitionAllSelection, transitionSelection } from "./select.utils";
+let selectId = 0;
+/**
+ * ## Design System
+ *
+ * Para a documentação completa de design, incluindo diretrizes de uso, acessibilidade e exemplos visuais, consulte o [Design System do GovBR](https://www.gov.br/ds/components/select?tab=designer).
+ *
+ * @category Formulários
+ * @status stable
+ * @slot default - Opções declaradas com elementos br-select-option.
+ * @slot feedback - Mensagem de validação, normalmente um br-message.
+ * @slot validation-loading - Indicador exibido durante validação assíncrona.
+ * @slot loading - Indicador exibido durante a busca remota de opções.
+ *
+ * @part container - Contêiner visual principal do select.
+ * @part input - Campo de seleção e busca.
+ * @part input-container - Contêiner visual do campo.
+ * @part input-label - Rótulo do campo.
+ * @part input-field - Campo input nativo.
+ * @part input-group - Grupo visual do campo.
+ * @part input-icon - Ícone do campo.
+ * @part input-action - Botão de abertura e fechamento.
+ * @part input-action-button - Botão interno da ação.
+ * @part list - Lista de opções.
+ * @part option - Opção individual.
+ * @part select-all - Alias legado para a opção de selecionar todos.
+ * @part empty-option - Alias legado para a opção vazia da lista.
+ * @part option-checkbox - Alias legado para o checkbox da opção.
+ * @part option-radio - Alias legado para o radio da opção.
+ * @part hidden-select - Select nativo invisível usado na integração com formulários.
+ * @part feedback - Área de mensagem de validação.
+ * @part validation-loading - Área do indicador de validação assíncrona.
+ */
+export class Select {
+    constructor() {
+        /**
+         * Remove a borda do input quando o componente não está em foco.
+         *
+         * @default false
+         */
+        this.borderless = false;
+        /**
+         * Desativa toda a interação do select.
+         *
+         * @default false
+         */
+        this.disabled = false;
+        /**
+         * Exibe label e campo na mesma linha.
+         *
+         * @default false
+         * @deprecated Use `inline`.
+         */
+        this.isInline = false;
+        /**
+         * Habilita o modo de seleção múltipla.
+         *
+         * @default false
+         * @deprecated Use `multiple`.
+         */
+        this.isMultiple = false;
+        /**
+         * Mantém a lista aberta depois de uma seleção.
+         *
+         * @default false
+         * @deprecated O comportamento atual usa o fechamento padrão do select; mantenha esta prop
+         * apenas para compatibilidade com integrações legadas.
+         */
+        this.keepOpenOnSelect = false;
+        /**
+         * Define quantas opções ficam visíveis na janela da lista.
+         *
+         * @default 6
+         */
+        this.visibleItems = 6;
+        /**
+         * Informa a altura base de cada opção para o cálculo de virtual scroll.
+         *
+         * @default 40
+         */
+        this.itemHeight = 40;
+        /**
+         * Controla a largura do campo de entrada.
+         *
+         * @type {string}
+         * @example '20rem'
+         */
+        this.inputWidth = undefined;
+        /**
+         * Define quantas opções extras são renderizadas antes e depois da área visível no virtual scroll.
+         *
+         * @default 1
+         */
+        this.overscan = 1;
+        /**
+         * Controla o estado aberto/fechado da lista.
+         *
+         * @default false
+         * @deprecated Use `open`.
+         */
+        this.isOpen = false;
+        /**
+         * Valor público do select baseado nas opções atualmente selecionadas.
+         *
+         * @type {string | string[] | undefined}
+         * @remarks Em modo múltiplo, o valor público é um array de strings.
+         */
+        this.value = '';
+        /**
+         * Texto exibido quando não há seleção.
+         *
+         * @type {string | undefined}
+         */
+        this.placeholder = '';
+        /**
+         * Indica que o preenchimento do select é obrigatório.
+         *
+         * @default false
+         */
+        this.required = false;
+        /**
+         * Rótulo apresentado para a opção de selecionar todos no modo múltiplo.
+         *
+         * @default 'Selecionar todos'
+         */
+        this.selectAllLabel = Select.SELECT_ALL_LABEL;
+        /**
+         * Habilita a filtragem textual das opções por rótulo ou valor.
+         *
+         * @default true
+         */
+        this.filterable = true;
+        /**
+         * Define se as opções são filtradas localmente ou fornecidas por uma busca remota.
+         * Em `remote`, o componente emite `brSelectSearch`; a aplicação deve buscar,
+         * validar e aplicar as opções por `setOptions()`.
+         * @default 'local'
+         */
+        this.searchMode = 'local';
+        /**
+         * Indica que uma busca remota de opções está pendente.
+         * Enquanto ativo, novas opções não podem ser selecionadas; a aplicação
+         * continua responsável por debounce, cancelamento, erros e autenticação.
+         * @default false
+         */
+        this.loading = false;
+        /**
+         * Exibe o ícone de busca no campo de entrada.
+         *
+         * @default false
+         */
+        this.showSearchIcon = false;
+        /**
+         * Rótulo apresentado quando todas as opções já estão selecionadas no modo múltiplo.
+         *
+         * @default 'Desselecionar todos'
+         */
+        this.unselectAllLabel = Select.DESELECT_ALL_LABEL;
+        /**
+         * Opções fornecidas como array ou JSON, além das opções projetadas por slot.
+         *
+         * @deprecated O formato de opções tipado atual é preferível; o formato legado permanece aceito.
+         */
+        this.options = [];
+        /** Identificador público do controle. */
+        this.customId = `br-select-${selectId++}`;
+        /** Quantidade mínima de opções selecionadas no modo múltiplo. */
+        this.minSelections = 0;
+        /** Quantidade máxima de opções selecionadas no modo múltiplo. */
+        this.maxSelections = 0;
+        this.shouldRestoreSelectedOptionOnOpen = false;
+        this.pendingOptions = null;
+        this.slotElement = null;
+        this.handleSlotChange = () => this.syncOptionsFromSlot();
+        this.lastEmittedStateKey = '';
+        this.isStateChangeReady = false;
+        this.isValueChangeReady = false;
+        this.listboxId = `${this.customId}-listbox`;
+        this.activeOptionIndex = -1;
+        this.searchTerm = '';
+        this.formDisabled = false;
+        this.isValidating = false;
+        this.validatorMessage = null;
+        this.hasFeedbackSlot = false;
+        this.hasValidationLoadingSlot = false;
+        this.selectedValuesState = [];
+        this.customValidationMessage = '';
+        this.validationRunId = 0;
+        this.lastAnnouncedOpen = false;
+        this.isApplyingExternalValue = false;
+        this.suppressValueChange = false;
+        this.hasImperativeOptions = false;
+        this.remoteSelectedOptions = new Map();
+        this.selectionInitialized = false;
+        this.selectedValues = [];
+        this.suppressFocusOpen = false;
+        /**
+         * Sincroniza as opções declaradas no slot com a lista interna renderizada.
+         *
+         * @remarks
+         * Esse passo mantém alinhados o estado visual da lista e o texto exibido no input
+         * quando as opções são adicionadas, removidas ou alteradas dinamicamente.
+         */
+        this.syncOptionsFromSlot = (updateDisplayValue = true) => {
+            if (this.hasImperativeOptions)
+                return;
+            const nodes = this.slotElement?.assignedNodes({ flatten: true }) ?? Array.from(this.el.childNodes);
+            const options = nodes.map((n) => this.nodeToOption(n)).filter((o) => Boolean(o));
+            // Envia opções para o br-select-list
+            if (this.selectListElement)
+                this.selectListElement.options = this.getListOptions(options);
+            if (updateDisplayValue)
+                this.syncDisplayValue(options);
+        };
+    }
+    formDisabledCallback(disabled) {
+        this.formDisabled = disabled;
+    }
+    formResetCallback() {
+        this.validationRunId++;
+        this.validatorMessage = null;
+        this.customValidationMessage = '';
+        this.applySelectedValue(this.initialValue);
+    }
+    formStateRestoreCallback(state) {
+        if (typeof state !== 'string' || state === '')
+            return;
+        try {
+            this.applySelectedValue(JSON.parse(state));
+        }
+        catch {
+            this.applySelectedValue(state);
+        }
+    }
+    componentWillLoad() {
+        this.hasFeedbackSlot = hasNamedLightDomSlot(this.el, 'feedback');
+        this.hasValidationLoadingSlot = hasNamedLightDomSlot(this.el, 'validation-loading');
+        this.setSelectionMode(this.effectiveMultiple);
+        const initialOptions = this.getHostOptions();
+        const propOptions = this.getOptionsProp();
+        const sourceOptions = initialOptions.length === 0 && propOptions.length > 0 ? propOptions : initialOptions;
+        this.setSelectedValues(this.valueFromPublicValue(this.value) ??
+            sourceOptions.filter((option) => option.selected).map((option) => option.value));
+        this.selectionInitialized = true;
+        if (initialOptions.length === 0 && propOptions.length > 0) {
+            this.pendingOptions = propOptions;
+            this.syncDisplayValue(propOptions);
+        }
+        else {
+            this.syncDisplayValue(initialOptions);
+        }
+        this.initialValue = Array.isArray(this.value) ? [...this.value] : this.value;
+        this.syncFormState();
+    }
+    componentDidLoad() {
+        this.lastEmittedStateKey = this.getStateChangeKey();
+        this.isStateChangeReady = true;
+        this.setSelectionMode(this.effectiveMultiple);
+        // Inicializa sincronização de opções a partir do slot
+        this.slotElement = this.el.shadowRoot?.querySelector('slot:not([name])');
+        if (this.slotElement) {
+            this.syncOptionsFromSlot(false);
+            this.slotElement.addEventListener('slotchange', this.handleSlotChange);
+        }
+        if (this.pendingOptions && this.selectListElement) {
+            this.selectListElement.options = this.getListOptions(this.pendingOptions);
+            this.pendingOptions = null;
+        }
+        this.isValueChangeReady = true;
+        this.lastAnnouncedOpen = this.effectiveOpen;
+        if (this.effectiveOpen)
+            this.attachBlockingSurfaceListener();
+        this.updateValidity();
+    }
+    componentDidRender() {
+        this.syncNativeSelectSelection();
+        this.updateValidity();
+    }
+    disconnectedCallback() {
+        if (this.slotElement) {
+            this.slotElement.removeEventListener('slotchange', this.handleSlotChange);
+            this.slotElement = null;
+        }
+        this.detachBlockingSurfaceListener();
+    }
+    get effectiveMultiple() {
+        return this.multiple ?? this.isMultiple;
+    }
+    get effectiveInline() {
+        return this.inline ?? this.isInline;
+    }
+    get effectiveOpen() {
+        return this.open ?? this.isOpen;
+    }
+    valueFromPublicValue(value) {
+        if (this.effectiveMultiple)
+            return Array.isArray(value) ? [...new Set(value.filter(Boolean))] : null;
+        return typeof value === 'string' && value ? [value] : null;
+    }
+    setSelectedValues(values) {
+        const next = [...new Set(values.filter(Boolean))];
+        if (!this.effectiveMultiple && next.length > 1)
+            next.splice(1);
+        if (this.selectedValues.length === next.length &&
+            this.selectedValues.every((value, index) => value === next[index]))
+            return;
+        this.selectedValues = next;
+        this.selectedValuesState = next;
+    }
+    get canonicalSelectedValues() {
+        // A leitura do @State registra a dependência reativa; o campo síncrono evita snapshots atrasados na mesma interação.
+        void this.selectedValuesState;
+        return this.selectedValues;
+    }
+    applyCanonicalSelection(options, values = this.canonicalSelectedValues) {
+        if (!this.selectionInitialized)
+            return options.map((option) => ({ ...option }));
+        const selected = new Set(values);
+        return options.map((option) => ({ ...option, selected: selected.has(option.value) }));
+    }
+    getListOptions(options) {
+        const normalized = this.applyCanonicalSelection(options).filter((option) => option.value !== '__select_all__');
+        if (!this.effectiveMultiple)
+            return normalized;
+        const selectable = normalized.filter((option) => !this.isSelectAllLabel(this.getOptionLabel(option)));
+        const allSelected = selectable.length > 0 && selectable.every((option) => Boolean(option.selected));
+        const anySelected = selectable.some((option) => Boolean(option.selected));
+        return [
+            {
+                value: '__select_all__',
+                label: allSelected ? this.unselectAllLabel : this.selectAllLabel,
+                selected: allSelected,
+                indeterminate: anySelected && !allSelected,
+            },
+            ...selectable,
+        ];
+    }
+    isDisabled() {
+        return isFormControlDisabled(this.disabled, this.formDisabled);
+    }
+    handleDisabledChange(isDisabled) {
+        if (isDisabled && this.effectiveOpen) {
+            this.close();
+            return;
+        }
+        this.emitStateChange();
+    }
+    handleIsOpenChange(isOpen) {
+        if (this.open === undefined)
+            this.syncOpenState(isOpen);
+    }
+    handleFilterableChange(filterable) {
+        if (!filterable) {
+            this.clearSearch();
+        }
+    }
+    handleLoadingChange(loading) {
+        if (this.selectListElement)
+            this.selectListElement.loading = loading;
+    }
+    handleIsMultipleChange(isMultiple) {
+        if (this.multiple === undefined)
+            this.setSelectionMode(isMultiple);
+        this.syncDisplayValue();
+    }
+    handleMultipleChange(multiple) {
+        if (multiple !== undefined)
+            this.setSelectionMode(multiple);
+        this.syncDisplayValue();
+    }
+    handleOpenChange(open) {
+        if (open !== undefined)
+            this.syncOpenState(open);
+    }
+    handleExternalValueChange(value) {
+        if (this.isApplyingExternalValue)
+            return;
+        this.applySelectedValue(value);
+    }
+    handleOptionsChange() {
+        const options = this.getOptionsProp();
+        void this.setOptions(options);
+    }
+    syncOpenState(isOpen) {
+        if (this.lastAnnouncedOpen !== isOpen) {
+            (isOpen ? this.opened : this.closed).emit();
+            this.lastAnnouncedOpen = isOpen;
+        }
+        if (isOpen) {
+            this.attachBlockingSurfaceListener();
+            this.selectInputElement?.flipUp();
+            void this.openListAndRestorePointerFocus();
+        }
+        else {
+            this.detachBlockingSurfaceListener();
+            this.selectInputElement?.flipDown();
+            void this.selectListElement?.close();
+        }
+        this.emitStateChange();
+    }
+    attachBlockingSurfaceListener() {
+        this.cleanupBlockingSurfaceDismissal ?? (this.cleanupBlockingSurfaceDismissal = listenForExternalBlockingSurface(this.el, () => void this.close()));
+    }
+    detachBlockingSurfaceListener() {
+        this.cleanupBlockingSurfaceDismissal?.();
+        this.cleanupBlockingSurfaceDismissal = undefined;
+    }
+    handleSelectInputFocus() {
+        this.activeOptionIndex = -1;
+        if (this.suppressFocusOpen)
+            return;
+        if (this.filterable && !this.effectiveOpen) {
+            this.clearSearch();
+            void this.show();
+        }
+    }
+    handleSelectInputValueChange(event) {
+        if (!this.filterable || this.isDisabled())
+            return;
+        const nextSearchTerm = event.detail ?? '';
+        this.searchTerm = nextSearchTerm;
+        this.activeOptionIndex = -1;
+        this.brSelectSearch.emit({ query: nextSearchTerm });
+        /*
+         * A chamada imperativa garante que a transição para string vazia também
+         * alcance a lista interna. Isso evita depender apenas da remoção/atualização
+         * do atributo `search-term` no custom element.
+         */
+        void this.getSelectListController()?.setSearchTerm?.(nextSearchTerm);
+        if (!this.effectiveOpen) {
+            void this.show();
+        }
+    }
+    handleSelectInputActionClick() {
+        this.toggleOpenFromPointer();
+    }
+    handleSelectInputClick() {
+        if (this.filterable) {
+            if (!this.effectiveOpen) {
+                this.shouldRestoreSelectedOptionOnOpen = true;
+                void this.show();
+            }
+            return;
+        }
+        this.toggleOpenFromPointer();
+    }
+    handleSelectOptionStateChange(event) {
+        event.stopPropagation();
+        const detail = event.detail;
+        // Use a lista interna para preservar rótulos e opções remotas enquanto as
+        // props projetadas aguardam a próxima renderização.
+        const listOptions = this.getSelectListController()?.options;
+        const sourceOptions = Array.isArray(listOptions) && listOptions.length > 0
+            ? listOptions.map((option) => ({ ...option }))
+            : this.getCurrentOptions();
+        // No modo simples, o evento é a decisão final da interação. A lista
+        // virtualizada e as opções projetadas podem ainda conter o snapshot da
+        // interação anterior durante cliques consecutivos; derivar a coleção a
+        // partir do valor do evento evita que esse snapshot reapareça no valor
+        // público ou no formulário.
+        const selectableValues = sourceOptions
+            .filter((option) => !this.isSelectAllLabel(this.getOptionLabel(option)))
+            .map((option) => option.value);
+        const transition = this.isSelectAllLabel(detail.label ?? detail.value)
+            ? transitionAllSelection(this.selectedValues, Boolean(detail.selected), selectableValues)
+            : transitionSelection({
+                currentValues: this.selectedValues,
+                multiple: this.effectiveMultiple,
+                value: detail.value,
+                selected: Boolean(detail.selected),
+            });
+        this.setSelectedValues(transition.values);
+        const options = this.applyCanonicalSelection(sourceOptions, transition.values);
+        if (this.selectListElement)
+            this.selectListElement.options = this.getListOptions(options);
+        this.reflectRenderedListSelection(transition.values);
+        this.syncSlottedOptionSelection(transition.values);
+        this.rememberRemoteSelections(options);
+        this.syncDisplayValue(options);
+        this.syncActiveOptionIndex(event.detail);
+        this.emitStateChange(detail);
+        this.updateValidity();
+        if (!transition.changed)
+            return;
+        if (!this.effectiveMultiple) {
+            this.suppressFocusOpen = true;
+            void this.selectInputElement?.setFocus?.();
+            void this.close().finally(() => {
+                this.suppressFocusOpen = false;
+            });
+        }
+        dispatchNativeFormEvent(this.el, 'input');
+        dispatchNativeFormEvent(this.el, 'change');
+    }
+    handleSelectOptionHover(event) {
+        this.optionHover.emit(event.detail);
+    }
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: centraliza a navegação por teclado do componente.
+    async handleKeyDown(event) {
+        if (this.isDisabled())
+            return;
+        const path = this.getEventPath(event);
+        const isFromInput = path.includes(this.selectInputElement);
+        const isFromList = path.includes(this.selectListElement);
+        if (!isFromInput && !isFromList)
+            return;
+        switch (event.key) {
+            case 'ArrowDown':
+                event.preventDefault();
+                await this.openAndFocusBoundary(isFromInput, 1);
+                return;
+            case 'ArrowUp':
+                event.preventDefault();
+                await this.openAndFocusBoundary(isFromInput, -1);
+                return;
+            case 'Home':
+                if (!this.effectiveOpen)
+                    return;
+                event.preventDefault();
+                await this.focusOptionByIndex(0);
+                return;
+            case 'End':
+                if (!this.effectiveOpen)
+                    return;
+                event.preventDefault();
+                await this.focusOptionByIndex(this.getNavigableOptions().length - 1);
+                return;
+            case 'Enter':
+            case ' ':
+                if (isFromInput && this.filterable && event.key === ' ') {
+                    return;
+                }
+                if (isFromList) {
+                    return;
+                }
+                event.preventDefault();
+                if (!this.effectiveOpen) {
+                    await this.show();
+                    await this.focusInitialOption(1);
+                    return;
+                }
+                await this.selectFocusedOption();
+                return;
+            case 'Escape':
+                if (!this.effectiveOpen)
+                    return;
+                event.preventDefault();
+                await this.close();
+                this.activeOptionIndex = -1;
+                await this.selectInputElement?.setFocus?.();
+                return;
+            case 'Tab':
+                if (!this.effectiveOpen)
+                    return;
+                await this.close();
+                this.activeOptionIndex = -1;
+                return;
+            default:
+                return;
+        }
+    }
+    handleWindowClick(ev) {
+        this.handleOutsideClick(ev);
+    }
+    /**
+     * Habilita o select para interação do usuário.
+     *
+     * @returns Uma promise concluída após a atualização do estado.
+     */
+    async enable() {
+        this.disabled = false;
+    }
+    /**
+     * Desabilita o select e impede novas interações.
+     *
+     * @returns Uma promise concluída após a atualização do estado.
+     */
+    async disable() {
+        this.disabled = true;
+    }
+    /**
+     * Abre a lista de opções quando o componente está habilitado.
+     *
+     * @returns Uma promise concluída após a atualização do estado.
+     */
+    async show() {
+        if (this.isDisabled())
+            return;
+        if (this.open !== undefined)
+            this.open = true;
+        else
+            this.isOpen = true;
+    }
+    /**
+     * Fecha a lista de opções quando o componente está habilitado.
+     *
+     * @returns Uma promise concluída após a atualização do estado.
+     */
+    async close() {
+        if (this.isDisabled())
+            return;
+        if (this.open !== undefined)
+            this.open = false;
+        else
+            this.isOpen = false;
+        this.clearSearch();
+    }
+    /**
+     * Alterna entre os estados aberto e fechado do select.
+     *
+     * @returns {Promise<void>} Uma promise concluída após a atualização do estado.
+     */
+    async toggleOpen() {
+        if (this.isDisabled())
+            return;
+        if (this.open !== undefined)
+            this.open = !this.open;
+        else
+            this.isOpen = !this.isOpen;
+    }
+    /**
+     * Limpa a seleção atual.
+     *
+     * @deprecated Use `setValue('')` ou a API de formulário.
+     */
+    async clear() {
+        await this.setValue(this.effectiveMultiple ? [] : '');
+    }
+    /**
+     * Retorna o valor público atual.
+     *
+     * @deprecated Leia a propriedade `value` diretamente.
+     */
+    async getValue() {
+        return this.value ?? (this.effectiveMultiple ? [] : '');
+    }
+    /**
+     * Define o valor público do select.
+     *
+     * @deprecated Atribua a propriedade `value` diretamente.
+     */
+    async setValue(value) {
+        this.applySelectedValue(value);
+    }
+    /**
+     * Move o foco para o campo interno.
+     *
+     * @deprecated Use o foco nativo do componente quando possível.
+     */
+    async setFocus() {
+        await this.selectInputElement?.setFocus?.();
+    }
+    async checkValidity() {
+        return this.elementInternals?.checkValidity?.() ?? true;
+    }
+    async reportValidity() {
+        return this.elementInternals?.reportValidity?.() ?? true;
+    }
+    async setCustomValidity(message) {
+        this.customValidationMessage = message;
+        this.updateValidity();
+    }
+    async getValidationState() {
+        return getFormValidationState(this.elementInternals);
+    }
+    async validate() {
+        const validator = this.resolveValidator();
+        if (!validator || this.isDisabled())
+            return this.checkValidity();
+        const runId = ++this.validationRunId;
+        this.isValidating = true;
+        this.validatorMessage = null;
+        this.updateValidity();
+        this.brSelectValidationChange.emit({ validating: true, valid: null, message: null });
+        let message = null;
+        try {
+            const currentValue = this.effectiveMultiple
+                ? [...(Array.isArray(this.value) ? this.value : [])]
+                : String(this.value ?? '');
+            message = (await validator(currentValue)) || null;
+        }
+        catch {
+            message = 'Não foi possível validar a seleção.';
+        }
+        if (runId !== this.validationRunId)
+            return false;
+        this.validatorMessage = message;
+        this.isValidating = false;
+        this.updateValidity();
+        const valid = message === null && (await this.checkValidity());
+        this.brSelectValidationChange.emit({ validating: false, valid, message });
+        return valid;
+    }
+    /**
+     * Substitui a coleção atual de opções por uma nova lista.
+     *
+     * @param options Opções que devem ser exibidas pela lista interna.
+     * Em `search-mode="remote"`, a seleção atual é preservada mesmo quando não
+     * aparece na resposta recebida.
+     * @returns Uma promise concluída após a sincronização das opções.
+     */
+    async setOptions(options) {
+        this.hasImperativeOptions = true;
+        const nextOptions = this.searchMode === 'remote' ? this.applyRemoteSelection(options) : options;
+        this.suppressValueChange = true;
+        try {
+            if (this.selectListElement) {
+                this.selectListElement.options = this.getListOptions(nextOptions);
+            }
+            else {
+                this.pendingOptions = nextOptions;
+            }
+            this.syncDisplayValue(nextOptions);
+        }
+        finally {
+            this.suppressValueChange = false;
+        }
+    }
+    /**
+     * Adiciona ou atualiza uma única opção na coleção interna.
+     *
+     * @param option Opção que deve ser inserida ou atualizada.
+     * @returns Uma promise concluída após a sincronização da opção.
+     */
+    async setOption(option) {
+        this.hasImperativeOptions = true;
+        const currentOptions = this.getCurrentOptions();
+        const index = currentOptions.findIndex((currentOption) => currentOption.value === option.value);
+        const nextOptions = [...currentOptions];
+        if (index === -1)
+            nextOptions.push(option);
+        else
+            nextOptions[index] = option;
+        if (this.selectListElement) {
+            this.selectListElement.options = this.getListOptions(nextOptions);
+        }
+        else {
+            this.pendingOptions = nextOptions;
+        }
+        this.syncDisplayValue(nextOptions);
+    }
+    getHostOptions() {
+        return Array.from(this.el.childNodes)
+            .map((node) => this.nodeToOption(node))
+            .filter((option) => Boolean(option));
+    }
+    nodeToOption(node) {
+        if (node.nodeType === Node.ELEMENT_NODE)
+            return this.elementToOption(node);
+        if (node.nodeType === Node.TEXT_NODE)
+            return this.textNodeToOption(node);
+        return null;
+    }
+    elementToOption(el) {
+        if (el.tagName.toLowerCase() === 'br-select-option')
+            return this.optionElementToData(el);
+        const text = (el.textContent || '').trim();
+        return text ? { value: text, label: text } : null;
+    }
+    textNodeToOption(textNode) {
+        const text = (textNode.textContent || '').trim();
+        return text ? { value: text, label: text } : null;
+    }
+    optionElementToData(el) {
+        const rawValue = el.getAttribute('value') ?? el.value ?? '';
+        const rawLabel = el.getAttribute('label') ?? el.label ?? '';
+        let value = String(rawValue || '').trim();
+        let label = String(rawLabel || '').trim();
+        const inner = this.extractInnerTextFromOption(el);
+        const content = (el.innerHTML || '').trim();
+        const selected = el.hasAttribute('selected') || Boolean(el.selected);
+        if (!value) {
+            if (inner)
+                value = inner.trim();
+        }
+        if (!label)
+            label = inner?.trim() || value;
+        return { value: value || '', label: label || undefined, selected, content: content || undefined };
+    }
+    extractInnerTextFromOption(el) {
+        const fromSlot = this.getAssignedSlotText(el);
+        if (fromSlot)
+            return fromSlot;
+        const fallback = (el.textContent || '').trim();
+        return fallback || null;
+    }
+    getAssignedSlotText(el) {
+        try {
+            const innerSlot = el.shadowRoot?.querySelector('slot:not([name])');
+            if (!innerSlot?.assignedNodes)
+                return null;
+            const text = innerSlot
+                .assignedNodes({ flatten: true })
+                .map((node) => (node.textContent || '').trim())
+                .filter(Boolean)
+                .join(' ')
+                .trim();
+            return text || null;
+        }
+        catch (_e) {
+            return null;
+        }
+    }
+    getOptionLabel(option) {
+        return (option.label ?? option.value).trim();
+    }
+    getDisplayValue(options = this.getCurrentOptions()) {
+        const selectedOptions = options.filter((option) => {
+            if (!option.selected)
+                return false;
+            const optionLabel = this.getOptionLabel(option);
+            return !this.isSelectAllLabel(optionLabel);
+        });
+        if (selectedOptions.length === 0)
+            return '';
+        if (!this.effectiveMultiple) {
+            return this.getOptionLabel(selectedOptions[0]);
+        }
+        const [firstSelected, ...otherSelected] = selectedOptions;
+        const firstLabel = this.getOptionLabel(firstSelected);
+        if (otherSelected.length === 0)
+            return firstLabel;
+        return `${firstLabel} + (${otherSelected.length})`;
+    }
+    syncDisplayValue(options) {
+        const resolvedOptions = this.getFormOptions(options ?? this.getCurrentOptions());
+        this.displayValue = this.getDisplayValue(resolvedOptions);
+        this.syncValue(resolvedOptions);
+    }
+    syncValue(options) {
+        this.setSelectedValues(options
+            .filter((option) => option.selected && !this.isSelectAllLabel(this.getOptionLabel(option)))
+            .map((option) => option.value));
+        const nextValue = this.getSerializedValue(options);
+        this.syncFormState(options);
+        if (this.value === nextValue)
+            return;
+        this.isApplyingExternalValue = true;
+        this.value = nextValue;
+        this.isApplyingExternalValue = false;
+        if (!this.isValueChangeReady || this.suppressValueChange)
+            return;
+        this.valueChange.emit(Array.isArray(nextValue) ? nextValue.join(',') : nextValue);
+    }
+    getSerializedValue(options) {
+        const selectedValues = options
+            .filter((option) => {
+            if (!option.selected)
+                return false;
+            const optionLabel = this.getOptionLabel(option);
+            return !this.isSelectAllLabel(optionLabel);
+        })
+            .map((option) => option.value);
+        if (this.effectiveMultiple)
+            return selectedValues;
+        if (selectedValues.length === 0)
+            return '';
+        return selectedValues[0];
+    }
+    getOptionsProp() {
+        if (Array.isArray(this.options))
+            return this.options;
+        try {
+            const parsed = JSON.parse(this.options || '[]');
+            return Array.isArray(parsed) ? parsed : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    applySelectedValue(value) {
+        const currentOptions = this.getCurrentOptions();
+        const requestedValues = this.valueFromPublicValue(value) ?? [];
+        this.setSelectedValues(requestedValues);
+        const options = currentOptions.map((option) => ({
+            ...option,
+            selected: requestedValues.includes(option.value),
+        }));
+        this.isApplyingExternalValue = true;
+        if (this.selectListElement)
+            this.selectListElement.options = this.getListOptions(options);
+        else
+            this.pendingOptions = options;
+        this.reflectRenderedListSelection(requestedValues);
+        this.value = value;
+        this.isApplyingExternalValue = false;
+        this.remoteSelectedOptions.clear();
+        this.rememberRemoteSelections(options);
+        if (this.searchMode === 'remote') {
+            const selectedValues = new Set(Array.isArray(value) ? value : [value ?? '']);
+            selectedValues.forEach((selectedValue) => {
+                if (selectedValue && !currentOptions.some((option) => option.value === selectedValue)) {
+                    this.remoteSelectedOptions.set(selectedValue, {
+                        value: selectedValue,
+                        label: selectedValue,
+                        selected: true,
+                    });
+                }
+            });
+            this.syncDisplayValue(this.getCurrentOptions());
+            return;
+        }
+        this.syncDisplayValue(options);
+    }
+    applyRemoteSelection(options) {
+        this.rememberRemoteSelections(this.getCurrentOptions());
+        const selectedValues = new Set(this.selectedValues);
+        const nextOptions = options.map((option) => ({
+            ...option,
+            selected: selectedValues.has(option.value) || Boolean(option.selected),
+        }));
+        this.rememberRemoteSelections(nextOptions);
+        return nextOptions;
+    }
+    rememberRemoteSelections(options) {
+        if (this.searchMode !== 'remote')
+            return;
+        const visibleValues = new Set(options.map((option) => option.value));
+        options.forEach((option) => {
+            if (option.selected)
+                this.remoteSelectedOptions.set(option.value, { ...option, selected: true });
+            else if (visibleValues.has(option.value))
+                this.remoteSelectedOptions.delete(option.value);
+        });
+    }
+    getFormOptions(options) {
+        if (this.searchMode !== 'remote')
+            return options;
+        const result = options.map((option) => ({ ...option }));
+        const existingValues = new Set(result.map((option) => option.value));
+        this.remoteSelectedOptions.forEach((option, value) => {
+            if (!existingValues.has(value))
+                result.push({ ...option, selected: true });
+        });
+        return result;
+    }
+    syncFormState(options = this.getCurrentOptions()) {
+        const selected = this.getFormOptions(options).filter((option) => option.selected && !this.isSelectAllLabel(this.getOptionLabel(option)));
+        const selectedValues = selected.map((option) => option.value);
+        const formValue = this.effectiveMultiple ? JSON.stringify(selectedValues) : (selectedValues[0] ?? null);
+        safeSetFormValue(this.elementInternals, formValue);
+        this.syncNativeSelectSelection(selectedValues);
+        this.updateValidity(selectedValues.length);
+    }
+    syncNativeSelectSelection(values = this.getSelectedValues()) {
+        const nativeSelect = this.getNativeSelect();
+        if (!nativeSelect)
+            return;
+        const selectedValues = new Set(values);
+        Array.from(nativeSelect.options).forEach((option) => {
+            option.selected = option.value === '' ? selectedValues.size === 0 : selectedValues.has(option.value);
+        });
+    }
+    getSelectedValues() {
+        return [...this.selectedValues];
+    }
+    updateValidity(selectedCount = this.getSelectedValues().length) {
+        const nativeSelect = this.getNativeSelect();
+        if (!nativeSelect)
+            return;
+        const selectionMessage = this.effectiveMultiple && this.minSelections > 0 && selectedCount < this.minSelections
+            ? `Selecione pelo menos ${this.minSelections} opções.`
+            : this.effectiveMultiple && this.maxSelections > 0 && selectedCount > this.maxSelections
+                ? `Selecione no máximo ${this.maxSelections} opções.`
+                : '';
+        nativeSelect.setCustomValidity(this.customValidationMessage || this.validatorMessage || selectionMessage);
+        syncNativeFormValidity(this.elementInternals, nativeSelect);
+    }
+    getNativeSelect() {
+        return (this.el.shadowRoot?.querySelector('select[part="hidden-select"]') ??
+            this.nativeSelect);
+    }
+    resolveValidator() {
+        return resolveFormValidator(this.validator);
+    }
+    getRenderedDisplayValue() {
+        return this.displayValue ?? this.getDisplayValue();
+    }
+    /**
+     * Retorna o id da opção atualmente ativa para consumo do `aria-activedescendant`.
+     *
+     * @returns O id da opção ativa ou `undefined` quando a lista está fechada.
+     */
+    getActiveDescendant() {
+        if (!this.effectiveOpen || this.activeOptionIndex < 0)
+            return undefined;
+        return `${this.listboxId}-option-${this.activeOptionIndex}`;
+    }
+    toggleOpenFromPointer() {
+        if (!this.effectiveOpen) {
+            this.shouldRestoreSelectedOptionOnOpen = true;
+        }
+        void this.toggleOpen();
+    }
+    async openListAndRestorePointerFocus() {
+        await this.selectListElement?.open();
+        if (!this.shouldRestoreSelectedOptionOnOpen)
+            return;
+        this.shouldRestoreSelectedOptionOnOpen = false;
+        await this.scrollFirstSelectedOptionToTop();
+    }
+    async scrollFirstSelectedOptionToTop() {
+        const options = this.getNavigableOptions();
+        const firstSelectedIndex = options.findIndex((option) => !this.isSelectAllLabel(this.getOptionLabel(option)) && Boolean(option.selected));
+        if (firstSelectedIndex < 0)
+            return;
+        const didScroll = await this.getSelectListController()?.scrollFirstSelectedOptionToTop?.();
+        if (didScroll) {
+            this.activeOptionIndex = firstSelectedIndex;
+        }
+    }
+    async openAndFocusBoundary(fromInput, direction) {
+        if (!this.effectiveOpen) {
+            await this.show();
+            await this.focusInitialOption(direction);
+            return;
+        }
+        if (fromInput && this.activeOptionIndex < 0) {
+            await this.focusInitialOption(direction);
+            return;
+        }
+        await this.moveActiveOption(direction);
+    }
+    /**
+     * Define qual opção deve receber foco ao abrir o select pelo teclado.
+     *
+     * @param direction Direção inicial da navegação. `1` abre do topo para baixo e `-1` do fim para cima.
+     */
+    async focusInitialOption(direction) {
+        const options = this.getNavigableOptions();
+        if (options.length === 0)
+            return;
+        const selectedIndex = options.findIndex((option) => Boolean(option.selected));
+        const fallbackIndex = direction > 0 ? 0 : options.length - 1;
+        const initialIndex = selectedIndex >= 0 ? selectedIndex : fallbackIndex;
+        await this.focusOptionByIndex(initialIndex);
+    }
+    async moveActiveOption(step) {
+        const options = this.getNavigableOptions();
+        if (options.length === 0)
+            return;
+        const baseIndex = this.getCurrentActiveIndex();
+        const nextIndex = Math.min(options.length - 1, Math.max(0, baseIndex + step));
+        await this.focusOptionByIndex(nextIndex);
+    }
+    /**
+     * Resolve o índice ativo atual a partir do estado local ou da opção já selecionada.
+     *
+     * @returns O índice que deve servir como base para a próxima navegação por teclado.
+     */
+    getCurrentActiveIndex() {
+        if (this.activeOptionIndex >= 0)
+            return this.activeOptionIndex;
+        const options = this.getNavigableOptions();
+        const selectedIndex = options.findIndex((option) => Boolean(option.selected));
+        return selectedIndex >= 0 ? selectedIndex : 0;
+    }
+    /**
+     * Encaminha o foco lógico para uma opção específica da lista interna.
+     *
+     * @param index Índice da opção que deve receber foco.
+     */
+    async focusOptionByIndex(index) {
+        const didFocus = await this.getSelectListController()?.focusOption?.(index);
+        if (didFocus) {
+            this.activeOptionIndex = index;
+        }
+    }
+    /**
+     * Seleciona a opção atualmente ativa sem duplicar a lógica de seleção da lista.
+     *
+     * @remarks
+     * Em modo simples, a opção ativa é sempre marcada. Em modo múltiplo, a seleção é alternada.
+     */
+    async selectFocusedOption() {
+        const options = this.getNavigableOptions();
+        if (options.length === 0)
+            return;
+        const index = this.getCurrentActiveIndex();
+        const option = options[index];
+        const nextSelected = this.effectiveMultiple ? !option?.selected : true;
+        if (this.effectiveMultiple && index === 0 && option && !this.isSelectAllLabel(this.getOptionLabel(option))) {
+            this.handleSelectOptionStateChange(new CustomEvent('brSelectOptionStateChange', {
+                detail: {
+                    value: '__select_all__',
+                    label: this.selectAllLabel,
+                    selected: true,
+                    disabled: false,
+                },
+            }));
+            return;
+        }
+        const didSelect = await this.getSelectListController()?.setOptionSelected?.(index, nextSelected);
+        if (didSelect) {
+            this.activeOptionIndex = index;
+        }
+    }
+    syncActiveOptionIndex(detail) {
+        const options = this.getNavigableOptions();
+        const optionIndex = options.findIndex((option) => option.value === detail.value);
+        if (optionIndex >= 0) {
+            this.activeOptionIndex = optionIndex;
+        }
+    }
+    /**
+     * Reflete no slot a seleção que foi consolidada pela lista interna.
+     *
+     * @param detail Estado emitido pela opção que disparou a mudança.
+     * @remarks
+     * Essa sincronização mantém as props/atributos das opções declaradas pelo consumidor em
+     * conformidade com o estado calculado internamente, inclusive no caso do "selecionar todos".
+     */
+    syncSlottedOptionSelection(values = this.selectedValues) {
+        const slottedOptions = Array.from(this.el.children).filter((el) => el.tagName.toLowerCase() === 'br-select-option');
+        if (slottedOptions.length === 0)
+            return;
+        const selectedValues = new Set(values);
+        slottedOptions.forEach((option) => {
+            const resolved = this.optionElementToData(option).value;
+            option.selected = selectedValues.has(resolved);
+            option.indeterminate = false;
+            if (option.selected)
+                option.setAttribute('selected', '');
+            else
+                option.removeAttribute('selected');
+        });
+        if (!this.effectiveMultiple)
+            return;
+        const selectableOptions = slottedOptions.filter((option) => {
+            const optionLabel = (option.label ?? option.value).trim();
+            return !this.isSelectAllLabel(optionLabel);
+        });
+        const allSelected = selectableOptions.length > 0 && selectableOptions.every((option) => Boolean(option.selected));
+        const anySelected = selectableOptions.some((option) => Boolean(option.selected));
+        slottedOptions.forEach((option) => {
+            const optionLabel = (option.label ?? option.value).trim();
+            if (!this.isSelectAllLabel(optionLabel))
+                return;
+            option.indeterminate = anySelected && !allSelected;
+            option.selected = allSelected;
+            this.normalizeSelectAllState(option);
+            if (option.selected)
+                option.setAttribute('selected', '');
+            else
+                option.removeAttribute('selected');
+        });
+    }
+    reflectRenderedListSelection(values) {
+        const renderedOptions = this.selectListElement?.shadowRoot?.querySelectorAll('br-select-option');
+        if (!renderedOptions)
+            return;
+        const selectedValues = new Set(values);
+        renderedOptions.forEach((option) => {
+            if (this.isSelectAllLabel(option.label))
+                return;
+            option.selected = selectedValues.has(option.value);
+        });
+    }
+    isSelectAllLabel(label) {
+        return label === this.selectAllLabel || label === this.unselectAllLabel;
+    }
+    getSelectAllLabel(selected, indeterminate) {
+        return selected && !indeterminate ? this.unselectAllLabel : this.selectAllLabel;
+    }
+    normalizeSelectAllState(option) {
+        const selected = Boolean(option.selected) && !option.indeterminate;
+        const indeterminate = Boolean(option.indeterminate);
+        option.selected = selected;
+        option.indeterminate = indeterminate;
+        option.label = this.getSelectAllLabel(selected, indeterminate);
+    }
+    handleOutsideClick(ev) {
+        if (!this.effectiveOpen)
+            return;
+        const clickPath = this.getEventPath(ev);
+        const isClickInsideSelect = clickPath.includes(this.el);
+        if (isClickInsideSelect)
+            return;
+        this.close();
+    }
+    emitStateChange(option) {
+        const payload = this.getStateChangeDetail(option);
+        const nextStateKey = JSON.stringify(payload);
+        if (!this.isStateChangeReady) {
+            this.lastEmittedStateKey = nextStateKey;
+            return;
+        }
+        if (this.lastEmittedStateKey === nextStateKey)
+            return;
+        this.lastEmittedStateKey = nextStateKey;
+        this.brSelectStateChange.emit(payload);
+    }
+    getStateChangeDetail(optionChange) {
+        const payload = {
+            isOpen: this.effectiveOpen,
+        };
+        const currentOptions = this.getFormOptions(this.getCurrentOptions());
+        if (this.effectiveMultiple) {
+            payload.options = currentOptions
+                .filter((option) => !this.isSelectAllLabel((option.label ?? option.value).trim()))
+                .map((option) => this.normalizeOptionForOutput(option));
+            return payload;
+        }
+        const selectedOption = currentOptions.find((option) => Boolean(option.selected));
+        if (selectedOption) {
+            payload.option = this.normalizeOptionForOutput(selectedOption);
+            return payload;
+        }
+        if (optionChange?.value) {
+            const { disabled: _disabled, ...normalizedOption } = optionChange;
+            payload.option = {
+                ...normalizedOption,
+                label: optionChange.label ?? optionChange.value,
+            };
+        }
+        return payload;
+    }
+    normalizeOptionForOutput(option) {
+        const optionLabel = (option.label ?? option.value).trim();
+        const isSelectAll = this.isSelectAllLabel(optionLabel);
+        const { disabled: _disabled, ...optionWithoutDisabled } = option;
+        if (isSelectAll) {
+            return optionWithoutDisabled;
+        }
+        const { indeterminate, ...normalized } = optionWithoutDisabled;
+        return normalized;
+    }
+    getStateChangeKey() {
+        return JSON.stringify(this.getStateChangeDetail());
+    }
+    /**
+     * Obtém o snapshot atual das opções respeitando a fonte mais atual disponível.
+     *
+     * @returns A coleção de opções normalizadas para leitura do estado público.
+     * @remarks
+     * A precedência é: lista interna, opções pendentes, conteúdo do slot e, por último,
+     * os filhos atuais do host.
+     */
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: prioriza a precedência entre slot, lista e opções remotas.
+    getCurrentOptions() {
+        // As opções projetadas são a fonte canônica quando não há coleção
+        // imperativa: a lista virtualizada pode manter um snapshot enquanto o
+        // consumidor altera `selected` diretamente no slot.
+        if (!this.hasImperativeOptions && this.slotElement) {
+            const nodes = this.slotElement.assignedNodes({ flatten: true }) ?? [];
+            const slotOptions = nodes
+                .map((node) => this.nodeToOption(node))
+                .filter((option) => Boolean(option));
+            if (slotOptions.length > 0) {
+                const normalizedSlotOptions = this.applyCanonicalSelection(slotOptions);
+                if (this.effectiveMultiple &&
+                    !normalizedSlotOptions.some((option) => this.isSelectAllLabel(this.getOptionLabel(option)))) {
+                    normalizedSlotOptions.unshift({
+                        value: '__select_all__',
+                        label: this.selectAllLabel,
+                        selected: false,
+                        indeterminate: false,
+                    });
+                }
+                return normalizedSlotOptions;
+            }
+        }
+        const listOptions = this.getSelectListController()?.options;
+        if (Array.isArray(listOptions) && listOptions.length > 0) {
+            const normalizedListOptions = listOptions.map((option) => ({ ...option }));
+            const hasRealOptions = normalizedListOptions.some((option) => !this.isSelectAllLabel(this.getOptionLabel(option)));
+            if (hasRealOptions) {
+                if (this.effectiveMultiple &&
+                    !normalizedListOptions.some((option) => this.isSelectAllLabel(this.getOptionLabel(option)))) {
+                    normalizedListOptions.unshift({
+                        value: '__select_all__',
+                        label: this.selectAllLabel,
+                        selected: false,
+                        indeterminate: false,
+                    });
+                }
+                return this.applyCanonicalSelection(normalizedListOptions);
+            }
+        }
+        if (this.pendingOptions) {
+            return this.applyCanonicalSelection(this.pendingOptions);
+        }
+        const hostOptions = this.applyCanonicalSelection(this.getHostOptions());
+        if (this.effectiveMultiple && hostOptions.length > 0) {
+            return [
+                {
+                    value: '__select_all__',
+                    label: this.selectAllLabel,
+                    selected: false,
+                    indeterminate: false,
+                },
+                ...hostOptions,
+            ];
+        }
+        return hostOptions;
+    }
+    normalizeSearchText(value) {
+        return value
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .toLocaleLowerCase('pt-BR')
+            .trim();
+    }
+    getNavigableOptions() {
+        const options = this.getCurrentOptions();
+        const normalizedTerm = this.normalizeSearchText(this.searchTerm);
+        if (!this.filterable || this.searchMode === 'remote' || !normalizedTerm)
+            return options;
+        return options.filter((option) => {
+            if (this.isSelectAllLabel(this.getOptionLabel(option)))
+                return this.effectiveMultiple;
+            const label = this.normalizeSearchText(this.getOptionLabel(option));
+            const value = this.normalizeSearchText(option.value);
+            return label.includes(normalizedTerm) || value.includes(normalizedTerm);
+        });
+    }
+    clearSearch() {
+        if (!this.searchTerm)
+            return;
+        this.searchTerm = '';
+        this.activeOptionIndex = -1;
+        void this.getSelectListController()?.setSearchTerm?.('');
+    }
+    getEventPath(ev) {
+        return ev.composedPath ? ev.composedPath() : (ev.path ?? []);
+    }
+    getSelectListController() {
+        return this.selectListElement;
+    }
+    getCssClassMap() {
+        return {
+            'br-select': true,
+        };
+    }
+    getAccessibleLabel() {
+        return this.label?.trim() || this.placeholder?.trim() || 'Selecao';
+    }
+    setSelectionMode(isMultiple) {
+        this.selectListElement?.setMultiple(isMultiple);
+    }
+    renderSelectInput() {
+        return (h("br-select-input", { part: "input", exportparts: "container:input-container, input:input-field, label:input-label, group:input-group, icon:input-icon, action:input-action, action-button:input-action-button", ref: (el) => (this.selectInputElement = el), "aria-activedescendant": this.getActiveDescendant(), "aria-controls": this.listboxId, "aria-disabled": String(this.isDisabled()), "aria-expanded": String(this.effectiveOpen), "aria-haspopup": "listbox", "aria-label": this.getAccessibleLabel(), "aria-required": String(this.required), borderless: this.borderless, "is-inline": this.effectiveInline, "is-open": this.effectiveOpen, label: this.label, name: this.name, placeholder: this.placeholder, required: this.required, disabled: this.isDisabled(), filterable: this.filterable, showSearchIcon: this.showSearchIcon, autocomplete: this.autocomplete, "input-width": this.inputWidth, role: "combobox", value: this.filterable && this.effectiveOpen ? this.searchTerm : this.getRenderedDisplayValue() }));
+    }
+    renderSelectList() {
+        return (h("br-select-list", { part: "list", options: this.getCurrentOptions(), exportparts: "list, option, checkbox, select-all, empty-option, option-checkbox, option-radio", "active-option-index": this.activeOptionIndex, "aria-label": this.getAccessibleLabel(), "aria-multiselectable": this.effectiveMultiple ? 'true' : 'false', id: this.listboxId, "visible-items": this.visibleItems, "item-height": this.itemHeight, overscan: this.overscan, "search-term": this.filterable && this.searchMode === 'local' ? this.searchTerm : '', role: "listbox", "select-all-label": this.selectAllLabel, "unselect-all-label": this.unselectAllLabel, ref: (el) => {
+                this.selectListElement = el;
+                this.selectListElement.loading = this.loading;
+                this.setSelectionMode(this.effectiveMultiple);
+                void this.getSelectListController()?.setSearchTerm?.(this.filterable ? this.searchTerm : '');
+            } }, h("slot", null), h("slot", { name: "loading", slot: "loading" })));
+    }
+    renderHiddenSelect() {
+        const options = this.getFormOptions(this.getCurrentOptions()).filter((option) => !this.isSelectAllLabel(this.getOptionLabel(option)));
+        const hasSelection = options.some((option) => option.selected);
+        return (h("select", { ref: (el) => (this.nativeSelect = el), part: "hidden-select", name: this.name, autocomplete: this.autocomplete, multiple: this.effectiveMultiple, required: this.required, disabled: this.isDisabled(), tabIndex: -1, "aria-hidden": "true", style: {
+                position: 'absolute',
+                width: '1px',
+                height: '1px',
+                padding: '0',
+                margin: '-1px',
+                overflow: 'hidden',
+                clip: 'rect(0, 0, 0, 0)',
+                whiteSpace: 'nowrap',
+                border: '0',
+            }, onChange: (event) => event.preventDefault() }, h("option", { value: "", selected: !hasSelection }), options.map((option) => (h("option", { key: option.value, value: option.value, selected: option.selected, disabled: option.disabled })))));
+    }
+    render() {
+        return (h(Host, { key: '9eab35d12b8b0fff68f16bb1e1ccc1209ea09687', "aria-busy": this.isValidating || this.loading ? 'true' : null }, h("div", { key: '68747830dd29319dc044caa056ffc13fea834bea', class: this.getCssClassMap(), part: "container" }, this.renderSelectInput(), this.renderSelectList(), h("div", { key: '825c7934402930816fba48f02d161d936c8a4e3e', part: "feedback", hidden: !this.hasFeedbackSlot && !this.validatorMessage }, h("slot", { key: '10b2ee676c54b913b39b6523d3ebce462ed031e3', name: "feedback", onSlotchange: (event) => (this.hasFeedbackSlot = hasAssignedSlotContent(event.currentTarget)) }, this.validatorMessage)), h("div", { key: '571a5a5e89ae14a91f8c88c0b1fb5e7341adb094', part: "validation-loading", hidden: !this.hasValidationLoadingSlot || !this.isValidating }, h("slot", { key: 'e9647f09ce303d15a564707e1d3a060280de10a1', name: "validation-loading" })), this.renderHiddenSelect())));
+    }
+    static get is() { return "br-select"; }
+    static get encapsulation() { return "shadow"; }
+    static get formAssociated() { return true; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["select.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["select.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "borderless": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Remove a borda do input quando o componente n\u00E3o est\u00E1 em foco."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "borderless",
+                "defaultValue": "false"
+            },
+            "disabled": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Desativa toda a intera\u00E7\u00E3o do select."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "disabled",
+                "defaultValue": "false"
+            },
+            "isInline": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }, {
+                            "name": "deprecated",
+                            "text": "Use `inline`."
+                        }],
+                    "text": "Exibe label e campo na mesma linha."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "is-inline",
+                "defaultValue": "false"
+            },
+            "inline": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Exibe r\u00F3tulo e controle em linha. Quando informada, tem preced\u00EAncia sobre `isInline`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "inline"
+            },
+            "isMultiple": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }, {
+                            "name": "deprecated",
+                            "text": "Use `multiple`."
+                        }],
+                    "text": "Habilita o modo de sele\u00E7\u00E3o m\u00FAltipla."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "is-multiple",
+                "defaultValue": "false"
+            },
+            "multiple": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Habilita sele\u00E7\u00E3o m\u00FAltipla. Quando informada, tem preced\u00EAncia sobre `isMultiple`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "multiple"
+            },
+            "keepOpenOnSelect": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }, {
+                            "name": "deprecated",
+                            "text": "O comportamento atual usa o fechamento padr\u00E3o do select; mantenha esta prop\napenas para compatibilidade com integra\u00E7\u00F5es legadas."
+                        }],
+                    "text": "Mant\u00E9m a lista aberta depois de uma sele\u00E7\u00E3o."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "keep-open-on-select",
+                "defaultValue": "false"
+            },
+            "visibleItems": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "6"
+                        }],
+                    "text": "Define quantas op\u00E7\u00F5es ficam vis\u00EDveis na janela da lista."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "visible-items",
+                "defaultValue": "6"
+            },
+            "itemHeight": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "40"
+                        }],
+                    "text": "Informa a altura base de cada op\u00E7\u00E3o para o c\u00E1lculo de virtual scroll."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "item-height",
+                "defaultValue": "40"
+            },
+            "inputWidth": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string | undefined",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "type",
+                            "text": "{string}"
+                        }, {
+                            "name": "example",
+                            "text": "'20rem'"
+                        }],
+                    "text": "Controla a largura do campo de entrada."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "input-width",
+                "defaultValue": "undefined"
+            },
+            "overscan": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "1"
+                        }],
+                    "text": "Define quantas op\u00E7\u00F5es extras s\u00E3o renderizadas antes e depois da \u00E1rea vis\u00EDvel no virtual scroll."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "overscan",
+                "defaultValue": "1"
+            },
+            "isOpen": {
+                "type": "boolean",
+                "mutable": true,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }, {
+                            "name": "deprecated",
+                            "text": "Use `open`."
+                        }],
+                    "text": "Controla o estado aberto/fechado da lista."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "is-open",
+                "defaultValue": "false"
+            },
+            "open": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Controla o estado aberto. Quando informada, tem preced\u00EAncia sobre `isOpen`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "open"
+            },
+            "label": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "type",
+                            "text": "{string | undefined}"
+                        }],
+                    "text": "Texto exibido como r\u00F3tulo do campo."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "label"
+            },
+            "name": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "type",
+                            "text": "{string | undefined}"
+                        }],
+                    "text": "Nome do campo para integra\u00E7\u00E3o com formul\u00E1rios."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "name"
+            },
+            "value": {
+                "type": "string",
+                "mutable": true,
+                "complexType": {
+                    "original": "string | string[]",
+                    "resolved": "string | string[]",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "type",
+                            "text": "{string | string[] | undefined}"
+                        }, {
+                            "name": "remarks",
+                            "text": "Em modo m\u00FAltiplo, o valor p\u00FAblico \u00E9 um array de strings."
+                        }],
+                    "text": "Valor p\u00FAblico do select baseado nas op\u00E7\u00F5es atualmente selecionadas."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "value",
+                "defaultValue": "''"
+            },
+            "placeholder": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "type",
+                            "text": "{string | undefined}"
+                        }],
+                    "text": "Texto exibido quando n\u00E3o h\u00E1 sele\u00E7\u00E3o."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "placeholder",
+                "defaultValue": "''"
+            },
+            "required": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Indica que o preenchimento do select \u00E9 obrigat\u00F3rio."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "required",
+                "defaultValue": "false"
+            },
+            "selectAllLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "'Selecionar todos'"
+                        }],
+                    "text": "R\u00F3tulo apresentado para a op\u00E7\u00E3o de selecionar todos no modo m\u00FAltiplo."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "select-all-label",
+                "defaultValue": "Select.SELECT_ALL_LABEL"
+            },
+            "filterable": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "true"
+                        }],
+                    "text": "Habilita a filtragem textual das op\u00E7\u00F5es por r\u00F3tulo ou valor."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "filterable",
+                "defaultValue": "true"
+            },
+            "searchMode": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "SelectSearchMode",
+                    "resolved": "\"local\" | \"remote\"",
+                    "references": {
+                        "SelectSearchMode": {
+                            "location": "import",
+                            "path": "./select.types",
+                            "id": "src/components/select/select.types.ts::SelectSearchMode",
+                            "referenceLocation": "SelectSearchMode"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "'local'"
+                        }],
+                    "text": "Define se as op\u00E7\u00F5es s\u00E3o filtradas localmente ou fornecidas por uma busca remota.\nEm `remote`, o componente emite `brSelectSearch`; a aplica\u00E7\u00E3o deve buscar,\nvalidar e aplicar as op\u00E7\u00F5es por `setOptions()`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "search-mode",
+                "defaultValue": "'local'"
+            },
+            "loading": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Indica que uma busca remota de op\u00E7\u00F5es est\u00E1 pendente.\nEnquanto ativo, novas op\u00E7\u00F5es n\u00E3o podem ser selecionadas; a aplica\u00E7\u00E3o\ncontinua respons\u00E1vel por debounce, cancelamento, erros e autentica\u00E7\u00E3o."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "loading",
+                "defaultValue": "false"
+            },
+            "showSearchIcon": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Exibe o \u00EDcone de busca no campo de entrada."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "show-search-icon",
+                "defaultValue": "false"
+            },
+            "unselectAllLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "'Desselecionar todos'"
+                        }],
+                    "text": "R\u00F3tulo apresentado quando todas as op\u00E7\u00F5es j\u00E1 est\u00E3o selecionadas no modo m\u00FAltiplo."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "unselect-all-label",
+                "defaultValue": "Select.DESELECT_ALL_LABEL"
+            },
+            "options": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string | { label: string; value: string; selected?: boolean }[] | SelectOptionData[]",
+                    "resolved": "SelectOptionData[] | string | { label: string; value: string; selected?: boolean; }[]",
+                    "references": {
+                        "SelectOptionData": {
+                            "location": "import",
+                            "path": "./select.types",
+                            "id": "src/components/select/select.types.ts::SelectOptionData",
+                            "referenceLocation": "SelectOptionData"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "deprecated",
+                            "text": "O formato de op\u00E7\u00F5es tipado atual \u00E9 prefer\u00EDvel; o formato legado permanece aceito."
+                        }],
+                    "text": "Op\u00E7\u00F5es fornecidas como array ou JSON, al\u00E9m das op\u00E7\u00F5es projetadas por slot."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "options",
+                "defaultValue": "[]"
+            },
+            "autocomplete": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "InputToggle",
+                    "resolved": "\"off\" | \"on\"",
+                    "references": {
+                        "InputToggle": {
+                            "location": "import",
+                            "path": "../input/input.types",
+                            "id": "src/components/input/input.types.ts::InputToggle",
+                            "referenceLocation": "InputToggle"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Controla o autocomplete do campo de busca interno."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "autocomplete"
+            },
+            "customId": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Identificador p\u00FAblico do controle."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "custom-id",
+                "defaultValue": "`br-select-${selectId++}`"
+            },
+            "minSelections": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Quantidade m\u00EDnima de op\u00E7\u00F5es selecionadas no modo m\u00FAltiplo."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "min-selections",
+                "defaultValue": "0"
+            },
+            "maxSelections": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Quantidade m\u00E1xima de op\u00E7\u00F5es selecionadas no modo m\u00FAltiplo."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "max-selections",
+                "defaultValue": "0"
+            },
+            "validator": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "SelectValidator | string",
+                    "resolved": "((value: string | string[]) => string | Promise<string>) | string",
+                    "references": {
+                        "SelectValidator": {
+                            "location": "import",
+                            "path": "./select.types",
+                            "id": "src/components/select/select.types.ts::SelectValidator",
+                            "referenceLocation": "SelectValidator"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Valida\u00E7\u00E3o s\u00EDncrona ou ass\u00EDncrona executada no m\u00E9todo `validate()`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "validator"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "activeOptionIndex": {},
+            "displayValue": {},
+            "searchTerm": {},
+            "formDisabled": {},
+            "isValidating": {},
+            "validatorMessage": {},
+            "hasFeedbackSlot": {},
+            "hasValidationLoadingSlot": {},
+            "selectedValuesState": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "brSelectStateChange",
+                "name": "brSelectStateChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [{
+                            "name": "event",
+                            "text": "brSelectStateChange"
+                        }, {
+                            "name": "type",
+                            "text": "{EventEmitter<SelectStateChangeDetail>}"
+                        }, {
+                            "name": "remarks",
+                            "text": "O payload consolidado informa abertura, desabilita\u00E7\u00E3o e sele\u00E7\u00E3o atual."
+                        }],
+                    "text": "Evento emitido quando o estado p\u00FAblico do select muda."
+                },
+                "complexType": {
+                    "original": "SelectStateChangeDetail",
+                    "resolved": "{ isOpen: boolean; option?: SelectOptionData; options?: SelectOptionData[]; }",
+                    "references": {
+                        "SelectStateChangeDetail": {
+                            "location": "import",
+                            "path": "./select.types",
+                            "id": "src/components/select/select.types.ts::SelectStateChangeDetail",
+                            "referenceLocation": "SelectStateChangeDetail"
+                        }
+                    }
+                }
+            }, {
+                "method": "valueChange",
+                "name": "valueChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [{
+                            "name": "deprecated",
+                            "text": "Use os eventos nativos `input` e `change`."
+                        }],
+                    "text": "Evento emitido quando o valor p\u00FAblico do select \u00E9 alterado."
+                },
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                }
+            }, {
+                "method": "optionHover",
+                "name": "optionHover",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [{
+                            "name": "deprecated",
+                            "text": "Use a navega\u00E7\u00E3o e os eventos de estado atuais."
+                        }],
+                    "text": "Emite a op\u00E7\u00E3o que recebeu foco ou hover."
+                },
+                "complexType": {
+                    "original": "{ label: string; value: string }",
+                    "resolved": "{ label: string; value: string; }",
+                    "references": {}
+                }
+            }, {
+                "method": "brSelectSearch",
+                "name": "brSelectSearch",
+                "bubbles": true,
+                "cancelable": false,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitido uma vez por edi\u00E7\u00E3o do campo de busca, inclusive ao limpar a consulta.\nO `detail` cont\u00E9m `{ query }`; o evento \u00E9 informativo e n\u00E3o cancel\u00E1vel.\nA aplica\u00E7\u00E3o deve controlar debounce, transporte e ciclo de vida da busca."
+                },
+                "complexType": {
+                    "original": "SelectSearchDetail",
+                    "resolved": "{ query: string; }",
+                    "references": {
+                        "SelectSearchDetail": {
+                            "location": "import",
+                            "path": "./select.types",
+                            "id": "src/components/select/select.types.ts::SelectSearchDetail",
+                            "referenceLocation": "SelectSearchDetail"
+                        }
+                    }
+                }
+            }, {
+                "method": "opened",
+                "name": "opened",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [{
+                            "name": "deprecated",
+                            "text": "Use `brSelectStateChange`."
+                        }],
+                    "text": "Emitido quando a lista \u00E9 aberta."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }, {
+                "method": "closed",
+                "name": "closed",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [{
+                            "name": "deprecated",
+                            "text": "Use `brSelectStateChange`."
+                        }],
+                    "text": "Emitido quando a lista \u00E9 fechada."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }, {
+                "method": "brSelectValidationChange",
+                "name": "brSelectValidationChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Informa o in\u00EDcio e o resultado de uma valida\u00E7\u00E3o s\u00EDncrona ou ass\u00EDncrona.\nO `detail` cont\u00E9m `validating`, `valid` e `message`."
+                },
+                "complexType": {
+                    "original": "{\n    validating: boolean;\n    valid: boolean | null;\n    message: string | null;\n  }",
+                    "resolved": "{ validating: boolean; valid: boolean; message: string; }",
+                    "references": {}
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "enable": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Habilita o select para intera\u00E7\u00E3o do usu\u00E1rio.",
+                    "tags": [{
+                            "name": "returns",
+                            "text": "Uma promise conclu\u00EDda ap\u00F3s a atualiza\u00E7\u00E3o do estado."
+                        }]
+                }
+            },
+            "disable": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Desabilita o select e impede novas intera\u00E7\u00F5es.",
+                    "tags": [{
+                            "name": "returns",
+                            "text": "Uma promise conclu\u00EDda ap\u00F3s a atualiza\u00E7\u00E3o do estado."
+                        }]
+                }
+            },
+            "show": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Abre a lista de op\u00E7\u00F5es quando o componente est\u00E1 habilitado.",
+                    "tags": [{
+                            "name": "returns",
+                            "text": "Uma promise conclu\u00EDda ap\u00F3s a atualiza\u00E7\u00E3o do estado."
+                        }]
+                }
+            },
+            "close": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Fecha a lista de op\u00E7\u00F5es quando o componente est\u00E1 habilitado.",
+                    "tags": [{
+                            "name": "returns",
+                            "text": "Uma promise conclu\u00EDda ap\u00F3s a atualiza\u00E7\u00E3o do estado."
+                        }]
+                }
+            },
+            "toggleOpen": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Alterna entre os estados aberto e fechado do select.",
+                    "tags": [{
+                            "name": "returns",
+                            "text": "Uma promise conclu\u00EDda ap\u00F3s a atualiza\u00E7\u00E3o do estado."
+                        }]
+                }
+            },
+            "clear": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Limpa a sele\u00E7\u00E3o atual.",
+                    "tags": [{
+                            "name": "deprecated",
+                            "text": "Use `setValue('')` ou a API de formul\u00E1rio."
+                        }]
+                }
+            },
+            "getValue": {
+                "complexType": {
+                    "signature": "() => Promise<string | string[]>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<string | string[]>"
+                },
+                "docs": {
+                    "text": "Retorna o valor p\u00FAblico atual.",
+                    "tags": [{
+                            "name": "deprecated",
+                            "text": "Leia a propriedade `value` diretamente."
+                        }]
+                }
+            },
+            "setValue": {
+                "complexType": {
+                    "signature": "(value: string | string[]) => Promise<void>",
+                    "parameters": [{
+                            "name": "value",
+                            "type": "string | string[]",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Define o valor p\u00FAblico do select.",
+                    "tags": [{
+                            "name": "deprecated",
+                            "text": "Atribua a propriedade `value` diretamente."
+                        }]
+                }
+            },
+            "setFocus": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Move o foco para o campo interno.",
+                    "tags": [{
+                            "name": "deprecated",
+                            "text": "Use o foco nativo do componente quando poss\u00EDvel."
+                        }]
+                }
+            },
+            "checkValidity": {
+                "complexType": {
+                    "signature": "() => Promise<boolean>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "reportValidity": {
+                "complexType": {
+                    "signature": "() => Promise<boolean>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "setCustomValidity": {
+                "complexType": {
+                    "signature": "(message: string) => Promise<void>",
+                    "parameters": [{
+                            "name": "message",
+                            "type": "string",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "getValidationState": {
+                "complexType": {
+                    "signature": "() => Promise<FormValidationState>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "FormValidationState": {
+                            "location": "import",
+                            "path": "../../shared/utils/form",
+                            "id": "src/shared/utils/form.ts::FormValidationState",
+                            "referenceLocation": "FormValidationState"
+                        }
+                    },
+                    "return": "Promise<FormValidationState>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "validate": {
+                "complexType": {
+                    "signature": "() => Promise<boolean>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "setOptions": {
+                "complexType": {
+                    "signature": "(options: SelectOptionData[]) => Promise<void>",
+                    "parameters": [{
+                            "name": "options",
+                            "type": "SelectOptionData[]",
+                            "docs": "Op\u00E7\u00F5es que devem ser exibidas pela lista interna.\nEm `search-mode=\"remote\"`, a sele\u00E7\u00E3o atual \u00E9 preservada mesmo quando n\u00E3o\naparece na resposta recebida."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "SelectOptionData": {
+                            "location": "import",
+                            "path": "./select.types",
+                            "id": "src/components/select/select.types.ts::SelectOptionData",
+                            "referenceLocation": "SelectOptionData"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Substitui a cole\u00E7\u00E3o atual de op\u00E7\u00F5es por uma nova lista.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "options Op\u00E7\u00F5es que devem ser exibidas pela lista interna.\nEm `search-mode=\"remote\"`, a sele\u00E7\u00E3o atual \u00E9 preservada mesmo quando n\u00E3o\naparece na resposta recebida."
+                        }, {
+                            "name": "returns",
+                            "text": "Uma promise conclu\u00EDda ap\u00F3s a sincroniza\u00E7\u00E3o das op\u00E7\u00F5es."
+                        }]
+                }
+            },
+            "setOption": {
+                "complexType": {
+                    "signature": "(option: SelectOptionData) => Promise<void>",
+                    "parameters": [{
+                            "name": "option",
+                            "type": "{ content?: string; disabled?: boolean; indeterminate?: boolean; label?: string; selected?: boolean; value: string; }",
+                            "docs": "Op\u00E7\u00E3o que deve ser inserida ou atualizada."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "SelectOptionData": {
+                            "location": "import",
+                            "path": "./select.types",
+                            "id": "src/components/select/select.types.ts::SelectOptionData",
+                            "referenceLocation": "SelectOptionData"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Adiciona ou atualiza uma \u00FAnica op\u00E7\u00E3o na cole\u00E7\u00E3o interna.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "option Op\u00E7\u00E3o que deve ser inserida ou atualizada."
+                        }, {
+                            "name": "returns",
+                            "text": "Uma promise conclu\u00EDda ap\u00F3s a sincroniza\u00E7\u00E3o da op\u00E7\u00E3o."
+                        }]
+                }
+            }
+        };
+    }
+    static get elementRef() { return "el"; }
+    static get watchers() {
+        return [{
+                "propName": "disabled",
+                "methodName": "handleDisabledChange"
+            }, {
+                "propName": "isOpen",
+                "methodName": "handleIsOpenChange"
+            }, {
+                "propName": "filterable",
+                "methodName": "handleFilterableChange"
+            }, {
+                "propName": "loading",
+                "methodName": "handleLoadingChange"
+            }, {
+                "propName": "isMultiple",
+                "methodName": "handleIsMultipleChange"
+            }, {
+                "propName": "multiple",
+                "methodName": "handleMultipleChange"
+            }, {
+                "propName": "open",
+                "methodName": "handleOpenChange"
+            }, {
+                "propName": "value",
+                "methodName": "handleExternalValueChange"
+            }, {
+                "propName": "options",
+                "methodName": "handleOptionsChange"
+            }];
+    }
+    static get listeners() {
+        return [{
+                "name": "brSelectInputFocus",
+                "method": "handleSelectInputFocus",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "brSelectInputValueChange",
+                "method": "handleSelectInputValueChange",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "brSelectInputActionClick",
+                "method": "handleSelectInputActionClick",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "brSelectInputClick",
+                "method": "handleSelectInputClick",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "brSelectOptionStateChange",
+                "method": "handleSelectOptionStateChange",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "brInternalSelectOptionHover",
+                "method": "handleSelectOptionHover",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "keydown",
+                "method": "handleKeyDown",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "click",
+                "method": "handleWindowClick",
+                "target": "window",
+                "capture": false,
+                "passive": false
+            }];
+    }
+    static get attachInternalsMemberName() { return "elementInternals"; }
+}
+Select.SELECT_ALL_LABEL = 'Selecionar todos';
+Select.DESELECT_ALL_LABEL = 'Desselecionar todos';