@govbr-ds/webcomponents 2.5.0 → 2.6.0

package/dist/cjs/br-table.cjs.entry.js

@@ -4,331 +4,2498 @@
  */
 'use strict';
 
-var index = require('./index-Bc30P_6z.js');
-var id = require('./id-DE4jSi-L.js');
+var index = require('./index-BP8UIQro.js');
+var helpers = require('./helpers-DkkDubv1.js');
 var ownership = require('./ownership-UnpufyCx.js');
-var propWarning = require('./prop-warning-xvEHQz8H.js');
-var props = require('./props-D8dybmr0.js');
-var tableConstants = require('./table-constants-BOPSay0B.js');
+var table_utils = require('./table.utils-De-9_NgJ.js');
+var focus = require('./focus-BhfJnFgJ.js');
+require('./format-bytes-Cs8SH2w0.js');
+require('./id-DE4jSi-L.js');
 
+/** Modelo lógico e materializador virtual da tabela. */
 /**
- * Tokens CSS utilizados pela tabela.
- * Centralizam variáveis customizadas para controle de layout e estilo.
+ * Converte a representação de conteúdo da API (`TableDataContent`) em nós DOM.
+ *
+ * Comportamento importante:
+ * - Se um item for uma instância de `Node`, a tabela irá reutilizá-lo tal qual
+ *   (isto é, o nó é transferido para a célula com `appendChild()`). Ou seja,
+ *   não é feita clonagem — o elemento é removido da sua posição anterior no DOM
+ *   e passa a pertencer à célula da tabela.
+ * - Se o item não for um `Node`, será convertido em `TextNode` com `String(entry)`.
+ *
+ * Riscos e observações (resumido): clonagem externa é responsabilidade do
+ * consumidor quando necessário; event listeners adicionados via
+ * `addEventListener` não são clonados automaticamente; duplicação de `id`
+ * deve ser evitada ao reutilizar nós em múltiplos lugares.
+ *
+ * @param content Conteúdo fornecido pelo consumidor (Node | string | array)
+ * @returns Array de `Node` pronto para ser anexado à célula
+ */
+const materializeContent = (content) => {
+    if (content === undefined || content === null)
+        return [];
+    const entries = Array.isArray(content) ? content : [content];
+    return entries.map((entry) => (entry instanceof Node ? entry : document.createTextNode(String(entry))));
+};
+const applyOptionalAttribute = (element, name, value) => {
+    if (value !== undefined && value !== null)
+        element.setAttribute(name, value);
+};
+/**
+ * Cria um elemento `br-table-action` a partir do descriptor público `TableActionData`.
+ * O elemento retornado ainda não está anexado ao host — quem chamar decide o slot.
+ */
+const createAction = (data, slot) => {
+    const action = document.createElement('br-table-action');
+    action.setAttribute('label', data.label);
+    if (data.iconName !== undefined)
+        action.setAttribute('icon-name', data.iconName);
+    if (data.ariaLabel !== undefined)
+        action.setAttribute('aria-label', data.ariaLabel);
+    if (slot !== undefined)
+        action.setAttribute('slot', slot);
+    return action;
+};
+/**
+ * Constrói um `br-table-cell` a partir de `TableCellData`.
+ *
+ * Observação: o conteúdo passado em `data.content` será materializado via
+ * `materializeContent` e, se incluir `Node`, esses nós serão transferidos
+ * (movidos) para a célula.
+ */
+const createCell = (data) => {
+    const cell = document.createElement('br-table-cell');
+    cell.toggleAttribute('row-header', Boolean(data.rowHeader));
+    if (data.colSpan !== undefined)
+        cell.setAttribute('col-span', String(data.colSpan));
+    if (data.rowSpan !== undefined)
+        cell.setAttribute('row-span', String(data.rowSpan));
+    applyOptionalAttribute(cell, 'horizontal-alignment', data.horizontalAlignment);
+    applyOptionalAttribute(cell, 'vertical-alignment', data.verticalAlignment);
+    applyOptionalAttribute(cell, 'overflow', data.overflow);
+    applyOptionalAttribute(cell, 'tooltip-state', data.tooltipState);
+    applyOptionalAttribute(cell, 'tooltip-mode', data.tooltipMode);
+    if (data.cellActionsLimit !== undefined)
+        cell.setAttribute('cell-actions-limit', String(data.cellActionsLimit));
+    if (data.sortValue !== undefined)
+        cell.setAttribute('sort-value', String(data.sortValue));
+    materializeContent(data.content).forEach((node) => {
+        cell.appendChild(node);
+    });
+    data.actions?.forEach((action) => {
+        cell.appendChild(createAction(action));
+    });
+    return cell;
+};
+/**
+ * Constrói um `br-table-header-cell` a partir de `TableColumnData`.
+ * Conteúdo é materializado com `materializeContent`.
+ */
+const createColumn = (data) => {
+    const column = document.createElement('br-table-header-cell');
+    if (data.colSpan !== undefined)
+        column.setAttribute('col-span', String(data.colSpan));
+    if (data.rowSpan !== undefined)
+        column.setAttribute('row-span', String(data.rowSpan));
+    applyOptionalAttribute(column, 'column-width', data.columnWidth);
+    applyOptionalAttribute(column, 'horizontal-alignment', data.horizontalAlignment);
+    applyOptionalAttribute(column, 'vertical-alignment', data.verticalAlignment);
+    applyOptionalAttribute(column, 'overflow', data.overflow);
+    applyOptionalAttribute(column, 'tooltip-state', data.tooltipState);
+    applyOptionalAttribute(column, 'tooltip-mode', data.tooltipMode);
+    column.toggleAttribute('sortable', Boolean(data.sortable));
+    materializeContent(data.content).forEach((node) => {
+        column.appendChild(node);
+    });
+    return column;
+};
+/**
+ * Constrói um `br-table-row` a partir de `TableRowData`.
+ *
+ * Notas:
+ * - As células são criadas com `createCell` e anexadas ao `br-table-row`.
+ * - `expandedContent`, quando presente, é materializado e marcado com
+ *   `slot="expanded-content"` para posterior renderização de conteúdo
+ *   expandido; se o conteúdo for um nó não-`HTMLElement`, ele é embrulhado
+ *   em um `span` com o slot apropriado.
+ */
+const createRow = (data) => {
+    const row = document.createElement('br-table-row');
+    applyOptionalAttribute(row, 'row-group', data.rowGroup);
+    row.toggleAttribute('selected', Boolean(data.selected));
+    row.toggleAttribute('disabled', Boolean(data.disabled));
+    row.toggleAttribute('expanded', Boolean(data.expanded));
+    applyOptionalAttribute(row, 'row-expansion', data.rowExpansion);
+    if (data.virtualExpandedContentHeight !== undefined) {
+        row.setAttribute('virtual-expanded-content-height', String(data.virtualExpandedContentHeight));
+    }
+    applyOptionalAttribute(row, 'horizontal-alignment', data.horizontalAlignment);
+    applyOptionalAttribute(row, 'vertical-alignment', data.verticalAlignment);
+    applyOptionalAttribute(row, 'overflow', data.overflow);
+    applyOptionalAttribute(row, 'tooltip-state', data.tooltipState);
+    applyOptionalAttribute(row, 'tooltip-mode', data.tooltipMode);
+    data.cells.forEach((cell) => {
+        row.appendChild(createCell(cell));
+    });
+    materializeContent(data.expandedContent).forEach((contentNode) => {
+        let node = contentNode;
+        if (node instanceof HTMLElement)
+            node.setAttribute('slot', 'expanded-content');
+        else {
+            const wrapper = document.createElement('span');
+            wrapper.setAttribute('slot', 'expanded-content');
+            wrapper.appendChild(node);
+            node = wrapper;
+        }
+        row.appendChild(node);
+    });
+    return row;
+};
+/**
+ * Gerencia o modelo lógico e a materialização virtual da tabela.
+ *
+ * Responsabilidades principais:
+ * - Capturar marcação já presente no host (`capture`).
+ * - Substituir o conjunto lógico por dados programáticos (`replace`).
+ * - Materializar a janela virtual, preservando linhas já montadas (`mount`, `renderRange`).
+ *
+ * Observação sobre materialização de conteúdo:
+ * - Quando `TableDataContent` contém nós (`Node`), esses nós são
+ *   transferidos para as células usando `appendChild()` (re-anexação no DOM).
+ *   Não há clonagem automática; consumidores que precisam preservar o
+ *   nó original devem clonar antes de passá-lo à tabela.
+ */
+class TableDataStore {
+    constructor() {
+        this.data = {
+            headerRows: [],
+            columns: [],
+            rows: [],
+            globalActions: [],
+            contextualActions: [],
+        };
+        this.body = null;
+        this.rowElements = [];
+        this.renderedRows = [];
+    }
+    /** Invalida apenas as unidades derivadas quando uma chave de grupo muda. */
+    invalidateGroups() {
+        this.itemGroups = undefined;
+        this.pageBoundaries = undefined;
+    }
+    getItemGroups() {
+        this.itemGroups ?? (this.itemGroups = table_utils.getTableRowGroups(this.rowElements));
+        return this.itemGroups;
+    }
+    capture(host) {
+        const headerRows = Array.from(host.querySelectorAll('br-table-header > br-table-row'));
+        if (headerRows.length === 0)
+            headerRows.push(document.createElement('br-table-row'));
+        const columns = table_utils.getTableLeafHeaders(headerRows)
+            .filter((el) => !el.hasAttribute(table_utils.TABLE_SELECTION_GENERATED_ATTR) && !el.hasAttribute(table_utils.TABLE_EXPANSION_GENERATED_ATTR))
+            .map((element) => ({ element }));
+        const rows = Array.from(host.querySelectorAll('br-table-row'))
+            .filter((row) => row.closest('br-table-header') === null)
+            .map((row, index) => {
+            row.setAttribute('data-virtual-index', String(index));
+            const cells = Array.from(row.querySelectorAll('br-table-cell'))
+                .filter((cell) => !cell.hasAttribute(table_utils.TABLE_SELECTION_GENERATED_ATTR) && !cell.hasAttribute(table_utils.TABLE_EXPANSION_GENERATED_ATTR))
+                .map((cell) => ({ element: cell }));
+            return {
+                element: row,
+                cells,
+                originalIndex: index,
+            };
+        });
+        const actions = Array.from(host.children).filter((el) => el.tagName.toLowerCase() === 'br-table-action');
+        this.data = {
+            headerRows,
+            columns,
+            rows,
+            globalActions: actions
+                .filter((el) => el.getAttribute('slot') === 'global-actions')
+                .map((element) => ({ element })),
+            contextualActions: actions
+                .filter((el) => el.getAttribute('slot') === 'contextual-actions')
+                .map((element) => ({ element })),
+        };
+        this.refreshRowElements();
+    }
+    replace(data) {
+        const rows = data.rows.map((rowData, index) => {
+            const element = createRow(rowData);
+            element.setAttribute('data-virtual-index', String(index));
+            return {
+                element,
+                cells: Array.from(element.querySelectorAll('br-table-cell')).map((cell) => ({
+                    element: cell,
+                })),
+                originalIndex: index,
+            };
+        });
+        const headerRows = (data.headerRows?.length ? data.headerRows : [data.columns]).map((cells) => {
+            const row = document.createElement('br-table-row');
+            row.append(...cells.map(createColumn));
+            return row;
+        });
+        this.data = {
+            headerRows,
+            columns: table_utils.getTableLeafHeaders(headerRows).map((element) => ({ element })),
+            rows,
+            globalActions: (data.globalActions ?? []).map((action) => ({ element: createAction(action, 'global-actions') })),
+            contextualActions: (data.contextualActions ?? []).map((action) => ({
+                element: createAction(action, 'contextual-actions'),
+            })),
+        };
+        this.refreshRowElements();
+    }
+    mount(host) {
+        const header = document.createElement('br-table-header');
+        header.setAttribute('slot', 'header');
+        header.append(...this.data.headerRows);
+        this.body = document.createElement('br-table-body');
+        this.body.setAttribute('slot', 'body');
+        this.renderedRows = [];
+        Array.from(host.children)
+            .filter((child) => {
+            const tag = child.tagName.toLowerCase();
+            const slot = child.getAttribute('slot');
+            return (tag === 'br-table-header' ||
+                tag === 'br-table-body' ||
+                (tag === 'br-table-action' && (slot === 'global-actions' || slot === 'contextual-actions')));
+        })
+            .forEach((child) => {
+            child.remove();
+        });
+        this.data.globalActions.forEach(({ element }) => {
+            host.appendChild(element);
+        });
+        this.data.contextualActions.forEach(({ element }) => {
+            host.appendChild(element);
+        });
+        host.appendChild(header);
+        host.appendChild(this.body);
+    }
+    /**
+     * Reordena o dataset lógico completo antes da materialização virtual.
+     * Critérios com menor `columnIndex` possuem maior prioridade no multi-sort.
+     */
+    sortRows(sorting) {
+        const criteria = [...sorting].sort((a, b) => a.columnIndex - b.columnIndex);
+        const byElement = new Map(this.data.rows.map((row) => [row.element, row]));
+        const groups = table_utils.getTableRowGroups(this.rowElements).map((group) => group.flatMap((row) => {
+            const entry = byElement.get(row);
+            return entry ? [entry] : [];
+        }));
+        groups.sort((groupA, groupB) => {
+            const rowA = groupA[0];
+            const rowB = groupB[0];
+            for (const criterion of criteria) {
+                const valueA = this.getSortValue(rowA, criterion.columnIndex);
+                const valueB = this.getSortValue(rowB, criterion.columnIndex);
+                const comparison = this.compareSortValues(valueA, valueB);
+                if (comparison !== 0) {
+                    return criterion.direction === 'asc' ? comparison : -comparison;
+                }
+            }
+            return rowA.originalIndex - rowB.originalIndex;
+        });
+        this.data.rows = groups.flat();
+        this.data.rows.forEach(({ element }, index) => {
+            element.setAttribute('data-virtual-index', String(index));
+        });
+        this.refreshRowElements();
+    }
+    /** Retorna as colunas lógicas, sem as colunas geradas de seleção/expansão. */
+    getColumns() {
+        return table_utils.getTableLeafHeaders(this.data.headerRows).filter((cell) => !cell.hasAttribute(table_utils.TABLE_SELECTION_GENERATED_ATTR) && !cell.hasAttribute(table_utils.TABLE_EXPANSION_GENERATED_ATTR));
+    }
+    getSortValue(row, columnIndex) {
+        const cell = table_utils.getTablePlacements([row.element], 'br-table-cell')
+            .filter(({ cell }) => !cell.hasAttribute(table_utils.TABLE_SELECTION_GENERATED_ATTR) && !cell.hasAttribute(table_utils.TABLE_EXPANSION_GENERATED_ATTR))
+            .find((entry) => {
+            const column = columnIndex + this.generatedColumnCount();
+            return column >= entry.column && column < entry.column + entry.colSpan;
+        })?.cell;
+        if (cell === undefined)
+            return '';
+        const explicitValue = cell.getAttribute('sort-value');
+        if (explicitValue !== null)
+            return explicitValue.trim();
+        return cell.textContent?.trim() ?? '';
+    }
+    generatedColumnCount() {
+        return (this.rowElements[0]?.querySelectorAll(`:scope > [${table_utils.TABLE_SELECTION_GENERATED_ATTR}], :scope > [${table_utils.TABLE_EXPANSION_GENERATED_ATTR}]`).length ?? 0);
+    }
+    /** Itens lógicos de paginação: grupos contíguos ou linhas independentes. */
+    getItemCount() {
+        return this.getItemGroups().length;
+    }
+    /** Limites físicos da página, sem dividir grupos. */
+    getPageRange(startItem, itemCount) {
+        if (!this.pageBoundaries) {
+            const boundaries = [0];
+            this.getItemGroups().forEach((group) => {
+                boundaries.push(boundaries[boundaries.length - 1] + group.length);
+            });
+            this.pageBoundaries = boundaries;
+        }
+        const count = this.pageBoundaries.length - 1;
+        return {
+            start: this.pageBoundaries[Math.min(startItem, count)],
+            end: this.pageBoundaries[Math.min(startItem + itemCount, count)],
+        };
+    }
+    compareSortValues(valueA, valueB) {
+        return valueA.localeCompare(valueB, 'pt-BR', {
+            numeric: true,
+            sensitivity: 'base',
+        });
+    }
+    renderRange(range, rows = this.data.rows, indexOffset = 0) {
+        const body = this.body;
+        if (body === null)
+            return;
+        const focused = body.contains(document.activeElement) ? focus.getDeepActiveElement() : null;
+        const children = [];
+        const renderedRows = [];
+        const addSpacer = (height, position) => {
+            if (height <= 0)
+                return;
+            const spacer = body.querySelector(`:scope > [data-table-virtual-spacer="${position}"]`) ??
+                this.createSpacer(height, position);
+            spacer.style.height = `${height}px`;
+            children.push(spacer);
+        };
+        addSpacer(range.beforeHeight, 'before');
+        const rangeRows = rows.slice(range.start, range.end).map(({ element }) => element);
+        let logicalIndex = range.start;
+        for (const group of table_utils.getTableRowGroups(rangeRows)) {
+            if (group.length > 1 ||
+                group[0].hasAttribute('row-group') ||
+                Array.from(group[0].children).some((cell) => table_utils.resolveTableSpan(cell.getAttribute('col-span')) > 1)) {
+                const first = group[0];
+                const wrapper = first.parentElement?.hasAttribute('data-table-row-group')
+                    ? first.parentElement
+                    : document.createElement('div');
+                wrapper.setAttribute('data-table-row-group', '');
+                wrapper.setAttribute('role', 'presentation');
+                let expandedRow = group.length + 1;
+                group.forEach((row) => {
+                    // Detalhes ficam após as linhas do grupo para não sobrepor suas células mescladas.
+                    row.style.setProperty('--table-expanded-grid-row', String(expandedRow));
+                    if (row.hasAttribute('expanded'))
+                        expandedRow++;
+                });
+                table_utils.applyTablePlacements(table_utils.getTablePlacements(group, 'br-table-cell'));
+                group.forEach((row) => {
+                    row.setAttribute('data-virtual-index', String(logicalIndex++ + indexOffset));
+                    if (row.parentElement !== wrapper)
+                        wrapper.append(row);
+                    renderedRows.push(row);
+                });
+                children.push(wrapper);
+                continue;
+            }
+            const index = logicalIndex++;
+            const row = rows[index]?.element;
+            if (row === undefined)
+                continue;
+            row.style.removeProperty('--table-expanded-grid-row');
+            row.querySelectorAll(':scope > br-table-cell').forEach((cell) => {
+                cell.style.removeProperty('--table-cell-grid-column');
+                cell.style.removeProperty('--table-cell-grid-row');
+            });
+            row.setAttribute('data-virtual-index', String(index + indexOffset));
+            children.push(row);
+            renderedRows.push(row);
+        }
+        addSpacer(range.afterHeight, 'after');
+        const retained = new Set(children);
+        Array.from(body.children).forEach((child) => {
+            if (!retained.has(child))
+                child.remove();
+        });
+        // Preserva conexão, hover e foco das linhas que continuam na mesma posição.
+        let next = body.firstElementChild;
+        children.forEach((child) => {
+            if (child !== next)
+                body.insertBefore(child, next);
+            next = child.nextElementSibling;
+        });
+        this.renderedRows = renderedRows;
+        if (focused instanceof HTMLElement && focused.isConnected && focus.getDeepActiveElement() !== focused) {
+            focused.focus({ preventScroll: true });
+        }
+    }
+    getRows() {
+        return this.rowElements.slice();
+    }
+    /** Visão interna somente leitura, estável até a ordem, os dados ou o recorte mudarem. */
+    getRowsView(start = 0, end = this.rowElements.length) {
+        if (start === 0 && end === this.rowElements.length)
+            return this.rowElements;
+        const view = this.rowView;
+        if (view?.source === this.rowElements && view.start === start && view.end === end)
+            return view.rows;
+        const rows = this.rowElements.slice(start, end);
+        this.rowView = { source: this.rowElements, start, end, rows };
+        return rows;
+    }
+    refreshRowElements() {
+        this.invalidateGroups();
+        this.rowElements = this.data.rows.map(({ element }) => element);
+        this.rowView = undefined;
+    }
+    getRow(index) {
+        return this.data.rows[index]?.element;
+    }
+    getRowCount() {
+        return this.data.rows.length;
+    }
+    getRenderedRows() {
+        return this.renderedRows.filter((row) => row.isConnected);
+    }
+    createSpacer(height, position) {
+        const spacer = document.createElement('div');
+        spacer.setAttribute('data-table-virtual-spacer', position);
+        spacer.setAttribute('role', 'presentation');
+        spacer.style.gridColumn = '1 / -1';
+        spacer.style.height = `${Math.max(0, height)}px`;
+        spacer.style.pointerEvents = 'none';
+        return spacer;
+    }
+}
+
+/**
+ * Factories dos elementos utilizados pela expansão de linhas.
+ *
+ * @module table-expansion-elements
+ */
+/**
+ * Sincroniza ícone, rótulos e estado acessível da ação de expansão.
+ *
+ * @param action Componente de ação que será atualizado.
+ * @param expanded Estado atual da linha.
+ * @param rowIndex Índice da linha no corpo, começando em zero.
+ */
+function syncExpansionAction(action, expanded, rowIndex) {
+    const stateLabel = expanded ? 'Recolher' : 'Expandir';
+    action.setAttribute('label', `${stateLabel} linha ${rowIndex + 1}`);
+    action.setAttribute('aria-label', `${stateLabel} linha ${rowIndex + 1}`);
+    action.setAttribute('icon-name', expanded ? 'fa-solid:chevron-up' : 'fa-solid:chevron-down');
+    action.setAttribute('aria-expanded', String(expanded));
+}
+/**
+ * Cria uma ação de expansão reutilizando `br-table-action`.
+ *
+ * @param options Estado inicial e índice da linha.
+ * @returns Ação identificada para consumo interno do controller.
+ */
+function createExpansionAction({ expanded, rowIndex }) {
+    const action = document.createElement('br-table-action');
+    action.setAttribute(table_utils.TABLE_EXPANSION_ACTION_ATTR, '');
+    syncExpansionAction(action, expanded, rowIndex);
+    return action;
+}
+/**
+ * Cria a célula estrutural da coluna de expansão.
+ *
+ * @param action Ação opcional; linhas desabilitadas utilizam célula vazia.
+ * @returns Célula marcada como gerada pelo controller de expansão.
+ */
+function createExpansionCell(action) {
+    const cell = document.createElement('br-table-cell');
+    cell.setAttribute(table_utils.TABLE_EXPANSION_COLUMN_ATTR, '');
+    cell.setAttribute(table_utils.TABLE_EXPANSION_GENERATED_ATTR, '');
+    cell.setAttribute('horizontal-alignment', table_utils.TABLE_ALIGNMENT.CENTER);
+    cell.setAttribute('vertical-alignment', table_utils.TABLE_ALIGNMENT.CENTER);
+    if (action !== undefined)
+        cell.appendChild(action);
+    return cell;
+}
+/**
+ * Cria o cabeçalho vazio que define a coluna de expansão no grid.
+ *
+ * @param slotName Slot utilizado pelos demais cabeçalhos.
+ * @returns Cabeçalho com largura e alinhamentos apropriados ao chevron.
+ */
+function createExpansionHeaderCell(slotName) {
+    const cell = document.createElement('br-table-header-cell');
+    cell.setAttribute(table_utils.TABLE_EXPANSION_COLUMN_ATTR, '');
+    cell.setAttribute(table_utils.TABLE_EXPANSION_GENERATED_ATTR, '');
+    cell.setAttribute('column-width', table_utils.TABLE_EXPANSION_COLUMN_WIDTH);
+    cell.setAttribute('horizontal-alignment', table_utils.TABLE_ALIGNMENT.CENTER);
+    cell.setAttribute('vertical-alignment', table_utils.TABLE_ALIGNMENT.CENTER);
+    cell.setAttribute('aria-label', 'Expansão de linha');
+    if (slotName !== undefined)
+        cell.setAttribute('slot', slotName);
+    return cell;
+}
+
+/**
+ * Controller responsável pela expansão de linhas.
+ *
+ * @module table-expansion
+ */
+/**
+ * Coordena a coluna, as ações e o estado de expansão das linhas.
+ *
+ * @remarks A coluna permanece estruturalmente alinhada mesmo em linhas desabilitadas.
+ */
+class TableExpansionController {
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Sincroniza a estrutura segundo a configuração global e os overrides das linhas.
+     *
+     * @param tableEnabled Indica se a expansão está habilitada na tabela.
+     */
+    sync(tableEnabled) {
+        const rows = this.getBodyRows();
+        const hasExpandableRows = rows.some((row) => this.isRowEnabled(row, tableEnabled));
+        if (!hasExpandableRows) {
+            this.removeColumn();
+            return;
+        }
+        this.ensureHeaderCell();
+        rows.forEach((row, rowIndex) => {
+            this.syncRow(row, rowIndex, tableEnabled);
+        });
+    }
+    /**
+     * Consome cliques originados pelas ações internas de expansão.
+     *
+     * @param event Evento emitido por `br-table-action`.
+     * @returns `true` quando o evento foi tratado como expansão.
+     */
+    handleActionClick(event) {
+        const action = event
+            .composedPath()
+            .find((node) => node instanceof HTMLElement &&
+            node.tagName.toLowerCase() === 'br-table-action' &&
+            node.hasAttribute(table_utils.TABLE_EXPANSION_ACTION_ATTR));
+        if (action === undefined)
+            return false;
+        const row = action.closest('br-table-row');
+        if (row === null)
+            return false;
+        if (row.hasAttribute('disabled'))
+            return true;
+        this.setExpanded(row, !row.hasAttribute('expanded'), 'action');
+        return true;
+    }
+    /**
+     * Define o estado de expansão de uma linha elegível.
+     *
+     * @param row Linha que receberá a mudança.
+     * @param expanded Novo estado de expansão.
+     * @param source Origem utilizada no evento público.
+     */
+    setExpanded(row, expanded, source = 'programmatic') {
+        if (!row.hasAttribute('data-row-expansion-enabled'))
+            return;
+        row.toggleAttribute('expanded', expanded);
+        row.removeAttribute('aria-expanded');
+        this.syncRowAction(row);
+        const rows = this.getBodyRows();
+        this.options.onChange({ row, rowIndex: rows.indexOf(row), expanded, source });
+    }
+    /**
+     * Recolhe todas as linhas atualmente expandidas.
+     */
+    collapseAll() {
+        this.getBodyRows().forEach((row) => {
+            if (row.hasAttribute('expanded'))
+                this.setExpanded(row, false);
+        });
+    }
+    getBodyRows() {
+        if (this.options.getRows !== undefined) {
+            return this.options.getRows();
+        }
+        return Array.from(this.options.host.querySelectorAll('br-table-row')).filter((row) => row.closest('br-table-header') === null);
+    }
+    /**
+     * Resolve o override declarado diretamente na linha.
+     */
+    getRowOverride(row) {
+        const value = row.getAttribute('row-expansion');
+        if (value === table_utils.TABLE_ROW_EXPANSION.ENABLED)
+            return true;
+        if (value === table_utils.TABLE_ROW_EXPANSION.DISABLED)
+            return false;
+        return undefined;
+    }
+    isRowEnabled(row, tableEnabled) {
+        const override = this.getRowOverride(row);
+        return override ?? tableEnabled;
+    }
+    /**
+     * Garante que a coluna de expansão permaneça na primeira posição.
+     */
+    ensureHeaderCell() {
+        const firstHeader = this.options.host.querySelector('br-table-header-cell');
+        if (firstHeader === null)
+            return;
+        let cell = this.options.host.querySelector(`br-table-header-cell[${table_utils.TABLE_EXPANSION_GENERATED_ATTR}]`);
+        if (cell === null) {
+            const slotName = firstHeader.getAttribute('slot');
+            cell = createExpansionHeaderCell(slotName ?? undefined);
+        }
+        const parent = firstHeader.parentElement;
+        if (parent !== null && parent.firstElementChild !== cell)
+            parent.prepend(cell);
+    }
+    /**
+     * Sincroniza ação, célula estrutural e atributos de uma linha.
+     */
+    syncRow(row, rowIndex, tableEnabled) {
+        let cell = row.querySelector(`br-table-cell[${table_utils.TABLE_EXPANSION_GENERATED_ATTR}]`);
+        if (!this.isRowEnabled(row, tableEnabled)) {
+            if (cell === null) {
+                cell = createExpansionCell();
+                row.prepend(cell);
+            }
+            else {
+                cell.replaceChildren();
+            }
+            row.removeAttribute('data-row-expansion-enabled');
+            row.removeAttribute('expanded');
+            row.removeAttribute('aria-expanded');
+            if (row.firstElementChild !== cell)
+                row.prepend(cell);
+            return;
+        }
+        row.setAttribute('data-row-expansion-enabled', '');
+        if (cell === null) {
+            const action = createExpansionAction({ expanded: row.hasAttribute('expanded'), rowIndex });
+            cell = createExpansionCell(action);
+            row.prepend(cell);
+        }
+        else if (cell.querySelector(`br-table-action[${table_utils.TABLE_EXPANSION_ACTION_ATTR}]`) === null) {
+            cell.appendChild(createExpansionAction({ expanded: row.hasAttribute('expanded'), rowIndex }));
+        }
+        row.removeAttribute('aria-expanded');
+        if (row.firstElementChild !== cell)
+            row.prepend(cell);
+        this.syncRowAction(row, rowIndex);
+    }
+    /**
+     * Atualiza ícone e rótulos da ação pertencente à linha.
+     */
+    syncRowAction(row, rowIndex) {
+        const action = row.querySelector(`br-table-action[${table_utils.TABLE_EXPANSION_ACTION_ATTR}]`);
+        if (action === null)
+            return;
+        const resolvedIndex = rowIndex ?? this.getBodyRows().indexOf(row);
+        syncExpansionAction(action, row.hasAttribute('expanded'), resolvedIndex);
+    }
+    /**
+     * Remove somente os elementos e atributos gerados pela expansão.
+     */
+    removeColumn() {
+        this.options.host.querySelectorAll(`[${table_utils.TABLE_EXPANSION_GENERATED_ATTR}]`).forEach((node) => {
+            node.remove();
+        });
+        this.getBodyRows().forEach((row) => {
+            row.removeAttribute('data-row-expansion-enabled');
+            row.removeAttribute('expanded');
+            row.removeAttribute('aria-expanded');
+        });
+    }
+}
+
+/**
+ * Factories dos elementos utilizados pela seleção de linhas.
+ *
+ * @module table-selection-elements
+ */
+/**
+ * Cria uma instância configurada do componente `br-checkbox`.
+ *
+ * @param options Categoria, rótulo acessível e nome do controle.
+ * @returns Checkbox pronto para ser anexado a uma célula.
+ */
+function createSelectionCheckbox({ kind, label, name }) {
+    const checkbox = document.createElement('br-checkbox');
+    checkbox.setAttribute(table_utils.TABLE_SELECTION_CHECKBOX_ATTR, kind);
+    checkbox.setAttribute('compact', '');
+    checkbox.setAttribute('has-hidden-label', '');
+    checkbox.setAttribute('label', label);
+    checkbox.setAttribute('name', name);
+    return checkbox;
+}
+/**
+ * Cria a célula estrutural de seleção de uma linha.
+ *
+ * @param checkbox Controle associado à linha.
+ * @returns Célula marcada como gerada pelo controller de seleção.
+ */
+function createSelectionCell(checkbox) {
+    const cell = document.createElement('br-table-cell');
+    cell.setAttribute(table_utils.TABLE_SELECTION_COLUMN_ATTR, '');
+    cell.setAttribute(table_utils.TABLE_SELECTION_GENERATED_ATTR, '');
+    cell.setAttribute('horizontal-alignment', table_utils.TABLE_ALIGNMENT.CENTER);
+    cell.setAttribute('vertical-alignment', table_utils.TABLE_ALIGNMENT.CENTER);
+    cell.appendChild(checkbox);
+    return cell;
+}
+/**
+ * Cria o cabeçalho que define largura e alinhamentos da coluna de seleção.
+ *
+ * @param options Checkbox global e slot opcional do cabeçalho.
+ * @returns Cabeçalho configurado para participar do grid da tabela.
+ */
+function createSelectionHeaderCell({ checkbox, slotName, }) {
+    const cell = document.createElement('br-table-header-cell');
+    cell.setAttribute(table_utils.TABLE_SELECTION_COLUMN_ATTR, '');
+    cell.setAttribute(table_utils.TABLE_SELECTION_GENERATED_ATTR, '');
+    cell.setAttribute('horizontal-alignment', table_utils.TABLE_ALIGNMENT.CENTER);
+    cell.setAttribute('vertical-alignment', table_utils.TABLE_ALIGNMENT.CENTER);
+    /*
+     * A tabela consulta esses atributos antes de o Custom Element necessariamente
+     * concluir seu upgrade; por isso a configuração inicial utiliza atributos.
+     */
+    cell.setAttribute('column-width', table_utils.TABLE_SELECTION_COLUMN_WIDTH);
+    if (slotName !== undefined) {
+        cell.setAttribute('slot', slotName);
+    }
+    cell.appendChild(checkbox);
+    return cell;
+}
+
+/**
+ * Controller responsável pela seleção de linhas.
+ *
+ * @module table-selection
+ */
+/**
+ * Coordena a estrutura e o estado da seleção sem acoplar regras ao componente raiz.
+ *
+ * @remarks O controller mantém checkbox, atributos da linha, ARIA e cabeçalho sincronizados.
+ */
+class TableSelectionController {
+    constructor(options) {
+        this.options = options;
+        this.isSynchronizing = false;
+        this.checkboxDisabledStates = new WeakMap();
+    }
+    /**
+     * Sincroniza a coluna de seleção com a configuração atual da tabela.
+     *
+     * @param enabled Indica se a seleção está habilitada globalmente.
+     */
+    sync(enabled) {
+        if (!enabled) {
+            this.remove();
+            return;
+        }
+        this.ensureHeaderCell();
+        this.ensureRowCells();
+        this.syncRowsFromState();
+        this.syncHeaderCheckbox();
+    }
+    /**
+     * Processa eventos emitidos exclusivamente pelos checkboxes gerados.
+     *
+     * @param event Evento `checkedChange` recebido pela tabela.
+     * @returns `true` quando o evento pertencia ao subsistema de seleção.
+     */
+    handleCheckboxChange(event) {
+        const checkbox = this.getCheckboxFromEvent(event);
+        if (checkbox === null || this.isSynchronizing)
+            return false;
+        const kind = checkbox.getAttribute(table_utils.TABLE_SELECTION_CHECKBOX_ATTR);
+        if (kind === 'all') {
+            this.selectAll(Boolean(event.detail), 'all');
+            return true;
+        }
+        if (kind !== 'row')
+            return false;
+        const row = checkbox.closest('br-table-row');
+        const rowIndex = row instanceof HTMLElement ? this.getBodyRows().indexOf(row) : -1;
+        if (row instanceof HTMLElement) {
+            this.applyRowState(row, Boolean(event.detail));
+        }
+        this.syncHeaderCheckbox();
+        this.notifyChange('row', rowIndex >= 0 ? rowIndex : undefined);
+        return true;
+    }
+    /**
+     * Retorna o estado de seleção derivado das linhas do corpo.
+     *
+     * @returns Linhas que possuem `selected` ou `data-selected`.
+     */
+    getSelectedRows() {
+        return this.getBodyRows().filter((row) => row.hasAttribute('selected') || row.hasAttribute('data-selected'));
+    }
+    /**
+     * Aplica o mesmo estado a todas as linhas selecionáveis.
+     *
+     * @param selected Novo estado das linhas.
+     * @param source Origem utilizada no evento de mudança.
+     */
+    selectAll(selected, source = 'programmatic') {
+        const entries = this.getSelectableEntries();
+        this.isSynchronizing = true;
+        entries.forEach(({ checkbox, row }) => {
+            checkbox.checked = selected;
+            this.applyRowState(row, selected);
+        });
+        this.isSynchronizing = false;
+        this.syncHeaderCheckbox();
+        this.notifyChange(source);
+    }
+    /**
+     * Limpa todas as linhas selecionáveis.
+     *
+     * @param source Origem utilizada no evento de mudança.
+     */
+    clear(source = 'programmatic') {
+        this.selectAll(false, source);
+    }
+    getCheckboxFromEvent(event) {
+        const target = event
+            .composedPath()
+            .find((node) => node?.tagName?.toLowerCase() === 'br-checkbox');
+        return target?.hasAttribute(table_utils.TABLE_SELECTION_CHECKBOX_ATTR) ? target : null;
+    }
+    getBodyRows() {
+        if (this.options.getRows !== undefined)
+            return this.options.getRows();
+        return Array.from(this.options.host.querySelectorAll('br-table-row')).filter((row) => row.closest('br-table-header') === null);
+    }
+    getRowCheckbox(row) {
+        return row.querySelector(`br-checkbox[${table_utils.TABLE_SELECTION_CHECKBOX_ATTR}="row"]`);
+    }
+    getSelectableEntries() {
+        return this.getBodyRows().flatMap((row) => {
+            const checkbox = this.getRowCheckbox(row);
+            const disabled = row.hasAttribute('disabled') || checkbox?.hasAttribute('disabled') === true;
+            return checkbox === null || disabled ? [] : [{ row, checkbox }];
+        });
+    }
+    getHeaderCheckbox() {
+        return this.options.host.querySelector(`br-table-header-cell[${table_utils.TABLE_SELECTION_COLUMN_ATTR}] br-checkbox[${table_utils.TABLE_SELECTION_CHECKBOX_ATTR}="all"]`);
+    }
+    /**
+     * Atualiza o estado visual e acessível de uma linha.
+     */
+    applyRowState(row, selected) {
+        row.toggleAttribute('selected', selected);
+        row.toggleAttribute('data-selected', selected);
+        row.setAttribute('aria-selected', String(selected));
+    }
+    syncRowsFromState() {
+        this.isSynchronizing = true;
+        this.getBodyRows().forEach((row) => {
+            const selected = row.hasAttribute('selected') || row.hasAttribute('data-selected');
+            this.applyRowState(row, selected);
+            const checkbox = this.getRowCheckbox(row);
+            if (checkbox !== null) {
+                checkbox.checked = selected;
+                this.syncCheckboxDisabledState(row, checkbox);
+            }
+        });
+        this.isSynchronizing = false;
+    }
+    syncCheckboxDisabledState(row, checkbox) {
+        const hasPreviousDisabledState = this.checkboxDisabledStates.has(checkbox);
+        if (row.hasAttribute('disabled')) {
+            if (!hasPreviousDisabledState) {
+                this.checkboxDisabledStates.set(checkbox, checkbox.disabled);
+            }
+            checkbox.disabled = true;
+        }
+        else if (hasPreviousDisabledState) {
+            checkbox.disabled = this.checkboxDisabledStates.get(checkbox) ?? false;
+            this.checkboxDisabledStates.delete(checkbox);
+        }
+    }
+    /**
+     * Sincroniza o checkbox global, incluindo o estado indeterminado.
+     */
+    syncHeaderCheckbox() {
+        const headerCheckbox = this.getHeaderCheckbox();
+        if (headerCheckbox === null)
+            return;
+        const entries = this.getSelectableEntries();
+        const checkedCount = entries.filter(({ checkbox }) => checkbox.checked).length;
+        this.isSynchronizing = true;
+        headerCheckbox.checked = entries.length > 0 && checkedCount === entries.length;
+        headerCheckbox.indeterminate = checkedCount > 0 && checkedCount < entries.length;
+        this.isSynchronizing = false;
+    }
+    /**
+     * Garante a existência do cabeçalho da coluna de seleção.
+     */
+    ensureHeaderCell() {
+        const existing = this.options.host.querySelector(`br-table-header-cell[${table_utils.TABLE_SELECTION_GENERATED_ATTR}]`);
+        if (existing !== null)
+            return;
+        const firstHeaderCell = this.options.host.querySelector('br-table-header-cell');
+        if (firstHeaderCell === null)
+            return;
+        const slotName = firstHeaderCell.getAttribute('slot');
+        const checkbox = createSelectionCheckbox({
+            kind: 'all',
+            label: 'Selecionar todas as linhas',
+            name: `${this.options.idPrefix}-selection-all`,
+        });
+        const cell = createSelectionHeaderCell({
+            checkbox,
+            slotName: slotName ?? undefined,
+        });
+        firstHeaderCell.parentElement?.insertBefore(cell, firstHeaderCell);
+    }
+    /**
+     * Garante uma célula de seleção para cada linha do corpo.
+     */
+    ensureRowCells() {
+        this.getBodyRows().forEach((row, index) => {
+            const existingCheckbox = this.getRowCheckbox(row);
+            if (existingCheckbox !== null) {
+                existingCheckbox.setAttribute('label', `Selecionar linha ${index + 1}`);
+                existingCheckbox.setAttribute('name', `${this.options.idPrefix}-selection-row-${index + 1}`);
+                return;
+            }
+            const checkbox = createSelectionCheckbox({
+                kind: 'row',
+                label: `Selecionar linha ${index + 1}`,
+                name: `${this.options.idPrefix}-selection-row-${index + 1}`,
+            });
+            const cell = createSelectionCell(checkbox);
+            row.prepend(cell);
+        });
+    }
+    /**
+     * Remove somente os elementos e atributos gerados pela seleção.
+     */
+    remove() {
+        this.options.host.querySelectorAll(`[${table_utils.TABLE_SELECTION_GENERATED_ATTR}]`).forEach((node) => {
+            node.remove();
+        });
+        // Desabilitar a UI de seleção remove os controles e a projeção ARIA.
+        // O estado lógico (`selected`/`data-selected`) pertence ao dataset e deve
+        // sobreviver à virtualização e a mudanças de `hasRowSelection`.
+        this.getBodyRows().forEach((row) => {
+            row.removeAttribute('aria-selected');
+        });
+    }
+    /**
+     * Publica um retrato consistente da seleção após uma mudança.
+     */
+    notifyChange(source, rowIndex) {
+        const selectedRows = this.getSelectedRows();
+        const allRows = this.getBodyRows();
+        this.options.onChange({
+            selectedRows,
+            selectedIndexes: selectedRows.map((row) => allRows.indexOf(row)),
+            selectedCount: selectedRows.length,
+            rowIndex,
+            source,
+        });
+    }
+}
+
+const VIRTUAL_BUFFER_ROWS = 4;
+/**
+ * Materializa uma quantidade estável de linhas ao redor da viewport.
+ *
+ * @remarks
+ * A quantidade de elementos montados é calculada por `visibleRows` mais um
+ * buffer interno fixo de quatro linhas. A janela é ampliada aos limites dos
+ * grupos contíguos, podendo exceder essa quantidade para manter mesclas íntegras.
+ * Linhas expandidas alteram a altura
+ * total, mas não aumentam a quantidade de `br-table-row` materializados.
+ *
+ * A janela só é reposicionada quando a área visível se aproxima de uma das
+ * bordas do buffer. Isso reduz substituições de DOM durante o scroll.
+ * As somas de alturas são reutilizadas até `reset`, `invalidateRow`, uma nova
+ * sequência lógica ou uma medição diferente. Somente a faixa montada é medida.
  */
-const TABLE_TOKENS = {
+class TableVirtualListController {
+    constructor(options) {
+        this.options = options;
+        this.measuredHeights = new Map();
+        this.currentRange = null;
+        this.viewport = null;
+        this.measurementVersion = 0;
+        this.scheduleSync = () => {
+            if (this.rafId !== undefined)
+                return;
+            this.rafId = requestAnimationFrame(() => {
+                this.rafId = undefined;
+                this.sync();
+            });
+        };
+        this.handleScroll = () => this.scheduleSync();
+    }
+    connect() {
+        const viewport = this.options.getViewport();
+        if (viewport === null || viewport === this.viewport)
+            return;
+        this.disconnectViewport();
+        this.viewport = viewport;
+        viewport.style.overflowAnchor = 'none';
+        viewport.addEventListener('scroll', this.handleScroll, { passive: true });
+        if (typeof ResizeObserver !== 'undefined') {
+            this.resizeObserver = new ResizeObserver(() => this.scheduleSync());
+            this.resizeObserver.observe(viewport);
+        }
+    }
+    disconnect() {
+        this.measurementVersion += 1;
+        this.pendingRevealIndex = undefined;
+        this.disconnectViewport();
+        if (this.rafId !== undefined)
+            cancelAnimationFrame(this.rafId);
+        if (this.measurementRafId !== undefined)
+            cancelAnimationFrame(this.measurementRafId);
+        this.rafId = undefined;
+        this.measurementRafId = undefined;
+    }
+    reset(scrollToTop = true) {
+        this.measurementVersion += 1;
+        this.pendingRevealIndex = undefined;
+        this.measuredHeights.clear();
+        this.prefix = undefined;
+        this.currentRange = null;
+        if (scrollToTop && this.viewport !== null)
+            this.viewport.scrollTop = 0;
+        this.sync(true);
+    }
+    invalidateRow(index) {
+        this.measurementVersion += 1;
+        this.measuredHeights.delete(index);
+        this.prefix = undefined;
+        this.currentRange = null;
+        this.scheduleSync();
+    }
+    /** Recalcula a área útil sem descartar alturas de linhas ou a posição do scroll. */
+    refreshViewport() {
+        this.scheduleSync();
+    }
+    /** Materializa o destino antes do foco; null representa o cabeçalho. */
+    revealRow(index) {
+        const viewport = this.viewport;
+        if (viewport === null)
+            return;
+        // Uma nova tecla substitui o destino ainda pendente de medição.
+        this.pendingRevealIndex = undefined;
+        if (index === null) {
+            viewport.scrollTop = 0;
+            this.sync();
+            return;
+        }
+        const prefix = this.getPrefix(this.options.getRows());
+        const top = prefix[index];
+        const bottom = prefix[index + 1];
+        const viewportHeight = Math.max(1, viewport.clientHeight - this.options.getStickyHeaderHeight());
+        if (top < viewport.scrollTop || bottom > viewport.scrollTop + viewportHeight) {
+            this.pendingRevealIndex = index;
+            viewport.scrollTop = top;
+            this.sync(true);
+        }
+    }
+    sync(force = false) {
+        this.connect();
+        const viewport = this.viewport;
+        const rows = this.options.getRows();
+        if (viewport === null)
+            return;
+        const prefix = this.getPrefix(rows);
+        if (rows.length === 0) {
+            const empty = { start: 0, end: 0, beforeHeight: 0, afterHeight: 0 };
+            this.currentRange = empty;
+            this.options.renderRange(empty);
+            this.options.onAfterRender?.();
+            return;
+        }
+        // Linhas ainda não hidratadas têm altura zero e podem limitar o scroll nativo.
+        const scrollTop = this.pendingRevealIndex === undefined ? viewport.scrollTop : prefix[this.pendingRevealIndex];
+        const headerHeight = this.options.getStickyHeaderHeight();
+        const viewportHeight = Math.max(viewport.clientHeight - headerHeight, 1);
+        const bufferRows = this.resolveBufferRows(rows.length);
+        const visibleStart = this.findRowAtOffset(prefix, scrollTop);
+        const visibleEnd = Math.min(rows.length, this.findRowAtOffset(prefix, scrollTop + viewportHeight) + 1);
+        if (!force && this.canKeepCurrentRange(visibleStart, visibleEnd, bufferRows)) {
+            return;
+        }
+        const renderedCount = this.resolveRenderedRowCount(rows.length);
+        const range = this.createStableRange(prefix, rows.length, visibleStart, renderedCount, bufferRows);
+        if (!force && this.isSameRange(range, this.currentRange))
+            return;
+        this.measurementVersion += 1;
+        this.currentRange = range;
+        const previousScrollTop = viewport.scrollTop;
+        this.options.renderRange(range);
+        // Mover as linhas para o fragmento pode limitar temporariamente o scroll nativo.
+        viewport.scrollTop = previousScrollTop;
+        this.options.onAfterRender?.();
+        this.scheduleMeasurement();
+    }
+    /**
+     * Resolve a quantidade total de linhas adicionais mantidas no pool virtual.
+     * O buffer é fixo para tornar o custo de DOM previsível durante o scroll.
+     */
+    resolveBufferRows(totalRows) {
+        const visibleRows = this.resolveVisibleCapacity(totalRows);
+        if (visibleRows <= 0 || visibleRows >= totalRows)
+            return 0;
+        return Math.min(VIRTUAL_BUFFER_ROWS, totalRows - visibleRows);
+    }
+    /** Resolve a quantidade efetiva de linhas visíveis para o dataset atual. */
+    resolveVisibleCapacity(totalRows) {
+        const configuredVisibleRows = this.options.visibleRows();
+        if (totalRows <= 0)
+            return 0;
+        const normalizedVisibleRows = Number.isFinite(configuredVisibleRows)
+            ? Math.min(50, Math.max(1, Math.floor(configuredVisibleRows)))
+            : 10;
+        return Math.min(totalRows, normalizedVisibleRows);
+    }
+    /**
+     * Mantém a janela atual enquanto a viewport estiver dentro de sua zona
+     * segura. A troca ocorre em blocos, e não a cada nova linha visível.
+     */
+    canKeepCurrentRange(visibleStart, visibleEnd, bufferRows) {
+        const range = this.currentRange;
+        if (range === null)
+            return false;
+        const guard = bufferRows > 0 ? 1 : 0;
+        const safeStart = range.start + guard;
+        const safeEnd = range.end - guard;
+        const atStart = range.start === 0;
+        const atEnd = range.end === this.options.getRows().length;
+        const hasSafeStart = atStart ? visibleStart >= range.start : visibleStart >= safeStart;
+        const hasSafeEnd = atEnd ? visibleEnd <= range.end : visibleEnd <= safeEnd;
+        return hasSafeStart && hasSafeEnd;
+    }
+    /**
+     * Mantém uma quantidade fixa de linhas materializadas para um mesmo
+     * `visibleRows`: capacidade visível + até quatro linhas de buffer.
+     */
+    resolveRenderedRowCount(totalRows) {
+        const visibleCapacity = this.resolveVisibleCapacity(totalRows);
+        if (visibleCapacity >= totalRows)
+            return totalRows;
+        return Math.min(totalRows, visibleCapacity + VIRTUAL_BUFFER_ROWS);
+    }
+    /** Centraliza a faixa ao redor do início visível sem variar seu tamanho. */
+    createStableRange(prefix, totalRows, visibleStart, renderedCount, bufferRows) {
+        const bufferBefore = Math.floor(bufferRows / 2);
+        const desiredStart = visibleStart - bufferBefore;
+        const maxStart = Math.max(0, totalRows - renderedCount);
+        const initialStart = Math.min(Math.max(0, desiredStart), maxStart);
+        const { start, end } = table_utils.expandTableGroupRange(this.options.getRows(), initialStart, Math.min(totalRows, initialStart + renderedCount));
+        return {
+            start,
+            end,
+            beforeHeight: prefix[start],
+            afterHeight: prefix[totalRows] - prefix[end],
+        };
+    }
+    /** Reutiliza as somas enquanto a sequência lógica e suas alturas permanecem válidas. */
+    getPrefix(rows) {
+        if (rows !== this.indexedRows) {
+            this.measurementVersion += 1;
+            this.indexedRows = rows;
+            this.measuredHeights.clear();
+            this.prefix = undefined;
+            this.currentRange = null;
+            this.pendingRevealIndex = undefined;
+        }
+        if (this.prefix !== undefined)
+            return this.prefix;
+        const prefix = new Array(rows.length + 1).fill(0);
+        rows.forEach((row, index) => {
+            prefix[index + 1] = prefix[index] + (this.measuredHeights.get(index) ?? this.estimateHeight(row));
+        });
+        this.prefix = prefix;
+        return prefix;
+    }
+    estimateHeight(row) {
+        const base = Math.max(1, this.options.estimatedRowHeight());
+        if (!row.hasAttribute('expanded'))
+            return base;
+        const rowOverride = Number(row.getAttribute('virtual-expanded-content-height'));
+        const expandedHeight = Number.isFinite(rowOverride) && rowOverride > 0
+            ? rowOverride
+            : Math.max(0, this.options.estimatedExpandedHeight());
+        return base + expandedHeight;
+    }
+    findRowAtOffset(prefix, offset) {
+        let low = 0;
+        let high = prefix.length - 1;
+        const target = Math.max(0, offset);
+        while (low < high) {
+            const mid = Math.floor((low + high + 1) / 2);
+            if (prefix[mid] <= target)
+                low = mid;
+            else
+                high = mid - 1;
+        }
+        return Math.min(low, prefix.length - 2);
+    }
+    /**
+     * Mede somente as linhas materializadas e preserva a posição visual da linha
+     * âncora caso a altura de itens anteriores seja corrigida.
+     */
+    scheduleMeasurement() {
+        if (this.measurementRafId !== undefined)
+            cancelAnimationFrame(this.measurementRafId);
+        const version = ++this.measurementVersion;
+        this.measurementRafId = requestAnimationFrame(() => {
+            this.measurementRafId = undefined;
+            const viewport = this.viewport;
+            const rows = this.options.getRows();
+            if (viewport === null || rows.length === 0)
+                return;
+            const prefixBefore = this.getPrefix(rows);
+            const range = this.currentRange;
+            if (range === null || version !== this.measurementVersion)
+                return;
+            void this.measureRows(rows, range).then((measurements) => {
+                if (!this.isMeasurementCurrent(version, viewport, rows, range))
+                    return;
+                this.applyMeasurements(measurements, prefixBefore, viewport, rows);
+            });
+        });
+    }
+    isMeasurementCurrent(version, viewport, rows, range) {
+        return (version === this.measurementVersion &&
+            this.viewport === viewport &&
+            this.currentRange === range &&
+            this.options.getRows() === rows);
+    }
+    applyMeasurements(measurements, prefixBefore, viewport, rows) {
+        const anchorIndex = this.findRowAtOffset(prefixBefore, viewport.scrollTop);
+        const anchorOffset = viewport.scrollTop - prefixBefore[anchorIndex];
+        const { changed, revealed } = this.updateMeasuredHeights(measurements, prefixBefore);
+        if (changed)
+            this.prefix = undefined;
+        const prefixAfter = this.getPrefix(rows);
+        if (revealed && this.pendingRevealIndex !== undefined) {
+            viewport.scrollTop = prefixAfter[this.pendingRevealIndex];
+            this.pendingRevealIndex = undefined;
+        }
+        if (!changed)
+            return;
+        const anchoredScrollTop = prefixAfter[anchorIndex] + anchorOffset;
+        const correction = anchoredScrollTop - viewport.scrollTop;
+        // Corrige somente mudanças perceptíveis. O ajuste ocorre no mesmo frame
+        // da medição, evitando o salto causado pela alteração dos spacers.
+        if (!revealed && Math.abs(correction) > 0.5)
+            viewport.scrollTop = anchoredScrollTop;
+        this.currentRange = null;
+        this.scheduleSync();
+    }
+    updateMeasuredHeights(measurements, prefix) {
+        let changed = false;
+        let revealed = false;
+        for (const { index, height } of measurements) {
+            if (height <= 0)
+                continue;
+            if (index === this.pendingRevealIndex)
+                revealed = true;
+            const previous = prefix[index + 1] - prefix[index];
+            if (Math.abs(previous - height) > 0.5) {
+                this.measuredHeights.set(index, height);
+                changed = true;
+            }
+        }
+        return { changed, revealed };
+    }
+    async measureRows(rows, range) {
+        return Promise.all(Array.from({ length: range.end - range.start }, (_, offset) => {
+            const index = range.start + offset;
+            const row = rows[index];
+            if (!row.isConnected)
+                return { index, height: 0 };
+            return row.getMeasuredHeight().then((height) => ({
+                index,
+                height: row.isConnected ? height : 0,
+            }));
+        }));
+    }
+    disconnectViewport() {
+        if (this.viewport !== null)
+            this.measurementVersion += 1;
+        this.viewport?.removeEventListener('scroll', this.handleScroll);
+        this.resizeObserver?.disconnect();
+        this.resizeObserver = undefined;
+        this.viewport = null;
+    }
+    isSameRange(a, b) {
+        return (b !== null &&
+            a.start === b.start &&
+            a.end === b.end &&
+            Math.abs(a.beforeHeight - b.beforeHeight) < 0.5 &&
+            Math.abs(a.afterHeight - b.afterHeight) < 0.5);
+    }
+}
+
+const tableCss = () => `*,*::before,*::after{box-sizing:border-box}:host{line-height:var(--font-line-height-medium);-webkit-text-size-adjust:100%;-moz-text-size-adjust:100%;text-size-adjust:100%}main{display:block}hr{box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace;font-size:1em}a{background-color:rgba(0,0,0,0)}b,strong{font-weight:bolder}small{font-size:80%}img{border-style:none}button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:var(--font-line-height-medium);margin:0}button,input{overflow:visible}button,select{text-transform:none}button,[type=button],[type=reset],[type=submit]{appearance:button}button::-moz-focus-inner,[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner{border-style:none;padding:0}button:-moz-focusring,[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:.35em .75em .625em}legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{vertical-align:baseline}textarea{overflow:auto}[type=checkbox],[type=radio]{box-sizing:border-box;padding:0}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{appearance:textfield;outline-offset:-2px}[type=search]::-webkit-search-decoration{appearance:none}::-webkit-file-upload-button{appearance:button;font:inherit}details{display:block}summary{display:list-item}template{display:none}[hidden]{display:none}.d-none{display:none !important}@media (min-width: 576px){.d-sm-block{display:block !important}.d-sm-flex{display:flex !important}}[data-toggle=dropdown]+*{position:absolute}.dropdown{position:relative}.dropdown [data-toggle=dropdown]+*{box-shadow:var(--surface-shadow-sm);left:0;position:absolute;top:100%}.dropdown>.br-notification{left:auto;right:0}.dropdown .br-item{--color:var(--color-light);--color-rgb:var(--color-light-rgb);--text-color:var(--color-light);--interactive:var(--interactive-light);--interactive-rgb:var(--color-rgb);--visited:var(--visited-light);--hover:var(--hover-light);--pressed:var(--pressed-light);--focus-color:var(--focus-color-light);--focus:var(--focus-color-light);--item-padding-y:var(--spacing-scale-2x);background-color:var(--background-light);color:var(--color)}.dropdown .br-item:not(:last-child){border-bottom:1px solid var(--border-color)}.dropdown .br-item.selected{--color:var(--color-dark);--color-rgb:var(--color-dark-rgb);--text-color:var(--color-dark);--interactive:var(--interactive-dark);--interactive-rgb:var(--interactive-dark-rgb);--visited:var(--visited-dark);--hover:var(--hover-dark);--pressed:var(--pressed-dark);--focus-color:var(--focus-color-dark);--focus:var(--focus-color-dark)}.justify-content-start{justify-content:flex-start !important}.justify-content-end{justify-content:flex-end !important}.justify-content-center{justify-content:center !important}.align-items-center{align-items:center !important}.col,[class*=col-]{padding-left:calc(var(--grid-gutter)*.5);padding-right:calc(var(--grid-gutter)*.5);width:100%}.col{flex:1 0 0%;min-width:8.3333333333%}.col-auto{flex:0 0 auto;width:auto}.col-2{flex-basis:16.6666666667%;max-width:16.6666666667%}.container,.container-fluid,.container-lg{--grid-margin:var(--grid-portrait-margin);--grid-maxwidth:var(--grid-portrait-maxwidth);margin-left:auto;margin-right:auto;max-width:var(--grid-maxwidth);padding-left:var(--grid-margin);padding-right:var(--grid-margin);width:100%}.row{--grid-gutter:var(--grid-portrait-gutter);display:flex;flex-wrap:wrap;margin-left:calc(var(--grid-gutter)*-0.5);margin-right:calc(var(--grid-gutter)*-0.5)}@media (min-width: 576px){.container,.container-lg,.container-fluid{--grid-margin:var(--grid-tablet-margin)}.row{--grid-gutter:var(--grid-tablet-gutter)}.container{--grid-maxwidth:calc(var(--grid-breakpoint-sm) - var(--grid-tablet-margin))}.col-sm-4{flex-basis:33.3333333333%;max-width:33.3333333333%}}@media (min-width: 992px){.container,.container-lg,.container-fluid{--grid-margin:var(--grid-tablet-margin)}.row{--grid-gutter:var(--grid-tablet-gutter)}.container{--grid-maxwidth:calc(var(--grid-breakpoint-md) - var(--grid-tablet-margin))}}@media (min-width: 1280px){.container,.container-lg,.container-fluid{--grid-margin:var(--grid-desktop-margin)}.row{--grid-gutter:var(--grid-desktop-gutter)}.container,.container-lg{--grid-maxwidth:calc(var(--grid-breakpoint-lg) - var(--grid-desktop-margin))}.col-lg-3{flex-basis:25%;max-width:25%}}@media (min-width: 1600px){.container,.container-lg,.container-fluid{--grid-margin:var(--grid-tv-margin)}.row{--grid-gutter:var(--grid-tv-gutter)}.container,.container-lg{--grid-maxwidth:calc(var(--grid-breakpoint-xl) - var(--grid-tv-margin))}}.ease{animation-timing-function:cubic-bezier(0.25, 0.1, 0.25, 1)}.ease-out{animation-timing-function:cubic-bezier(0, 0, 0.58, 1)}.ease-in-out{animation-timing-function:cubic-bezier(0.42, 0, 0.58, 1)}.fast{animation-duration:var(--duration-fast)}.slow{animation-duration:var(--duration-slow)}.mt-1{margin-top:var(--spacing-scale-half) !important}.mr-1{margin-right:var(--spacing-scale-half) !important}.mb-1{margin-bottom:var(--spacing-scale-half) !important}.ml-1{margin-left:var(--spacing-scale-half) !important}.mb-4{margin-bottom:var(--spacing-scale-3x) !important}.pt-half{padding-top:var(--spacing-scale-half) !important}.highlight{background:var(--status-highlight-background) linear-gradient(var(--status-highlight-overlay), var(--status-highlight-overlay));color:var(--status-highlight-text);padding:0 var(--spacing-scale-half)}[disabled],.disabled{cursor:not-allowed;opacity:var(--disabled)}[disabled] *,.disabled *{pointer-events:none}fieldset[disabled]{opacity:1}.text-center{text-align:center !important}.text-right{text-align:right !important}.text-nowrap{white-space:nowrap !important}.text-uppercase{text-transform:uppercase !important}.text-bold{font-weight:700 !important}.text-base{font-size:var(--font-size-scale-base) !important}.text-down-01{font-size:var(--font-size-scale-down-01) !important}@media (min-width: 576px){.text-sm-center{text-align:center !important}.text-sm-left{text-align:left !important}.text-sm-right{text-align:right !important}}p{color:var(--color);font-size:var(--font-size-scale-base);font-weight:var(--font-weight-regular);line-height:var(--font-line-height-medium);margin-bottom:var(--spacing-scale-2x);margin-top:0}p a{text-decoration:underline}@media (min-width: 576px){p{font-size:var(--font-size-scale-up-01)}}a{--focus-offset:var(--spacing-scale-half)}a:focus{outline:none}a.focus-visible,a:focus-visible{outline-color:var(--focus);outline-offset:var(--focus-offset);outline-style:var(--focus-style);outline-width:var(--focus-width)}a:not(:disabled):hover{background-image:linear-gradient(rgba(var(--interactive-rgb), var(--hover)), rgba(var(--interactive-rgb), var(--hover)))}a:not(:disabled):active{background-image:linear-gradient(rgba(var(--interactive-rgb), var(--pressed)), rgba(var(--interactive-rgb), var(--pressed)))}a{color:var(--interactive);text-decoration:none}.main-content a{text-decoration:underline}button{cursor:pointer}img{max-width:100%;vertical-align:middle}h2,.h2{color:var(--color);font-size:var(--font-size-scale-up-03);font-weight:var(--font-weight-semi-bold);line-height:var(--font-line-height-low);margin-bottom:var(--spacing-scale-2xh);margin-top:var(--spacing-scale-3xh);padding-bottom:var(--spacing-scale-2xh)}@media (min-width: 576px){.h2,h2{font-size:var(--font-size-scale-up-05);font-weight:var(--font-weight-regular)}}ul,ol{margin-bottom:var(--spacing-scale-2x);margin-top:0;padding:0 0 0 var(--spacing-scale-5x)}table{--table-background:var(--background);--table-color:var(--color);--table-border-color:var(--gray-20);--table-border-style:solid;--table-border-width:1px;--table-hover:var(--color-rgb);--table-padding:var(--spacing-scale-3x);--table-font-weight:var(--font-weight-medium);--table-th-background:var(--background-alternative);--table-th-font-weight:var(--font-weight-semi-bold);--table-row-size:var(--spacing-scale-2x);border-collapse:collapse;width:100%}tr.selected,tr.is-selected{--color:var(--color-dark);--color-rgb:var(--color-dark-rgb);--text-color:var(--color-dark);--interactive:var(--interactive-dark);--interactive-rgb:var(--interactive-dark-rgb);--visited:var(--visited-dark);--hover:var(--hover-dark);--pressed:var(--pressed-dark);--focus-color:var(--focus-color-dark);--focus:var(--focus-color-dark)}label,.label{color:var(--color);font-size:var(--font-size-scale-base);font-weight:var(--font-weight-semi-bold);line-height:var(--font-line-height-medium);margin-bottom:var(--spacing-scale-half)}fieldset,.fieldset{border:var(--surface-width-none);margin-bottom:var(--spacing-scale-5x);margin-top:0;padding:0}legend,.legend{color:var(--color);font-size:var(--font-size-scale-up-01);font-weight:var(--font-weight-semi-bold);line-height:var(--font-line-height-low);margin-bottom:var(--spacing-scale-2x);margin-top:var(--spacing-scale-2x)}::placeholder,.placeholder{color:var(--color-light);font-size:var(--font-size-scale-base);font-style:italic;font-weight:var(--font-weight-regular);line-height:var(--font-line-height-medium);margin-bottom:var(--spacing-scale-half);margin-top:var(--spacing-scale-half);opacity:1}input,textarea,.input{color:var(--color-light);font-size:var(--font-size-scale-up-01);font-weight:var(--font-weight-medium);line-height:var(--font-line-height-low);margin-bottom:var(--spacing-scale-half)}pre,.pre{background:var(--gray-5);margin:var(--spacing-scale-2x) 0 var(--spacing-scale-4x);padding:var(--spacing-scale-2x)}mark,.mark{background:var(--red-warm-vivid-10);color:var(--color)}*[data-toggle=collapse]:not(:disabled):hover{background-image:linear-gradient(rgba(var(--interactive-rgb), var(--hover)), rgba(var(--interactive-rgb), var(--hover)))}*[data-toggle=collapse]:focus{outline:none}*[data-toggle=collapse].focus-visible,*[data-toggle=collapse]:focus-visible{outline-color:var(--focus);outline-offset:var(--focus-offset);outline-style:var(--focus-style);outline-width:var(--focus-width)}@media (prefers-reduced-motion: reduce){:host,:host::before,:host::after,:host *,:host *::before,:host *::after{animation:none !important;scroll-behavior:auto !important;transition:none !important}}:host-context([data-wbc-reduced-motion=true])::before,:host-context([data-wbc-reduced-motion=true])::after,:host-context([data-wbc-reduced-motion=true]) *,:host-context([data-wbc-reduced-motion=true]) *::before,:host-context([data-wbc-reduced-motion=true]) *::after{animation:none !important;scroll-behavior:auto !important;transition:none !important}:host{display:block;overflow-anchor:none;min-width:0;min-height:0;--table-row-size:var(--spacing-scale-3x);--br-table-divider-base-width:var(--surface-width-sm);--br-table-row-hover-opacity:0;--br-table-loading-opacity:0.5}:host([loading]){position:relative;isolation:isolate;min-height:220px}:host([has-row-hover]){--br-table-row-hover-opacity:var(--surface-opacity-xs)}.br-table{display:flex;overflow-anchor:none;flex:0 0 auto;flex-direction:column;width:100%;min-width:0;min-height:0;overflow:hidden}br-table-bar{flex:0 0 auto}.br-table-scroll-shell{position:relative;flex:0 0 auto;box-sizing:border-box;width:100%;min-width:0;min-height:0;overflow:hidden;contain:size;overflow-anchor:none}.br-table-scroll{position:absolute;inset:0;box-sizing:border-box;width:100%;height:100%;min-width:0;min-height:0;overflow:auto;overflow-anchor:none;overscroll-behavior-x:contain;overscroll-behavior-y:contain;-webkit-overflow-scrolling:touch}.br-table-content{display:grid;grid-template-columns:var(--br-table-column-widths);min-width:0}.br-table-scroll-shell.loading .br-table-scroll{isolation:isolate}.br-table-content.loading{opacity:var(--br-table-loading-opacity)}[part=loading]{position:absolute;z-index:var(--z-index-layer-4);inset:0;display:flex;align-items:center;justify-content:center;box-sizing:border-box;padding:var(--spacing-scale-2x);overflow:hidden;background:var(--surface-overlay-scrim);pointer-events:auto}.br-table-loading-panel{box-sizing:border-box;width:max-content;min-width:min(100%,220px);max-width:100%;max-height:100%;padding:var(--spacing-scale-3x);overflow:auto;background:var(--background);color:var(--color);box-shadow:var(--surface-shadow-sm);text-align:center}@media (width <= 991px){.br-table-content{min-width:max-content}}.br-table-scroll-shell::after{position:absolute;z-index:3;inset:0;background:linear-gradient(to bottom, rgba(0, 0, 0, 0.16), transparent) 0 var(--table-scroll-header-height, 0)/100% var(--table-scroll-shadow-top, 0),linear-gradient(to top, rgba(0, 0, 0, 0.16), transparent) bottom/100% var(--table-scroll-shadow-bottom, 0),linear-gradient(to right, rgba(0, 0, 0, 0.16), transparent) left/var(--table-scroll-shadow-left, 0) 100%,linear-gradient(to left, rgba(0, 0, 0, 0.16), transparent) right/var(--table-scroll-shadow-right, 0) 100%;background-repeat:no-repeat;content:"";pointer-events:none}.br-table-loading-panel:focus-visible{outline:var(--focus-width) var(--focus-style) var(--focus);outline-offset:var(--focus-offset)}`;
+
+const MIN_VISIBLE_ROWS = 1;
+const MAX_VISIBLE_ROWS = 50;
+const DEFAULT_VISIBLE_ROWS = 10;
+const Table = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.brTableActionClick = index.createEvent(this, "brTableActionClick", 7);
+        this.brTableSelectionChange = index.createEvent(this, "brTableSelectionChange", 7);
+        this.brTableRowExpansionChange = index.createEvent(this, "brTableRowExpansionChange", 7);
+        this.brTableSortChange = index.createEvent(this, "brTableSortChange", 7);
+        this.brTableSortRequest = index.createEvent(this, "brTableSortRequest", 7);
+        this.brTablePageChange = index.createEvent(this, "brTablePageChange", 7);
+        this.brTablePageSizeChange = index.createEvent(this, "brTablePageSizeChange", 7);
+        this.brTableSearch = index.createEvent(this, "brTableSearch", 7);
+        /**
+         * Habilita divisores entre colunas quando `columnDivider` não é informado.
+         *
+         * @deprecated Use `columnDivider` instead.
+         * @default false
+         */
+        this.hasColumnDivider = false;
+        /**
+         * Habilita divisores entre linhas quando `rowDivider` não é informado.
+         *
+         * @deprecated Use `rowDivider` instead.
+         * @default false
+         */
+        this.hasRowDivider = false;
+        /**
+         * Habilita o realce visual das linhas ao passar o ponteiro.
+         *
+         * @default false
+         */
+        this.hasRowHover = false;
+        /**
+         * Indica que as linhas estão sendo atualizadas pelo consumidor.
+         *
+         * @remarks Mantém os dados anteriores, reduz sua opacidade e exibe o slot
+         * `loading` em um painel central com scrim sobre toda a tabela, incluindo
+         * barra de ações e paginação. O scrim fica limitado ao componente.
+         * Reflete o atributo `loading` e pode ser alterada diretamente ou pelos métodos
+         * `startLoading()` e `stopLoading()`. Não bloqueia o teclado nem gerencia
+         * requisições, erros ou substituição dos dados.
+         * @default false
+         */
+        this.loading = false;
+        /**
+         * Força a apresentação da barra contextual.
+         *
+         * @default false
+         */
+        this.showContextualBar = false;
+        /**
+         * Limite usado para decidir quando agrupar ações globais em um menu.
+         * Quando o número de ações excede esse valor, as ações são agrupadas no
+         * dropdown (atualmente todas são movidas para o menu colapsado).
+         *
+         * @default 4
+         */
+        this.headingActionsLimit = 4;
+        /**
+         * Limite usado para decidir quando agrupar ações contextuais em um menu.
+         * Quando o número de ações excede esse valor, as ações são agrupadas no
+         * dropdown (atualmente todas são movidas para o menu colapsado).
+         *
+         * @default 4
+         */
+        this.contextualActionsLimit = 4;
+        /**
+         * Texto do tooltip do botão de ações agrupadas na barra de título.
+         * Quando vazio ou composto apenas por espaços, usa "Mais ações".
+         * Não altera o nome acessível do botão nem os rótulos do menu.
+         *
+         * @default 'Mais ações'
+         */
+        this.moreActionsHeadingLabel = 'Mais ações';
+        /**
+         * Texto do tooltip do botão de ações agrupadas da barra contextual.
+         * Quando vazio ou composto apenas por espaços, usa "Mais ações".
+         * Não altera o nome acessível do botão nem os rótulos do menu.
+         *
+         * @default 'Mais ações'
+         */
+        this.moreActionsContextualLabel = 'Mais ações';
+        /**
+         * Limite padrão de ações exibidas em cada célula.
+         *
+         * @default 4
+         */
+        this.cellActionsLimit = 4;
+        /**
+         * Habilita a coluna de seleção de linhas.
+         *
+         * @default false
+         */
+        this.hasRowSelection = false;
+        /**
+         * Habilita a coluna de expansão de linhas.
+         *
+         * @default false
+         */
+        this.hasRowExpansion = false;
+        /**
+         * Disponibiliza a interface de busca, sem filtrar ou destacar o conteúdo.
+         * A aplicação recebe `brTableSearch` e atualiza os dados local ou remotamente.
+         *
+         * @default false
+         */
+        this.hasSearch = false;
+        /**
+         * Habilita a paginação da tabela, renderizando `br-table-footer` internamente.
+         *
+         * @remarks A paginação define o subconjunto lógico disponível para a lista
+         * virtual. `pageSize` conta linhas independentes ou grupos completos, e
+         * `visibleRows` controla quantas delas cabem simultaneamente na viewport.
+         * Quando os dados completos ainda não estão disponíveis localmente
+         * (paginação por API), informe `totalItems` e forneça o subconjunto
+         * correspondente após `brTablePageChange`.
+         * @default false
+         */
+        this.hasPagination = false;
+        /**
+         * Página atual exibida pela paginação (1-indexada).
+         *
+         * @remarks Atualizada internamente quando `TableDataStore` já cobre a
+         * página solicitada. Utilize como valor inicial ou para navegar
+         * programaticamente para outra página.
+         * @default 1
+         */
+        this.currentPage = 1;
+        /**
+         * Opções disponíveis de itens por página no seletor da paginação.
+         *
+         * @default [10, 20, 30]
+         */
+        this.pageSizeOptions = [10, 20, 30];
+        /**
+         * Define se a tabela aceita uma única coluna ordenada ou múltiplas colunas.
+         * No modo `multi`, a prioridade é sempre a ordem visual da esquerda para a direita.
+         *
+         * @default single
+         */
+        this.sortMode = table_utils.TABLE_SORT_MODE.SINGLE;
+        /**
+         * Define se a tabela ordena as linhas localmente ou deixa a aplicação aplicar
+         * a ordenação solicitada. Em `manual`, a tabela mantém os indicadores e emite
+         * `brTableSortChange`, mas não reordena as linhas; use `setData()` para fornecer
+         * os resultados customizados ou remotos. Valores não reconhecidos usam a
+         * estratégia local.
+         *
+         * @default local
+         */
+        this.sortStrategy = table_utils.TABLE_SORT_STRATEGY.LOCAL;
+        /**
+         * Quantidade de linhas de dados visíveis simultaneamente na viewport.
+         *
+         * @remarks Não limita o conjunto de dados nem realiza paginação. A altura da
+         * região de scroll é derivada desta quantidade e da densidade atual. Mesmo
+         * com `hasPagination` habilitado, esta propriedade continua definindo
+         * apenas a capacidade visual da viewport; `pageSize` define o tamanho lógico
+         * da página.
+         * @default 10
+         */
+        this.visibleRows = 10;
+        /** Altura adicional estimada para conteúdo expandido ainda não medido. */
+        this.virtualExpandedContentHeight = 240;
+        /**
+         * Estratégia padrão para conteúdos que excedem a célula.
+         *
+         * @default wrap
+         */
+        this.overflow = table_utils.TABLE_OVERFLOW.WRAP;
+        /**
+         * Estado visual padrão dos tooltips.
+         *
+         * @default info
+         */
+        this.tooltipState = table_utils.TABLE_TOOLTIP_STATE.INFO;
+        this.selectedRowsCount = 0;
+        this.measuredCollapsedRowHeight = null;
+        this.measuredHeaderHeight = null;
+        this.hasGlobalActionsContent = false;
+        this.hasContextualActionsContent = false;
+        this.hasScrollableContent = false;
+        this.generatedHeaderPrefix = helpers.Helpers.generateUniqueId();
+        this.dataStore = new TableDataStore();
+        this.isRenderingData = false;
+        this.selfMutationDepth = 0;
+        this.viewportMeasureFrame = null;
+        this.sorting = [];
+        this.openDropdowns = new Set();
+        this.headerHeights = new Map();
+        this.handleViewportScroll = () => {
+            for (const dropdown of this.openDropdowns) {
+                if (dropdown.isConnected)
+                    void dropdown.close();
+            }
+            this.openDropdowns.clear();
+        };
+        this.handleFooterPageChange = (event) => {
+            if (this.dataStore.getItemCount() >= this.resolvePaginationTotalItems()) {
+                this.currentPage = event.detail.page;
+            }
+            this.brTablePageChange.emit(event.detail);
+        };
+        this.handleFooterPerPageChange = (event) => {
+            this.applyFooterPerPageChange(event.detail.perPage);
+        };
+        /**
+         * Ressincroniza todas as estruturas derivadas após uma mudança no conteúdo.
+         * A ordem preserva expansão antes de seleção e ambas antes das colunas de dados.
+         */
+        this.handleStructureChange = () => {
+            this.syncBarActionsContent();
+            this.runWithoutSelfMutations(() => {
+                this.syncSelectionStructure();
+                this.syncExpansionStructure();
+                this.syncRowHoverState();
+                this.annotateBoundaries();
+                this.updateColumnWidths();
+                this.updateAllCellAlignments();
+                this.updateAllCellOverflow();
+                this.updateActionDensities();
+                this.applyAriaMetadata();
+            });
+            this.updateSelectionCount();
+            for (const entry of this.headerHeights.values())
+                entry.refresh();
+            this.updateHeaderHeight();
+            this.virtualList.sync();
+        };
+    }
+    handleHeaderHeight(event) {
+        const { host, height } = event.detail;
+        if (host.closest('br-table') !== this.el || !Number.isFinite(height) || height < 0)
+            return;
+        this.headerHeights.set(host, event.detail);
+        this.updateHeaderHeight();
+    }
+    updateHeaderHeight() {
+        for (const host of this.headerHeights.keys()) {
+            if (host.closest('br-table') !== this.el)
+                this.headerHeights.delete(host);
+        }
+        const multilevelHeader = this.el.querySelector('br-table-header[data-multilevel]');
+        const height = multilevelHeader?.getBoundingClientRect().height ??
+            Math.max(0, ...Array.from(this.headerHeights.values(), (entry) => entry.height));
+        if (height === this.measuredHeaderHeight)
+            return;
+        this.measuredHeaderHeight = height;
+        this.virtualList?.refreshViewport();
+    }
+    handleDropdownOpenChange(event) {
+        const dropdown = event.composedPath()[0];
+        if (!(dropdown instanceof HTMLElement) || dropdown.localName !== 'br-dropdown')
+            return;
+        if (ownership.findComposedOwner(dropdown, 'br-table') !== this.el)
+            return;
+        const menu = dropdown;
+        if (event.detail.open)
+            this.openDropdowns.add(menu);
+        else
+            this.openDropdowns.delete(menu);
+    }
+    handleCellFocusRegistration(event) {
+        if (event.detail.host.closest('br-table') !== this.el)
+            return;
+        this.keyboard.register(event.detail);
+    }
+    handleGridFocusIn(event) {
+        this.keyboard.focusIn(event);
+    }
+    handleGridFocusOut(event) {
+        this.keyboard.focusOut(event);
+    }
+    handleGridKeyDown(event) {
+        this.keyboard.keyDown(event);
+    }
+    applyFooterPerPageChange(perPage) {
+        const nextPageSize = Math.max(1, Math.floor(perPage));
+        if (nextPageSize === this.resolvePageSize())
+            return;
+        this.pageSize = nextPageSize;
+        this.currentPage = 1;
+        this.brTablePageSizeChange.emit({ pageSize: nextPageSize });
+    }
+    /**
+     * Inicializa os controllers antes da primeira renderização completa.
+     */
+    componentWillLoad() {
+        this.keyboard = new table_utils.TableKeyboardController(this.el, () => this.getKeyboardRows(), (cell) => {
+            const row = cell.closest('br-table-row');
+            const index = row === null ? -1 : this.getVirtualRows().indexOf(row);
+            this.virtualList.revealRow(index >= 0 ? index : null);
+        }, () => this.resolveConfiguredVisibleRows());
+        this.selection = new TableSelectionController({
+            host: this.el,
+            idPrefix: this.generatedHeaderPrefix,
+            getRows: () => this.dataStore.getRows(),
+            onChange: (detail) => {
+                this.selectedRowsCount = detail.selectedCount;
+                this.brTableSelectionChange.emit(detail);
+            },
+        });
+        this.expansion = new TableExpansionController({
+            host: this.el,
+            getRows: () => this.dataStore.getRows(),
+            onChange: (detail) => {
+                const virtualIndex = this.getVirtualRows().indexOf(detail.row);
+                if (virtualIndex >= 0)
+                    this.virtualList?.invalidateRow(virtualIndex);
+                this.brTableRowExpansionChange.emit(detail);
+            },
+        });
+        this.virtualList = new TableVirtualListController({
+            getRows: () => this.getVirtualRows(),
+            getViewport: () => this.el.shadowRoot?.querySelector('.br-table-scroll') ?? null,
+            getStickyHeaderHeight: () => this.measuredHeaderHeight ?? 0,
+            renderRange: (range) => {
+                this.isRenderingData = true;
+                const offset = this.resolveVirtualRangeOffset();
+                this.runWithoutSelfMutations(() => this.dataStore.renderRange({
+                    ...range,
+                    start: range.start + offset,
+                    end: range.end + offset,
+                }));
+                this.isRenderingData = false;
+            },
+            visibleRows: () => this.resolveConfiguredVisibleRows(),
+            estimatedRowHeight: () => this.resolveVirtualRowHeight(),
+            estimatedExpandedHeight: () => this.virtualExpandedContentHeight,
+            onAfterRender: () => queueMicrotask(() => this.syncRenderedRange()),
+        });
+    }
+    /**
+     * Retoma a coordenação de densidade quando a tabela é reinserida.
+     */
+    connectedCallback() {
+        if (this.structureObserver === undefined)
+            return;
+        this.observeStructureChanges();
+        this.updateActionDensities();
+        this.syncScrollShadows();
+    }
+    /**
+     * Monta a estrutura derivada e registra os listeners de coordenação.
+     */
+    componentDidLoad() {
+        this.captureAndRenderInitialData();
+        this.syncHeaderSortState();
+        this.syncSelectionStructure();
+        this.syncExpansionStructure();
+        this.syncRowHoverState();
+        this.virtualList.connect();
+        this.virtualList.reset(false);
+        this.syncBarActionsContent();
+        this.annotateBoundaries();
+        this.registerColumnWidthListener();
+        this.registerAlignmentListener();
+        this.registerOverflowListener();
+        this.applyDensity();
+        this.updateActionDensities();
+        this.applyExpandedContentHeight();
+        this.applyDividers();
+        this.observeStructureChanges();
+        queueMicrotask(() => {
+            this.updateColumnWidths();
+            this.updateAllCellAlignments();
+            this.updateAllCellOverflow();
+            this.applyAriaMetadata();
+            this.updateSelectionCount();
+            this.scheduleViewportHeightMeasurement();
+            this.updateScrollableContentState();
+        });
+    }
+    syncScrollShadows() {
+        const viewport = this.el.shadowRoot?.querySelector('.br-table-scroll');
+        const content = this.el.shadowRoot?.querySelector('.br-table-content');
+        if (!this.scrollShadows && viewport && content && viewport.parentElement) {
+            this.scrollShadows = new table_utils.TableScrollShadows(viewport, content, viewport.parentElement);
+        }
+        this.scrollShadows?.update();
+    }
+    componentDidRender() {
+        this.syncScrollShadows();
+        this.updateScrollableContentState();
+    }
+    /**
+     * Libera o observer quando a tabela é removida do documento.
+     */
+    disconnectedCallback() {
+        this.scrollShadows?.disconnect();
+        this.scrollShadows = undefined;
+        this.openDropdowns.clear();
+        this.keyboard?.disconnect();
+        this.structureObserver?.disconnect();
+        this.virtualList?.disconnect();
+        this.headerHeights.clear();
+        if (this.viewportMeasureFrame !== null)
+            cancelAnimationFrame(this.viewportMeasureFrame);
+        this.viewportMeasureFrame = null;
+    }
+    /**
+     * Recalcula o grid quando a largura padrão muda.
+     */
+    handleTableColumnWidthChange() {
+        this.updateColumnWidths();
+    }
+    /**
+     * Reaplica os tokens e recalcula a virtualização quando a densidade muda.
+     */
+    handleDensityChange() {
+        this.invalidateViewportMetrics();
+        this.applyDensity();
+        this.updateActionDensities();
+        this.virtualList?.reset(false);
+        this.scheduleViewportHeightMeasurement();
+    }
+    /**
+     * Recalcula a viewport e a janela virtual quando a quantidade visível muda.
+     */
+    handleVisibleRowsChange() {
+        this.syncVisibleRange(false);
+    }
+    /** Reinicia a janela virtual quando a paginação é alternada. */
+    handleHasPaginationChange() {
+        this.virtualList.reset(true);
+        this.scheduleViewportHeightMeasurement();
+    }
+    /** Reinicia a janela virtual no subconjunto correspondente à página atual. */
+    handleCurrentPageChange() {
+        if (this.hasPagination)
+            this.virtualList.reset(true);
+    }
+    /** Reinicia a página e a janela virtual quando o tamanho lógico da página muda. */
+    handlePageSizeChange() {
+        if (!this.hasPagination)
+            return;
+        this.currentPage = 1;
+        this.virtualList.reset(true);
+        this.scheduleViewportHeightMeasurement();
+    }
+    /** Normaliza a quantidade pública de linhas visíveis para o intervalo suportado. */
+    resolveConfiguredVisibleRows() {
+        if (!Number.isFinite(this.visibleRows))
+            return DEFAULT_VISIBLE_ROWS;
+        return Math.min(MAX_VISIBLE_ROWS, Math.max(MIN_VISIBLE_ROWS, Math.floor(this.visibleRows)));
+    }
+    /** Quantidade total de itens usada pela paginação, priorizando o valor explícito. */
+    resolvePaginationTotalItems() {
+        return this.totalItems ?? this.dataStore.getItemCount();
+    }
+    /** Resolve o tamanho lógico da página sem acoplá-lo à altura da viewport. */
+    resolvePageSize() {
+        const rawPageSize = this.pageSize ?? this.resolveConfiguredVisibleRows();
+        if (!Number.isFinite(rawPageSize))
+            return this.resolveConfiguredVisibleRows();
+        return Math.max(1, Math.floor(rawPageSize));
+    }
+    /** Retorna a página normalizada para o total e o tamanho atuais. */
+    resolveCurrentPage() {
+        if (!this.hasPagination)
+            return 1;
+        const totalPages = Math.max(1, Math.ceil(this.resolvePaginationTotalItems() / this.resolvePageSize()));
+        return Math.min(Math.max(1, Math.floor(this.currentPage || 1)), totalPages);
+    }
+    /**
+     * Retorna o dataset lógico consumido pela lista virtual. Com paginação local,
+     * corresponde apenas ao slice da página; com paginação remota, corresponde
+     * ao subconjunto atualmente fornecido pelo consumidor.
+     */
+    getVirtualRows() {
+        const rows = this.dataStore.getRowsView();
+        if (!this.hasPagination)
+            return rows;
+        const totalItems = this.resolvePaginationTotalItems();
+        if (this.dataStore.getItemCount() < totalItems)
+            return rows;
+        const pageSize = this.resolvePageSize();
+        const range = this.dataStore.getPageRange((this.resolveCurrentPage() - 1) * pageSize, pageSize);
+        return this.dataStore.getRowsView(range.start, range.end);
+    }
+    /**
+     * Converte os índices locais da janela virtual para índices do dataset
+     * completo quando a paginação é realizada localmente.
+     *
+     * Na paginação remota, o data store contém somente a página fornecida pelo
+     * consumidor, portanto não há offset físico a aplicar ao renderRange.
+     */
+    resolveVirtualRangeOffset() {
+        if (!this.hasPagination)
+            return 0;
+        const totalRows = this.dataStore.getItemCount();
+        const totalItems = this.resolvePaginationTotalItems();
+        if (totalRows < totalItems)
+            return 0;
+        return this.dataStore.getPageRange((this.resolveCurrentPage() - 1) * this.resolvePageSize(), this.resolvePageSize())
+            .start;
+    }
+    /** Atualiza a janela virtual; a paginação apenas altera seu dataset de entrada. */
+    syncVisibleRange(resetScroll) {
+        this.virtualList.reset(resetScroll);
+    }
+    /**
+     * Resolve a altura-base estimada da linha a partir da densidade atual.
+     *
+     * @remarks A célula utiliza a densidade como padding vertical. A estimativa
+     * soma duas vezes esse padding a uma altura de conteúdo de uma linha (24px).
+     * Após a materialização, a lista virtual substitui a estimativa pela altura
+     * efetivamente medida.
+     */
+    resolveVirtualRowHeight() {
+        const density = table_utils.resolveTokenValue(this.density, {
+            fallback: table_utils.TABLE_DENSITY_MAP[table_utils.TABLE_DENSITY.MEDIUM],
+            semanticMap: table_utils.TABLE_DENSITY_MAP,
+        });
+        const verticalPadding = Number.parseFloat(density);
+        return 24 + verticalPadding * 2;
+    }
+    /**
+     * Define a altura da região rolável pelo número de itens lógicos solicitado.
+     * Grupos contam como um item, mas reservam a altura de todas as suas linhas.
+     */
+    resolveScrollViewportHeight() {
+        const estimatedRowHeight = this.resolveVirtualRowHeight();
+        const rowHeight = Math.max(this.measuredCollapsedRowHeight ?? 0, estimatedRowHeight);
+        const headerHeight = Math.max(this.measuredHeaderHeight ?? 0, rowHeight);
+        const rows = this.getVirtualRows();
+        const configuredHeightRows = this.heightRows !== undefined && Number.isFinite(this.heightRows)
+            ? Math.max(1, Math.floor(this.heightRows))
+            : this.resolveConfiguredVisibleRows();
+        const logicalRows = Math.min(configuredHeightRows, this.dataStore.getItemCount());
+        const pageOffset = this.resolveVirtualRangeOffset();
+        const physicalRange = this.dataStore.getPageRange(pageOffset, logicalRows);
+        const physicalRows = rows.length === 0 ? 0 : Math.min(rows.length, physicalRange.end - pageOffset);
+        const dataRowsHeight = physicalRows * rowHeight;
+        return `${headerHeight + dataRowsHeight}px`;
+    }
+    /**
+     * Reaplica os divisores após qualquer mudança relacionada.
+     */
+    handleDividerChange() {
+        this.applyDividers();
+    }
     /**
-     * Define o template de colunas aplicado ao grid.
+     * Recalcula os alinhamentos herdados de todas as células.
      */
-    COLUMN_WIDTHS: '--br-table-column-widths',
+    handleAlignmentChange() {
+        this.updateAllCellAlignments();
+    }
     /**
-     * Controla o espaçamento interno das células.
+     * Recalcula o overflow herdado de todas as células.
      */
-    DENSITY: '--br-table-density',
+    handleOverflowChange() {
+        this.updateAllCellOverflow();
+    }
+    handleVirtualExpandedContentHeightChange() {
+        this.applyExpandedContentHeight();
+        this.syncVisibleRange(false);
+    }
     /**
-     * Define o alinhamento horizontal do conteúdo das células.
+     * Sincroniza a estrutura quando a seleção é habilitada ou desabilitada.
      */
-    HORIZONTAL_ALIGNMENT: '--br-table-horizontal-alignment',
+    handleRowSelectionChange() {
+        this.syncSelectionStructure();
+        this.handleStructureChange();
+    }
+    /** Sincroniza a elegibilidade visual de hover das linhas. */
+    handleRowHoverChange() {
+        this.syncRowHoverState();
+    }
     /**
-     * Define o alinhamento vertical do conteúdo das células.
+     * Sincroniza a estrutura quando a expansão é habilitada ou desabilitada.
      */
-    VERTICAL_ALIGNMENT: '--br-table-vertical-alignment',
+    handleRowExpansionChange() {
+        this.handleStructureChange();
+    }
+    /** Normaliza o estado ativo quando o consumidor alterna entre multi e single-sort. */
+    handleSortModeChange() {
+        if (this.sortMode === table_utils.TABLE_SORT_MODE.SINGLE && this.sorting.length > 1) {
+            const firstCriterion = this.getSortingByColumnOrder()[0];
+            this.sorting = firstCriterion === undefined ? [] : [firstCriterion];
+            this.applySorting(false);
+        }
+    }
+    /** Reaplica o estado atual quando a estratégia de ordenação muda. */
+    handleSortStrategyChange() {
+        if (this.dataStore.getColumns().length === 0)
+            return;
+        this.applySorting(false);
+    }
+    /** Consome solicitações emitidas pelo trigger de ordenação do cabeçalho. */
+    handleSortRequest(event) {
+        const header = event
+            .composedPath()
+            .find((node) => node instanceof HTMLElement &&
+            node.tagName.toLowerCase() === 'br-table-header-cell' &&
+            node.hasAttribute('sortable'));
+        if (header === undefined || header.closest('br-table') !== this.el)
+            return;
+        const columnIndex = this.dataStore.getColumns().indexOf(header);
+        if (columnIndex < 0)
+            return;
+        event.stopImmediatePropagation();
+        const nextSorting = this.resolveNextSorting(columnIndex);
+        const requestEvent = this.brTableSortRequest.emit({
+            mode: this.sortMode,
+            columnIndex,
+            currentSorting: this.getSortingByColumnOrder().map((criterion) => ({ ...criterion })),
+            nextSorting: nextSorting.map((criterion) => ({ ...criterion })),
+        });
+        if (requestEvent.defaultPrevented) {
+            return;
+        }
+        this.sorting = nextSorting;
+        this.applySorting(true);
+    }
     /**
-     * Define o estilo visual das linhas divisórias.
+     * Encaminha mudanças dos checkboxes ao controller de seleção.
      */
-    DIVIDER_STYLE: '--br-table-divider-style',
+    handleSelectionCheckboxChange(event) {
+        this.selection.handleCheckboxChange(event);
+    }
     /**
-     * Controla a visibilidade/intensidade do divisor entre colunas.
+     * Consome ações internas de expansão e normaliza as demais ações.
      */
-    COLUMN_DIVIDER_FACTOR: '--br-table-column-divider-factor',
+    handleActionClick(event) {
+        if (event.target === this.el) {
+            return;
+        }
+        if (this.expansion.handleActionClick(event)) {
+            event.stopImmediatePropagation();
+            event.stopPropagation();
+            return;
+        }
+        event.stopImmediatePropagation();
+        event.stopPropagation();
+        if (event.detail.type !== 'row') {
+            this.brTableActionClick.emit(event.detail);
+            return;
+        }
+        this.brTableActionClick.emit({
+            ...event.detail,
+            rowIndex: this.resolveActionRowIndex(event),
+        });
+    }
+    /** Resolve o índice da linha associado à ação quando o contexto é `row`. */
+    resolveActionRowIndex(event) {
+        const row = event
+            .composedPath()
+            .find((node) => node instanceof HTMLElement && node.tagName.toLowerCase() === 'br-table-row');
+        if (row === undefined)
+            return undefined;
+        const rowIndex = this.getBodyRows().indexOf(row);
+        return rowIndex >= 0 ? rowIndex : undefined;
+    }
+    /** Inicia o estado visual de carregamento sem alterar os dados da tabela. */
+    async startLoading() {
+        this.loading = true;
+    }
+    /** Interrompe o estado visual de carregamento sem alterar os dados da tabela. */
+    async stopLoading() {
+        this.loading = false;
+    }
     /**
-     * Controla a visibilidade/intensidade do divisor entre linhas.
+     * Substitui os dados lógicos da tabela e reconstrói seus subcomponentes.
+     *
+     * @remarks Esta é a mesma estrutura interna utilizada após a ingestão dos slots.
+     * @param data Colunas, linhas e ações que formarão a tabela.
+     * @example
+     * ```js
+     * const table = document.querySelector('br-table');
+     * await table.setData({
+     *   columns: [],
+     *   headerRows: [
+     *     [{ content: 'Unidade', rowSpan: 2 }, { content: 'Equipe', colSpan: 2 }],
+     *     [{ content: 'Nome', sortable: true }, { content: 'Cargo', sortable: true }],
+     *   ],
+     *   rows: [
+     *     { rowGroup: 'brasilia', cells: [
+     *       { content: 'Brasília', rowSpan: 2, rowHeader: true },
+     *       { content: 'Ana' }, { content: 'Analista' },
+     *     ] },
+     *     { rowGroup: 'brasilia', cells: [{ content: 'Carlos' }, { content: 'Técnico' }] },
+     *   ],
+     * });
+     * ```
      */
-    ROW_DIVIDER_FACTOR: '--br-table-row-divider-factor',
+    async setData(data) {
+        this.invalidateViewportMetrics();
+        const previousSorting = this.sorting.map((criterion) => ({ ...criterion }));
+        this.isRenderingData = true;
+        this.dataStore.replace(data);
+        this.dataStore.mount(this.el);
+        this.isRenderingData = false;
+        await Promise.resolve();
+        this.sorting = this.resolvePreservedSorting(previousSorting);
+        if (this.sorting.length > 0) {
+            this.applySorting(false);
+        }
+        else {
+            this.syncHeaderSortState();
+            this.syncSelectionStructure();
+            this.syncExpansionStructure();
+            this.syncRowHoverState();
+            this.syncVisibleRange(true);
+            this.handleStructureChange();
+        }
+        this.scheduleViewportHeightMeasurement();
+    }
+    /** Preserva apenas critérios que continuam válidos no novo dataset. */
+    resolvePreservedSorting(previousSorting) {
+        const columns = this.dataStore.getColumns();
+        const validSorting = previousSorting.filter(({ columnIndex }) => {
+            if (columnIndex < 0 || columnIndex >= columns.length)
+                return false;
+            return columns[columnIndex]?.hasAttribute('sortable') === true;
+        });
+        if (this.sortMode !== table_utils.TABLE_SORT_MODE.MULTI) {
+            const first = validSorting[0];
+            return first === undefined ? [] : [first];
+        }
+        return [...validSorting].sort((a, b) => a.columnIndex - b.columnIndex);
+    }
     /**
-     * Controla o comportamento de overflow do conteúdo das células.
+     * Captura a entrada declarativa inicial e a materializa a partir do modelo virtual.
      */
-    CELL_OVERFLOW: '--br-table-cell-overflow',
+    captureAndRenderInitialData() {
+        this.invalidateViewportMetrics();
+        this.isRenderingData = true;
+        this.dataStore.capture(this.el);
+        this.dataStore.mount(this.el);
+        this.isRenderingData = false;
+    }
     /**
-     * Controla o comportamento de overflow de texto dentro das células.
+     * Retorna as linhas atualmente selecionadas.
+     *
+     * @returns Elementos `br-table-row` selecionados no corpo.
      */
-    CELL_TEXT_OVERFLOW: '--br-table-cell-text-overflow',
+    async getSelectedRows() {
+        return this.selection.getSelectedRows();
+    }
     /**
-     * Controla o comportamento de quebra de linha dentro das células.
+     * Seleciona todas as linhas elegíveis.
      */
-    CELL_WHITE_SPACE: '--br-table-cell-white-space',
-};
-
-/**
- * Resolve um valor de token aplicando validação e fallback.
- *
- * @param raw Valor bruto informado.
- * @param options Configurações de resolução.
- * @param options.fallback Valor padrão utilizado quando `raw` é inválido.
- * @param options.semanticMap Mapa opcional de valores semânticos.
- * @param options.validators Lista opcional de validadores.
- *
- * @returns Valor final resolvido.
- *
- * @remarks
- * Ordem de resolução:
- * 1. Retorna fallback se `raw` for vazio ou indefinido.
- * 2. Retorna o valor do mapa semântico, se aplicável.
- * 3. Retorna `raw` se passar por algum validador.
- * 4. Caso contrário, retorna o fallback.
- */
-function resolveTokenValue(raw, options) {
-    if (raw === undefined || raw === '')
-        return options.fallback;
-    const { semanticMap, validators = [], fallback } = options;
-    if (semanticMap && raw in semanticMap) {
-        return semanticMap[raw];
-    }
-    const isValid = validators.some((validator) => validator(raw));
-    return isValid ? raw : fallback;
-}
-/**
- * Valida valores positivos em pixels.
- *
- * @example 16px
- */
-const positivePxValidator = (value) => /^\d+(\.\d+)?px$/.test(value) && parseFloat(value) > 0;
-/**
- * Valida valores positivos em frações de grid.
- *
- * @example 1fr
- */
-const positiveFrValidator = (value) => /^\d+(\.\d+)?fr$/.test(value) && parseFloat(value) > 0;
-
-const tableCss = () => `*,*::before,*::after{box-sizing:border-box}:host{line-height:var(--font-line-height-medium);-webkit-text-size-adjust:100%;-moz-text-size-adjust:100%;text-size-adjust:100%}main{display:block}hr{box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace;font-size:1em}a{background-color:rgba(0,0,0,0)}b,strong{font-weight:bolder}small{font-size:80%}img{border-style:none}button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:var(--font-line-height-medium);margin:0}button,input{overflow:visible}button,select{text-transform:none}button,[type=button],[type=reset],[type=submit]{appearance:button}button::-moz-focus-inner,[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner{border-style:none;padding:0}button:-moz-focusring,[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:.35em .75em .625em}legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{vertical-align:baseline}textarea{overflow:auto}[type=checkbox],[type=radio]{box-sizing:border-box;padding:0}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{appearance:textfield;outline-offset:-2px}[type=search]::-webkit-search-decoration{appearance:none}::-webkit-file-upload-button{appearance:button;font:inherit}details{display:block}summary{display:list-item}template{display:none}[hidden]{display:none}.d-none{display:none !important}@media (min-width: 576px){.d-sm-block{display:block !important}.d-sm-flex{display:flex !important}}[data-toggle=dropdown]+*{position:absolute}.dropdown{position:relative}.dropdown [data-toggle=dropdown]+*{box-shadow:var(--surface-shadow-sm);left:0;position:absolute;top:100%}.dropdown>.br-notification{left:auto;right:0}.dropdown .br-item{--color:var(--color-light);--color-rgb:var(--color-light-rgb);--text-color:var(--color-light);--interactive:var(--interactive-light);--interactive-rgb:var(--color-rgb);--visited:var(--visited-light);--hover:var(--hover-light);--pressed:var(--pressed-light);--focus-color:var(--focus-color-light);--focus:var(--focus-color-light);--item-padding-y:var(--spacing-scale-2x);background-color:var(--background-light);color:var(--color)}.dropdown .br-item:not(:last-child){border-bottom:1px solid var(--border-color)}.dropdown .br-item.selected{--color:var(--color-dark);--color-rgb:var(--color-dark-rgb);--text-color:var(--color-dark);--interactive:var(--interactive-dark);--interactive-rgb:var(--interactive-dark-rgb);--visited:var(--visited-dark);--hover:var(--hover-dark);--pressed:var(--pressed-dark);--focus-color:var(--focus-color-dark);--focus:var(--focus-color-dark)}.justify-content-start{justify-content:flex-start !important}.justify-content-end{justify-content:flex-end !important}.justify-content-center{justify-content:center !important}.align-items-center{align-items:center !important}.col,[class*=col-]{padding-left:calc(var(--grid-gutter)*.5);padding-right:calc(var(--grid-gutter)*.5);width:100%}.col{flex:1 0 0%;min-width:8.3333333333%}.col-auto{flex:0 0 auto;width:auto}.col-2{flex-basis:16.6666666667%;max-width:16.6666666667%}.container,.container-fluid,.container-lg{--grid-margin:var(--grid-portrait-margin);--grid-maxwidth:var(--grid-portrait-maxwidth);margin-left:auto;margin-right:auto;max-width:var(--grid-maxwidth);padding-left:var(--grid-margin);padding-right:var(--grid-margin);width:100%}.row{--grid-gutter:var(--grid-portrait-gutter);display:flex;flex-wrap:wrap;margin-left:calc(var(--grid-gutter)*-0.5);margin-right:calc(var(--grid-gutter)*-0.5)}@media (min-width: 576px){.container,.container-lg,.container-fluid{--grid-margin:var(--grid-tablet-margin)}.row{--grid-gutter:var(--grid-tablet-gutter)}.container{--grid-maxwidth:calc(var(--grid-breakpoint-sm) - var(--grid-tablet-margin))}.col-sm-4{flex-basis:33.3333333333%;max-width:33.3333333333%}}@media (min-width: 992px){.container,.container-lg,.container-fluid{--grid-margin:var(--grid-tablet-margin)}.row{--grid-gutter:var(--grid-tablet-gutter)}.container{--grid-maxwidth:calc(var(--grid-breakpoint-md) - var(--grid-tablet-margin))}}@media (min-width: 1280px){.container,.container-lg,.container-fluid{--grid-margin:var(--grid-desktop-margin)}.row{--grid-gutter:var(--grid-desktop-gutter)}.container,.container-lg{--grid-maxwidth:calc(var(--grid-breakpoint-lg) - var(--grid-desktop-margin))}.col-lg-3{flex-basis:25%;max-width:25%}}@media (min-width: 1600px){.container,.container-lg,.container-fluid{--grid-margin:var(--grid-tv-margin)}.row{--grid-gutter:var(--grid-tv-gutter)}.container,.container-lg{--grid-maxwidth:calc(var(--grid-breakpoint-xl) - var(--grid-tv-margin))}}.ease{animation-timing-function:cubic-bezier(0.25, 0.1, 0.25, 1)}.ease-out{animation-timing-function:cubic-bezier(0, 0, 0.58, 1)}.ease-in-out{animation-timing-function:cubic-bezier(0.42, 0, 0.58, 1)}.fast{animation-duration:var(--duration-fast)}.slow{animation-duration:var(--duration-slow)}.mt-1{margin-top:var(--spacing-scale-half) !important}.mr-1{margin-right:var(--spacing-scale-half) !important}.mb-1{margin-bottom:var(--spacing-scale-half) !important}.ml-1{margin-left:var(--spacing-scale-half) !important}.mx-3{margin-left:var(--spacing-scale-2x) !important;margin-right:var(--spacing-scale-2x) !important}.mb-4{margin-bottom:var(--spacing-scale-3x) !important}.ml-auto{margin-left:auto !important}.pt-half{padding-top:var(--spacing-scale-half) !important}@media (min-width: 576px){.ml-sm-0{margin-left:var(--spacing-scale-default) !important}}.highlight{background:var(--status-highlight-background) linear-gradient(var(--status-highlight-overlay), var(--status-highlight-overlay));color:var(--status-highlight-text);padding:0 var(--spacing-scale-half)}[disabled],.disabled{cursor:not-allowed;opacity:var(--disabled)}[disabled] *,.disabled *{pointer-events:none}fieldset[disabled]{opacity:1}.text-center{text-align:center !important}.text-right{text-align:right !important}.text-nowrap{white-space:nowrap !important}.text-uppercase{text-transform:uppercase !important}.text-bold{font-weight:700 !important}.text-base{font-size:var(--font-size-scale-base) !important}.text-down-01{font-size:var(--font-size-scale-down-01) !important}@media (min-width: 576px){.text-sm-center{text-align:center !important}.text-sm-left{text-align:left !important}.text-sm-right{text-align:right !important}}p{color:var(--color);font-size:var(--font-size-scale-base);font-weight:var(--font-weight-regular);line-height:var(--font-line-height-medium);margin-bottom:var(--spacing-scale-2x);margin-top:0}p a{text-decoration:underline}@media (min-width: 576px){p{font-size:var(--font-size-scale-up-01)}}a{--focus-offset:var(--spacing-scale-half)}a:focus{outline:none}a.focus-visible,a:focus-visible{outline-color:var(--focus);outline-offset:var(--focus-offset);outline-style:var(--focus-style);outline-width:var(--focus-width)}a:not(:disabled):hover{background-image:linear-gradient(rgba(var(--interactive-rgb), var(--hover)), rgba(var(--interactive-rgb), var(--hover)))}a:not(:disabled):active{background-image:linear-gradient(rgba(var(--interactive-rgb), var(--pressed)), rgba(var(--interactive-rgb), var(--pressed)))}a{color:var(--interactive);text-decoration:none}.main-content a{text-decoration:underline}button{cursor:pointer}img{max-width:100%;vertical-align:middle}h2,.h2{color:var(--color);font-size:var(--font-size-scale-up-03);font-weight:var(--font-weight-semi-bold);line-height:var(--font-line-height-low);margin-bottom:var(--spacing-scale-2xh);margin-top:var(--spacing-scale-3xh);padding-bottom:var(--spacing-scale-2xh)}@media (min-width: 576px){.h2,h2{font-size:var(--font-size-scale-up-05);font-weight:var(--font-weight-regular)}}ul,ol{margin-bottom:var(--spacing-scale-2x);margin-top:0;padding:0 0 0 var(--spacing-scale-5x)}table{--table-background:var(--background);--table-color:var(--color);--table-border-color:var(--gray-20);--table-border-style:solid;--table-border-width:1px;--table-hover:var(--color-rgb);--table-padding:var(--spacing-scale-3x);--table-font-weight:var(--font-weight-medium);--table-th-background:var(--background-alternative);--table-th-font-weight:var(--font-weight-semi-bold);--table-row-size:var(--spacing-scale-2x);border-collapse:collapse;width:100%}tr.selected,tr.is-selected{--color:var(--color-dark);--color-rgb:var(--color-dark-rgb);--text-color:var(--color-dark);--interactive:var(--interactive-dark);--interactive-rgb:var(--interactive-dark-rgb);--visited:var(--visited-dark);--hover:var(--hover-dark);--pressed:var(--pressed-dark);--focus-color:var(--focus-color-dark);--focus:var(--focus-color-dark)}label,.label{color:var(--color);font-size:var(--font-size-scale-base);font-weight:var(--font-weight-semi-bold);line-height:var(--font-line-height-medium);margin-bottom:var(--spacing-scale-half)}fieldset,.fieldset{border:var(--surface-width-none);margin-bottom:var(--spacing-scale-5x);margin-top:0;padding:0}legend,.legend{color:var(--color);font-size:var(--font-size-scale-up-01);font-weight:var(--font-weight-semi-bold);line-height:var(--font-line-height-low);margin-bottom:var(--spacing-scale-2x);margin-top:var(--spacing-scale-2x)}::placeholder,.placeholder{color:var(--color-light);font-size:var(--font-size-scale-base);font-style:italic;font-weight:var(--font-weight-regular);line-height:var(--font-line-height-medium);margin-bottom:var(--spacing-scale-half);margin-top:var(--spacing-scale-half);opacity:1}input,textarea,.input{color:var(--color-light);font-size:var(--font-size-scale-up-01);font-weight:var(--font-weight-medium);line-height:var(--font-line-height-low);margin-bottom:var(--spacing-scale-half)}pre,.pre{background:var(--gray-5);margin:var(--spacing-scale-2x) 0 var(--spacing-scale-4x);padding:var(--spacing-scale-2x)}*[data-toggle=collapse]:not(:disabled):hover{background-image:linear-gradient(rgba(var(--interactive-rgb), var(--hover)), rgba(var(--interactive-rgb), var(--hover)))}*[data-toggle=collapse]:focus{outline:none}*[data-toggle=collapse].focus-visible,*[data-toggle=collapse]:focus-visible{outline-color:var(--focus);outline-offset:var(--focus-offset);outline-style:var(--focus-style);outline-width:var(--focus-width)}@media (prefers-reduced-motion: reduce){:host,:host::before,:host::after,:host *,:host *::before,:host *::after{animation:none !important;scroll-behavior:auto !important;transition:none !important}}:host-context([data-wbc-reduced-motion=true])::before,:host-context([data-wbc-reduced-motion=true])::after,:host-context([data-wbc-reduced-motion=true]) *,:host-context([data-wbc-reduced-motion=true]) *::before,:host-context([data-wbc-reduced-motion=true]) *::after{animation:none !important;scroll-behavior:auto !important;transition:none !important}:host{display:block;--table-row-size:var(--spacing-scale-3x);--br-table-divider-base-width:var(--surface-width-sm);--br-table-loading-opacity:0.5}.br-table{position:relative;width:100%}.br-table-content{display:grid;grid-template-columns:var(--br-table-column-widths);min-width:0}[part=loading]{position:absolute;z-index:2;inset:0;display:grid;place-items:center;pointer-events:auto}.br-table-content.loading{opacity:var(--br-table-loading-opacity)}@media (width <= 991px){.br-table{overflow-x:auto;-webkit-overflow-scrolling:touch}.br-table-content{min-width:max-content}}`;
-
-const Table = class {
-    constructor(hostRef) {
-        index.registerInstance(this, hostRef);
-        /**
-         * Ativa divisores verticais entre colunas.
-         *
-         * @default false
-         * @deprecated Use `columnDivider`.
-         */
-        this.hasColumnDivider = false;
-        /**
-         * Ativa divisores horizontais entre linhas.
-         *
-         * @default false
-         * @deprecated Use `rowDivider`.
-         */
-        this.hasRowDivider = false;
-        /**
-         * Define o comportamento de overflow para as células.
-         *
-         * @remarks Valores aceitos:
-         * - truncate
-         * - wrap
-         *
-         * Observação:
-         * - O overflow é independente de `columnWidth`.
-         * - Com `columnWidth="content"`, a coluna tende a crescer com o conteúdo (`max-content`), o que pode reduzir casos visíveis de truncagem.
-         * - Com `columnWidth="fill"`, a coluna ocupa o espaço disponível (`1fr`), então a truncagem tende a ficar mais evidente quando não há espaço suficiente.
-         *
-         * @default wrap
-         */
-        this.overflow = tableConstants.TABLE_OVERFLOW.WRAP;
-        /**
-         * Define o estado semântico do tooltip nas células da tabela.
-         *
-         * @remarks Valores aceitos:
-         * - info
-         * - warning
-         * - danger
-         * - success
-         *
-         * @default info
-         */
-        this.tooltipState = tableConstants.TABLE_TOOLTIP_STATE.INFO;
-        /**
-         * Indica que as linhas estão sendo atualizadas pelo consumidor.
-         * O componente mantém o conteúdo anterior, aplica `aria-busy="true"` e
-         * exibe o slot `loading` sobre os dados; transporte, erro e substituição das
-         * linhas ficam sob responsabilidade da aplicação.
-         * A prop pode ser alterada diretamente ou pelos métodos `startLoading()` e
-         * `stopLoading()`.
-         * @default false
-         */
-        this.loading = false;
-        this.headers = [];
-        this.rows = [];
-        this.cells = [];
-        this.rowCells = new Map();
-        this.columnIndexes = new Map();
-        this.structureReady = false;
-        this.structureRefreshFrame = null;
-        this.handleColumnWidthEvent = () => {
-            this.scheduleStructureRefresh();
-        };
-        this.handleAlignmentEvent = (event) => {
-            if (!this.structureReady) {
-                this.scheduleStructureRefresh();
+    async selectAllRows() {
+        this.selection.selectAll(true);
+    }
+    /**
+     * Limpa a seleção de todas as linhas elegíveis.
+     */
+    async clearSelection() {
+        this.selection.clear();
+    }
+    /** Retorna o estado atual de ordenação aplicado na tabela. */
+    async getSorting() {
+        return this.getSortingByColumnOrder().map((criterion) => ({ ...criterion }));
+    }
+    /**
+     * Expande uma linha elegível do corpo.
+     *
+     * @param rowIndex Índice da linha, começando em zero.
+     */
+    async expandRow(rowIndex) {
+        const row = this.getBodyRows()[rowIndex];
+        if (row !== undefined)
+            this.expansion.setExpanded(row, true);
+    }
+    /**
+     * Recolhe uma linha do corpo.
+     *
+     * @param rowIndex Índice da linha, começando em zero.
+     */
+    async collapseRow(rowIndex) {
+        const row = this.getBodyRows()[rowIndex];
+        if (row !== undefined)
+            this.expansion.setExpanded(row, false);
+    }
+    /**
+     * Recolhe todas as linhas que estiverem expandidas.
+     */
+    async collapseAllRows() {
+        this.expansion.collapseAll();
+    }
+    /** Resolve o próximo estado de ordenação para a coluna acionada. */
+    resolveNextSorting(columnIndex) {
+        const current = this.sorting.find((criterion) => criterion.columnIndex === columnIndex);
+        const nextDirection = current === undefined
+            ? table_utils.TABLE_SORT_DIRECTION.ASC
+            : current.direction === table_utils.TABLE_SORT_DIRECTION.ASC
+                ? table_utils.TABLE_SORT_DIRECTION.DESC
+                : undefined;
+        if (this.sortMode !== table_utils.TABLE_SORT_MODE.MULTI) {
+            return nextDirection === undefined ? [] : [{ columnIndex, direction: nextDirection }];
+        }
+        const nextSorting = this.sorting.filter((criterion) => criterion.columnIndex !== columnIndex);
+        if (nextDirection !== undefined)
+            nextSorting.push({ columnIndex, direction: nextDirection });
+        return nextSorting.sort((a, b) => a.columnIndex - b.columnIndex);
+    }
+    /** Mantém a prioridade do multi-sort estritamente da esquerda para a direita. */
+    getSortingByColumnOrder() {
+        return [...this.sorting].sort((a, b) => a.columnIndex - b.columnIndex);
+    }
+    /**
+     * Aplica a ordenação ao dataset completo e só então reinicia a janela virtual.
+     */
+    applySorting(emitChange) {
+        this.sorting = this.getSortingByColumnOrder();
+        if (this.sortStrategy !== table_utils.TABLE_SORT_STRATEGY.MANUAL) {
+            this.dataStore.sortRows(this.sorting);
+        }
+        this.syncHeaderSortState();
+        this.syncSelectionStructure();
+        this.syncExpansionStructure();
+        this.syncRowHoverState();
+        this.syncVisibleRange(true);
+        this.handleStructureChange();
+        if (emitChange) {
+            this.brTableSortChange.emit({
+                mode: this.sortMode,
+                sorting: this.sorting.map((criterion) => ({ ...criterion })),
+                rows: this.dataStore.getRows(),
+            });
+        }
+    }
+    /** Reflete o estado lógico nos cabeçalhos para atualizar ícones e semântica. */
+    syncHeaderSortState() {
+        this.dataStore.getColumns().forEach((header, columnIndex) => {
+            if (!header.hasAttribute('sortable')) {
+                header.removeAttribute('sort-direction');
+                header.removeAttribute('aria-sort');
                 return;
             }
-            this.updateAlignmentForTarget(event.target);
-        };
-        this.handleOverflowEvent = (event) => {
-            if (!this.structureReady) {
-                this.scheduleStructureRefresh();
+            const criterion = this.sorting.find((entry) => entry.columnIndex === columnIndex);
+            if (criterion === undefined) {
+                header.removeAttribute('sort-direction');
+                header.setAttribute('aria-sort', 'none');
                 return;
             }
-            this.updateOverflowForTarget(event.target);
-        };
-        this.generatedHeaderPrefix = id.generateUniqueId();
-        /**
-         * Recalcula estrutura, tokens e metadados de acessibilidade quando há mudança de slots.
-         */
-        this.handleStructureChange = () => {
-            this.scheduleStructureRefresh();
-        };
+            header.setAttribute('sort-direction', criterion.direction);
+            header.setAttribute('aria-sort', criterion.direction === table_utils.TABLE_SORT_DIRECTION.ASC ? 'ascending' : 'descending');
+        });
     }
-    get effectiveDividerStyle() {
-        return props.resolveAllowedPropValue(this.el, 'dividerStyle', this.dividerStyle, ['solid', 'dashed'], 'solid');
+    /**
+     * Observa linhas adicionadas, removidas ou alteradas em tempo de execução.
+     */
+    observeStructureChanges() {
+        this.structureObserver?.disconnect();
+        this.structureObserver = new MutationObserver((mutations) => this.handleStructureMutations(mutations));
+        this.structureObserver.observe(this.el, {
+            attributeFilter: [
+                'row-group',
+                'row-span',
+                'col-span',
+                'selected',
+                'disabled',
+                'row-expansion',
+                'expanded',
+                'virtual-expanded-content-height',
+                'aria-label',
+                'aria-labelledby',
+                'style',
+                'class',
+            ],
+            attributes: true,
+            attributeOldValue: true,
+            childList: true,
+            subtree: true,
+        });
     }
-    get effectiveHorizontalAlignment() {
-        return props.resolveAllowedPropValue(this.el, 'horizontalAlignment', this.horizontalAlignment, ['start', 'center', 'end'], undefined, { allowUndefined: true });
+    /**
+     * Processa mutações externas: estrutura completa quando linhas mudam e somente
+     * densidade quando a herança CSS dentro da tabela pode ter mudado.
+     */
+    handleStructureMutations(mutations) {
+        if (mutations.some((mutation) => mutation.type === 'attributes' &&
+            mutation.target === this.el &&
+            (mutation.attributeName === 'aria-label' || mutation.attributeName === 'aria-labelledby'))) {
+            index.forceUpdate(this);
+        }
+        if (this.isRenderingData)
+            return;
+        if (mutations.some((mutation) => this.isRelevantStructureMutation(mutation))) {
+            this.handleStructureChange();
+        }
+        else if (mutations.some((mutation) => (mutation.type === 'childList' ||
+            mutation.attributeName === 'style' ||
+            (mutation.attributeName === 'class' && !table_utils.isHydrationClassMutation(mutation))) &&
+            mutation.target instanceof HTMLElement &&
+            mutation.target.closest('br-table') === this.el)) {
+            this.updateActionDensities();
+        }
     }
-    get effectiveVerticalAlignment() {
-        return props.resolveAllowedPropValue(this.el, 'verticalAlignment', this.verticalAlignment, ['start', 'center', 'end'], undefined, { allowUndefined: true });
+    /**
+     * Executa escritas internas sem realimentar o observer estrutural.
+     *
+     * @remarks Mutações externas já pendentes são preservadas e reprocessadas;
+     * somente os registros gerados durante `write` são descartados, pois quem
+     * escreve já sincroniza o estado derivado.
+     */
+    runWithoutSelfMutations(write) {
+        const observer = this.structureObserver;
+        if (observer === undefined || this.selfMutationDepth > 0) {
+            write();
+            return;
+        }
+        const pending = observer.takeRecords();
+        this.selfMutationDepth++;
+        try {
+            write();
+        }
+        finally {
+            this.selfMutationDepth--;
+            observer.takeRecords();
+            if (pending.length > 0) {
+                queueMicrotask(() => {
+                    if (this.structureObserver === observer)
+                        this.handleStructureMutations(pending);
+                });
+            }
+        }
     }
-    get effectiveOverflow() {
-        return props.resolveAllowedPropValue(this.el, 'overflow', this.overflow, ['truncate', 'wrap'], tableConstants.TABLE_OVERFLOW.WRAP);
+    /**
+     * Determina se uma mutação exige sincronização estrutural da tabela.
+     */
+    isRelevantStructureMutation(mutation) {
+        if (mutation.type === 'attributes') {
+            return this.handleRowAttributeMutation(mutation);
+        }
+        const changedNodes = Array.from(mutation.addedNodes).concat(Array.from(mutation.removedNodes));
+        return this.hasRowChangeInNodes(changedNodes);
     }
-    get effectiveTooltipState() {
-        return props.resolveAllowedPropValue(this.el, 'tooltipState', this.tooltipState, ['info', 'warning', 'danger', 'success'], tableConstants.TABLE_TOOLTIP_STATE.INFO);
+    /**
+     * Processa mutações de atributo aplicadas às linhas.
+     */
+    handleGroupingMutation(mutation, target) {
+        const current = target.getAttribute(mutation.attributeName ?? '');
+        const unchanged = mutation.attributeName === 'row-group'
+            ? (mutation.oldValue?.trim() || '') === (current?.trim() || '')
+            : table_utils.resolveTableSpan(mutation.oldValue) === table_utils.resolveTableSpan(current);
+        if (unchanged)
+            return false;
+        this.dataStore.invalidateGroups();
+        this.virtualList?.reset(false);
+        index.forceUpdate(this);
+        return true;
     }
-    get effectiveTooltipMode() {
-        return props.resolveAllowedPropValue(this.el, 'tooltipMode', this.tooltipMode, [tableConstants.TABLE_TOOLTIP_MODE.INHERIT, tableConstants.TABLE_TOOLTIP_MODE.ENABLED, tableConstants.TABLE_TOOLTIP_MODE.DISABLED], undefined, { allowUndefined: true });
+    handleRowAttributeMutation(mutation) {
+        const target = mutation.target;
+        if (['row-group', 'row-span', 'col-span'].includes(mutation.attributeName ?? '')) {
+            return this.handleGroupingMutation(mutation, target);
+        }
+        if (!target.matches('br-table-row'))
+            return false;
+        if (mutation.attributeName === 'style' || mutation.attributeName === 'class')
+            return false;
+        if (mutation.attributeName === 'row-expansion' &&
+            (mutation.oldValue ?? table_utils.TABLE_ROW_EXPANSION.INHERIT) ===
+                (target.getAttribute('row-expansion') ?? table_utils.TABLE_ROW_EXPANSION.INHERIT)) {
+            return false;
+        }
+        if (mutation.attributeName === 'expanded' || mutation.attributeName === 'virtual-expanded-content-height') {
+            const logicalIndex = Number(target.getAttribute('data-virtual-index')) - this.resolveVirtualRangeOffset();
+            if (Number.isInteger(logicalIndex) && this.getVirtualRows()[logicalIndex] === target) {
+                this.virtualList.invalidateRow(logicalIndex);
+            }
+            return mutation.attributeName === 'expanded';
+        }
+        return true;
     }
     /**
-     * Reaplica a largura das colunas quando alterada.
+     * Verifica se os nós alterados impactam linhas da tabela.
      */
-    handleTableColumnWidthChange() {
-        this.updateColumnWidths();
+    hasRowChangeInNodes(nodes) {
+        return nodes.some((node) => node instanceof HTMLElement && (node.matches('br-table-row') || node.querySelector('br-table-row') !== null));
     }
     /**
-     * Reaplica o token de densidade quando alterado.
+     * Detecta a presença de ações atribuídas às barras.
      */
-    handleDensityChange() {
-        this.applyDensity();
+    syncBarActionsContent() {
+        const children = Array.from(this.el.children);
+        this.hasGlobalActionsContent = children.some((child) => child.getAttribute('slot') === 'global-actions');
+        this.hasContextualActionsContent = children.some((child) => child.getAttribute('slot') === 'contextual-actions');
     }
     /**
-     * Atualiza os tokens de divisor quando qualquer propriedade relacionada é alterada.
+     * Atualiza o estado reativo usado pela barra contextual.
      */
-    handleDividerChange() {
-        this.applyDividers();
+    updateSelectionCount() {
+        this.selectedRowsCount = this.selection.getSelectedRows().length;
     }
     /**
-     * Atualiza os tokens de alinhamento quando alterados.
+     * Sincroniza células, checkboxes e estado da seleção.
      */
-    handleAlignmentChange() {
-        this.updateAllCellAlignments();
+    syncSelectionStructure() {
+        this.selection.sync(this.hasRowSelection);
+        this.updateSelectionCount();
     }
     /**
-     * Atualiza os tokens de overflow quando a propriedade é alterada.
+     * Sincroniza células, ações e estado da expansão.
      */
-    handleOverflowChange() {
-        this.updateAllCellOverflow();
-    }
-    handleTooltipPropsChange() {
-        this.validateTooltipProps();
+    syncExpansionStructure() {
+        this.expansion.sync(this.hasRowExpansion);
     }
-    validateTooltipProps() {
+    /** Aplica às linhas a marca consumida pelo estilo de hover das células. */
+    syncRowHoverState() {
+        this.dataStore.getRows().forEach((row) => {
+            row.toggleAttribute('data-row-hover-enabled', this.hasRowHover);
+        });
     }
     /**
-     * Ciclo de vida do componente que é chamado após o componente ser carregado no DOM.
-     * Inicializa os tokens visuais após a montagem do componente.
+     * Retorna somente as linhas pertencentes ao corpo da tabela.
      */
-    componentDidLoad() {
-        this.refreshStructure();
-        this.applyDensity();
-        this.applyDividers();
-        this.validateTooltipProps();
-        // garante cálculo inicial após filhos renderizarem
-        queueMicrotask(() => {
-            this.updateColumnWidths();
+    getBodyRows() {
+        return this.dataStore.getRows();
+    }
+    /** Atualiza somente os elementos atualmente materializados pela lista virtual. */
+    syncRenderedRange() {
+        this.runWithoutSelfMutations(() => {
+            this.annotateBoundaries();
             this.updateAllCellAlignments();
             this.updateAllCellOverflow();
+            this.updateActionDensities();
             this.applyAriaMetadata();
         });
+        this.updateScrollableContentState();
     }
-    connectedCallback() {
-        this.el.addEventListener('brColumnWidthChange', this.handleColumnWidthEvent);
-        this.el.addEventListener('brAlignmentChange', this.handleAlignmentEvent);
-        this.el.addEventListener('brOverflowChange', this.handleOverflowEvent);
+    updateActionDensities() {
+        const densities = this.getAllCells().map((cell) => ({
+            cell,
+            density: table_utils.resolveTableDensityFromElement(cell),
+        }));
+        densities.forEach(({ cell, density }) => {
+            if (cell.getAttribute('action-density') !== density)
+                cell.setAttribute('action-density', density);
+            cell.querySelectorAll('br-table-action').forEach((action) => {
+                if (action.getAttribute('density') !== density)
+                    action.setAttribute('density', density);
+            });
+        });
     }
-    disconnectedCallback() {
-        this.el.removeEventListener('brColumnWidthChange', this.handleColumnWidthEvent);
-        this.el.removeEventListener('brAlignmentChange', this.handleAlignmentEvent);
-        this.el.removeEventListener('brOverflowChange', this.handleOverflowEvent);
-        if (this.structureRefreshFrame !== null) {
-            cancelAnimationFrame(this.structureRefreshFrame);
-            this.structureRefreshFrame = null;
+    updateScrollableContentState() {
+        const viewport = this.el.shadowRoot?.querySelector('.br-table-scroll');
+        const nextHasScrollableContent = viewport !== null &&
+            viewport !== undefined &&
+            (viewport.scrollHeight > viewport.clientHeight + 1 || viewport.scrollWidth > viewport.clientWidth + 1);
+        if (this.hasScrollableContent !== nextHasScrollableContent) {
+            this.hasScrollableContent = nextHasScrollableContent;
         }
     }
-    /** Inicia o estado de carregamento da tabela. */
-    async startLoading() {
-        this.loading = true;
+    /**
+     * Mede cabeçalho e uma linha colapsada já renderizada para garantir que
+     * `visibleRows` corresponda à quantidade real de linhas visíveis.
+     * A estimativa baseada em densidade continua sendo usada somente antes da
+     * primeira materialização.
+     */
+    /**
+     * Invalida as métricas que definem a altura externa da viewport.
+     *
+     * @remarks A altura não deve ser recalculada durante o scroll, porque
+     * diferentes janelas podem conter linhas com alturas distintas. Recalcular
+     * nesse momento faria o próprio `br-table` crescer ou encolher e deslocaria
+     * elementos externos à tabela.
+     */
+    invalidateViewportMetrics() {
+        this.measuredCollapsedRowHeight = null;
     }
-    /** Interrompe o estado de carregamento da tabela. */
-    async stopLoading() {
-        this.loading = false;
+    scheduleViewportHeightMeasurement() {
+        if (this.measuredCollapsedRowHeight !== null && this.measuredHeaderHeight !== null)
+            return;
+        if (this.viewportMeasureFrame !== null)
+            return;
+        this.viewportMeasureFrame = requestAnimationFrame(() => {
+            this.viewportMeasureFrame = null;
+            for (const entry of this.headerHeights.values())
+                entry.refresh();
+            this.updateHeaderHeight();
+            this.applyMeasuredViewportHeight();
+        });
+    }
+    applyMeasuredViewportHeight() {
+        const viewport = this.el.shadowRoot?.querySelector('.br-table-scroll');
+        if (viewport === null || viewport === undefined)
+            return;
+        const referenceRow = this.dataStore.getRenderedRows().find((row) => !row.hasAttribute('expanded'));
+        const measuredRowHeight = referenceRow === undefined
+            ? 0
+            : Math.max(0, ...Array.from(referenceRow.querySelectorAll('br-table-cell'))
+                .filter((cell) => Number(cell.getAttribute('aria-rowspan') ?? 1) <= 1)
+                .map((cell) => cell.shadowRoot?.querySelector('.br-table-cell')?.getBoundingClientRect().height ?? 0));
+        const rowHeight = measuredRowHeight > 0 ? measuredRowHeight : this.resolveVirtualRowHeight();
+        const rowHeightChanged = this.measuredCollapsedRowHeight !== rowHeight;
+        if (rowHeightChanged)
+            this.measuredCollapsedRowHeight = rowHeight;
+        // O JSX usa os valores medidos por meio de resolveScrollViewportHeight().
+        // Mantê-los em @State evita que uma renderização posterior restaure a
+        // estimativa baseada apenas na densidade.
     }
     /**
-     * Marca a última linha e a última coluna para permitir estilização condicional.
+     * Marca limites de linha e coluna usados pelos estilos de divisores.
      */
-    refreshStructure() {
-        this.headers = Array.from(this.el.querySelectorAll('br-table-header-cell')).filter((element) => ownership.findComposedOwner(element, 'br-table') === this.el);
-        this.rows = Array.from(this.el.querySelectorAll('br-table-row')).filter((element) => ownership.findComposedOwner(element, 'br-table') === this.el);
-        this.cells = [
-            ...this.headers,
-            ...Array.from(this.el.querySelectorAll('br-table-cell')).filter((element) => ownership.findComposedOwner(element, 'br-table') === this.el),
+    /** Matriz lógica inclui células mescladas nas posições ocupadas. */
+    getKeyboardRows() {
+        const headerRows = Array.from(this.el.querySelectorAll('br-table-header > br-table-row'));
+        const matrices = [
+            table_utils.getTablePlacements(headerRows, 'br-table-header-cell'),
+            ...table_utils.getTableRowGroups(this.getVirtualRows()).map((group) => table_utils.getTablePlacements(group, 'br-table-cell')),
         ];
-        this.rowCells.clear();
-        this.columnIndexes.clear();
-        const columnCount = this.headers.length;
-        this.headers.forEach((column, columnIndex) => {
+        return matrices.flatMap((placements) => {
+            const matrix = [];
+            for (const { cell, row, column, rowSpan, colSpan } of placements) {
+                for (let y = row; y < row + rowSpan; y++) {
+                    matrix[y] ?? (matrix[y] = []);
+                    for (let x = column; x < column + colSpan; x++)
+                        matrix[y][x] = cell;
+                }
+            }
+            return matrix.filter((row) => row.length > 0);
+        });
+    }
+    syncHeaderGrouping() {
+        table_utils.applyTableHeaderLayout(this.el.querySelector('br-table-header'));
+    }
+    annotateBoundaries() {
+        this.syncHeaderGrouping();
+        const columns = this.getHeaderCells();
+        const columnCount = columns.length;
+        const logicalLastRow = this.dataStore.getRowCount() - 1;
+        columns.forEach((column, columnIndex) => {
             if (!(column instanceof HTMLElement))
                 return;
-            const isLastColumn = columnIndex === columnCount - 1;
-            column.toggleAttribute('data-last-column', isLastColumn);
-            this.columnIndexes.set(column, columnIndex);
-        });
-        this.rows.forEach((row, rowIndex) => {
-            const isLastRow = rowIndex === this.rows.length - 1;
-            const rowCells = Array.from(row.querySelectorAll('br-table-cell, br-table-header-cell')).filter((cell) => ownership.findComposedOwner(cell, 'br-table-row') === row);
-            this.rowCells.set(row, rowCells);
-            rowCells.forEach((cell, columnIndex) => {
+            column.toggleAttribute('data-last-column', columnIndex === columnCount - 1);
+        });
+        this.dataStore.getRenderedRows().forEach((row) => {
+            const logicalIndex = Number(row.getAttribute('data-virtual-index'));
+            const isLastRow = logicalIndex === logicalLastRow;
+            const cells = Array.from(row.querySelectorAll('br-table-cell'));
+            cells.forEach((cell, columnIndex) => {
                 if (!(cell instanceof HTMLElement))
                     return;
-                const isLastColumn = columnIndex === columnCount - 1;
                 cell.toggleAttribute('data-last-row', isLastRow);
-                cell.toggleAttribute('data-last-column', isLastColumn);
-                this.columnIndexes.set(cell, columnIndex);
+                cell.toggleAttribute('data-last-column', columnIndex === columnCount - 1);
             });
         });
-        this.structureReady = true;
     }
-    scheduleStructureRefresh() {
-        if (this.structureRefreshFrame !== null)
-            return;
-        this.structureRefreshFrame = requestAnimationFrame(() => {
-            this.structureRefreshFrame = null;
-            this.refreshStructure();
+    /**
+     * Registra a coordenação de mudanças de largura emitidas pelas colunas.
+     */
+    registerColumnWidthListener() {
+        this.el.addEventListener('brColumnWidthChange', () => {
             this.updateColumnWidths();
-            this.updateAllCellAlignments();
-            this.updateAllCellOverflow();
             this.applyAriaMetadata();
         });
     }
     /**
-     * Atualiza a largura das colunas com base nos cabeçalhos.
-     * @returns void
+     * Recalcula e aplica a definição de colunas do grid.
      */
     updateColumnWidths() {
         const headers = this.getHeaderCells();
@@ -338,9 +2505,7 @@ const Table = class {
         this.applyGridTemplate(template);
     }
     /**
-     * Constrói o template de grid para a tabela com base nos cabeçalhos.
-     * @param headers Os elementos de cabeçalho da tabela.
-     * @returns Uma string representando o template de grid CSS.
+     * Constrói o valor de `grid-template-columns` na ordem dos cabeçalhos.
      */
     buildGridTemplate(headers) {
         const tableWidth = this.resolveTableColumnWidth();
@@ -348,52 +2513,45 @@ const Table = class {
         return columnWidths.join(' ');
     }
     /**
-     * Resolve a largura de uma coluna específica com base no cabeçalho e na largura global da tabela.
+     * Resolve a largura padrão declarada na tabela.
      */
     resolveTableColumnWidth() {
-        return this.resolveWidthToken(this.columnWidth, tableConstants.COLUMN_WIDTH_MAP[tableConstants.COLUMN_WIDTH_SEMANTICS.FILL], this.el);
+        return this.resolveWidthToken(this.columnWidth, table_utils.COLUMN_WIDTH_MAP[table_utils.COLUMN_WIDTH_SEMANTICS.FILL]);
     }
     /**
-     * Resolve a largura de uma coluna específica com base no cabeçalho e na largura global da tabela.
-     * @param header O elemento de cabeçalho da coluna.
-     * @param fallback A largura de fallback a ser usada caso o cabeçalho não defina uma largura.
-     * @returns A largura resolvida da coluna.
+     * Resolve a largura de uma coluna com fallback para a tabela.
      */
     resolveColumnWidth(header, fallback) {
         const headerWidth = header.getAttribute('column-width');
-        return this.resolveWidthToken(headerWidth, fallback, header);
+        return this.resolveWidthToken(headerWidth, fallback);
     }
     /**
-     * Aplica o template de grid à tabela definindo a propriedade CSS customizada correspondente.
-     * @param raw O template de grid bruto a ser aplicado.
-     * @param fallback O template de grid de fallback a ser usado caso o valor bruto seja inválido.
-     * @return void
+     * Valida e converte larguras semânticas ou valores CSS aceitos.
      */
-    resolveWidthToken(raw, fallback, host) {
-        if (raw !== undefined && raw !== '') {
-            const isValid = raw in tableConstants.COLUMN_WIDTH_MAP || positivePxValidator(raw) || positiveFrValidator(raw);
-            if (!isValid) {
-                propWarning.reportInvalidPropValue(host, 'columnWidth', raw, 'Use `fill`, `content`, uma largura positiva em `px` ou uma fração positiva em `fr`.', `Aplicando fallback ${fallback}.`);
-            }
-            else {
-                propWarning.clearInvalidPropWarning(host, 'columnWidth');
-            }
-        }
-        return resolveTokenValue(raw ?? undefined, {
+    resolveWidthToken(raw, fallback) {
+        return table_utils.resolveTokenValue(raw ?? undefined, {
             fallback,
-            semanticMap: tableConstants.COLUMN_WIDTH_MAP,
-            validators: [positivePxValidator, positiveFrValidator],
+            semanticMap: table_utils.COLUMN_WIDTH_MAP,
+            validators: [table_utils.positivePxValidator, table_utils.positiveFrValidator],
         });
     }
     /**
-     * Aplica o template de grid à tabela definindo a propriedade CSS customizada correspondente.
-     * @param template O template de grid a ser aplicado.
+     * Publica a definição de colunas por meio do token do grid.
      */
     applyGridTemplate(template) {
-        this.el.style.setProperty(TABLE_TOKENS.COLUMN_WIDTHS, template);
+        this.el.style.setProperty(table_utils.TABLE_TOKENS.COLUMN_WIDTHS, template);
+    }
+    /**
+     * Registra a coordenação de mudanças de alinhamento emitidas pelos filhos.
+     */
+    registerAlignmentListener() {
+        this.el.addEventListener('brAlignmentChange', () => {
+            this.updateAllCellAlignments();
+            this.applyAriaMetadata();
+        });
     }
     /**
-     * Atualiza o alinhamento de todas as células da tabela com base nos tokens de alinhamento.
+     * Recalcula os alinhamentos efetivos de todas as células.
      */
     updateAllCellAlignments() {
         const cells = this.getAllCells();
@@ -402,76 +2560,61 @@ const Table = class {
         });
     }
     /**
-     * Atualiza o alinhamento de uma célula específica com base nos tokens de alinhamento.
-     * @param cell A célula a ser atualizada.
+     * Aplica os alinhamentos efetivos como tokens locais da célula.
      */
     updateAlignmentForCell(cell) {
         const horizontal = this.resolveHorizontalAlignmentForCell(cell);
         const vertical = this.resolveVerticalAlignmentForCell(cell);
-        cell.style.setProperty(TABLE_TOKENS.HORIZONTAL_ALIGNMENT, horizontal);
-        cell.style.setProperty(TABLE_TOKENS.VERTICAL_ALIGNMENT, vertical);
+        cell.style.setProperty(table_utils.TABLE_TOKENS.HORIZONTAL_ALIGNMENT, horizontal);
+        cell.style.setProperty(table_utils.TABLE_TOKENS.VERTICAL_ALIGNMENT, vertical);
     }
     /**
-     * Resolve o alinhamento horizontal de uma célula específica com base nos tokens de alinhamento.
-     * @param cell A célula a ser avaliada.
-     * @returns O valor do token de alinhamento horizontal resolvido.
+     * Resolve o alinhamento horizontal conforme a hierarquia da tabela.
      */
     resolveHorizontalAlignmentForCell(cell) {
-        // Cell
         const cellValue = cell.getAttribute('horizontal-alignment');
         if (cellValue !== null)
             return this.resolveAlignmentToken(cellValue);
-        // Row
-        const row = ownership.findComposedOwner(cell, 'br-table-row');
+        const row = cell.closest('br-table-row');
         const rowValue = row?.getAttribute('horizontal-alignment');
         if (rowValue !== null)
             return this.resolveAlignmentToken(rowValue);
-        // Column (header)
         const columnValue = this.getColumnAlignment(cell, 'horizontal-alignment');
         if (columnValue !== null)
             return this.resolveAlignmentToken(columnValue);
-        // Table
-        if (this.effectiveHorizontalAlignment !== undefined)
-            return this.resolveAlignmentToken(this.effectiveHorizontalAlignment);
-        // Fallback
-        return tableConstants.TABLE_ALIGNMENT_MAP[tableConstants.TABLE_ALIGNMENT.START];
+        if (this.horizontalAlignment !== undefined)
+            return this.resolveAlignmentToken(this.horizontalAlignment);
+        return table_utils.TABLE_ALIGNMENT_MAP[table_utils.TABLE_ALIGNMENT.START];
     }
     /**
-     * Resolve o alinhamento vertical de uma célula específica com base nos tokens de alinhamento.
-     * @param cell A célula a ser avaliada.
-     * @returns O valor do token de alinhamento vertical resolvido.
+     * Resolve o alinhamento vertical conforme a hierarquia da tabela.
      */
     resolveVerticalAlignmentForCell(cell) {
         const cellValue = cell.getAttribute('vertical-alignment');
         if (cellValue !== null)
             return this.resolveAlignmentToken(cellValue);
-        const row = ownership.findComposedOwner(cell, 'br-table-row');
+        const row = cell.closest('br-table-row');
         const rowValue = row?.getAttribute('vertical-alignment');
         if (rowValue !== null)
             return this.resolveAlignmentToken(rowValue);
         const columnValue = this.getColumnAlignment(cell, 'vertical-alignment');
         if (columnValue !== null)
             return this.resolveAlignmentToken(columnValue);
-        if (this.effectiveVerticalAlignment !== undefined)
-            return this.resolveAlignmentToken(this.effectiveVerticalAlignment);
-        return tableConstants.TABLE_ALIGNMENT_MAP[tableConstants.TABLE_ALIGNMENT.START];
+        if (this.verticalAlignment !== undefined)
+            return this.resolveAlignmentToken(this.verticalAlignment);
+        return table_utils.TABLE_ALIGNMENT_MAP[table_utils.TABLE_ALIGNMENT.START];
     }
     /**
-     * Resolve um valor de token de alinhamento com base no valor bruto e no mapeamento semântico definido.
-     * @param value O valor bruto do token de alinhamento a ser resolvido.
-     * @returns O valor do token de alinhamento resolvido, ou o valor de fallback se o valor bruto for inválido.
+     * Converte um alinhamento semântico no valor CSS correspondente.
      */
     resolveAlignmentToken(value) {
-        return resolveTokenValue(value ?? undefined, {
-            fallback: tableConstants.TABLE_ALIGNMENT_MAP[tableConstants.TABLE_ALIGNMENT.START],
-            semanticMap: tableConstants.TABLE_ALIGNMENT_MAP,
+        return table_utils.resolveTokenValue(value ?? undefined, {
+            fallback: table_utils.TABLE_ALIGNMENT_MAP[table_utils.TABLE_ALIGNMENT.START],
+            semanticMap: table_utils.TABLE_ALIGNMENT_MAP,
         });
     }
     /**
-     * Retorna o valor do atributo de alinhamento de uma coluna específica.
-     * @param cell A célula para a qual o alinhamento da coluna deve ser obtido.
-     * @param attribute O atributo de alinhamento a ser obtido ('horizontal-alignment' ou 'vertical-alignment').
-     * @returns O valor do atributo de alinhamento da coluna, ou null se não estiver definido.
+     * Obtém um atributo herdável no cabeçalho da coluna correspondente.
      */
     getColumnAlignment(cell, attribute) {
         const columnIndex = this.getColumnIndex(cell);
@@ -482,145 +2625,130 @@ const Table = class {
         return header?.getAttribute(attribute) ?? null;
     }
     /**
-     * Obtém o índice da coluna para uma célula específica, permitindo a associação entre células e seus respectivos cabeçalhos para herança de propriedades como alinhamento e largura.
-     * @param cell A célula para a qual o índice da coluna deve ser obtido.
-     * @returns O índice da coluna correspondente à célula, ou -1 se a célula não estiver dentro de uma linha válida.
+     * Retorna a posição de uma célula dentro de sua linha.
      */
     getColumnIndex(cell) {
-        return this.columnIndexes.get(cell) ?? -1;
+        const row = cell.closest('br-table-row');
+        if (row === null)
+            return -1;
+        const group = row.parentElement?.hasAttribute('data-table-row-group')
+            ? Array.from(row.parentElement.querySelectorAll(':scope > br-table-row'))
+            : [row];
+        return table_utils.getTablePlacements(group, 'br-table-cell').find((entry) => entry.cell === cell)?.column ?? -1;
     }
     /**
-     * Constrói o template de grid para a tabela com base nos cabeçalhos.
-     * @return Array de larguras de coluna resolvidas.
+     * Retorna os cabeçalhos na ordem visual do grid.
      */
     getHeaderCells() {
-        return this.headers;
+        return table_utils.getTableLeafHeaders(Array.from(this.el.querySelectorAll('br-table-header > br-table-row')));
     }
     /**
-     * Obtém todas as células (tanto de corpo quanto de cabeçalho) da tabela, permitindo a aplicação de estilos e tokens de forma abrangente.
-     * @returns Um array contendo todas as células da tabela.
+     * Retorna células de cabeçalho e de dados.
      */
     getAllCells() {
-        return this.cells;
+        return Array.from(this.el.querySelectorAll('br-table-cell, br-table-header-cell'));
+    }
+    /**
+     * Registra a coordenação de mudanças de overflow emitidas pelos filhos.
+     */
+    registerOverflowListener() {
+        this.el.addEventListener('brOverflowChange', () => {
+            this.updateAllCellOverflow();
+            this.applyAriaMetadata();
+        });
     }
     /**
-     * Aplica metadados ARIA para melhorar a navegação por leitores de tela.
+     * Aplica contagens e índices ARIA à estrutura atual.
      */
     applyAriaMetadata() {
-        const rows = this.rows;
-        const headers = this.getHeaderCells();
-        this.el.setAttribute('aria-colcount', String(headers.length));
-        this.el.setAttribute('aria-rowcount', String(rows.length));
-        rows.forEach((row, rowIndex) => {
-            row.setAttribute('aria-rowindex', String(rowIndex + 1));
-        });
-        headers.forEach((header, headerIndex) => {
-            const colIndex = String(headerIndex + 1);
-            const headerId = header.id || `${this.generatedHeaderPrefix}-${headerIndex + 1}`;
-            header.id = headerId;
-            header.setAttribute('aria-colindex', colIndex);
-        });
-        const bodyCells = this.cells.filter((cell) => cell.tagName === 'BR-TABLE-CELL');
-        bodyCells.forEach((cell) => {
-            const columnIndex = this.getColumnIndex(cell);
-            if (columnIndex === -1)
-                return;
-            const colIndex = String(columnIndex + 1);
-            const header = headers[columnIndex];
-            cell.setAttribute('aria-colindex', colIndex);
-            if (header !== undefined && header.id !== '') {
-                cell.setAttribute('aria-labelledby', header.id);
-            }
+        this.syncHeaderGrouping();
+        const headerRows = Array.from(this.el.querySelectorAll('br-table-header > br-table-row'));
+        const bodyRows = this.dataStore.getRenderedRows();
+        const tableGrid = this.el.shadowRoot?.querySelector('.br-table-content');
+        const grouped = this.dataStore.getItemCount() !== this.dataStore.getRowCount();
+        const remote = this.hasPagination && this.dataStore.getItemCount() < this.resolvePaginationTotalItems();
+        const logicalRowCount = remote ? this.resolvePaginationTotalItems() : this.dataStore.getRowCount();
+        tableGrid?.setAttribute('aria-colcount', String(this.getHeaderCells().length));
+        tableGrid?.setAttribute('aria-rowcount', grouped && remote ? '-1' : String(logicalRowCount + headerRows.length));
+        headerRows.forEach((row, index) => {
+            row.setAttribute('aria-rowindex', String(index + 1));
+        });
+        const headerPlacements = table_utils.getTablePlacements(headerRows, 'br-table-header-cell');
+        headerPlacements.forEach(({ cell, column }, index) => {
+            cell.id || (cell.id = `${this.generatedHeaderPrefix}-${index + 1}`);
+            cell.setAttribute('aria-colindex', String(column + 1));
         });
+        bodyRows.forEach((row) => {
+            const offset = remote && !grouped ? (this.resolveCurrentPage() - 1) * this.resolvePageSize() : 0;
+            const logicalIndex = Number(row.getAttribute('data-virtual-index'));
+            if (grouped && remote)
+                row.removeAttribute('aria-rowindex');
+            else
+                row.setAttribute('aria-rowindex', String(logicalIndex + offset + headerRows.length + 1));
+        });
+        for (const group of table_utils.getTableRowGroups(bodyRows)) {
+            for (const { cell, column, rowSpan, colSpan } of table_utils.getTablePlacements(group, 'br-table-cell')) {
+                cell.setAttribute('aria-colindex', String(column + 1));
+                if (rowSpan > 1)
+                    cell.setAttribute('aria-rowspan', String(rowSpan));
+                else
+                    cell.removeAttribute('aria-rowspan');
+                if (colSpan > 1)
+                    cell.setAttribute('aria-colspan', String(colSpan));
+                else
+                    cell.removeAttribute('aria-colspan');
+            }
+        }
+        this.keyboard?.sync();
     }
     /**
-     * Atualiza os tokens de overflow para todas as células da tabela, garantindo que as mudanças na propriedade de overflow sejam refletidas dinamicamente em todas as células, controlando o comportamento de overflow, text-overflow e white-space conforme definido no token.
+     * Recalcula o overflow efetivo de todas as células.
      */
     updateAllCellOverflow() {
         this.getAllCells().forEach((cell) => {
             this.updateOverflowForCell(cell);
         });
     }
-    updateAlignmentForTarget(target) {
-        if (target === null || !this.el.contains(target))
-            return;
-        if (target.tagName === 'BR-TABLE-CELL' || target.tagName === 'BR-TABLE-HEADER-CELL') {
-            this.updateAlignmentForCell(target);
-            return;
-        }
-        if (target.tagName === 'BR-TABLE-ROW') {
-            this.rowCells.get(target)?.forEach((cell) => {
-                this.updateAlignmentForCell(cell);
-            });
-            return;
-        }
-        this.updateAllCellAlignments();
-    }
-    updateOverflowForTarget(target) {
-        if (target === null || !this.el.contains(target))
-            return;
-        if (target.tagName === 'BR-TABLE-CELL' || target.tagName === 'BR-TABLE-HEADER-CELL') {
-            this.updateOverflowForCell(target);
-            return;
-        }
-        if (target.tagName === 'BR-TABLE-ROW') {
-            this.rowCells.get(target)?.forEach((cell) => {
-                this.updateOverflowForCell(cell);
-            });
-            return;
-        }
-        this.updateAllCellOverflow();
-    }
     /**
-     * Atualiza os tokens de overflow para uma célula específica, controlando o comportamento de overflow, text-overflow e white-space com base na resolução do token de overflow para a célula, que considera atributos específicos da célula, da linha, da coluna e da tabela para determinar o comportamento final de overflow a ser aplicado.
-     * @param cell A célula para a qual os tokens de overflow devem ser atualizados.
+     * Aplica a configuração efetiva de overflow como tokens locais.
      */
     updateOverflowForCell(cell) {
         const mode = this.resolveOverflowForCell(cell);
-        const config = tableConstants.TABLE_OVERFLOW_MAP[mode];
-        cell.style.setProperty(TABLE_TOKENS.CELL_OVERFLOW, config.overflow);
-        cell.style.setProperty(TABLE_TOKENS.CELL_TEXT_OVERFLOW, config.textOverflow);
-        cell.style.setProperty(TABLE_TOKENS.CELL_WHITE_SPACE, config.whiteSpace);
-        // O atributo 'applied-overflow' deve sempre aparecer
+        const config = table_utils.TABLE_OVERFLOW_MAP[mode];
+        cell.style.setProperty(table_utils.TABLE_TOKENS.CELL_OVERFLOW, config.overflow);
+        cell.style.setProperty(table_utils.TABLE_TOKENS.CELL_TEXT_OVERFLOW, config.textOverflow);
+        cell.style.setProperty(table_utils.TABLE_TOKENS.CELL_WHITE_SPACE, config.whiteSpace);
         cell.setAttribute('data-applied-overflow', mode);
     }
     /**
-     * Resolve o token de overflow para uma célula específica, considerando a hierarquia de atributos (célula, linha, coluna, tabela) para determinar o comportamento de overflow final a ser aplicado à célula.
-     * @param cell A célula para a qual o token de overflow deve ser resolvido.
-     * @returns O valor do token de overflow resolvido para a célula, determinando o comportamento de overflow a ser aplicado.
+     * Resolve o overflow conforme célula, linha, coluna e tabela.
      */
     resolveOverflowForCell(cell) {
-        // Resolução hierárquica: célula > linha > coluna > tabela > fallback
         let value = cell.getAttribute('overflow');
         if (value === null) {
-            const row = ownership.findComposedOwner(cell, 'br-table-row');
+            const row = cell.closest('br-table-row');
             value = row?.getAttribute('overflow') ?? null;
         }
         if (value === null) {
             value = this.getColumnAttribute(cell, 'overflow') ?? null;
         }
         if (value === null) {
-            value = this.effectiveOverflow;
+            value = this.overflow ?? null;
         }
         if (value === null) {
-            value = tableConstants.TABLE_OVERFLOW.WRAP;
+            value = table_utils.TABLE_OVERFLOW.WRAP;
         }
-        return value === tableConstants.TABLE_OVERFLOW.TRUNCATE ? tableConstants.TABLE_OVERFLOW.TRUNCATE : tableConstants.TABLE_OVERFLOW.WRAP;
+        return value === table_utils.TABLE_OVERFLOW.TRUNCATE ? table_utils.TABLE_OVERFLOW.TRUNCATE : table_utils.TABLE_OVERFLOW.WRAP;
     }
     /**
-     * Obtém o valor de um atributo específico de uma coluna para uma célula, permitindo a herança de propriedades da coluna para as células associadas com base no cabeçalho correspondente.
-     * @param cell A célula para a qual o atributo da coluna deve ser obtido.
-     * @param attribute O atributo específico a ser obtido da coluna (por exemplo, 'horizontal-alignment' ou 'vertical-alignment').
-     * @returns O valor do atributo da coluna correspondente à célula, ou null se não estiver definido.
+     * Obtém um atributo no cabeçalho correspondente à célula.
      */
     getColumnAttribute(cell, attribute) {
         const header = this.getHeaderForCell(cell);
         return header?.getAttribute(attribute) ?? null;
     }
     /**
-     * Obtém o elemento de cabeçalho correspondente a uma célula específica, permitindo a associação entre células e seus respectivos cabeçalhos para herança de propriedades como alinhamento e largura.
-     * @param cell A célula para a qual o cabeçalho correspondente deve ser obtido.
-     * @returns O elemento de cabeçalho correspondente à célula, ou null se não for encontrado.
+     * Localiza o cabeçalho que ocupa a mesma coluna da célula.
      */
     getHeaderForCell(cell) {
         const index = this.getColumnIndex(cell);
@@ -629,57 +2757,88 @@ const Table = class {
         const headers = this.getHeaderCells();
         return headers[index] ?? null;
     }
+    /** Publica a altura padrão da área expandida para herança pelas linhas. */
+    applyExpandedContentHeight() {
+        const value = Number.isFinite(this.virtualExpandedContentHeight)
+            ? Math.max(1, this.virtualExpandedContentHeight)
+            : 240;
+        this.el.style.setProperty(table_utils.TABLE_TOKENS.EXPANDED_CONTENT_HEIGHT, `${value}px`);
+    }
     /**
-     * Resolve e aplica o token de densidade.
+     * Converte a densidade semântica em tokens de espaçamento.
      */
     applyDensity() {
-        const density = props.resolveDensity(this.el, this.density, { allowUndefined: true });
-        const resolved = resolveTokenValue(density ?? undefined, {
-            fallback: tableConstants.TABLE_DENSITY_MAP[tableConstants.TABLE_DENSITY.MEDIUM],
-            semanticMap: tableConstants.TABLE_DENSITY_MAP,
+        const resolved = table_utils.resolveTokenValue(this.density, {
+            fallback: table_utils.TABLE_DENSITY_MAP[table_utils.TABLE_DENSITY.MEDIUM],
+            semanticMap: table_utils.TABLE_DENSITY_MAP,
         });
-        this.el.style.setProperty(TABLE_TOKENS.DENSITY, resolved);
+        const resolvedToolbarPadding = table_utils.resolveTokenValue(this.density, {
+            fallback: table_utils.TABLE_BAR_PADDING_MAP[table_utils.TABLE_DENSITY.MEDIUM],
+            semanticMap: table_utils.TABLE_BAR_PADDING_MAP,
+        });
+        this.el.style.setProperty(table_utils.TABLE_TOKENS.DENSITY, resolved);
+        this.el.style.setProperty(table_utils.TABLE_TOKENS.BAR_PADDING, resolvedToolbarPadding);
     }
     /**
-     * Resolve e aplica os tokens relacionados aos divisores
-     * (estilo e fatores de linha/coluna).
+     * Aplica estilo e fatores de visibilidade dos divisores.
      */
     applyDividers() {
-        const style = resolveTokenValue(this.effectiveDividerStyle, {
-            fallback: tableConstants.TABLE_DIVIDER_STYLE_MAP[tableConstants.TABLE_DIVIDER_STYLE.SOLID],
-            semanticMap: tableConstants.TABLE_DIVIDER_STYLE_MAP,
+        const style = table_utils.resolveTokenValue(this.dividerStyle, {
+            fallback: table_utils.TABLE_DIVIDER_STYLE_MAP[table_utils.TABLE_DIVIDER_STYLE.SOLID],
+            semanticMap: table_utils.TABLE_DIVIDER_STYLE_MAP,
         });
         const rowFactor = (this.rowDivider ?? this.hasRowDivider) ? '1' : '0';
         const columnFactor = (this.columnDivider ?? this.hasColumnDivider) ? '1' : '0';
-        this.el.style.setProperty(TABLE_TOKENS.DIVIDER_STYLE, style);
-        this.el.style.setProperty(TABLE_TOKENS.ROW_DIVIDER_FACTOR, rowFactor);
-        this.el.style.setProperty(TABLE_TOKENS.COLUMN_DIVIDER_FACTOR, columnFactor);
+        this.el.style.setProperty(table_utils.TABLE_TOKENS.DIVIDER_STYLE, style);
+        this.el.style.setProperty(table_utils.TABLE_TOKENS.ROW_DIVIDER_FACTOR, rowFactor);
+        this.el.style.setProperty(table_utils.TABLE_TOKENS.COLUMN_DIVIDER_FACTOR, columnFactor);
     }
     /**
-     * Retorna o mapa de classes base do componente.
+     * Renderiza barras, slots e o grid principal.
      *
-     * @returns Um objeto representando as classes CSS a serem aplicadas ao elemento da tabela.
+     * @remarks `role="grid"` fica isolado no contêiner que só possui os dois
+     * elementos `role="rowgroup"` como filhos; a barra de ações e o rodapé
+     * ficam fora dessa árvore para não serem contados como filhos inválidos do
+     * papel `grid`. O nome acessível vai como `aria-label` (string), pois um
+     * `aria-labelledby` não resolveria um id do light DOM a partir da shadow tree.
      */
-    getTableCssClassMap() {
-        return {
-            'br-table': true,
-        };
+    renderContent(accessibleName) {
+        return (index.h(index.Fragment, null, index.h("br-table-bar", { "prop:density": this.density ?? table_utils.TABLE_DENSITY.MEDIUM, "prop:heading": this.heading ?? '', "prop:headingActionsLimit": this.headingActionsLimit, "prop:contextualActionsLimit": this.contextualActionsLimit, "prop:hasGlobalActionsContent": this.hasGlobalActionsContent, "prop:hasContextualActionsContent": this.hasContextualActionsContent, "prop:selectedRowsCount": this.selectedRowsCount, "prop:showContextualBar": this.showContextualBar || this.selectedRowsCount > 0, "prop:hasSearch": this.hasSearch, "attr:data-br-table-heading-actions-tooltip-label": this.moreActionsHeadingLabel, "attr:data-br-table-contextual-actions-tooltip-label": this.moreActionsContextualLabel, style: {
+                [table_utils.TABLE_TOKENS.DENSITY]: table_utils.resolveTokenValue(this.density, {
+                    fallback: table_utils.TABLE_DENSITY_MAP[table_utils.TABLE_DENSITY.MEDIUM],
+                    semanticMap: table_utils.TABLE_DENSITY_MAP,
+                }),
+            } }, index.h("slot", { name: "global-actions", slot: "global-actions" }), index.h("slot", { name: "contextual-actions", slot: "contextual-actions" })), index.h("div", { class: { 'br-table-scroll-shell': true, loading: this.loading }, style: {
+                height: this.resolveScrollViewportHeight(),
+                '--table-scroll-header-height': `${this.measuredHeaderHeight ?? 0}px`,
+            } }, index.h("div", { class: "br-table-scroll", part: "scroll-container", style: { height: this.resolveScrollViewportHeight() }, onScroll: this.handleViewportScroll }, index.h("div", { class: { 'br-table-content': true, loading: this.loading }, role: "grid", "aria-label": accessibleName, "aria-multiselectable": this.hasRowSelection ? 'true' : null, "aria-busy": this.loading ? 'true' : null, "aria-hidden": this.loading && this.dataStore.getRowCount() === 0 && this.dataStore.getColumns().length === 0
+                ? 'true'
+                : null, part: "content" }, index.h("slot", { name: "header", onSlotchange: this.handleStructureChange }), index.h("slot", { name: "body", onSlotchange: this.handleStructureChange }))))));
     }
-    /**
-     * Renderiza a estrutura interna da tabela (header e body).
-     *
-     * @returns JSX.Element representando o conteúdo da tabela, incluindo os slots para header e body.
-     */
-    renderContent() {
-        return (index.h("div", { class: { 'br-table-content': true, loading: this.loading }, part: "content" }, index.h("slot", { name: "header", onSlotchange: this.handleStructureChange }), index.h("slot", { name: "body", onSlotchange: this.handleStructureChange })));
+    /** Resolve o nome acessível do papel `grid`, sempre como texto plano. */
+    resolveAccessibleGridName() {
+        const explicitLabelledby = this.el.getAttribute('aria-labelledby')?.trim();
+        const root = this.el.getRootNode();
+        if (explicitLabelledby && (root instanceof Document || root instanceof ShadowRoot)) {
+            const referencedText = explicitLabelledby
+                .split(/\s+/)
+                .map((id) => root.getElementById(id)?.textContent?.trim())
+                .filter(Boolean)
+                .join(' ')
+                .replace(/\s+/g, ' ');
+            if (referencedText.length > 0)
+                return referencedText;
+        }
+        const explicitLabel = this.el.getAttribute('aria-label')?.trim();
+        if (explicitLabel)
+            return explicitLabel;
+        return this.heading?.trim() || 'Tabela';
     }
     /**
-     * Renderiza o host do componente.
-     *
-     * @returns JSX.Element representando o elemento host do componente, contendo a estrutura da tabela.
+     * Renderiza o componente com semântica ARIA de grid.
      */
     render() {
-        return (index.h(index.Host, { key: '98c729fdca76ed9a92354b8caf2c46030ea0f1e4', role: "table", "aria-busy": this.loading ? 'true' : null }, index.h("div", { key: 'b64e8d0e0ce41e2983b7a55fe9c5764df107db2b', class: this.getTableCssClassMap(), part: "container" }, this.renderContent(), this.loading ? (index.h("div", { part: "loading", role: "status", "aria-live": "polite" }, index.h("slot", { name: "loading" }, index.h("br-loading", { size: "small", label: "Carregando dados" })))) : null)));
+        return (index.h(index.Host, { key: 'a8583b9c76f2d800732bae952ec638fb9960ee81', "aria-busy": this.loading ? 'true' : null }, index.h("div", { key: '22bce3d4db20241d4fb03e792e0b3c5ee2dabcaf', class: "br-table", part: "container" }, this.renderContent(this.resolveAccessibleGridName())), this.hasPagination && (index.h("br-table-footer", { key: '4bf01e2f882971c10159c5f2a9d7ce78fcd1db9a', part: "footer", "prop:currentPage": this.currentPage, "prop:pageSize": this.resolvePageSize(), pageSizeOptions: this.pageSizeOptions, "prop:totalItems": this.resolvePaginationTotalItems(), "prop:density": this.density ?? 'medium', "attr:has-scroll": this.hasScrollableContent ? '' : null, onBrInternalTableFooterPageChange: this.handleFooterPageChange, onBrInternalTableFooterPerPageChange: this.handleFooterPerPageChange })), this.loading ? (index.h("div", { part: "loading", role: "status", "aria-live": "polite" }, index.h("div", { class: "br-table-loading-panel", role: "region", "aria-label": "Carregamento da tabela", tabIndex: 0 }, index.h("slot", { name: "loading" }, index.h("br-loading", { density: "medium", label: "Carregando dados", labelPosition: "bottom" }))))) : null));
     }
     get el() { return index.getElement(this); }
     static get watchers() { return {
@@ -689,6 +2848,18 @@ const Table = class {
         "density": [{
                 "handleDensityChange": 0
             }],
+        "visibleRows": [{
+                "handleVisibleRowsChange": 0
+            }],
+        "hasPagination": [{
+                "handleHasPaginationChange": 0
+            }],
+        "currentPage": [{
+                "handleCurrentPageChange": 0
+            }],
+        "pageSize": [{
+                "handlePageSizeChange": 0
+            }],
         "hasColumnDivider": [{
                 "handleDividerChange": 0
             }],
@@ -713,11 +2884,23 @@ const Table = class {
         "overflow": [{
                 "handleOverflowChange": 0
             }],
-        "tooltipState": [{
-                "handleTooltipPropsChange": 0
+        "virtualExpandedContentHeight": [{
+                "handleVirtualExpandedContentHeightChange": 0
+            }],
+        "hasRowSelection": [{
+                "handleRowSelectionChange": 0
+            }],
+        "hasRowHover": [{
+                "handleRowHoverChange": 0
+            }],
+        "hasRowExpansion": [{
+                "handleRowExpansionChange": 0
+            }],
+        "sortMode": [{
+                "handleSortModeChange": 0
             }],
-        "tooltipMode": [{
-                "handleTooltipPropsChange": 0
+        "sortStrategy": [{
+                "handleSortStrategyChange": 0
             }]
     }; }
 };