@tylertech/forge 2.8.0 → 2.10.0

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

@@ -1,2430 +0,0 @@
-/**
- * @license
- * Copyright 2022 Tyler Technologies, Inc. 
- * License: Apache-2.0
- */
-import {
-  createPredicate,
-  findWhere,
-  getPropertyValue,
-  matchesPredicate
-} from "./chunk.RV3E762Y.js";
-import {
-  CHECKBOX_CONSTANTS,
-  CheckboxComponent
-} from "./chunk.7UAH67PT.js";
-import {
-  EXPANSION_PANEL_CONSTANTS,
-  ExpansionPanelComponent
-} from "./chunk.KNR5DXE4.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.WSH4S3GM.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,
-      CheckboxComponent
-    ]
-  })
-], 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.XE7ZMJBZ.js.map