@tylertech/forge 2.0.0 → 2.1.0

package/dist/esm/chunks/chunk.BOWCSPCH.js

@@ -0,0 +1,2428 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import {
+  createPredicate,
+  findWhere,
+  getPropertyValue,
+  matchesPredicate
+} from "./chunk.RV3E762Y.js";
+import {
+  CHECKBOX_CONSTANTS
+} from "./chunk.KCK3G74Y.js";
+import {
+  EXPANSION_PANEL_CONSTANTS,
+  ExpansionPanelComponent
+} from "./chunk.KRW2IAIU.js";
+import {
+  getEventPath
+} from "./chunk.EY57VTRF.js";
+import {
+  tylIconArrowDownward
+} from "./chunk.GS2AXUCN.js";
+import {
+  TOOLTIP_CONSTANTS
+} from "./chunk.NX5SKZLU.js";
+import {
+  ICON_CONSTANTS,
+  IconComponent,
+  IconRegistry
+} from "./chunk.P43Z3YAS.js";
+import {
+  FormFieldComponentDelegate
+} from "./chunk.HZISALRH.js";
+import {
+  BaseAdapter
+} from "./chunk.KZATVOA6.js";
+import {
+  FoundationProperty
+} from "./chunk.MMIZOYAS.js";
+import {
+  COMPONENT_NAME_PREFIX,
+  CustomElement
+} from "./chunk.35U3UPDV.js";
+import {
+  BaseComponent
+} from "./chunk.VK6LIH3B.js";
+import {
+  defineCustomElement
+} from "./chunk.K2PCTUVN.js";
+import {
+  addClass,
+  removeAllChildren,
+  removeClass,
+  removeElement,
+  replaceElement,
+  safeCssWidth,
+  toggleClass
+} from "./chunk.4JURZYE4.js";
+import {
+  coerceBoolean,
+  coerceNumber,
+  debounce,
+  isDefined,
+  isFunction,
+  isNumber,
+  isObject,
+  isString
+} from "./chunk.MEFT5FQC.js";
+import {
+  __decorateClass,
+  __spreadValues
+} from "./chunk.LM5TVNZY.js";
+
+// node_modules/@tylertech/forge-core/esm/utils/item-manager.js
+var ItemManager = class {
+  constructor(_key) {
+    this._key = _key;
+    this._items = [];
+  }
+  getItems() {
+    return [...this._items];
+  }
+  count() {
+    return this._items.length;
+  }
+  setKey(key) {
+    this._key = key;
+  }
+  add(data) {
+    if (!(data instanceof Array)) {
+      data = [data];
+    }
+    data.forEach((item) => {
+      if (!this.exists(item)) {
+        this._items.push(item);
+      }
+    });
+    return this;
+  }
+  remove(data) {
+    if (!(data instanceof Array)) {
+      data = [data];
+    }
+    for (let i = data.length - 1; i >= 0; i--) {
+      if (this.exists(data[i])) {
+        this._items.splice(this._items.indexOf(this._getItem(data[i])), 1);
+      }
+    }
+    return this;
+  }
+  clear() {
+    this._items = [];
+    return this;
+  }
+  exists(data) {
+    return this._getItem(data) !== null;
+  }
+  _getItem(data) {
+    if (this._key) {
+      return findWhere(this._items, createPredicate(this._key, data)) || null;
+    } else {
+      return this._items.find((item) => item === data) || null;
+    }
+  }
+};
+
+// dist/build/lib/staging/src/table/table-constants.ts
+var elementName = `${COMPONENT_NAME_PREFIX}table`;
+var classes = {
+  TABLE: "forge-table",
+  TABLE_DENSE: "forge-table--dense",
+  TABLE_ROOMY: "forge-table--roomy",
+  TABLE_RESIZABLE: "forge-table--resizable",
+  TABLE_RESIZING: "forge-table--resizing",
+  TABLE_RESIZE_HANDLE: "forge-table__resize-handle",
+  TABLE_NO_WRAP_CONTENT: "forge-table--no-wrap-content",
+  TABLE_LAYOUT_FIXED: "forge-table--layout-fixed",
+  TABLE_FILTER_VISIBLE: "forge-table--filter-visible",
+  TABLE_FIXED: "forge-table--fixed",
+  TABLE_HEAD: "forge-table-head",
+  TABLE_HEAD_ROW: "forge-table-head__row",
+  TABLE_HEAD_ROW_FILTER: "forge-table-head__row__filter",
+  TABLE_HEAD_CELL: "forge-table-head__cell",
+  TABLE_HEAD_CELL_CONTAINER: "forge-table-head__cell-container",
+  TABLE_HEAD_CELL_SORTABLE: "forge-table-head__cell--sortable",
+  TABLE_HEAD_CELL_SORT_ICON: "forge-table-head__cell-sort-icon",
+  TABLE_HEAD_CELL_TEXT: "forge-table-head__cell-text",
+  TABLE_HEAD_CELL_SORT_ICON_ACTIVE: "forge-table-head__cell-sort-icon--active",
+  TABLE_HEAD_CELL_SORTED_ASCENDING: "forge-table-head__cell--sorted-ascending",
+  TABLE_HEAD_CELL_SORTED_DESCENDING: "forge-table-head__cell--sorted-descending",
+  TABLE_HEAD_CELL_SORT_ORDER: "forge-table-head__cell__sort-order",
+  TABLE_HEAD_CELL_SORT_ORDER_HIDDEN: "forge-table-head__cell__sort-order--hidden",
+  TABLE_BODY: "forge-table-body",
+  TABLE_BODY_ROW: "forge-table-body__row",
+  TABLE_BODY_ROW_SELECTED: "forge-table-body__row--selected",
+  TABLE_BODY_ROW_CLICKABLE: "forge-table-body__row--clickable",
+  TABLE_BODY_CELL: "forge-table-body__cell",
+  TABLE_ROW: "forge-table-row",
+  TABLE_ROW_EXPANDED: "forge-table-row--expanded",
+  TABLE_ROW_EXPANDABLE_CONTENT: "forge-table-row__expandable-content",
+  TABLE_ROW_EXPANDABLE_CONTENT_CELL: "forge-table-row__expandable-content-cell",
+  TABLE_CELL: "forge-table-cell",
+  TABLE_CELL_SELECT: "forge-table-cell__select",
+  TABLE_CELL_SELECT_CHECKBOX: "forge-table-cell__select-checkbox",
+  TABLE_CELL_SELECT_CHECKBOX_CONTAINER: "forge-table-cell__select-checkbox-container",
+  TABLE_CELL_SELECT_CHECKBOX_CONTAINER_ALIGN_RIGHT: "forge-table-cell__select-checkbox-container--align-right",
+  TABLE_CELL_SELECT_CHECKBOX_CONTAINER_ALIGN_LEFT: "forge-table-cell__select-checkbox-container--align-left",
+  TABLE_CELL_SELECT_CHECKBOX_CONTAINER_ALIGN_CENTER: "forge-table-cell__select-checkbox-container--align-center",
+  TABLE_CELL_CONTAINER: "forge-table-cell__container",
+  TABLE_CELL_CONTAINER_TEXT: "forge-table-cell__container-text",
+  TABLE_CELL_CENTER: "forge-table-cell--center",
+  TABLE_CELL_RIGHT: "forge-table-cell--right",
+  TABLE_CELL_RESIZABLE: "forge-table-cell--resizing"
+};
+var selectors = {
+  TABLE: ".forge-table",
+  CHECKBOX_INPUT: "forge-checkbox > input[type=checkbox]:not([forge-ignore])",
+  SELECT_ALL_TEMPLATE_CHECKBOX_INPUT: "input[type=checkbox]:not([forge-ignore])",
+  ROW_SELECTED: `.${classes.TABLE_BODY_ROW_SELECTED}`
+};
+var attributes = {
+  SELECT: "select",
+  MULTISELECT: "multiselect",
+  SELECT_KEY: "select-key",
+  DENSE: "dense",
+  ROOMY: "roomy",
+  FILTER: "filter",
+  FIXED_HEADERS: "fixed-headers",
+  LAYOUT_TYPE: "layout-type",
+  WRAP_CONTENT: "wrap-content",
+  RESIZABLE: "resizable",
+  MIN_RESIZE_WIDTH: "min-resize-width",
+  ALLOW_ROW_CLICK: "allow-row-click",
+  MULTI_COLUMN_SORT: "multi-column-sort",
+  SELECT_CHECKBOX_ALIGNMENT: "select-checkbox-alignment",
+  TOOLTIP_SELECT: "tooltip-select",
+  TOOLTIP_SELECT_ALL: "tooltip-select-all",
+  CHECKBOX_TYPE: "forge-checkbox-type",
+  CUSTOM_CELL_TEMPLATE: "data-cell-template",
+  CUSTOM_CELL_TEMPLATE_STOP_PROPAGATION: "data-cell-template-stop-propagation"
+};
+var events = {
+  ROW_CLICK: `${elementName}-row-click`,
+  SELECT: `${elementName}-select`,
+  SELECT_DOUBLE: `${elementName}-select-double`,
+  SELECT_ALL: `${elementName}-select-all`,
+  SORT: `${elementName}-sort`,
+  FILTER: `${elementName}-filter`,
+  INITIALIZED: `${elementName}-initialized`,
+  COLUMN_RESIZE: `${elementName}-column-resize`
+};
+var strings = {
+  SELECT_ALL: "select-all",
+  SELECT_ROW: "select-row",
+  DEFAULT_LAYOUT_TYPE: "auto"
+};
+var icons = {
+  SORT_DOWN: "arrow_downward"
+};
+var numbers = {
+  DEFAULT_FILTER_DEBOUNCE_TIME: 750,
+  MIN_RESIZE_WIDTH: 100,
+  RESIZE_HOVER_DURATION: 150
+};
+var TABLE_CONSTANTS = {
+  elementName,
+  classes,
+  selectors,
+  attributes,
+  events,
+  strings,
+  icons,
+  numbers
+};
+
+// dist/build/lib/staging/src/table/types.ts
+var CellAlign = /* @__PURE__ */ ((CellAlign2) => {
+  CellAlign2["Left"] = "left";
+  CellAlign2["Right"] = "right";
+  CellAlign2["Center"] = "center";
+  return CellAlign2;
+})(CellAlign || {});
+var SortDirection = /* @__PURE__ */ ((SortDirection2) => {
+  SortDirection2["Ascending"] = "ASC";
+  SortDirection2["Descending"] = "DESC";
+  SortDirection2["Unset"] = "UNSET";
+  return SortDirection2;
+})(SortDirection || {});
+var TableFilterType = /* @__PURE__ */ ((TableFilterType2) => {
+  TableFilterType2["InputText"] = "text";
+  TableFilterType2["InputNumber"] = "number";
+  TableFilterType2["Select"] = "select";
+  TableFilterType2["SelectMultiple"] = "select-multiple";
+  TableFilterType2["Date"] = "date";
+  TableFilterType2["DateRange"] = "date-range";
+  return TableFilterType2;
+})(TableFilterType || {});
+
+// dist/build/lib/staging/src/table/table-utils.ts
+function isTemplateResultObject(val) {
+  return val && typeof val === "object" && "content" in val;
+}
+var TableUtils = class {
+  static createTable(configuration) {
+    TableUtils._resetTable(configuration.tableElement);
+    const thead = TableUtils._createTableHead(configuration);
+    const tbody = TableUtils._createTableBody(configuration);
+    if (configuration.clickListener) {
+      TableUtils._attachRowClickListeners(tbody, configuration.clickListener, configuration.doubleClickListener);
+      TableUtils._addRowClickAttributes(tbody);
+    }
+    if (configuration.fixedHeaders) {
+      TableUtils.setFixedHeaders(configuration);
+    }
+    if (configuration.resizable) {
+      TableUtils.setResizable(configuration);
+    }
+    if (configuration.dense) {
+      TableUtils.setDenseState(configuration.tableElement, configuration.dense);
+    }
+    if (configuration.wrapContent) {
+      TableUtils.setWrapContentState(configuration.tableElement, configuration.wrapContent);
+    }
+    if (configuration.selectListener) {
+      TableUtils._addSelectColumn(thead, tbody, configuration.selectListener, configuration.selectAllListener, configuration.selectAllTemplate, configuration.selectCheckboxAlignment, configuration.data, configuration.tooltipSelect, configuration.tooltipSelectAll);
+    }
+    if (configuration.resizable || configuration.columnConfigurations.some((c) => !!c.sortable)) {
+      TableUtils._attachHeadRowMouseDownListener(thead, configuration.headRowMouseDownListener);
+      if (TableUtils._isMac()) {
+        TableUtils._attachHeadRowContextMenuListener(thead, configuration.headRowContextMenuListener);
+      }
+    }
+    TableUtils.setLayoutType(configuration);
+    TableUtils._setTableHead(configuration.tableElement, thead);
+    if (configuration.filter) {
+      TableUtils.setFilterRow(configuration);
+    }
+    TableUtils._setTableBody(configuration.tableElement, tbody);
+  }
+  static _setTableHead(tableElement, thead) {
+    if (tableElement.tHead) {
+      replaceElement(thead, tableElement.tHead);
+    } else {
+      tableElement.appendChild(thead);
+    }
+  }
+  static _setTableBody(tableElement, tbody) {
+    if (tableElement.tBodies.length) {
+      replaceElement(tbody, tableElement.tBodies[0]);
+    } else {
+      tableElement.appendChild(tbody);
+    }
+  }
+  static recreateTableBody(configuration) {
+    const tbody = TableUtils._createTableBody(configuration);
+    if (configuration.clickListener) {
+      TableUtils._attachRowClickListeners(tbody, configuration.clickListener, configuration.doubleClickListener);
+    }
+    if (configuration.selectListener) {
+      TableUtils._createBodySelectColumn(tbody, configuration.selectCheckboxAlignment, configuration.data, configuration.tooltipSelect, configuration.tooltipSelectAll);
+      TableUtils._attachRowSelectListeners(tbody, configuration.selectListener);
+    }
+    TableUtils._setTableBody(configuration.tableElement, tbody);
+  }
+  static _resetTable(tableElement) {
+    removeAllChildren(tableElement);
+  }
+  static _createMultisortTooltip() {
+    const tooltip = document.createElement(TOOLTIP_CONSTANTS.elementName);
+    tooltip.textContent = "Ctrl + click to sort multiple columns";
+    tooltip.position = "bottom";
+    tooltip.delay = 0;
+    return tooltip;
+  }
+  static _createTableHead(tableConfiguration) {
+    const thead = document.createElement("thead");
+    const tr = thead.insertRow();
+    addClass([TABLE_CONSTANTS.classes.TABLE_ROW, TABLE_CONSTANTS.classes.TABLE_HEAD_ROW], tr);
+    let setInitialSort = false;
+    for (let i = 0; i < tableConfiguration.columnConfigurations.length; i++) {
+      const columnConfig = tableConfiguration.columnConfigurations[i];
+      const th = document.createElement("th");
+      th.scope = "col";
+      addClass([TABLE_CONSTANTS.classes.TABLE_CELL, TABLE_CONSTANTS.classes.TABLE_HEAD_CELL], th);
+      const cellContainer = document.createElement("div");
+      cellContainer.classList.add(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_CONTAINER);
+      if (tableConfiguration.multiColumnSort) {
+        const tooltip = TableUtils._createMultisortTooltip();
+        cellContainer.appendChild(tooltip);
+      }
+      if (columnConfig.align) {
+        TableUtils._setCellAlignmentClass(cellContainer, columnConfig.align);
+      }
+      if (isDefined(columnConfig.width)) {
+        const width = safeCssWidth(columnConfig.width);
+        if (width) {
+          th.style.width = width;
+        }
+      }
+      if (tableConfiguration.resizable && columnConfig.resizable !== false) {
+        const resizeHandle = document.createElement("div");
+        resizeHandle.classList.add(TABLE_CONSTANTS.classes.TABLE_RESIZE_HANDLE);
+        th.appendChild(resizeHandle);
+      }
+      if (isDefined(columnConfig.headerCellStyle) && isObject(columnConfig.headerCellStyle)) {
+        Object.assign(th.style, columnConfig.headerCellStyle);
+        Object.assign(cellContainer.style, columnConfig.headerCellStyle);
+      }
+      const span = document.createElement("span");
+      span.classList.add(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_TEXT);
+      span.textContent = columnConfig.header && typeof columnConfig.header === "string" ? columnConfig.header.trim() : "";
+      if (columnConfig.sortable) {
+        th.classList.add(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORTABLE);
+        const sortOrderElement = document.createElement("span");
+        addClass([TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORT_ORDER_HIDDEN, TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORT_ORDER], sortOrderElement);
+        const iconElement = document.createElement(ICON_CONSTANTS.elementName);
+        iconElement.name = TABLE_CONSTANTS.icons.SORT_DOWN;
+        addClass([TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORT_ICON], iconElement);
+        if (tableConfiguration.multiColumnSort) {
+          if (typeof columnConfig.initialSort === "object" && columnConfig.initialSort.sortOrder) {
+            sortOrderElement.textContent = columnConfig.initialSort.sortOrder.toString();
+            if (tableConfiguration.columnConfigurations.filter((c) => typeof c.initialSort === "object").length > 1) {
+              removeClass(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORT_ORDER_HIDDEN, sortOrderElement);
+            }
+            th.classList.add(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORTED_DESCENDING);
+            iconElement.classList.add(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORT_ICON_ACTIVE);
+            TableUtils._setColumnSortDirection(th, columnConfig.initialSort.direction);
+          }
+        } else {
+          if (tableConfiguration.sortedColumn === i && !setInitialSort && !tableConfiguration.multiColumnSort) {
+            th.classList.add(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORTED_DESCENDING);
+            iconElement.classList.add(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORT_ICON_ACTIVE);
+            TableUtils._setColumnSortDirection(th, tableConfiguration.sortDirection);
+            setInitialSort = true;
+          }
+        }
+        cellContainer.appendChild(iconElement);
+        cellContainer.appendChild(sortOrderElement);
+      }
+      if (typeof columnConfig.headerTemplate === "function") {
+        Promise.resolve(columnConfig.headerTemplate(i, cellContainer, columnConfig)).then((element) => {
+          if (element) {
+            const node = document.createElement("div");
+            addClass(TABLE_CONSTANTS.classes.TABLE_CELL_CONTAINER, node);
+            if (typeof element === "string") {
+              node.innerHTML = element;
+            } else {
+              TableUtils._prepend(element, node);
+            }
+            node.setAttribute(TABLE_CONSTANTS.attributes.CUSTOM_CELL_TEMPLATE, "");
+            TableUtils._prepend(node, cellContainer);
+          }
+        });
+      } else {
+        TableUtils._prepend(span, cellContainer);
+      }
+      th.appendChild(cellContainer);
+      tr.appendChild(th);
+    }
+    return thead;
+  }
+  static setSortDirection(tableElement, columnIndex, sortDirection) {
+    const cell = TableUtils._getHeaderCellByIndex(tableElement, columnIndex);
+    TableUtils._setColumnSortDirection(cell, sortDirection);
+  }
+  static _setColumnSortDirection(thElement, sortDirection) {
+    if (thElement.classList.contains(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORTED_ASCENDING)) {
+      thElement.classList.remove(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORTED_ASCENDING);
+    }
+    if (thElement.classList.contains(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORTED_DESCENDING)) {
+      thElement.classList.remove(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORTED_DESCENDING);
+    }
+    if (!sortDirection || sortDirection === "DESC" /* Descending */) {
+      thElement.classList.add(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORTED_DESCENDING);
+    } else {
+      thElement.classList.add(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORTED_ASCENDING);
+    }
+  }
+  static _createTableBody(configuration) {
+    const tbody = document.createElement("tbody");
+    const rowData = TableUtils._getOrderedRowData(configuration.columnConfigurations, configuration.data);
+    rowData.forEach((cellData, rowIndex) => {
+      const tr = tbody.insertRow();
+      addClass([TABLE_CONSTANTS.classes.TABLE_ROW, TABLE_CONSTANTS.classes.TABLE_BODY_ROW], tr);
+      TableUtils._populateRowCells(configuration, tr, cellData, rowIndex);
+      if (typeof configuration.rowCreatedCallback === "function") {
+        configuration.rowCreatedCallback(tr, rowIndex, __spreadValues({}, configuration.data[rowIndex].data));
+      }
+    });
+    return tbody;
+  }
+  static _populateRowCells(configuration, tr, cellData, rowIndex) {
+    for (let i = 0; i < cellData.length; i++) {
+      const columnConfig = configuration.columnConfigurations[i];
+      const td = tr.insertCell();
+      addClass([TABLE_CONSTANTS.classes.TABLE_CELL, TABLE_CONSTANTS.classes.TABLE_BODY_CELL], td);
+      if (isDefined(columnConfig.width)) {
+        const width = safeCssWidth(columnConfig.width);
+        if (width) {
+          td.style.width = width;
+        }
+      }
+      const div = document.createElement("div");
+      div.classList.add(TABLE_CONSTANTS.classes.TABLE_CELL_CONTAINER);
+      if (isDefined(columnConfig.cellStyle) && isObject(columnConfig.cellStyle)) {
+        Object.assign(td.style, columnConfig.cellStyle);
+        Object.assign(div.style, columnConfig.cellStyle);
+      }
+      if (columnConfig.template && typeof columnConfig.template === "function") {
+        const rowData = configuration.data[rowIndex] ? configuration.data[rowIndex].data : void 0;
+        Promise.resolve(columnConfig.template(rowIndex, div, rowData)).then((result) => {
+          const config = isTemplateResultObject(result) ? result : { content: result, stopClickPropagation: columnConfig.stopCellTemplateClickPropagation };
+          if (!config.content) {
+            return;
+          }
+          if (typeof config.content === "string") {
+            div.innerHTML = config.content;
+          } else {
+            div.appendChild(config.content);
+          }
+          div.setAttribute(TABLE_CONSTANTS.attributes.CUSTOM_CELL_TEMPLATE, "");
+          if (config.stopClickPropagation) {
+            div.setAttribute(TABLE_CONSTANTS.attributes.CUSTOM_CELL_TEMPLATE_STOP_PROPAGATION, "");
+          }
+        });
+      } else if (columnConfig.property) {
+        const span = document.createElement("span");
+        span.classList.add(TABLE_CONSTANTS.classes.TABLE_CELL_CONTAINER_TEXT);
+        div.appendChild(span);
+        if (columnConfig.transform && typeof columnConfig.transform === "function") {
+          Promise.resolve(columnConfig.transform(cellData[i])).then((value) => span.textContent = value);
+        } else {
+          if (cellData[i] === void 0 || cellData[i] === null) {
+            span.textContent = "";
+          } else {
+            span.textContent = cellData[i].toString();
+          }
+        }
+      }
+      if (columnConfig.align) {
+        TableUtils._setCellAlignmentClass(div, columnConfig.align);
+      }
+      td.appendChild(div);
+      if (isDefined(columnConfig.columnSpan)) {
+        if (columnConfig.columnSpan === "all") {
+          td.colSpan = cellData.length - i;
+          break;
+        } else if (typeof columnConfig.columnSpan === "number" && columnConfig.columnSpan > 0) {
+          let colspan = columnConfig.columnSpan;
+          if (columnConfig.columnSpan > cellData.length - i) {
+            colspan = cellData.length;
+          }
+          td.colSpan = colspan;
+          i = i + (colspan - 1);
+        }
+      }
+      if (typeof configuration.cellCreatedCallback === "function") {
+        configuration.cellCreatedCallback(td, rowIndex, i);
+      }
+    }
+  }
+  static _setCellAlignmentClass(el, align) {
+    switch (align) {
+      case "center" /* Center */:
+        el.classList.add(TABLE_CONSTANTS.classes.TABLE_CELL_CENTER);
+        break;
+      case "right" /* Right */:
+        el.classList.add(TABLE_CONSTANTS.classes.TABLE_CELL_RIGHT);
+        break;
+    }
+  }
+  static _getNonExpandedRows(rows) {
+    return Array.from(rows).filter((row) => !row.classList.contains(TABLE_CONSTANTS.classes.TABLE_ROW_EXPANDABLE_CONTENT));
+  }
+  static _getExpandedRows(rows) {
+    return Array.from(rows).filter((row) => row.classList.contains(TABLE_CONSTANTS.classes.TABLE_ROW_EXPANDABLE_CONTENT));
+  }
+  static _createColumnDataMap(columnConfigurations, data) {
+    return columnConfigurations.map((columnConfig) => {
+      return {
+        config: columnConfig,
+        data: data.map((item) => {
+          if (columnConfig.property) {
+            const value = getPropertyValue(item.data, columnConfig.property);
+            return isDefined(value) ? value : null;
+          }
+          return null;
+        })
+      };
+    });
+  }
+  static _getOrderedRowData(columnConfigurations, data) {
+    const columnDataMap = TableUtils._createColumnDataMap(columnConfigurations, data);
+    const rowData = [];
+    for (const columnData of columnDataMap) {
+      for (let j = 0; j < columnData.data.length; j++) {
+        if (!rowData[j]) {
+          rowData[j] = [];
+        }
+        rowData[j].push(columnData.data[j]);
+      }
+    }
+    return rowData;
+  }
+  static _attachRowClickListeners(tbodyElement, clickListener, doubleClickListener) {
+    const nonExpandedRows = TableUtils._getNonExpandedRows(tbodyElement.rows);
+    nonExpandedRows.forEach((row) => {
+      row.addEventListener("click", clickListener);
+      if (doubleClickListener) {
+        row.addEventListener("dblclick", doubleClickListener);
+      }
+    });
+  }
+  static _addRowClickAttributes(tbodyElement) {
+    const nonExpandedRows = TableUtils._getNonExpandedRows(tbodyElement.rows);
+    nonExpandedRows.forEach((row) => {
+      row.classList.add(TABLE_CONSTANTS.classes.TABLE_BODY_ROW_CLICKABLE);
+    });
+  }
+  static _removeRowClickAttributes(tbodyElement) {
+    const nonExpandedRows = TableUtils._getNonExpandedRows(tbodyElement.rows);
+    nonExpandedRows.forEach((row) => {
+      row.classList.remove(TABLE_CONSTANTS.classes.TABLE_BODY_ROW_CLICKABLE);
+    });
+  }
+  static _attachRowSelectListeners(tbodyElement, clickListener) {
+    const nonExpandedRows = TableUtils._getNonExpandedRows(tbodyElement.rows);
+    nonExpandedRows.forEach((row) => TableUtils._attachRowSelectListener(row, clickListener));
+  }
+  static _attachRowSelectListener(row, clickListener) {
+    const checkboxElement = TableUtils._getCheckboxElement(row);
+    checkboxElement.addEventListener("click", clickListener);
+  }
+  static _detachRowSelectListeners(tbodyElement, clickListener) {
+    Array.from(tbodyElement.rows).forEach((row) => {
+      const checkboxElement = TableUtils._getCheckboxElement(row);
+      if (checkboxElement) {
+        checkboxElement.removeEventListener("click", clickListener);
+      }
+    });
+  }
+  static _detachRowClickListeners(tbodyElement, clickListener, doubleClickListener) {
+    Array.from(tbodyElement.rows).forEach((row) => {
+      row.removeEventListener("click", clickListener);
+      row.removeEventListener("dblclick", doubleClickListener);
+    });
+  }
+  static _attachSelectAllListener(theadElement, listener) {
+    const lastTheadRow = theadElement.rows[theadElement.rows.length - 1];
+    const checkboxElement = TableUtils._getCheckboxElement(lastTheadRow);
+    if (!checkboxElement) {
+      throw new Error("Checkbox element not found.");
+    }
+    checkboxElement.addEventListener("change", listener);
+  }
+  static _tryAttachSelectAllTemplateListener(theadElement, listener) {
+    const lastTheadRow = theadElement.rows[theadElement.rows.length - 1];
+    const checkboxElement = TableUtils._tryGetCheckboxElement(lastTheadRow);
+    if (checkboxElement) {
+      checkboxElement.addEventListener("change", listener);
+    }
+  }
+  static _detachSelectAllListener(theadElement, listener) {
+    const lastTheadRow = theadElement.rows[theadElement.rows.length - 1];
+    const checkboxElement = TableUtils._tryGetCheckboxElement(lastTheadRow);
+    if (!checkboxElement) {
+      return;
+    }
+    checkboxElement.removeEventListener("change", listener);
+  }
+  static _attachHeadRowMouseDownListener(theadElement, listener) {
+    const firstRow = theadElement.rows[0];
+    if (!firstRow) {
+      throw new Error("Missing table header row. Unable to attach sort listener.");
+    }
+    firstRow.addEventListener("mousedown", listener);
+  }
+  static _attachHeadRowContextMenuListener(theadElement, listener) {
+    const firstRow = theadElement.rows[0];
+    if (!firstRow) {
+      throw new Error("Missing table header row. Unable to attach sort listener.");
+    }
+    firstRow.addEventListener("contextmenu", listener);
+  }
+  static _createSelectColumn(theadElement, tbodyElement, showSelectAll, selectAllTemplate, registerListener, selectCheckboxAlignment, data, tooltipSelect, tooltipSelectAll) {
+    if (theadElement) {
+      TableUtils._createHeadSelectColumn(theadElement, showSelectAll, selectAllTemplate, registerListener, selectCheckboxAlignment, tooltipSelectAll);
+    }
+    if (tbodyElement) {
+      TableUtils._createBodySelectColumn(tbodyElement, selectCheckboxAlignment, data, tooltipSelect, tooltipSelectAll);
+    }
+  }
+  static _createHeadSelectColumn(theadElement, showSelectAll, selectAllTemplate, registerListener, selectCheckboxAlignment, tooltipSelectAll) {
+    var _a;
+    Array.from(theadElement.rows).forEach((row) => {
+      const th = document.createElement("th");
+      addClass([TABLE_CONSTANTS.classes.TABLE_CELL, TABLE_CONSTANTS.classes.TABLE_HEAD_CELL], th);
+      row.insertBefore(th, row.cells.item(0));
+    });
+    if (showSelectAll) {
+      const lastRowFirstCell = (_a = theadElement.rows.item(theadElement.rows.length - 1)) == null ? void 0 : _a.cells.item(0);
+      lastRowFirstCell.classList.add(TABLE_CONSTANTS.classes.TABLE_CELL_SELECT);
+      if (typeof selectAllTemplate === "function") {
+        TableUtils._renderSelectAllTemplate(selectAllTemplate, theadElement).then(() => {
+          if (typeof registerListener === "function") {
+            registerListener();
+          }
+        });
+      } else {
+        lastRowFirstCell == null ? void 0 : lastRowFirstCell.appendChild(TableUtils._createCheckboxElement(true, selectCheckboxAlignment, null, null, null, tooltipSelectAll));
+      }
+    }
+  }
+  static _createBodySelectColumn(tbodyElement, selectCheckboxAlignment, data, tooltipSelect, tooltipSelectAll) {
+    const nonExpandedRows = TableUtils._getNonExpandedRows(tbodyElement.rows);
+    nonExpandedRows.forEach((row, rowIndex) => TableUtils._addRowSelectColumn(row, selectCheckboxAlignment, rowIndex, data[rowIndex], tooltipSelect, tooltipSelectAll));
+    if (tbodyElement.rows.length) {
+      const firstRow = tbodyElement.rows.item(0);
+      if (firstRow) {
+        TableUtils._updateExpandedRowColspan(tbodyElement.rows, firstRow.cells.length);
+      }
+    }
+  }
+  static _addRowSelectColumn(row, selectCheckboxAlignment, rowIndex, rowData, tooltipSelect, tooltipSelectAll) {
+    const td = row.insertCell(0);
+    addClass([TABLE_CONSTANTS.classes.TABLE_CELL, TABLE_CONSTANTS.classes.TABLE_BODY_CELL, TABLE_CONSTANTS.classes.TABLE_CELL_SELECT], td);
+    td.appendChild(TableUtils._createCheckboxElement(false, selectCheckboxAlignment, rowIndex, rowData, tooltipSelect, tooltipSelectAll));
+  }
+  static _destroySelectColumn(theadElement, tbodyElement) {
+    const nonExpandedRows = TableUtils._getNonExpandedRows(tbodyElement.rows);
+    Array.from(theadElement.rows).forEach((row) => row.removeChild(row.cells.item(0)));
+    Array.from(nonExpandedRows).forEach((row) => row.removeChild(row.cells.item(0)));
+    if (tbodyElement.rows.length) {
+      const firstRow = tbodyElement.rows.item(0);
+      if (firstRow) {
+        TableUtils._updateExpandedRowColspan(tbodyElement.rows, firstRow.cells.length);
+      }
+    }
+  }
+  static _hasSelectColumn(theadElement, tbodyElement) {
+    const tableRows = [...Array.from(theadElement.rows), ...Array.from(tbodyElement.rows)];
+    return tableRows.some((row) => {
+      const firstCell = row.cells.item(0);
+      return firstCell.classList.contains(TABLE_CONSTANTS.classes.TABLE_CELL_SELECT);
+    });
+  }
+  static _createCheckboxElement(isHeader, alignment, rowIndex, rowData, tooltipSelect, tooltipSelectAll) {
+    const checkboxContainer = document.createElement("div");
+    checkboxContainer.classList.add(TABLE_CONSTANTS.classes.TABLE_CELL_SELECT_CHECKBOX_CONTAINER);
+    if (alignment) {
+      switch (alignment) {
+        case "center" /* Center */:
+          checkboxContainer.classList.add(TABLE_CONSTANTS.classes.TABLE_CELL_SELECT_CHECKBOX_CONTAINER_ALIGN_CENTER);
+          break;
+        case "left" /* Left */:
+          checkboxContainer.classList.add(TABLE_CONSTANTS.classes.TABLE_CELL_SELECT_CHECKBOX_CONTAINER_ALIGN_LEFT);
+          break;
+        case "right" /* Right */:
+          checkboxContainer.classList.add(TABLE_CONSTANTS.classes.TABLE_CELL_SELECT_CHECKBOX_CONTAINER_ALIGN_RIGHT);
+          break;
+      }
+    }
+    const checkboxElement = document.createElement(CHECKBOX_CONSTANTS.elementName);
+    const checkboxInputElement = document.createElement("input");
+    checkboxInputElement.type = "checkbox";
+    let tooltipText = tooltipSelect ? tooltipSelect : "";
+    if (rowData && typeof tooltipSelect === "function") {
+      tooltipText = tooltipSelect.call(null, rowIndex, rowData.data);
+    }
+    const tooltip = document.createElement("forge-tooltip");
+    tooltip.position = "left";
+    if (isHeader) {
+      tooltip.textContent = tooltipSelectAll ? tooltipSelectAll : "";
+    } else {
+      tooltip.textContent = tooltipText;
+    }
+    checkboxInputElement.setAttribute("aria-label", "Select row");
+    checkboxElement.appendChild(checkboxInputElement);
+    checkboxContainer.appendChild(tooltip);
+    checkboxContainer.appendChild(checkboxElement);
+    return checkboxContainer;
+  }
+  static _getCheckboxElement(rowElement) {
+    return rowElement.querySelector(TABLE_CONSTANTS.selectors.CHECKBOX_INPUT);
+  }
+  static _tryGetCheckboxElement(rowElement) {
+    return rowElement.querySelector(TABLE_CONSTANTS.selectors.CHECKBOX_INPUT) || rowElement.querySelector(TABLE_CONSTANTS.selectors.SELECT_ALL_TEMPLATE_CHECKBOX_INPUT);
+  }
+  static _setSelectedCheckboxState(checkboxElement, isSelected) {
+    if (checkboxElement) {
+      checkboxElement.checked = isSelected;
+    }
+  }
+  static _setIndeterminateCheckboxState(checkboxElement, isIndeterminate) {
+    if (checkboxElement) {
+      checkboxElement.indeterminate = isIndeterminate;
+    }
+  }
+  static _setRowSelectedState(rowElement, isSelected) {
+    if (isSelected) {
+      if (!rowElement.classList.contains(TABLE_CONSTANTS.classes.TABLE_BODY_ROW_SELECTED)) {
+        rowElement.classList.add(TABLE_CONSTANTS.classes.TABLE_BODY_ROW_SELECTED);
+      }
+    } else {
+      rowElement.classList.remove(TABLE_CONSTANTS.classes.TABLE_BODY_ROW_SELECTED);
+    }
+  }
+  static _updateExpandedRowColspan(rows, cellCount) {
+    const expandedRows = TableUtils._getExpandedRows(rows);
+    expandedRows.forEach((row) => {
+      const cell = row.cells.item(0);
+      if (cell) {
+        cell.colSpan = cellCount;
+      }
+    });
+  }
+  static updateSelectedState(rowElement, isSelected) {
+    TableUtils._setRowSelectedState(rowElement, isSelected);
+    TableUtils._setSelectedCheckboxState(TableUtils._getCheckboxElement(rowElement), isSelected);
+  }
+  static getRowByIndex(tableElement, index) {
+    return TableUtils._getNonExpandedRows(tableElement.tBodies[0].rows)[index];
+  }
+  static updateSelectAllState(tableElement, isAllSelected, isIndeterminate) {
+    if (!tableElement.tHead) {
+      return;
+    }
+    const lastTheadRow = tableElement.tHead.rows[tableElement.tHead.rows.length - 1];
+    const selectAllCheckboxElement = TableUtils._tryGetCheckboxElement(lastTheadRow);
+    if (selectAllCheckboxElement) {
+      TableUtils._setSelectedCheckboxState(selectAllCheckboxElement, isAllSelected);
+      TableUtils._setIndeterminateCheckboxState(selectAllCheckboxElement, !!isIndeterminate);
+    }
+  }
+  static setSelectedRows(tableElement, key, data, selectedRows, preserveExisting = false) {
+    if (!tableElement.tBodies.length) {
+      return;
+    }
+    if (!preserveExisting) {
+      TableUtils.clearSelectedRows(tableElement);
+    }
+    const rows = tableElement.tBodies[0].rows;
+    let selectedRowCount = 0;
+    if (selectedRows.length) {
+      Array.from(rows).forEach((row, index) => {
+        const rowData = data[index];
+        const existingSelection = findWhere(selectedRows, createPredicate(key, rowData));
+        if (existingSelection) {
+          TableUtils._setRowSelectedState(row, true);
+          TableUtils._setSelectedCheckboxState(TableUtils._getCheckboxElement(row), true);
+          selectedRowCount++;
+        }
+      });
+    }
+    TableUtils.updateSelectAllState(tableElement, selectedRowCount > 0 && rows.length === selectedRowCount);
+  }
+  static clearSelectedRows(tableElement) {
+    if (!tableElement.tBodies.length) {
+      return;
+    }
+    const nonExpandedRows = TableUtils._getNonExpandedRows(tableElement.tBodies[0].rows);
+    nonExpandedRows.forEach((row) => {
+      TableUtils._setRowSelectedState(row, false);
+      TableUtils._setSelectedCheckboxState(TableUtils._getCheckboxElement(row), false);
+    });
+  }
+  static setSortedColumn(tableElement, columnIndex, sortDirection) {
+    const cell = TableUtils._getHeaderCellByIndex(tableElement, columnIndex);
+    const iconElement = TableUtils._getSortIconElementFromHeaderCell(cell);
+    iconElement.classList.add(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORT_ICON_ACTIVE);
+    TableUtils._setColumnSortDirection(cell, sortDirection);
+  }
+  static setMultiSortColumnSortNumber(tableElement, hasMultipleColumnsSorted, columnIndex, sortOrder) {
+    const cell = TableUtils._getHeaderCellByIndex(tableElement, columnIndex);
+    const cellContainer = cell.querySelector(`.${TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_CONTAINER}`);
+    const sortOrderElement = cellContainer.querySelector(`.${TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORT_ORDER}`);
+    if (sortOrderElement) {
+      toggleClass(sortOrderElement, typeof sortOrder !== "number" || !hasMultipleColumnsSorted, TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORT_ORDER_HIDDEN);
+      if (sortOrder) {
+        sortOrderElement.textContent = sortOrder.toString();
+      }
+    }
+  }
+  static removeColumnSort(tableElement, columnIndex) {
+    const cell = TableUtils._getHeaderCellByIndex(tableElement, columnIndex);
+    if (cell.classList.contains(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORTED_ASCENDING)) {
+      cell.classList.remove(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORTED_ASCENDING);
+    }
+    if (cell.classList.contains(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORTED_DESCENDING)) {
+      cell.classList.remove(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORTED_DESCENDING);
+    }
+    const existingIconElement = TableUtils._getSortIconElementFromHeaderCell(cell);
+    if (existingIconElement && existingIconElement.classList.contains(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORT_ICON_ACTIVE)) {
+      existingIconElement.classList.remove(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORT_ICON_ACTIVE);
+    }
+  }
+  static _getHeaderCellByIndex(tableElement, index) {
+    if (!tableElement.tHead) {
+      throw new Error("Table head element cannot be null.");
+    }
+    const headerRow = tableElement.tHead.rows.item(0);
+    return headerRow.cells.item(index);
+  }
+  static _getSortIconElementFromHeaderCell(cell) {
+    return cell.querySelector(`.${TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_SORT_ICON}`);
+  }
+  static setSelectColumnVisibility(tableElement, isVisible, selectListener, selectAllListener, selectAllTemplate, selectCheckboxAlignment, data, tooltipSelect, tooltipSelectAll) {
+    const theadElement = tableElement.tHead;
+    const tbodyElement = tableElement.tBodies[0];
+    if (!theadElement || !tbodyElement) {
+      return;
+    }
+    if (isVisible) {
+      TableUtils._addSelectColumn(theadElement, tbodyElement, selectListener, selectAllListener, selectAllTemplate, selectCheckboxAlignment, data, tooltipSelect, tooltipSelectAll);
+    } else if (TableUtils._hasSelectColumn(theadElement, tbodyElement)) {
+      if (selectListener) {
+        TableUtils._detachRowSelectListeners(tbodyElement, selectListener);
+      }
+      if (selectAllListener) {
+        TableUtils._detachSelectAllListener(theadElement, selectAllListener);
+      }
+      TableUtils._destroySelectColumn(theadElement, tbodyElement);
+    }
+  }
+  static _addSelectColumn(theadElement, tbodyElement, selectListener, selectAllListener, selectAllTemplate, selectCheckboxAlignment, data, tooltipSelect, tooltipSelectAll) {
+    TableUtils._createSelectColumn(theadElement, tbodyElement, !!selectAllListener, selectAllTemplate, () => {
+      if (selectAllListener) {
+        TableUtils._tryAttachSelectAllTemplateListener(theadElement, selectAllListener);
+      }
+    }, selectCheckboxAlignment, data, tooltipSelect, tooltipSelectAll);
+    if (selectListener) {
+      TableUtils._attachRowSelectListeners(tbodyElement, selectListener);
+    }
+    if (selectAllListener && !selectAllTemplate) {
+      TableUtils._tryAttachSelectAllTemplateListener(theadElement, selectAllListener);
+    }
+  }
+  static setDenseState(tableElement, isDense) {
+    if (tableElement.classList.contains(TABLE_CONSTANTS.classes.TABLE_DENSE)) {
+      tableElement.classList.remove(TABLE_CONSTANTS.classes.TABLE_DENSE);
+    }
+    if (isDense) {
+      tableElement.classList.add(TABLE_CONSTANTS.classes.TABLE_DENSE);
+    }
+  }
+  static setRoomyState(tableElement, isRoomy) {
+    if (tableElement.classList.contains(TABLE_CONSTANTS.classes.TABLE_ROOMY)) {
+      tableElement.classList.remove(TABLE_CONSTANTS.classes.TABLE_ROOMY);
+    }
+    if (isRoomy) {
+      tableElement.classList.add(TABLE_CONSTANTS.classes.TABLE_ROOMY);
+    }
+  }
+  static setResizable(configuration) {
+    const thead = configuration.tableElement.tHead;
+    if (configuration.resizable) {
+      configuration.tableElement.classList.add(TABLE_CONSTANTS.classes.TABLE_RESIZABLE);
+      TableUtils._addResizeHandles(thead, configuration);
+    } else {
+      configuration.tableElement.classList.remove(TABLE_CONSTANTS.classes.TABLE_RESIZABLE);
+      TableUtils._removeResizeHandles(thead);
+    }
+  }
+  static _addResizeHandles(thead, configuration) {
+    if (!thead) {
+      return;
+    }
+    const firstRow = thead.rows.item(0);
+    if (firstRow) {
+      let cells = Array.from(firstRow.cells);
+      if (configuration.selectListener) {
+        cells = cells.slice(1);
+      }
+      for (const cell of cells) {
+        const index = cells.indexOf(cell);
+        const columnConfig = configuration.columnConfigurations[index];
+        if (columnConfig.resizable !== false) {
+          const resizeHandle = document.createElement("div");
+          resizeHandle.classList.add(TABLE_CONSTANTS.classes.TABLE_RESIZE_HANDLE);
+          cell.appendChild(resizeHandle);
+        }
+      }
+    }
+  }
+  static _removeResizeHandles(thead) {
+    if (!thead) {
+      return;
+    }
+    const firstRow = thead.rows.item(0);
+    if (firstRow) {
+      const cells = Array.from(firstRow.cells);
+      for (const cell of cells) {
+        const resizeHandle = document.querySelector(`.${TABLE_CONSTANTS.classes.TABLE_RESIZE_HANDLE}`);
+        if (resizeHandle) {
+          cell.removeChild(resizeHandle);
+        }
+      }
+    }
+  }
+  static setWrapContentState(tableElement, wrapContent) {
+    if (wrapContent) {
+      tableElement.classList.remove(TABLE_CONSTANTS.classes.TABLE_NO_WRAP_CONTENT);
+    } else {
+      tableElement.classList.add(TABLE_CONSTANTS.classes.TABLE_NO_WRAP_CONTENT);
+    }
+  }
+  static setSelectAllVisibility(tableElement, isVisible, listener, selectAllTemplate, selectCheckboxAlignment, tooltipSelectAll) {
+    const theadElement = tableElement.tHead;
+    if (!theadElement) {
+      return;
+    }
+    if (!isVisible && listener) {
+      TableUtils._detachSelectAllListener(theadElement, listener);
+    }
+    const lastTheadRow = theadElement.rows[theadElement.rows.length - 1];
+    const selectAllCell = lastTheadRow.cells.item(0);
+    if (isVisible) {
+      if (!selectAllCell.childElementCount) {
+        selectAllCell.classList.add(TABLE_CONSTANTS.classes.TABLE_CELL_SELECT);
+        if (selectAllTemplate) {
+          TableUtils._renderSelectAllTemplate(selectAllTemplate, theadElement).then(() => {
+            if (listener) {
+              TableUtils._tryAttachSelectAllTemplateListener(theadElement, listener);
+            }
+          });
+        } else {
+          selectAllCell.appendChild(TableUtils._createCheckboxElement(true, selectCheckboxAlignment || null, null, null, null, tooltipSelectAll));
+        }
+        if (listener && !selectAllTemplate) {
+          TableUtils._attachSelectAllListener(theadElement, listener);
+        }
+      }
+    } else {
+      if (listener) {
+        TableUtils._detachSelectAllListener(theadElement, listener);
+      }
+      removeAllChildren(selectAllCell);
+    }
+  }
+  static setFilterRow(configuration) {
+    if (!configuration.tableElement.tHead) {
+      return;
+    }
+    const filterRowElement = TableUtils._getFilterRowElement(configuration.tableElement.tHead);
+    let selectAllCell;
+    if (configuration.filter) {
+      configuration.tableElement.classList.add(TABLE_CONSTANTS.classes.TABLE_FILTER_VISIBLE);
+    } else {
+      configuration.tableElement.classList.remove(TABLE_CONSTANTS.classes.TABLE_FILTER_VISIBLE);
+    }
+    if (configuration.filter && !filterRowElement) {
+      if (configuration.columnConfigurations.every((cc) => !cc.filter)) {
+        return;
+      }
+      if (configuration.selectListener && configuration.selectAllListener) {
+        const lastTheadRow = configuration.tableElement.tHead.rows[configuration.tableElement.tHead.rows.length - 1];
+        selectAllCell = lastTheadRow.cells.item(0);
+      }
+      const rowElement = TableUtils._createFilterRowElement(configuration);
+      if (rowElement && selectAllCell) {
+        Array.from(selectAllCell.children).forEach((child) => {
+          var _a;
+          (_a = rowElement.cells.item(0)) == null ? void 0 : _a.appendChild(child);
+        });
+      }
+    } else if (!configuration.filter && filterRowElement) {
+      if (configuration.selectListener && configuration.selectAllListener) {
+        selectAllCell = filterRowElement.cells.item(0);
+        const previousRowElementIndex = Array.from(configuration.tableElement.tHead.rows).indexOf(filterRowElement) - 1;
+        const previousRowElement = configuration.tableElement.tHead.rows.item(previousRowElementIndex);
+        if (previousRowElement) {
+          Array.from(selectAllCell.children).forEach((child) => {
+            var _a;
+            (_a = previousRowElement.cells.item(0)) == null ? void 0 : _a.appendChild(child);
+          });
+        }
+      }
+      removeElement(filterRowElement);
+    }
+  }
+  static _createFilterRowElement(configuration) {
+    if (!configuration.tableElement.tHead) {
+      throw new Error("Table head element cannot be null.");
+    }
+    const filterRow = configuration.tableElement.tHead.insertRow();
+    addClass([TABLE_CONSTANTS.classes.TABLE_ROW, TABLE_CONSTANTS.classes.TABLE_HEAD_ROW_FILTER], filterRow);
+    if (configuration.selectListener) {
+      const th = document.createElement("th");
+      addClass([TABLE_CONSTANTS.classes.TABLE_CELL, TABLE_CONSTANTS.classes.TABLE_HEAD_CELL], th);
+      filterRow.insertBefore(th, filterRow.cells[0]);
+      th.classList.add(TABLE_CONSTANTS.classes.TABLE_CELL_SELECT);
+    }
+    configuration.columnConfigurations.forEach((columnConfig, columnIndex) => {
+      const th = document.createElement("th");
+      addClass([TABLE_CONSTANTS.classes.TABLE_CELL, TABLE_CONSTANTS.classes.TABLE_HEAD_CELL], th);
+      if (columnConfig.filter && isDefined(columnConfig.filterDelegate)) {
+        const container = document.createElement("div");
+        container.classList.add(TABLE_CONSTANTS.classes.TABLE_HEAD_CELL_CONTAINER);
+        if (columnConfig.align) {
+          TableUtils._setCellAlignmentClass(container, columnConfig.align);
+        }
+        const element = TableUtils._createFilterElement(columnConfig, columnIndex, configuration.filterListener);
+        container.appendChild(element);
+        th.appendChild(container);
+      }
+      filterRow.appendChild(th);
+    });
+    return filterRow;
+  }
+  static _createFilterElement(columnConfig, columnIndex, filterListener) {
+    let delegate;
+    if (isFunction(columnConfig.filterDelegate)) {
+      delegate = columnConfig.filterDelegate();
+    } else if (columnConfig.filterDelegate instanceof FormFieldComponentDelegate) {
+      delegate = columnConfig.filterDelegate;
+    } else {
+      throw new Error("Invalid filter delegate.");
+    }
+    if (filterListener) {
+      if (!isDefined(columnConfig.filterDebounceTime) || isNumber(columnConfig.filterDebounceTime)) {
+        const debounceTime = isDefined(columnConfig.filterDebounceTime) ? columnConfig.filterDebounceTime : TABLE_CONSTANTS.numbers.DEFAULT_FILTER_DEBOUNCE_TIME;
+        delegate.onChange(debounce((value) => filterListener(value, columnIndex), debounceTime));
+      } else {
+        delegate.onChange((value) => filterListener(value, columnIndex));
+      }
+    }
+    return delegate.element;
+  }
+  static _getFilterRowElement(tHeadElement) {
+    if (!tHeadElement) {
+      return;
+    }
+    return Array.from(tHeadElement.rows).find((r) => r.classList.contains(TABLE_CONSTANTS.classes.TABLE_HEAD_ROW_FILTER));
+  }
+  static async expandRow(configuration, rowIndex, template) {
+    const tbody = configuration.tableElement.tBodies[0];
+    const nonExpandedRows = TableUtils._getNonExpandedRows(tbody.rows);
+    const requestedRow = nonExpandedRows[rowIndex];
+    requestedRow.classList.add(TABLE_CONSTANTS.classes.TABLE_ROW_EXPANDED);
+    const actualRowIndex = Array.from(tbody.rows).indexOf(requestedRow);
+    const expandedRow = tbody.insertRow(actualRowIndex + 1);
+    addClass([TABLE_CONSTANTS.classes.TABLE_ROW, TABLE_CONSTANTS.classes.TABLE_BODY_ROW, TABLE_CONSTANTS.classes.TABLE_ROW_EXPANDABLE_CONTENT], expandedRow);
+    const td = expandedRow.insertCell();
+    td.setAttribute("colspan", requestedRow.cells.length.toString());
+    td.classList.add(TABLE_CONSTANTS.classes.TABLE_ROW_EXPANDABLE_CONTENT_CELL);
+    const contentDiv = document.createElement("div");
+    const expansionPanel = document.createElement(EXPANSION_PANEL_CONSTANTS.elementName);
+    expansionPanel.appendChild(contentDiv);
+    td.appendChild(expansionPanel);
+    let content = template;
+    if (isFunction(template)) {
+      const rowData = configuration.data[rowIndex] ? configuration.data[rowIndex].data : void 0;
+      const templateValue = template(rowIndex, contentDiv, rowData);
+      try {
+        const result = await Promise.resolve(templateValue);
+        content = isTemplateResultObject(result) ? result.content : result;
+      } catch (e) {
+        console.error("Failed to load row template " + e.message);
+        content = "";
+      }
+    }
+    if (content) {
+      TableUtils._setRowTemplate(contentDiv, content);
+    }
+    window.requestAnimationFrame(() => expansionPanel.open = true);
+  }
+  static _setRowTemplate(element, template) {
+    if (isString(template)) {
+      element.innerHTML = template;
+    } else {
+      element.appendChild(template);
+    }
+  }
+  static collapseRow(configuration, rowIndex) {
+    if (!configuration.tableElement || !configuration.tableElement.tBodies.length || !configuration.tableElement.tBodies[0].rows.length) {
+      return Promise.resolve();
+    }
+    const tbody = configuration.tableElement.tBodies[0];
+    const nonExpandedRows = TableUtils._getNonExpandedRows(tbody.rows);
+    const requestedRow = nonExpandedRows[rowIndex];
+    const actualRowIndex = Array.from(tbody.rows).indexOf(requestedRow);
+    if (requestedRow && requestedRow.classList.contains(TABLE_CONSTANTS.classes.TABLE_ROW_EXPANDED)) {
+      const expandableRow = tbody.rows[actualRowIndex + 1];
+      const expansionPanel = expandableRow.querySelector(EXPANSION_PANEL_CONSTANTS.elementName);
+      if (expansionPanel && expansionPanel.open) {
+        expansionPanel.open = false;
+        return new Promise((resolve) => {
+          setTimeout(() => {
+            requestedRow.classList.remove(TABLE_CONSTANTS.classes.TABLE_ROW_EXPANDED);
+            removeElement(expandableRow);
+            resolve();
+          }, EXPANSION_PANEL_CONSTANTS.numbers.COLLAPSE_ANIMATION_DURATION);
+        });
+      }
+    }
+    return Promise.resolve();
+  }
+  static isRowExpanded(configuration, rowIndex) {
+    const tbody = configuration.tableElement.tBodies[0];
+    const nonExpandedRows = TableUtils._getNonExpandedRows(tbody.rows);
+    const requestedRow = nonExpandedRows[rowIndex];
+    return requestedRow && requestedRow.classList.contains(TABLE_CONSTANTS.classes.TABLE_ROW_EXPANDED);
+  }
+  static setFixedHeaders(configuration) {
+    if (configuration.fixedHeaders) {
+      configuration.tableElement.classList.add(TABLE_CONSTANTS.classes.TABLE_FIXED);
+    } else {
+      configuration.tableElement.classList.remove(TABLE_CONSTANTS.classes.TABLE_FIXED);
+    }
+  }
+  static setLayoutType(configuration) {
+    if (configuration.layoutType === "fixed") {
+      configuration.tableElement.classList.add(TABLE_CONSTANTS.classes.TABLE_LAYOUT_FIXED);
+    } else {
+      configuration.tableElement.classList.remove(TABLE_CONSTANTS.classes.TABLE_LAYOUT_FIXED);
+    }
+  }
+  static normalizeColumnWidths(configuration) {
+    const tableElement = configuration.tableElement;
+    if (tableElement.tHead && tableElement.tHead.rows.length) {
+      const cells = Array.from(tableElement.tHead.rows[0].cells);
+      for (const cell of cells) {
+        const expectedWidth = getComputedStyle(cell).width;
+        if (cell.style.width && cell.style.width !== expectedWidth) {
+          cell.style.width = expectedWidth;
+        }
+      }
+    }
+  }
+  static setColumnResizeIndicatorVisibility(configuration, columnIndex, isVisible) {
+    const tableElement = configuration.tableElement;
+    if (tableElement.tHead && tableElement.tHead.rows.length) {
+      const rows = Array.from(tableElement.tHead.rows);
+      for (const row of rows) {
+        const cell = row.cells[columnIndex];
+        if (cell) {
+          if (isVisible) {
+            cell.classList.add(TABLE_CONSTANTS.classes.TABLE_CELL_RESIZABLE);
+          } else {
+            cell.classList.remove(TABLE_CONSTANTS.classes.TABLE_CELL_RESIZABLE);
+          }
+        }
+      }
+    }
+    if (tableElement.tBodies.length) {
+      const rows = Array.from(tableElement.tBodies[0].rows);
+      for (const row of rows) {
+        const cell = row.cells[columnIndex];
+        if (cell) {
+          if (isVisible) {
+            cell.classList.add(TABLE_CONSTANTS.classes.TABLE_CELL_RESIZABLE);
+          } else {
+            cell.classList.remove(TABLE_CONSTANTS.classes.TABLE_CELL_RESIZABLE);
+          }
+        }
+      }
+    }
+  }
+  static setRowClickListeners(tableElement, allowClick, clickListener, doubleClickListener) {
+    const tbodyElement = tableElement.tBodies[0];
+    if (!tbodyElement) {
+      return;
+    }
+    if (allowClick) {
+      TableUtils._attachRowClickListeners(tbodyElement, clickListener, doubleClickListener);
+    } else {
+      TableUtils._detachRowClickListeners(tbodyElement, clickListener, doubleClickListener);
+    }
+  }
+  static setRowClickAttributes(tableElement, allowClick) {
+    const tbodyElement = tableElement.tBodies[0];
+    if (!tbodyElement) {
+      return;
+    }
+    if (allowClick) {
+      TableUtils._addRowClickAttributes(tbodyElement);
+    } else {
+      TableUtils._removeRowClickAttributes(tbodyElement);
+    }
+  }
+  static getOwnerDocument(el) {
+    return el.ownerDocument || document;
+  }
+  static _prepend(element, target) {
+    const elementToSetBefore = target.childNodes.item(0);
+    if (elementToSetBefore) {
+      target.insertBefore(element, elementToSetBefore);
+    } else {
+      target.appendChild(element);
+    }
+  }
+  static _isMac() {
+    return !!(navigator && navigator.platform && navigator.platform.substr(0, 3) === "Mac");
+  }
+  static _renderSelectAllTemplate(selectAllTemplate, theadElement) {
+    return Promise.resolve(selectAllTemplate()).then((element) => {
+      const lastTheadRow = theadElement.rows.item(theadElement.rows.length - 1);
+      if (!lastTheadRow) {
+        return;
+      }
+      const targetElement = lastTheadRow.cells.item(0);
+      if (element && targetElement) {
+        if (typeof element === "string") {
+          targetElement.innerHTML = element;
+        } else if (element instanceof HTMLElement) {
+          targetElement.appendChild(element);
+        }
+        targetElement.setAttribute(TABLE_CONSTANTS.attributes.CUSTOM_CELL_TEMPLATE, "");
+      }
+    });
+  }
+};
+
+// dist/build/lib/staging/src/table/table-adapter.ts
+var TableAdapter = class extends BaseAdapter {
+  constructor(component) {
+    super(component);
+  }
+  initialize() {
+    if (!this._tableElement) {
+      this._tableElement = document.createElement("table");
+      this._tableElement.classList.add(TABLE_CONSTANTS.classes.TABLE);
+      if (this._component.children.length) {
+        removeAllChildren(this._component);
+      }
+      this._component.appendChild(this._tableElement);
+    }
+  }
+  getTableElement() {
+    if (!this._tableElement) {
+      this.initialize();
+    }
+    return this._tableElement;
+  }
+  createTable(configuration) {
+    return TableUtils.createTable(configuration);
+  }
+  recreateTableBody(configuration) {
+    TableUtils.recreateTableBody(configuration);
+  }
+  setSelectedRows(tableElement, key, data, selectedRows, preserveExisting = false) {
+    TableUtils.setSelectedRows(tableElement, key, data, selectedRows, preserveExisting);
+  }
+  clearSelectedRows(tableElement) {
+    TableUtils.clearSelectedRows(tableElement);
+  }
+  updateSelectedState(rowElement, isSelected) {
+    TableUtils.updateSelectedState(rowElement, isSelected);
+  }
+  updateSelectAllState(tableElement, isAllSelected, isIndeterminate) {
+    TableUtils.updateSelectAllState(tableElement, isAllSelected, isIndeterminate);
+  }
+  setSortedColumn(tableElement, columnIndex, sortDirection) {
+    TableUtils.setSortedColumn(tableElement, columnIndex, sortDirection);
+  }
+  removeColumnSort(tableElement, columnIndex) {
+    TableUtils.removeColumnSort(tableElement, columnIndex);
+  }
+  setSortDirection(tableElement, columnIndex, sortDirection) {
+    TableUtils.setSortDirection(tableElement, columnIndex, sortDirection);
+  }
+  setSelectColumnVisibility(tableElement, isVisible, selectListener, selectAllListener, selectAllTemplate, selectCheckboxAlignment, data, tooltipSelect, tooltipSelectAll) {
+    TableUtils.setSelectColumnVisibility(tableElement, isVisible, selectListener, selectAllListener || null, selectAllTemplate || null, selectCheckboxAlignment || null, data || [], tooltipSelect || null, tooltipSelectAll || null);
+  }
+  setDense(tableElement, isDense) {
+    TableUtils.setDenseState(tableElement, isDense);
+  }
+  setRoomy(tableElement, isRoomy) {
+    TableUtils.setRoomyState(tableElement, isRoomy);
+  }
+  setResizable(configuration) {
+    TableUtils.setResizable(configuration);
+  }
+  setSelectAllVisibility(tableElement, isVisible, listener, selectAllTemplate, selectCheckboxAlignment, tooltipSelectAll = null) {
+    TableUtils.setSelectAllVisibility(tableElement, isVisible, listener, selectAllTemplate, selectCheckboxAlignment || null, tooltipSelectAll || null);
+  }
+  setFilterRow(configuration) {
+    TableUtils.setFilterRow(configuration);
+  }
+  expandRow(configuration, rowIndex, template) {
+    return TableUtils.expandRow(configuration, rowIndex, template);
+  }
+  collapseRow(configuration, rowIndex) {
+    return TableUtils.collapseRow(configuration, rowIndex);
+  }
+  isRowExpanded(configuration, rowIndex) {
+    return TableUtils.isRowExpanded(configuration, rowIndex);
+  }
+  setFixedHeaders(configuration) {
+    TableUtils.setFixedHeaders(configuration);
+  }
+  setTableLayoutType(configuration) {
+    TableUtils.setLayoutType(configuration);
+  }
+  setWrapContentState(configuration) {
+    TableUtils.setWrapContentState(configuration.tableElement, configuration.wrapContent);
+  }
+  addDocumentListener(type, listener) {
+    TableUtils.getOwnerDocument(this._component).addEventListener(type, listener);
+  }
+  removeDocumentListener(type, listener) {
+    TableUtils.getOwnerDocument(this._component).removeEventListener(type, listener);
+  }
+  normalizeColumnWidths(configuration) {
+    TableUtils.normalizeColumnWidths(configuration);
+  }
+  setResizeColumnVisibility(configuration, columnIndex, isVisible) {
+    TableUtils.setColumnResizeIndicatorVisibility(configuration, columnIndex, isVisible);
+  }
+  addTableClass(classes2) {
+    addClass(classes2, this._tableElement);
+  }
+  removeTableClass(classes2) {
+    removeClass(classes2, this._tableElement);
+  }
+  setRowClickListeners(tableElement, allowClick, clickListener, doubleClickListener) {
+    TableUtils.setRowClickListeners(tableElement, allowClick, clickListener, doubleClickListener);
+  }
+  setRowClickAttributes(tableElement, allowClick) {
+    TableUtils.setRowClickAttributes(tableElement, allowClick);
+  }
+};
+
+// dist/build/lib/staging/src/table/multi-sort-manager.ts
+var MultiSortManager = class {
+  constructor() {
+    this._sortedColumns = [];
+  }
+  get sortedColumns() {
+    return [...this._sortedColumns.map((c) => __spreadValues({}, c))];
+  }
+  addSortColumn(column) {
+    this._sortedColumns.push(__spreadValues({}, column));
+    this._updateSortNumbers();
+  }
+  updateSortColumn(column) {
+    const col = this._sortedColumns.find((c) => c.columnIndex === column.columnIndex);
+    if (col) {
+      switch (col.direction) {
+        case "ASC" /* Ascending */:
+          this.removeSortColumn(column);
+          break;
+        case "DESC" /* Descending */:
+          col.direction = "ASC" /* Ascending */;
+          break;
+        case "UNSET" /* Unset */:
+          col.direction = "DESC" /* Descending */;
+          break;
+      }
+    }
+  }
+  setSortColumns(columns) {
+    this._sortedColumns = [...columns.map((c) => __spreadValues({}, c))];
+  }
+  removeSortColumn(columnOrIndex) {
+    if (typeof columnOrIndex === "number") {
+      this._sortedColumns.splice(columnOrIndex, 1);
+    } else {
+      this._sortedColumns.splice(this._sortedColumns.indexOf(columnOrIndex), 1);
+    }
+    this._updateSortNumbers();
+  }
+  isSortColumn(columnOrIndex) {
+    if (typeof columnOrIndex === "number") {
+      return this._sortedColumns.some((c) => c.columnIndex === columnOrIndex);
+    } else {
+      return this._sortedColumns.includes(columnOrIndex);
+    }
+  }
+  clearMultiSort() {
+    this._sortedColumns = [];
+  }
+  getSortColumn(columnIndex) {
+    return this._sortedColumns.find((c) => c.columnIndex === columnIndex);
+  }
+  _updateSortNumbers() {
+    if (this._sortedColumns.every((c) => typeof c.sortOrder === "number")) {
+      this._sortedColumns.sort((col1, col2) => col1.sortOrder - col2.sortOrder);
+    }
+    this._sortedColumns.forEach((column, index) => column.sortOrder = index + 1);
+  }
+};
+
+// dist/build/lib/staging/src/table/table-row.ts
+var TableRow = class {
+  constructor(data, selected = false) {
+    this.data = data;
+    this.selected = selected;
+  }
+};
+
+// dist/build/lib/staging/src/table/table-foundation.ts
+var TableFoundation = class {
+  constructor(_adapter) {
+    this._adapter = _adapter;
+    this._tableRows = [];
+    this._data = [];
+    this._columnConfigurations = [];
+    this._select = false;
+    this._multiselect = true;
+    this._dense = false;
+    this._roomy = false;
+    this._filter = false;
+    this._fixedHeaders = false;
+    this._layoutType = TABLE_CONSTANTS.strings.DEFAULT_LAYOUT_TYPE;
+    this._wrapContent = true;
+    this._resizable = false;
+    this._minResizeWidth = TABLE_CONSTANTS.numbers.MIN_RESIZE_WIDTH;
+    this._multiColumnSort = false;
+    this._selectCheckboxAlignment = "center" /* Center */;
+    this._isAllSelected = false;
+    this._sortedColumnIndex = -1;
+    this._rendered = false;
+    this._allowRowClick = false;
+    this._multiSortManager = new MultiSortManager();
+    this._rowClickListener = (evt) => this._onRowClick(evt);
+    this._rowDoubleClickListener = (evt) => this._onRowDoubleClick(evt);
+    this._selectRowListener = (evt) => this._onRowSelected(evt);
+    this._selectAllListener = (evt) => this._onSelectAll(evt);
+    this._headRowMouseDownListener = (evt) => this._onHeadRowMouseDown(evt);
+    this._headRowContextMenuListener = (evt) => this._onHeadRowContextMenu(evt);
+    this._documentMouseMoveListener = (evt) => this._onMouseMove(evt);
+    this._documentMouseUpListener = (evt) => this._onMouseUp(evt);
+    this._filterListener = (value, columnIndex) => this._onFilter(value, columnIndex);
+    this._selectionManager = new ItemManager(this._selectKey);
+    this._hiddenColumnManager = new ItemManager();
+  }
+  initialize() {
+    this.connect();
+    this._adapter.setHostAttribute(TABLE_CONSTANTS.attributes.SELECT, this._select.toString());
+    this._adapter.setHostAttribute(TABLE_CONSTANTS.attributes.MULTISELECT, this._multiselect.toString());
+    this._adapter.setHostAttribute(TABLE_CONSTANTS.attributes.DENSE, this._dense.toString());
+    this._adapter.setHostAttribute(TABLE_CONSTANTS.attributes.ROOMY, this._roomy.toString());
+    this._adapter.setHostAttribute(TABLE_CONSTANTS.attributes.FILTER, this._filter.toString());
+    this._adapter.emitHostEvent(TABLE_CONSTANTS.events.INITIALIZED, void 0, false);
+  }
+  connect() {
+    this._adapter.initialize();
+  }
+  disconnect() {
+    this._resizeDescriptor = void 0;
+    this._adapter.removeDocumentListener("mousemove", this._documentMouseMoveListener);
+    this._adapter.removeDocumentListener("mouseup", this._documentMouseUpListener);
+  }
+  set data(value) {
+    if (Array.isArray(value) && value.length > 0) {
+      if (isObject(value[0])) {
+        this._data = value.map((v) => __spreadValues({}, v));
+      } else {
+        this._data = [...value];
+      }
+    } else {
+      this._data = [];
+    }
+    this._tableRows = this._data.map((data) => new TableRow(data, this._selectionManager.exists(data)));
+    this._renderBody();
+  }
+  get data() {
+    return JSON.parse(JSON.stringify(this._data));
+  }
+  set columnConfigurations(value) {
+    this._columnConfigurations = value.map((cc) => __spreadValues({}, cc));
+    this._hiddenColumnManager.clear();
+    this._columnConfigurations.forEach((cc) => {
+      if (cc.hidden) {
+        this._hiddenColumnManager.add(cc);
+      }
+    });
+    this._refreshTableSort();
+    this.render();
+  }
+  get columnConfigurations() {
+    return this._columnConfigurations.map((cc) => __spreadValues({}, cc));
+  }
+  get _visibleColumnConfigurations() {
+    return this._columnConfigurations.filter((cc) => !this._hiddenColumnManager.exists(cc));
+  }
+  get _tableConfiguration() {
+    return {
+      tableElement: this._adapter.getTableElement(),
+      columnConfigurations: this._visibleColumnConfigurations,
+      data: this._tableRows,
+      clickListener: this._allowRowClick ? this._rowClickListener : null,
+      doubleClickListener: this._allowRowClick ? this._rowDoubleClickListener : null,
+      selectListener: this._select ? this._selectRowListener : null,
+      selectAllListener: this._multiselect ? this._selectAllListener : null,
+      headRowMouseDownListener: this._headRowMouseDownListener,
+      headRowContextMenuListener: this._headRowContextMenuListener,
+      filterListener: this._filter ? this._filterListener : null,
+      sortDirection: this._sortDirection,
+      sortedColumn: this._sortedColumnIndex,
+      multiColumnSort: this._multiColumnSort,
+      filter: this._filter,
+      wrapContent: this._wrapContent,
+      fixedHeaders: this._fixedHeaders,
+      layoutType: this._layoutType,
+      dense: this._dense,
+      resizable: this._resizable,
+      rowCreatedCallback: this._rowCreatedCallback,
+      cellCreatedCallback: this._cellCreatedCallback,
+      selectAllTemplate: this._selectAllTemplate,
+      selectCheckboxAlignment: this._selectCheckboxAlignment,
+      tooltipSelect: this._tooltipSelect,
+      tooltipSelectAll: this._tooltipSelectAll
+    };
+  }
+  set select(value) {
+    if (this._select !== value) {
+      this._select = value;
+      this._adapter.setSelectColumnVisibility(this._adapter.getTableElement(), this._select, this._selectRowListener, this._multiselect ? this._selectAllListener : void 0, this._multiselect ? this._selectAllTemplate : null, this._selectCheckboxAlignment, this._tableRows, this._tooltipSelect, this._tooltipSelectAll);
+      this._updateSelections(true);
+      if (this._select) {
+        this._adapter.setHostAttribute(TABLE_CONSTANTS.attributes.SELECT, this._select.toString());
+      } else {
+        this._adapter.removeHostAttribute(TABLE_CONSTANTS.attributes.SELECT);
+      }
+    }
+  }
+  get select() {
+    return this._select;
+  }
+  set multiselect(value) {
+    if (this._multiselect !== value) {
+      this._multiselect = value;
+      if (this._select) {
+        this._adapter.setSelectAllVisibility(this._adapter.getTableElement(), this._multiselect, this._multiselect ? this._selectAllListener : null, this._multiselect ? this.selectAllTemplate : null, this._selectCheckboxAlignment, this._tooltipSelectAll);
+        this._updateSelections(true);
+      }
+      this._adapter.setHostAttribute(TABLE_CONSTANTS.attributes.MULTISELECT, this._multiselect.toString());
+    }
+  }
+  get multiselect() {
+    return this._multiselect;
+  }
+  get selectKey() {
+    if (Array.isArray(this._selectKey)) {
+      return [...this._selectKey];
+    }
+    return this._selectKey;
+  }
+  set selectKey(value) {
+    if (this._originalSelectKey === value) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      this._originalSelectKey = [...value];
+      this._selectKey = [...value];
+    } else {
+      this._originalSelectKey = value;
+      this._selectKey = [value];
+    }
+    this._selectionManager.setKey(this._selectKey);
+    this._updateSelections(false);
+  }
+  get dense() {
+    return this._dense;
+  }
+  set dense(value) {
+    if (this._dense !== value) {
+      this._dense = value;
+      this._adapter.setDense(this._adapter.getTableElement(), this._dense);
+      this._adapter.setHostAttribute(TABLE_CONSTANTS.attributes.DENSE, this._dense.toString());
+    }
+  }
+  get roomy() {
+    return this._roomy;
+  }
+  set roomy(value) {
+    if (value !== this._roomy) {
+      this._roomy = value;
+      this._applyRoomy();
+    }
+  }
+  set filter(value) {
+    if (this._filter !== value) {
+      this._filter = value;
+      this._adapter.setFilterRow(this._tableConfiguration);
+      this._adapter.setHostAttribute(TABLE_CONSTANTS.attributes.FILTER, this._filter.toString());
+    }
+  }
+  get filter() {
+    return this._filter;
+  }
+  set fixedHeaders(value) {
+    if (this._fixedHeaders !== value) {
+      this._fixedHeaders = value;
+      this._adapter.setFixedHeaders(this._tableConfiguration);
+    }
+  }
+  get fixedHeaders() {
+    return this._fixedHeaders;
+  }
+  get layoutType() {
+    return this._layoutType;
+  }
+  set layoutType(value) {
+    if (this._layoutType !== value) {
+      this._layoutType = value;
+      this._adapter.setTableLayoutType(this._tableConfiguration);
+    }
+  }
+  get wrapContent() {
+    return this._wrapContent;
+  }
+  set wrapContent(value) {
+    if (this._wrapContent !== value) {
+      this._wrapContent = value;
+      this._adapter.setWrapContentState(this._tableConfiguration);
+    }
+  }
+  get resizable() {
+    return this._resizable;
+  }
+  set resizable(value) {
+    if (this._resizable !== value) {
+      this._resizable = value;
+      this._adapter.setResizable(this._tableConfiguration);
+    }
+  }
+  get minResizeWidth() {
+    return this._minResizeWidth;
+  }
+  set minResizeWidth(value) {
+    if (this._minResizeWidth !== value) {
+      this._minResizeWidth = value;
+      if (!isNumber(this._minResizeWidth)) {
+        this._minResizeWidth = TABLE_CONSTANTS.numbers.MIN_RESIZE_WIDTH;
+      } else if (this._minResizeWidth < 0) {
+        this._minResizeWidth = 0;
+      }
+    }
+  }
+  get allowRowClick() {
+    return this._allowRowClick;
+  }
+  set allowRowClick(value) {
+    if (this._allowRowClick !== value) {
+      this._allowRowClick = value;
+      if (this._rendered) {
+        this._adapter.setRowClickListeners(this._adapter.getTableElement(), this._allowRowClick, this._rowClickListener, this._rowDoubleClickListener);
+        this._adapter.setRowClickAttributes(this._adapter.getTableElement(), this._allowRowClick);
+      }
+    }
+  }
+  get multiColumnSort() {
+    return this._multiColumnSort;
+  }
+  set multiColumnSort(value) {
+    if (value !== this._multiColumnSort) {
+      this._multiColumnSort = value;
+      this._refreshTableSort();
+      this.render();
+    }
+  }
+  get selectCheckboxAlignment() {
+    return this._selectCheckboxAlignment;
+  }
+  set selectCheckboxAlignment(value) {
+    if (value !== this._selectCheckboxAlignment) {
+      this._selectCheckboxAlignment = value;
+      this._adapter.setHostAttribute(TABLE_CONSTANTS.attributes.SELECT_CHECKBOX_ALIGNMENT, value);
+      this.render();
+    }
+  }
+  get tooltipSelect() {
+    return this._tooltipSelect;
+  }
+  set tooltipSelect(value) {
+    if (value !== this._tooltipSelect) {
+      this._tooltipSelect = value;
+      if (typeof value === "string") {
+        this._adapter.setHostAttribute(TABLE_CONSTANTS.attributes.TOOLTIP_SELECT, value);
+      }
+      this.render();
+    }
+  }
+  get tooltipSelectAll() {
+    return this._tooltipSelectAll;
+  }
+  set tooltipSelectAll(value) {
+    if (value !== this._tooltipSelectAll) {
+      this._tooltipSelectAll = value;
+      this._adapter.setHostAttribute(TABLE_CONSTANTS.attributes.TOOLTIP_SELECT_ALL, value);
+      this.render();
+    }
+  }
+  get selectAllTemplate() {
+    return this._selectAllTemplate;
+  }
+  set selectAllTemplate(value) {
+    if (value !== this._selectAllTemplate) {
+      this._selectAllTemplate = value;
+      this.render();
+    }
+  }
+  get rowCreated() {
+    return this._rowCreatedCallback;
+  }
+  set rowCreated(value) {
+    this._rowCreatedCallback = value;
+  }
+  get cellCreated() {
+    return this._cellCreatedCallback;
+  }
+  set cellCreated(value) {
+    this._cellCreatedCallback = value;
+  }
+  isRowSelected(rowData) {
+    const predicate = createPredicate(Array.isArray(this._selectKey) ? this._selectKey : [this._selectKey], rowData);
+    return this.selectKey ? !!this._selectionManager.getItems().find((item) => matchesPredicate(item, predicate)) : this._selectionManager.exists(rowData);
+  }
+  getSelectedRows() {
+    return this._selectionManager.getItems();
+  }
+  selectRows(data, clearCurrentSelections) {
+    if (!this._selectKey) {
+      throw new Error("You must set a selectKey to select rows.");
+    }
+    if (!this._multiselect || clearCurrentSelections) {
+      this.clearSelections();
+    }
+    if (data && data.length) {
+      this._selectionManager.add(data);
+      this._updateSelections(!clearCurrentSelections);
+    }
+  }
+  deselectRows(data) {
+    if (data && data.length) {
+      this._selectionManager.remove(data);
+      this._updateSelections(false);
+    }
+  }
+  clearSelections() {
+    const tableElement = this._adapter.getTableElement();
+    this._selectionManager.clear();
+    this._tableRows.forEach((tableRow) => tableRow.selected = false);
+    this._isAllSelected = false;
+    this._adapter.clearSelectedRows(tableElement);
+    if (this._select && this._multiselect) {
+      this._adapter.updateSelectAllState(tableElement, false);
+    }
+  }
+  hideColumn(columnIndex) {
+    const columnConfig = this._columnConfigurations[columnIndex];
+    if (this._sortedColumnIndex === columnIndex) {
+      this._sortedColumnIndex = -1;
+    }
+    if (!this._hiddenColumnManager.exists(columnConfig)) {
+      this._hiddenColumnManager.add(columnConfig);
+      this.render();
+    }
+  }
+  showColumn(columnIndex) {
+    const columnConfig = this._columnConfigurations[columnIndex];
+    if (this._hiddenColumnManager.exists(columnConfig)) {
+      this._hiddenColumnManager.remove(columnConfig);
+      this.render();
+    }
+  }
+  render() {
+    this._adapter.createTable(this._tableConfiguration);
+    this._renderSelections();
+    this._rendered = true;
+  }
+  _renderBody() {
+    if (!this._rendered) {
+      return;
+    }
+    this._adapter.recreateTableBody(this._tableConfiguration);
+    this._renderSelections();
+  }
+  _renderSelections() {
+    if (this.select) {
+      this._isAllSelected = this._getSelectAllState();
+      if (this._multiselect) {
+        this._adapter.updateSelectAllState(this._adapter.getTableElement(), this._isAllSelected, this._isIndeterminate(this._isAllSelected));
+      }
+    }
+    const selections = this._selectionManager.getItems();
+    if (selections.length) {
+      this._adapter.setSelectedRows(this._adapter.getTableElement(), this._selectKey, this._data, selections, false);
+    }
+  }
+  expandRow(rowIndex, template) {
+    if (!this._rendered) {
+      throw new Error("Cannot expand a row before the table has rendered.");
+    }
+    if (rowIndex < 0 || rowIndex > this._tableRows.length) {
+      throw new Error(`Invalid row index: ${rowIndex}.`);
+    }
+    return this._adapter.expandRow(this._tableConfiguration, rowIndex, template);
+  }
+  collapseRow(rowIndex) {
+    if (!this._rendered) {
+      return Promise.resolve();
+    }
+    if (rowIndex < 0 || rowIndex > this._tableRows.length) {
+      return Promise.resolve();
+    }
+    return this._adapter.collapseRow(this._tableConfiguration, rowIndex);
+  }
+  isRowExpanded(rowIndex) {
+    return this._adapter.isRowExpanded(this._tableConfiguration, rowIndex);
+  }
+  selectRowsByIndex(indexes, preserveExisting) {
+    const rowsToSelect = indexes.map((i) => this._data[i]).filter((obj) => !!obj);
+    this.selectRows(rowsToSelect, !preserveExisting);
+  }
+  deselectRowsByIndex(indexes) {
+    const rowsToDeselect = indexes.map((i) => this._data[i]).filter((obj) => !!obj);
+    this.deselectRows(rowsToDeselect);
+  }
+  _getSelectAllState() {
+    return this._tableRows.length > 0 && this._tableRows.every((tr) => tr.selected);
+  }
+  _updateSelections(preserveExisting) {
+    this._tableRows.forEach((tableRow) => tableRow.selected = this._selectionManager.exists(tableRow.data));
+    const isAllSelected = this._getSelectAllState();
+    this._adapter.setSelectedRows(this._adapter.getTableElement(), this._selectKey, this._data, this._selectionManager.getItems(), preserveExisting);
+    if (isAllSelected !== this._isAllSelected || this._isIndeterminate(isAllSelected)) {
+      this._isAllSelected = isAllSelected;
+      if (this._multiselect) {
+        this._adapter.updateSelectAllState(this._adapter.getTableElement(), this._isAllSelected, this._isIndeterminate(this._isAllSelected));
+      }
+    }
+  }
+  _onRowClick(evt) {
+    evt.stopImmediatePropagation();
+    if (evt.target.tagName === "INPUT" && evt.target.type === "checkbox") {
+      return;
+    }
+    const composedPath = getEventPath(evt);
+    const composedElements = composedPath.filter((node) => node.nodeType === 1);
+    const customCellTemplateElement = composedElements.find((el) => el.hasAttribute(TABLE_CONSTANTS.attributes.CUSTOM_CELL_TEMPLATE));
+    const stopClickPropagation = customCellTemplateElement && customCellTemplateElement.hasAttribute(TABLE_CONSTANTS.attributes.CUSTOM_CELL_TEMPLATE_STOP_PROPAGATION);
+    if (stopClickPropagation) {
+      return;
+    }
+    const { index, data } = this._getSelectedRowFromEvent(evt);
+    const evtData = { index, data };
+    this._adapter.emitHostEvent(TABLE_CONSTANTS.events.ROW_CLICK, evtData, true, false);
+  }
+  _onRowDoubleClick(evt) {
+    evt.stopPropagation();
+    if (evt.target.tagName === "INPUT" && evt.target.type === "checkbox") {
+      return;
+    }
+    const rowSelectedInfo = this._getSelectedRowFromEvent(evt);
+    const detail = {
+      index: rowSelectedInfo.index,
+      data: rowSelectedInfo.data
+    };
+    this._adapter.emitHostEvent(TABLE_CONSTANTS.events.SELECT_DOUBLE, detail, true, false);
+  }
+  _onRowSelected(evt) {
+    const rowSelectedInfo = this._getSelectedRowFromEvent(evt);
+    if (!this._multiselect) {
+      const existingSelections = this._tableRows.filter((item) => item.selected);
+      existingSelections.forEach((selection) => {
+        if (!matchesPredicate(selection.data, createPredicate(this._selectKey, rowSelectedInfo.data))) {
+          this.deselectRows([selection.data]);
+        }
+      });
+    }
+    const isSelected = !this._selectionManager.exists(rowSelectedInfo.data);
+    this._adapter.updateSelectedState(rowSelectedInfo.rowElement, isSelected);
+    if (isSelected) {
+      this._selectionManager.add(rowSelectedInfo.data);
+    } else {
+      this._selectionManager.remove(rowSelectedInfo.data);
+    }
+    this._tableRows[rowSelectedInfo.index].selected = isSelected;
+    let selectionIndexes = [rowSelectedInfo.index];
+    let isAllSelected = false;
+    if (this._multiselect) {
+      const shift = evt.shiftKey;
+      if (shift && this._previouslyClickedRow) {
+        selectionIndexes = this._shiftSelectRows(rowSelectedInfo);
+        if (selectionIndexes.includes(this._previouslyClickedRow.index)) {
+          const idx = selectionIndexes.indexOf(this._previouslyClickedRow.index);
+          selectionIndexes.splice(idx, 1);
+        }
+      }
+      isAllSelected = this._getSelectAllState();
+      this._adapter.updateSelectAllState(this._adapter.getTableElement(), isAllSelected, this._isIndeterminate(isAllSelected));
+    }
+    for (const index of selectionIndexes) {
+      const data = this._tableRows[index].data;
+      const selected = this._selectionManager.exists(data);
+      const detail = { selected, index, data };
+      this._adapter.emitHostEvent(TABLE_CONSTANTS.events.SELECT, detail, true, false);
+    }
+    if (this._isAllSelected !== isAllSelected) {
+      this._isAllSelected = isAllSelected;
+      const data = {
+        status: this._isAllSelected,
+        count: this._tableRows.filter((row) => row.selected).length,
+        data: [...this._data],
+        targetType: "row"
+      };
+      this._adapter.emitHostEvent(TABLE_CONSTANTS.events.SELECT_ALL, data, true, false);
+    }
+    this._previouslyClickedRow = __spreadValues({}, rowSelectedInfo);
+  }
+  _getSelectedRowFromEvent(evt) {
+    const composedPath = getEventPath(evt);
+    const rowElement = composedPath.find((el) => el.tagName === "TR");
+    const tbody = rowElement.parentElement;
+    const index = this._getNonExpandedRows(tbody).findIndex((el) => el === rowElement);
+    const data = this._tableRows[index].data;
+    return { rowElement, index, data };
+  }
+  _getNonExpandedRows(tbodyElement) {
+    return Array.from(tbodyElement.rows).filter((row) => !row.classList.contains(TABLE_CONSTANTS.classes.TABLE_ROW_EXPANDABLE_CONTENT));
+  }
+  _onSelectAll(evt) {
+    evt.stopPropagation();
+    this._isAllSelected = !this._isAllSelected;
+    const tableElement = this._adapter.getTableElement();
+    this._adapter.updateSelectAllState(tableElement, this._isAllSelected);
+    this._tableRows.forEach((tableRow, index) => {
+      tableRow.selected = this._isAllSelected;
+      if (this._isAllSelected) {
+        this._selectionManager.add(tableRow.data);
+      } else {
+        this._selectionManager.remove(tableRow.data);
+      }
+      const rowElement = TableUtils.getRowByIndex(tableElement, index);
+      if (rowElement) {
+        this._adapter.updateSelectedState(rowElement, this._isAllSelected);
+      }
+    });
+    const data = {
+      status: this._isAllSelected,
+      count: this._tableRows.filter((row) => row.selected).length,
+      data: [...this._data],
+      targetType: "select-all"
+    };
+    this._adapter.emitHostEvent(TABLE_CONSTANTS.events.SELECT_ALL, data, true, false);
+  }
+  _onHeadRowContextMenu(evt) {
+    evt.preventDefault();
+  }
+  _onHeadRowMouseDown(evt) {
+    if (evt.button !== 0) {
+      return;
+    }
+    const composedPath = getEventPath(evt);
+    const target = evt.target;
+    const rowElement = composedPath.find((el) => el.tagName === "TR");
+    const thElement = composedPath.find((el) => el.tagName === "TH");
+    const cellIndex = Array.from(rowElement.cells).findIndex((c) => c === thElement);
+    this._headCellMouseDownIndex = cellIndex;
+    if (target !== thElement && target.classList.contains(TABLE_CONSTANTS.classes.TABLE_RESIZE_HANDLE)) {
+      this._resizeDescriptor = {
+        element: thElement,
+        startWidth: thElement.offsetWidth,
+        startX: evt.pageX,
+        width: thElement.offsetWidth,
+        index: this._select ? cellIndex - 1 : cellIndex
+      };
+      this._adapter.addDocumentListener("mousemove", this._documentMouseMoveListener);
+      this._adapter.setResizeColumnVisibility(this._tableConfiguration, cellIndex, true);
+    }
+    this._adapter.addDocumentListener("mouseup", this._documentMouseUpListener);
+  }
+  _onMouseMove(evt) {
+    if (this._resizeDescriptor) {
+      let newWidth = this._resizeDescriptor.startWidth + (evt.pageX - this._resizeDescriptor.startX);
+      if (newWidth < this._minResizeWidth) {
+        newWidth = this._minResizeWidth;
+      }
+      this._resizeDescriptor.width = newWidth;
+      this._resizeDescriptor.element.style.width = `${newWidth}px`;
+      this._adapter.addTableClass(TABLE_CONSTANTS.classes.TABLE_RESIZING);
+    }
+  }
+  _onMouseUp(evt) {
+    this._adapter.removeDocumentListener("mousemove", this._documentMouseMoveListener);
+    this._adapter.removeDocumentListener("mouseup", this._documentMouseUpListener);
+    this._adapter.removeTableClass(TABLE_CONSTANTS.classes.TABLE_RESIZING);
+    if (this._headCellMouseDownIndex === void 0) {
+      return;
+    }
+    if (this._resizeDescriptor) {
+      this._adapter.normalizeColumnWidths(this._tableConfiguration);
+      this._adapter.setResizeColumnVisibility(this._tableConfiguration, this._headCellMouseDownIndex, false);
+      const resizeEventData = {
+        index: this._resizeDescriptor.index,
+        width: this._resizeDescriptor.width
+      };
+      this._adapter.emitHostEvent(TABLE_CONSTANTS.events.COLUMN_RESIZE, resizeEventData);
+      this._resizeDescriptor = void 0;
+    } else if (this._tableConfiguration.tableElement.tHead.contains(evt.target)) {
+      if (this._multiColumnSort) {
+        this._onMultiSort(this._headCellMouseDownIndex, evt.ctrlKey);
+      } else {
+        this._onSort(this._headCellMouseDownIndex);
+      }
+    }
+    this._headCellMouseDownIndex = void 0;
+  }
+  _onSort(cellIndex) {
+    const columnIndex = this._select ? cellIndex - 1 : cellIndex;
+    const columnConfig = columnIndex >= 0 ? this._visibleColumnConfigurations[columnIndex] : null;
+    if (!columnConfig || !columnConfig.sortable) {
+      return;
+    }
+    let desiredSortDirection = "ASC" /* Ascending */;
+    const isTogglingSortOnSameColumn = columnIndex === this._sortedColumnIndex;
+    const currentSortDirectionIsAscending = this._sortDirection === "ASC" /* Ascending */ || this._sortDirection === void 0;
+    const isUnsorting = isTogglingSortOnSameColumn && this._sortDirection === "DESC" /* Descending */;
+    if (isTogglingSortOnSameColumn && currentSortDirectionIsAscending) {
+      desiredSortDirection = "DESC" /* Descending */;
+    }
+    if (isUnsorting && !columnConfig.preventUnsort) {
+      desiredSortDirection = "UNSET" /* Unset */;
+    }
+    const data = {
+      direction: desiredSortDirection,
+      columnIndex
+    };
+    if (!this._adapter.emitHostEvent(TABLE_CONSTANTS.events.SORT, data, true, true)) {
+      return;
+    }
+    if (isTogglingSortOnSameColumn && this._sortDirection === "DESC" /* Descending */ && !columnConfig.preventUnsort) {
+      this._adapter.removeColumnSort(this._adapter.getTableElement(), this._select ? this._sortedColumnIndex + 1 : this._sortedColumnIndex);
+      this._sortedColumnIndex = -1;
+      return;
+    }
+    this._sortDirection = desiredSortDirection;
+    if (columnIndex === this._sortedColumnIndex) {
+      this._adapter.setSortDirection(this._adapter.getTableElement(), cellIndex, this._sortDirection);
+    } else {
+      if (this._sortedColumnIndex >= 0) {
+        this._adapter.removeColumnSort(this._adapter.getTableElement(), this._select ? this._sortedColumnIndex + 1 : this._sortedColumnIndex);
+      }
+      this._sortedColumnIndex = columnIndex;
+      this._adapter.setSortedColumn(this._adapter.getTableElement(), cellIndex, this._sortDirection);
+    }
+  }
+  _onMultiSort(cellIndex, ctrlKey) {
+    const columnIndex = this._select ? cellIndex - 1 : cellIndex;
+    const columnConfig = columnIndex >= 0 ? this._visibleColumnConfigurations[columnIndex] : null;
+    if (!columnConfig || !columnConfig.sortable) {
+      return;
+    }
+    const revertColumns = this._multiSortManager.sortedColumns;
+    const sortColumn = this._multiSortManager.getSortColumn(columnIndex);
+    if (sortColumn) {
+      this._multiSortManager.updateSortColumn(sortColumn);
+    } else if (ctrlKey) {
+      this._multiSortManager.addSortColumn({ direction: "DESC" /* Descending */, columnIndex, propertyName: columnConfig.property });
+    } else {
+      this._multiSortManager.clearMultiSort();
+      this._multiSortManager.addSortColumn({ direction: "DESC" /* Descending */, columnIndex, propertyName: columnConfig.property });
+    }
+    const data = this._multiSortManager.sortedColumns.map((col) => __spreadValues({}, col));
+    if (!this._adapter.emitHostEvent(TABLE_CONSTANTS.events.SORT, data, true, true)) {
+      this._multiSortManager.setSortColumns(revertColumns);
+      return;
+    }
+    const newSortedColumns = this._multiSortManager.sortedColumns;
+    const hasMultipleColumnsSorted = newSortedColumns.length > 1;
+    for (let virtualIndex = 0; virtualIndex < this._visibleColumnConfigurations.length; virtualIndex++) {
+      const actualIndex = this._select ? virtualIndex + 1 : virtualIndex;
+      if (!this._multiSortManager.isSortColumn(virtualIndex)) {
+        this._adapter.removeColumnSort(this._adapter.getTableElement(), actualIndex);
+        TableUtils.setMultiSortColumnSortNumber(this._adapter.getTableElement(), hasMultipleColumnsSorted, actualIndex, null);
+      } else {
+        const column = this._multiSortManager.getSortColumn(virtualIndex);
+        if (column) {
+          this._adapter.setSortedColumn(this._adapter.getTableElement(), actualIndex, column.direction);
+          TableUtils.setMultiSortColumnSortNumber(this._adapter.getTableElement(), hasMultipleColumnsSorted, actualIndex, column.sortOrder || null);
+        }
+      }
+    }
+  }
+  _onFilter(value, columnIndex) {
+    const data = { value, columnIndex };
+    this._adapter.emitHostEvent(TABLE_CONSTANTS.events.FILTER, data, true, false);
+  }
+  _shiftSelectRows(selectedRow) {
+    const indexes = [];
+    if (this._previouslyClickedRow) {
+      const prevIndex = this._previouslyClickedRow.index;
+      const currIndex = selectedRow.index;
+      let startIndex = currIndex >= prevIndex ? prevIndex : currIndex;
+      let endIndex = currIndex >= prevIndex ? currIndex : prevIndex;
+      endIndex += endIndex > startIndex ? 1 : 0;
+      startIndex += startIndex > endIndex ? 1 : 0;
+      let action = (data) => this.selectRows(data, false);
+      const existingSelection = this._tableRows.find((item) => item.selected && item.data === selectedRow.data);
+      const shouldDeselect = this._tableRows.find((item) => {
+        var _a;
+        return item.data === ((_a = this._previouslyClickedRow) == null ? void 0 : _a.data) && !item.selected;
+      });
+      if (!existingSelection || shouldDeselect) {
+        action = (data) => this.deselectRows(data);
+      }
+      for (let i = startIndex; i < endIndex; i++) {
+        indexes.push(i);
+      }
+      action(this.data.filter((v, i) => indexes.includes(i)));
+    }
+    return indexes;
+  }
+  _isIndeterminate(isAllSelected) {
+    return !isAllSelected && this.getSelectedRows().length > 0 && this._data.length !== this.getSelectedRows().length;
+  }
+  _applyRoomy() {
+    this._adapter.setRoomy(this._adapter.getTableElement(), this._roomy);
+    this._adapter.setHostAttribute(TABLE_CONSTANTS.attributes.ROOMY, this._roomy.toString());
+  }
+  _refreshTableSort() {
+    this._sortedColumnIndex = this._visibleColumnConfigurations.findIndex((c) => c.initialSort);
+    this._sortDirection = this._sortedColumnIndex >= 0 ? this._visibleColumnConfigurations[this._sortedColumnIndex].sortDirection : void 0;
+    if (this._multiColumnSort) {
+      const sortedColumns = [];
+      this._visibleColumnConfigurations.forEach((col, index) => {
+        if (typeof col.initialSort === "object") {
+          sortedColumns.push({
+            columnIndex: index,
+            direction: col.initialSort.direction,
+            sortOrder: col.initialSort.sortOrder,
+            propertyName: col.property
+          });
+        }
+      });
+      this._multiSortManager.setSortColumns(sortedColumns);
+    }
+  }
+};
+
+// dist/build/lib/staging/src/table/table.ts
+var TableComponent = class extends BaseComponent {
+  constructor() {
+    super();
+    IconRegistry.define(tylIconArrowDownward);
+    this._foundation = new TableFoundation(new TableAdapter(this));
+  }
+  static get observedAttributes() {
+    return [
+      TABLE_CONSTANTS.attributes.SELECT,
+      TABLE_CONSTANTS.attributes.MULTISELECT,
+      TABLE_CONSTANTS.attributes.SELECT_KEY,
+      TABLE_CONSTANTS.attributes.DENSE,
+      TABLE_CONSTANTS.attributes.ROOMY,
+      TABLE_CONSTANTS.attributes.FILTER,
+      TABLE_CONSTANTS.attributes.FIXED_HEADERS,
+      TABLE_CONSTANTS.attributes.LAYOUT_TYPE,
+      TABLE_CONSTANTS.attributes.WRAP_CONTENT,
+      TABLE_CONSTANTS.attributes.RESIZABLE,
+      TABLE_CONSTANTS.attributes.MIN_RESIZE_WIDTH,
+      TABLE_CONSTANTS.attributes.ALLOW_ROW_CLICK,
+      TABLE_CONSTANTS.attributes.MULTI_COLUMN_SORT,
+      TABLE_CONSTANTS.attributes.SELECT_CHECKBOX_ALIGNMENT,
+      TABLE_CONSTANTS.attributes.TOOLTIP_SELECT,
+      TABLE_CONSTANTS.attributes.TOOLTIP_SELECT_ALL
+    ];
+  }
+  initializedCallback() {
+    this._foundation.initialize();
+  }
+  connectedCallback() {
+    this._foundation.connect();
+  }
+  disconnectedCallback() {
+    this._foundation.disconnect();
+  }
+  attributeChangedCallback(name, oldValue, newValue) {
+    switch (name) {
+      case TABLE_CONSTANTS.attributes.SELECT:
+        this.select = coerceBoolean(newValue);
+        break;
+      case TABLE_CONSTANTS.attributes.MULTISELECT:
+        this.multiselect = coerceBoolean(newValue);
+        break;
+      case TABLE_CONSTANTS.attributes.SELECT_KEY:
+        this.selectKey = newValue;
+        break;
+      case TABLE_CONSTANTS.attributes.DENSE:
+        this.dense = coerceBoolean(newValue);
+        break;
+      case TABLE_CONSTANTS.attributes.ROOMY:
+        this.roomy = coerceBoolean(newValue);
+        break;
+      case TABLE_CONSTANTS.attributes.FILTER:
+        this.filter = coerceBoolean(newValue);
+        break;
+      case TABLE_CONSTANTS.attributes.FIXED_HEADERS:
+        this.fixedHeaders = coerceBoolean(newValue);
+        break;
+      case TABLE_CONSTANTS.attributes.LAYOUT_TYPE:
+        this.layoutType = newValue;
+        break;
+      case TABLE_CONSTANTS.attributes.WRAP_CONTENT:
+        this.wrapContent = coerceBoolean(newValue);
+        break;
+      case TABLE_CONSTANTS.attributes.RESIZABLE:
+        this.resizable = coerceBoolean(newValue);
+        break;
+      case TABLE_CONSTANTS.attributes.MIN_RESIZE_WIDTH:
+        this.minResizeWidth = coerceNumber(newValue);
+        break;
+      case TABLE_CONSTANTS.attributes.ALLOW_ROW_CLICK:
+        this.allowRowClick = coerceBoolean(newValue);
+        break;
+      case TABLE_CONSTANTS.attributes.MULTI_COLUMN_SORT:
+        this.multiColumnSort = coerceBoolean(newValue);
+        break;
+      case TABLE_CONSTANTS.attributes.SELECT_CHECKBOX_ALIGNMENT:
+        this.selectCheckboxAlignment = this.getAttribute(TABLE_CONSTANTS.attributes.SELECT_CHECKBOX_ALIGNMENT) || "center" /* Center */;
+        break;
+      case TABLE_CONSTANTS.attributes.TOOLTIP_SELECT:
+        this.tooltipSelect = newValue;
+        break;
+      case TABLE_CONSTANTS.attributes.TOOLTIP_SELECT_ALL:
+        this.tooltipSelectAll = newValue;
+        break;
+    }
+  }
+  hideColumn(columnIndex) {
+    this._foundation.hideColumn(columnIndex);
+  }
+  showColumn(columnIndex) {
+    this._foundation.showColumn(columnIndex);
+  }
+  getSelectedRows() {
+    return this._foundation.getSelectedRows();
+  }
+  selectRow(data) {
+    this._foundation.selectRows([data], false);
+  }
+  selectRows(data, preserveExisting = false) {
+    this._foundation.selectRows(data, !preserveExisting);
+  }
+  deselectRow(data) {
+    this._foundation.deselectRows([data]);
+  }
+  deselectRows(data) {
+    this._foundation.deselectRows(data);
+  }
+  clearSelections() {
+    this._foundation.clearSelections();
+  }
+  render() {
+    this._foundation.render();
+  }
+  expandRow(rowIndex, template) {
+    return this._foundation.expandRow(rowIndex, template);
+  }
+  collapseRow(rowIndex) {
+    return this._foundation.collapseRow(rowIndex);
+  }
+  isRowExpanded(rowIndex) {
+    return this._foundation.isRowExpanded(rowIndex);
+  }
+  selectRowsByIndex(indexes, preserveExisting) {
+    if (typeof indexes === "number") {
+      this._foundation.selectRowsByIndex([indexes], preserveExisting);
+    } else if (Array.isArray(indexes)) {
+      this._foundation.selectRowsByIndex(indexes, preserveExisting);
+    }
+  }
+  deselectRowsByIndex(indexes) {
+    if (typeof indexes === "number") {
+      this._foundation.deselectRowsByIndex([indexes]);
+    } else if (Array.isArray(indexes)) {
+      this._foundation.deselectRowsByIndex(indexes);
+    }
+  }
+  isRowSelected(rowData) {
+    return this._foundation.isRowSelected(rowData);
+  }
+};
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "data", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "columnConfigurations", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "select", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "multiselect", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "selectKey", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "tooltipSelect", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "tooltipSelectAll", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "dense", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "roomy", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "filter", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "fixedHeaders", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "layoutType", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "wrapContent", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "resizable", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "minResizeWidth", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "allowRowClick", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "multiColumnSort", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "rowCreated", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "cellCreated", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "selectAllTemplate", 2);
+__decorateClass([
+  FoundationProperty()
+], TableComponent.prototype, "selectCheckboxAlignment", 2);
+TableComponent = __decorateClass([
+  CustomElement({
+    name: TABLE_CONSTANTS.elementName,
+    dependencies: [
+      ExpansionPanelComponent,
+      IconComponent
+    ]
+  })
+], TableComponent);
+
+// dist/build/lib/staging/src/table/index.ts
+function defineTableComponent() {
+  defineCustomElement(TableComponent);
+}
+
+export {
+  TABLE_CONSTANTS,
+  CellAlign,
+  SortDirection,
+  TableFilterType,
+  TableAdapter,
+  TableRow,
+  TableFoundation,
+  TableComponent,
+  defineTableComponent
+};
+//# sourceMappingURL=chunk.BOWCSPCH.js.map