cax-design-system 2.8.2 → 2.8.3

package/esm2022/table/table.mjs

@@ -0,0 +1,2799 @@
+import { CommonModule, DOCUMENT, isPlatformBrowser } from '@angular/common';
+import { booleanAttribute, ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, Inject, Input, numberAttribute, Output, PLATFORM_ID, ViewChild, ViewEncapsulation } from '@angular/core';
+import { FilterMatchMode, FilterOperator, CaxTemplate } from 'cax-design-system/api';
+import { DomHandler } from 'cax-design-system/dom';
+import { ScrollerModule } from 'cax-design-system/scroller';
+import { ObjectUtils, UniqueComponentId } from 'cax-design-system/utils';
+import { ArrowDownIcon } from 'cax-design-system/icons/arrowdown';
+import { ArrowUpIcon } from 'cax-design-system/icons/arrowup';
+import { SpinnerIcon } from 'cax-design-system/icons/spinner';
+import { PaginatorModule } from 'cax-design-system/paginator';
+import { TableBody } from './components/table-body/table-body';
+import * as i0 from "@angular/core";
+import * as i1 from "./table.service";
+import * as i2 from "cax-design-system/api";
+import * as i3 from "@angular/platform-browser";
+import * as i4 from "@angular/common";
+import * as i5 from "cax-design-system/paginator";
+import * as i6 from "cax-design-system/scroller";
+/**
+ * Table displays data in tabular format.
+ * @group Components
+ */
+export class Table {
+    document;
+    platformId;
+    renderer;
+    el;
+    zone;
+    tableService;
+    cd;
+    filterService;
+    overlayService;
+    config;
+    domSanitizer;
+    fontSize = 'md';
+    rowSize = 'md';
+    /**
+     * An array of objects to represent dynamic columns that are frozen.
+     * @group Props
+     */
+    frozenColumns;
+    /**
+     * An array of objects to display as frozen.
+     * @group Props
+     */
+    frozenValue;
+    /**
+     * Inline style of the component.
+     * @group Props
+     */
+    style;
+    /**
+     * Style class of the component.
+     * @group Props
+     */
+    styleClass;
+    /**
+     * Inline style of the table.
+     * @group Props
+     */
+    tableStyle;
+    /**
+     * Style class of the table.
+     * @group Props
+     */
+    tableStyleClass;
+    /**
+     * When specified as true, enables the pagination.
+     * @group Props
+     */
+    paginator;
+    /**
+     * Number of page links to display in paginator.
+     * @group Props
+     */
+    pageLinks = 5;
+    /**
+     * Array of integer/object values to display inside rows per page dropdown of paginator
+     * @group Props
+     */
+    rowsPerPageOptions;
+    /**
+     * Whether to show it even there is only one page.
+     * @group Props
+     */
+    alwaysShowPaginator = true;
+    /**
+     * Position of the paginator, options are "top", "bottom" or "both".
+     * @group Props
+     */
+    paginatorPosition = 'bottom';
+    /**
+     * Custom style class for paginator
+     * @group Props
+     */
+    paginatorStyleClass;
+    /**
+     * Target element to attach the paginator dropdown overlay, valid values are "body" or a local ng-template variable of another element (note: use binding with brackets for template variables, e.g. [appendTo]="mydiv" for a div element having #mydiv as variable name).
+     * @group Props
+     */
+    paginatorDropdownAppendTo;
+    /**
+     * Paginator dropdown height of the viewport in pixels, a scrollbar is defined if height of list exceeds this value.
+     * @group Props
+     */
+    paginatorDropdownScrollHeight = '200px';
+    /**
+     * Template of the current page report element. Available placeholders are {currentPage},{totalPages},{rows},{first},{last} and {totalRecords}
+     * @group Props
+     */
+    currentPageReportTemplate = '{currentPage} of {totalPages}';
+    /**
+     * Whether to display current page report.
+     * @group Props
+     */
+    showCurrentPageReport;
+    /**
+     * Whether to display a dropdown to navigate to any page.
+     * @group Props
+     */
+    showJumpToPageDropdown;
+    /**
+     * Whether to display a input to navigate to any page.
+     * @group Props
+     */
+    showJumpToPageInput;
+    /**
+     * When enabled, icons are displayed on paginator to go first and last page.
+     * @group Props
+     */
+    showFirstLastIcon = true;
+    /**
+     * Whether to show page links.
+     * @group Props
+     */
+    showPageLinks = true;
+    /**
+     * Sort order to use when an unsorted column gets sorted by user interaction.
+     * @group Props
+     */
+    defaultSortOrder = 1;
+    /**
+     * Defines whether sorting works on single column or on multiple columns.
+     * @group Props
+     */
+    filterType = 'default';
+    sortType = 'default';
+    sortMode = 'single';
+    /**
+     * When true, resets paginator to first page after sorting. Available only when sortMode is set to single.
+     * @group Props
+     */
+    resetPageOnSort = true;
+    /**
+     * Specifies the selection mode, valid values are "single" and "multiple".
+     * @group Props
+     */
+    selectionMode;
+    /**
+     * When enabled with paginator and checkbox selection mode, the select all checkbox in the header will select all rows on the current page.
+     * @group Props
+     */
+    selectionPageOnly;
+    /**
+     * Selected row with a context menu.
+     * @group Props
+     */
+    contextMenuSelection;
+    /**
+     * Callback to invoke on context menu selection change.
+     * @param {*} object - row data.
+     * @group Emits
+     */
+    contextMenuSelectionChange = new EventEmitter();
+    /**
+     *  Defines the behavior of context menu selection, in "separate" mode context menu updates contextMenuSelection property whereas in joint mode selection property is used instead so that when row selection is enabled, both row selection and context menu selection use the same property.
+     * @group Props
+     */
+    contextMenuSelectionMode = 'separate';
+    /**
+     * A property to uniquely identify a record in data.
+     * @group Props
+     */
+    dataKey;
+    /**
+     * Defines whether metaKey should be considered for the selection. On touch enabled devices, metaKeySelection is turned off automatically.
+     * @group Props
+     */
+    metaKeySelection = false;
+    /**
+     * Defines if the row is selectable.
+     * @group Props
+     */
+    rowSelectable;
+    /**
+     * Function to optimize the dom operations by delegating to ngForTrackBy, default algorithm checks for object identity.
+     * @group Props
+     */
+    rowTrackBy = (index, item) => item;
+    /**
+     * Defines if data is loaded and interacted with in lazy manner.
+     * @group Props
+     */
+    lazy = false;
+    /**
+     * Whether to call lazy loading on initialization.
+     * @group Props
+     */
+    lazyLoadOnInit = true;
+    /**
+     * Algorithm to define if a row is selected, valid values are "equals" that compares by reference and "deepEquals" that compares all fields.
+     * @group Props
+     */
+    compareSelectionBy = 'deepEquals';
+    /**
+     * Character to use as the csv separator.
+     * @group Props
+     */
+    csvSeparator = ',';
+    /**
+     * Name of the exported file.
+     * @group Props
+     */
+    exportFilename = 'download';
+    /**
+     * An array of FilterMetadata objects to provide external filters.
+     * @group Props
+     */
+    filters = {};
+    /**
+     * An array of fields as string to use in global filtering.
+     * @group Props
+     */
+    globalFilterFields;
+    /**
+     * Delay in milliseconds before filtering the data.
+     * @group Props
+     */
+    filterDelay = 300;
+    /**
+     * Locale to use in filtering. The default locale is the host environment's current locale.
+     * @group Props
+     */
+    filterLocale;
+    /**
+     * Map instance to keep the expanded rows where key of the map is the data key of the row.
+     * @group Props
+     */
+    expandedRowKeys = {};
+    /**
+     * Map instance to keep the rows being edited where key of the map is the data key of the row.
+     * @group Props
+     */
+    editingRowKeys = {};
+    /**
+     * Whether multiple rows can be expanded at any time. Valid values are "multiple" and "single".
+     * @group Props
+     */
+    rowExpandMode = 'multiple';
+    /**
+     * Enables scrollable tables.
+     * @group Props
+     */
+    scrollable;
+    /**
+     * Orientation of the scrolling, options are "vertical", "horizontal" and "both".
+     * @group Props
+     * @deprecated Property is obselete since v14.2.0.
+     */
+    scrollDirection = 'vertical';
+    /**
+     * Type of the row grouping, valid values are "subheader" and "rowspan".
+     * @group Props
+     */
+    rowGroupMode;
+    /**
+     * Height of the scroll viewport in fixed pixels or the "flex" keyword for a dynamic size.
+     * @group Props
+     */
+    scrollHeight;
+    /**
+     * Whether the data should be loaded on demand during scroll.
+     * @group Props
+     */
+    virtualScroll;
+    /**
+     * Height of a row to use in calculations of virtual scrolling.
+     * @group Props
+     */
+    virtualScrollItemSize;
+    /**
+     * Whether to use the scroller feature. The properties of scroller component can be used like an object in it.
+     * @group Props
+     */
+    virtualScrollOptions;
+    /**
+     * Threshold in milliseconds to delay lazy loading during scrolling.
+     * @group Props
+     */
+    virtualScrollDelay = 250;
+    /**
+     * Width of the frozen columns container.
+     * @group Props
+     */
+    frozenWidth;
+    /**
+     * Defines if the table is responsive.
+     * @group Props
+     * @deprecated table is always responsive with scrollable behavior.
+     */
+    get responsive() {
+        return this._responsive;
+    }
+    set responsive(val) {
+        this._responsive = val;
+        console.warn('responsive property is deprecated as table is always responsive with scrollable behavior.');
+    }
+    _responsive;
+    /**
+     * Local ng-template varilable of a ContextMenu.
+     * @group Props
+     */
+    contextMenu;
+    /**
+     * When enabled, columns can be resized using drag and drop.
+     * @group Props
+     */
+    resizableColumns;
+    /**
+     * Defines whether the overall table width should change on column resize, valid values are "fit" and "expand".
+     * @group Props
+     */
+    columnResizeMode = 'fit';
+    /**
+     * When enabled, columns can be reordered using drag and drop.
+     * @group Props
+     */
+    reorderableColumns;
+    /**
+     * Displays a loader to indicate data load is in progress.
+     * @group Props
+     */
+    loading;
+    /**
+     * The icon to show while indicating data load is in progress.
+     * @group Props
+     */
+    loadingIcon;
+    /**
+     * Whether to show the loading mask when loading property is true.
+     * @group Props
+     */
+    showLoader = true;
+    /**
+     * Adds hover effect to rows without the need for selectionMode. Note that tr elements that can be hovered need to have "cax-selectable-row" class for rowHover to work.
+     * @group Props
+     */
+    rowHover;
+    /**
+     * Whether to use the default sorting or a custom one using sortFunction.
+     * @group Props
+     */
+    customSort;
+    /**
+     * Whether to use the initial sort badge or not.
+     * @group Props
+     */
+    showInitialSortBadge = true;
+    /**
+     * Whether the cell widths scale according to their content or not.  Deprecated:  Table layout is always "auto".
+     * @group Props
+     */
+    autoLayout;
+    /**
+     * Export function.
+     * @group Props
+     */
+    exportFunction;
+    /**
+     * Custom export header of the column to be exported as CSV.
+     * @group Props
+     */
+    exportHeader;
+    /**
+     * Unique identifier of a stateful table to use in state storage.
+     * @group Props
+     */
+    stateKey;
+    /**
+     * Defines where a stateful table keeps its state, valid values are "session" for sessionStorage and "local" for localStorage.
+     * @group Props
+     */
+    stateStorage = 'session';
+    /**
+     * Defines the editing mode, valid values are "cell" and "row".
+     * @group Props
+     */
+    editMode = 'cell';
+    /**
+     * Field name to use in row grouping.
+     * @group Props
+     */
+    groupRowsBy;
+    /**
+     * Order to sort when default row grouping is enabled.
+     * @group Props
+     */
+    groupRowsByOrder = 1;
+    /**
+     * Defines the responsive mode, valid options are "stack" and "scroll".
+     * @group Props
+     */
+    responsiveLayout = 'scroll';
+    /**
+     * The breakpoint to define the maximum width boundary when using stack responsive layout.
+     * @group Props
+     */
+    breakpoint = '960px';
+    /**
+     * Locale to be used in paginator formatting.
+     * @group Props
+     */
+    paginatorLocale;
+    /**
+     * An array of objects to display.
+     * @group Props
+     */
+    get value() {
+        return this._value;
+    }
+    set value(val) {
+        this._value = val;
+    }
+    /**
+     * An array of objects to represent dynamic columns.
+     * @group Props
+     */
+    get columns() {
+        return this._columns;
+    }
+    set columns(cols) {
+        this._columns = cols;
+    }
+    /**
+     * Index of the first row to be displayed.
+     * @group Props
+     */
+    get first() {
+        return this._first;
+    }
+    set first(val) {
+        this._first = val;
+    }
+    /**
+     * Number of rows to display per page.
+     * @group Props
+     */
+    get rows() {
+        return this._rows;
+    }
+    set rows(val) {
+        this._rows = val;
+    }
+    /**
+     * Number of total records, defaults to length of value when not defined.
+     * @group Props
+     */
+    get totalRecords() {
+        return this._totalRecords;
+    }
+    set totalRecords(val) {
+        this._totalRecords = val;
+        this.tableService.onTotalRecordsChange(this._totalRecords);
+    }
+    /**
+     * Name of the field to sort data by default.
+     * @group Props
+     */
+    get sortField() {
+        return this._sortField;
+    }
+    set sortField(val) {
+        this._sortField = val;
+    }
+    /**
+     * Order to sort when default sorting is enabled.
+     * @group Props
+     */
+    get sortOrder() {
+        return this._sortOrder;
+    }
+    set sortOrder(val) {
+        this._sortOrder = val;
+    }
+    /**
+     * An array of SortMeta objects to sort the data by default in multiple sort mode.
+     * @group Props
+     */
+    get multiSortMeta() {
+        return this._multiSortMeta;
+    }
+    set multiSortMeta(val) {
+        this._multiSortMeta = val;
+    }
+    /**
+     * Selected row in single mode or an array of values in multiple mode.
+     * @group Props
+     */
+    get selection() {
+        return this._selection;
+    }
+    set selection(val) {
+        this._selection = val;
+    }
+    /**
+     * Whether all data is selected.
+     * @group Props
+     */
+    get selectAll() {
+        return this._selection;
+    }
+    set selectAll(val) {
+        this._selection = val;
+    }
+    /**
+     * Emits when the all of the items selected or unselected.
+     * @param {TableSelectAllChangeEvent} event - custom  all selection change event.
+     * @group Emits
+     */
+    selectAllChange = new EventEmitter();
+    /**
+     * Callback to invoke on selection changed.
+     * @param {any | null} value - selected data.
+     * @group Emits
+     */
+    selectionChange = new EventEmitter();
+    /**
+     * Callback to invoke when a row is selected.
+     * @param {TableRowSelectEvent} event - custom select event.
+     * @group Emits
+     */
+    onRowSelect = new EventEmitter();
+    /**
+     * Callback to invoke when a row is unselected.
+     * @param {TableRowUnSelectEvent} event - custom unselect event.
+     * @group Emits
+     */
+    onRowUnselect = new EventEmitter();
+    /**
+     * Callback to invoke when pagination occurs.
+     * @param {TablePageEvent} event - custom pagination event.
+     * @group Emits
+     */
+    onPage = new EventEmitter();
+    /**
+     * Callback to invoke when a column gets sorted.
+     * @param {Object} object - sort meta.
+     * @group Emits
+     */
+    onSort = new EventEmitter();
+    /**
+     * Callback to invoke when data is filtered.
+     * @param {TableFilterEvent} event - custom filtering event.
+     * @group Emits
+     */
+    onFilter = new EventEmitter();
+    /**
+     * Callback to invoke when paging, sorting or filtering happens in lazy mode.
+     * @param {TableLazyLoadEvent} event - custom lazy loading event.
+     * @group Emits
+     */
+    onLazyLoad = new EventEmitter();
+    /**
+     * Callback to invoke when a row is expanded.
+     * @param {TableRowExpandEvent} event - custom row expand event.
+     * @group Emits
+     */
+    onRowExpand = new EventEmitter();
+    /**
+     * Callback to invoke when a row is collapsed.
+     * @param {TableRowCollapseEvent} event - custom row collapse event.
+     * @group Emits
+     */
+    onRowCollapse = new EventEmitter();
+    /**
+     * Callback to invoke when a row is selected with right click.
+     * @param {TableContextMenuSelectEvent} event - custom context menu select event.
+     * @group Emits
+     */
+    onContextMenuSelect = new EventEmitter();
+    /**
+     * Callback to invoke when a column is resized.
+     * @param {TableColResizeEvent} event - custom column resize event.
+     * @group Emits
+     */
+    onColResize = new EventEmitter();
+    /**
+     * Callback to invoke when a column is reordered.
+     * @param {TableColumnReorderEvent} event - custom column reorder event.
+     * @group Emits
+     */
+    onColReorder = new EventEmitter();
+    /**
+     * Callback to invoke when a row is reordered.
+     * @param {TableRowReorderEvent} event - custom row reorder event.
+     * @group Emits
+     */
+    onRowReorder = new EventEmitter();
+    /**
+     * Callback to invoke when a cell switches to edit mode.
+     * @param {TableEditInitEvent} event - custom edit init event.
+     * @group Emits
+     */
+    onEditInit = new EventEmitter();
+    /**
+     * Callback to invoke when cell edit is completed.
+     * @param {TableEditCompleteEvent} event - custom edit complete event.
+     * @group Emits
+     */
+    onEditComplete = new EventEmitter();
+    /**
+     * Callback to invoke when cell edit is cancelled with escape key.
+     * @param {TableEditCancelEvent} event - custom edit cancel event.
+     * @group Emits
+     */
+    onEditCancel = new EventEmitter();
+    /**
+     * Callback to invoke when state of header checkbox changes.
+     * @param {TableHeaderCheckboxToggleEvent} event - custom header checkbox event.
+     * @group Emits
+     */
+    onHeaderCheckboxToggle = new EventEmitter();
+    /**
+     * A function to implement custom sorting, refer to sorting section for details.
+     * @param {any} any - sort meta.
+     * @group Emits
+     */
+    sortFunction = new EventEmitter();
+    /**
+     * Callback to invoke on pagination.
+     * @param {number} number - first element.
+     * @group Emits
+     */
+    firstChange = new EventEmitter();
+    /**
+     * Callback to invoke on rows change.
+     * @param {number} number - Row count.
+     * @group Emits
+     */
+    rowsChange = new EventEmitter();
+    /**
+     * Callback to invoke table state is saved.
+     * @param {TableState} object - table state.
+     * @group Emits
+     */
+    onStateSave = new EventEmitter();
+    /**
+     * Callback to invoke table state is restored.
+     * @param {TableState} object - table state.
+     * @group Emits
+     */
+    onStateRestore = new EventEmitter();
+    containerViewChild;
+    resizeHelperViewChild;
+    reorderIndicatorUpViewChild;
+    reorderIndicatorDownViewChild;
+    wrapperViewChild;
+    tableViewChild;
+    tableHeaderViewChild;
+    tableFooterViewChild;
+    scroller;
+    templates;
+    /**
+     * Indicates the height of rows to be scrolled.
+     * @group Props
+     * @deprecated use virtualScrollItemSize property instead.
+     */
+    get virtualRowHeight() {
+        return this._virtualRowHeight;
+    }
+    set virtualRowHeight(val) {
+        this._virtualRowHeight = val;
+        console.warn('The virtualRowHeight property is deprecated.');
+    }
+    _virtualRowHeight = 28;
+    _value = [];
+    _columns;
+    _totalRecords = 0;
+    _first = 0;
+    _rows;
+    filteredValue;
+    headerTemplate;
+    headerGroupedTemplate;
+    bodyTemplate;
+    loadingBodyTemplate;
+    captionTemplate;
+    footerTemplate;
+    footerGroupedTemplate;
+    summaryTemplate;
+    colGroupTemplate;
+    expandedRowTemplate;
+    groupHeaderTemplate;
+    groupFooterTemplate;
+    frozenExpandedRowTemplate;
+    frozenHeaderTemplate;
+    frozenBodyTemplate;
+    frozenFooterTemplate;
+    frozenColGroupTemplate;
+    emptyMessageTemplate;
+    paginatorLeftTemplate;
+    paginatorRightTemplate;
+    paginatorDropdownItemTemplate;
+    loadingIconTemplate;
+    reorderIndicatorUpIconTemplate;
+    reorderIndicatorDownIconTemplate;
+    sortIconTemplate;
+    checkboxIconTemplate;
+    headerCheckboxIconTemplate;
+    paginatorDropdownIconTemplate;
+    paginatorFirstPageLinkIconTemplate;
+    paginatorLastPageLinkIconTemplate;
+    paginatorPreviousPageLinkIconTemplate;
+    paginatorNextPageLinkIconTemplate;
+    selectionKeys = {};
+    lastResizerHelperX;
+    reorderIconWidth;
+    reorderIconHeight;
+    draggedColumn;
+    draggedRowIndex;
+    droppedRowIndex;
+    rowDragging;
+    dropPosition;
+    editingCell;
+    editingCellData;
+    editingCellField;
+    editingCellRowIndex;
+    selfClick;
+    documentEditListener;
+    _multiSortMeta;
+    _sortField;
+    _sortOrder = 1;
+    preventSelectionSetterPropagation;
+    _selection;
+    _selectAll = null;
+    anchorRowIndex;
+    rangeRowIndex;
+    filterTimeout;
+    initialized;
+    rowTouched;
+    restoringSort;
+    restoringFilter;
+    stateRestored;
+    columnOrderStateRestored;
+    columnWidthsState;
+    tableWidthState;
+    overlaySubscription;
+    resizeColumnElement;
+    columnResizing = false;
+    rowGroupHeaderStyleObject = {};
+    id = UniqueComponentId();
+    styleElement;
+    responsiveStyleElement;
+    window;
+    constructor(document, platformId, renderer, el, zone, tableService, cd, filterService, overlayService, config, domSanitizer) {
+        this.document = document;
+        this.platformId = platformId;
+        this.renderer = renderer;
+        this.el = el;
+        this.zone = zone;
+        this.tableService = tableService;
+        this.cd = cd;
+        this.filterService = filterService;
+        this.overlayService = overlayService;
+        this.config = config;
+        this.domSanitizer = domSanitizer;
+        this.window = this.document.defaultView;
+    }
+    ngOnInit() {
+        if (this.lazy && this.lazyLoadOnInit) {
+            if (!this.virtualScroll) {
+                this.onLazyLoad.emit(this.createLazyLoadMetadata());
+            }
+            if (this.restoringFilter) {
+                this.restoringFilter = false;
+            }
+        }
+        if (this.responsiveLayout === 'stack') {
+            this.createResponsiveStyle();
+        }
+        this.initialized = true;
+    }
+    ngAfterContentInit() {
+        this.templates.forEach((item) => {
+            switch (item.getType()) {
+                case 'caption':
+                    this.captionTemplate = item.template;
+                    break;
+                case 'header':
+                    this.headerTemplate = item.template;
+                    break;
+                case 'headergrouped':
+                    this.headerGroupedTemplate = item.template;
+                    break;
+                case 'body':
+                    this.bodyTemplate = item.template;
+                    break;
+                case 'loadingbody':
+                    this.loadingBodyTemplate = item.template;
+                    break;
+                case 'footer':
+                    this.footerTemplate = item.template;
+                    break;
+                case 'footergrouped':
+                    this.footerGroupedTemplate = item.template;
+                    break;
+                case 'summary':
+                    this.summaryTemplate = item.template;
+                    break;
+                case 'colgroup':
+                    this.colGroupTemplate = item.template;
+                    break;
+                case 'rowexpansion':
+                    this.expandedRowTemplate = item.template;
+                    break;
+                case 'groupheader':
+                    this.groupHeaderTemplate = item.template;
+                    break;
+                case 'groupfooter':
+                    this.groupFooterTemplate = item.template;
+                    break;
+                case 'frozenheader':
+                    this.frozenHeaderTemplate = item.template;
+                    break;
+                case 'frozenbody':
+                    this.frozenBodyTemplate = item.template;
+                    break;
+                case 'frozenfooter':
+                    this.frozenFooterTemplate = item.template;
+                    break;
+                case 'frozencolgroup':
+                    this.frozenColGroupTemplate = item.template;
+                    break;
+                case 'frozenrowexpansion':
+                    this.frozenExpandedRowTemplate = item.template;
+                    break;
+                case 'emptymessage':
+                    this.emptyMessageTemplate = item.template;
+                    break;
+                case 'paginatorleft':
+                    this.paginatorLeftTemplate = item.template;
+                    break;
+                case 'paginatorright':
+                    this.paginatorRightTemplate = item.template;
+                    break;
+                case 'paginatordropdownicon':
+                    this.paginatorDropdownIconTemplate = item.template;
+                    break;
+                case 'paginatordropdownitem':
+                    this.paginatorDropdownItemTemplate = item.template;
+                    break;
+                case 'paginatorfirstpagelinkicon':
+                    this.paginatorFirstPageLinkIconTemplate = item.template;
+                    break;
+                case 'paginatorlastpagelinkicon':
+                    this.paginatorLastPageLinkIconTemplate = item.template;
+                    break;
+                case 'paginatorpreviouspagelinkicon':
+                    this.paginatorPreviousPageLinkIconTemplate = item.template;
+                    break;
+                case 'paginatornextpagelinkicon':
+                    this.paginatorNextPageLinkIconTemplate = item.template;
+                    break;
+                case 'loadingicon':
+                    this.loadingIconTemplate = item.template;
+                    break;
+                case 'reorderindicatorupicon':
+                    this.reorderIndicatorUpIconTemplate = item.template;
+                    break;
+                case 'reorderindicatordownicon':
+                    this.reorderIndicatorDownIconTemplate = item.template;
+                    break;
+                case 'sorticon':
+                    this.sortIconTemplate = item.template;
+                    break;
+                case 'checkboxicon':
+                    this.checkboxIconTemplate = item.template;
+                    break;
+                case 'headercheckboxicon':
+                    this.headerCheckboxIconTemplate = item.template;
+                    break;
+            }
+        });
+    }
+    ngAfterViewInit() {
+        if (isPlatformBrowser(this.platformId)) {
+            if (this.isStateful() && this.resizableColumns) {
+                this.restoreColumnWidths();
+            }
+        }
+    }
+    ngOnChanges(simpleChange) {
+        if (simpleChange.value) {
+            if (this.isStateful() && !this.stateRestored && isPlatformBrowser(this.platformId)) {
+                this.restoreState();
+            }
+            this._value = simpleChange.value.currentValue;
+            if (!this.lazy) {
+                this.totalRecords = this._value ? this._value.length : 0;
+                if (this.sortMode == 'single' && (this.sortField || this.groupRowsBy))
+                    this.sortSingle();
+                else if (this.sortMode == 'multiple' && (this.multiSortMeta || this.groupRowsBy))
+                    this.sortMultiple();
+                else if (this.hasFilter())
+                    //sort already filters
+                    this._filter();
+            }
+            this.tableService.onValueChange(simpleChange.value.currentValue);
+        }
+        if (simpleChange.columns) {
+            if (!this.isStateful()) {
+                this._columns = simpleChange.columns.currentValue;
+                this.tableService.onColumnsChange(simpleChange.columns.currentValue);
+            }
+            if (this._columns && this.isStateful() && this.reorderableColumns && !this.columnOrderStateRestored) {
+                this.restoreColumnOrder();
+                this.tableService.onColumnsChange(this._columns);
+            }
+        }
+        if (simpleChange.sortField) {
+            this._sortField = simpleChange.sortField.currentValue;
+            //avoid triggering lazy load prior to lazy initialization at onInit
+            if (!this.lazy || this.initialized) {
+                if (this.sortMode === 'single') {
+                    this.sortSingle();
+                }
+            }
+        }
+        if (simpleChange.groupRowsBy) {
+            //avoid triggering lazy load prior to lazy initialization at onInit
+            if (!this.lazy || this.initialized) {
+                if (this.sortMode === 'single') {
+                    this.sortSingle();
+                }
+            }
+        }
+        if (simpleChange.sortOrder) {
+            this._sortOrder = simpleChange.sortOrder.currentValue;
+            //avoid triggering lazy load prior to lazy initialization at onInit
+            if (!this.lazy || this.initialized) {
+                if (this.sortMode === 'single') {
+                    this.sortSingle();
+                }
+            }
+        }
+        if (simpleChange.groupRowsByOrder) {
+            //avoid triggering lazy load prior to lazy initialization at onInit
+            if (!this.lazy || this.initialized) {
+                if (this.sortMode === 'single') {
+                    this.sortSingle();
+                }
+            }
+        }
+        if (simpleChange.multiSortMeta) {
+            this._multiSortMeta = simpleChange.multiSortMeta.currentValue;
+            if (this.sortMode === 'multiple' && (this.initialized || (!this.lazy && !this.virtualScroll))) {
+                this.sortMultiple();
+            }
+        }
+        if (simpleChange.selection) {
+            this._selection = simpleChange.selection.currentValue;
+            if (!this.preventSelectionSetterPropagation) {
+                this.updateSelectionKeys();
+                this.tableService.onSelectionChange();
+            }
+            this.preventSelectionSetterPropagation = false;
+        }
+        if (simpleChange.selectAll) {
+            this._selectAll = simpleChange.selectAll.currentValue;
+            if (!this.preventSelectionSetterPropagation) {
+                this.updateSelectionKeys();
+                this.tableService.onSelectionChange();
+                if (this.isStateful()) {
+                    this.saveState();
+                }
+            }
+            this.preventSelectionSetterPropagation = false;
+        }
+    }
+    get processedData() {
+        return this.filteredValue || this.value || [];
+    }
+    _initialColWidths;
+    dataToRender(data) {
+        const _data = data || this.processedData;
+        if (_data && this.paginator) {
+            const first = this.lazy ? 0 : this.first;
+            return _data.slice(first, first + this.rows);
+        }
+        return _data;
+    }
+    updateSelectionKeys() {
+        if (this.dataKey && this._selection) {
+            this.selectionKeys = {};
+            if (Array.isArray(this._selection)) {
+                for (let data of this._selection) {
+                    this.selectionKeys[String(ObjectUtils.resolveFieldData(data, this.dataKey))] = 1;
+                }
+            }
+            else {
+                this.selectionKeys[String(ObjectUtils.resolveFieldData(this._selection, this.dataKey))] = 1;
+            }
+        }
+    }
+    onPageChange(event) {
+        this.first = event.first;
+        this.rows = event.rows;
+        this.onPage.emit({
+            first: this.first,
+            rows: this.rows
+        });
+        if (this.lazy) {
+            this.onLazyLoad.emit(this.createLazyLoadMetadata());
+        }
+        this.firstChange.emit(this.first);
+        this.rowsChange.emit(this.rows);
+        this.tableService.onValueChange(this.value);
+        if (this.isStateful()) {
+            this.saveState();
+        }
+        this.anchorRowIndex = null;
+        if (this.scrollable) {
+            this.resetScrollTop();
+        }
+    }
+    nextSortOrder = (current) => {
+        switch (current) {
+            case 0:
+                return 1;
+            case 1:
+                return -1;
+            case -1:
+                return 0;
+            default:
+                return 1; // fallback to default if somehow invalid
+        }
+    };
+    sort(event) {
+        let originalEvent = event.originalEvent;
+        if (this.sortMode === 'single') {
+            if (this.sortType === 'custom') {
+                this._sortOrder = this.sortField === event.field ? this.nextSortOrder(this._sortOrder) : this.defaultSortOrder;
+            }
+            else {
+                this._sortOrder = this.sortField === event.field ? this.sortOrder * -1 : this.defaultSortOrder;
+            }
+            this._sortField = event.field;
+            if (this.resetPageOnSort) {
+                this._first = 0;
+                this.firstChange.emit(this._first);
+                if (this.scrollable) {
+                    this.resetScrollTop();
+                }
+            }
+            this.sortSingle();
+        }
+        if (this.sortMode === 'multiple') {
+            let metaKey = originalEvent.metaKey || originalEvent.ctrlKey;
+            let sortMeta = this.getSortMeta(event.field);
+            if (sortMeta) {
+                if (!metaKey) {
+                    if (this.sortType === 'custom') {
+                        this._multiSortMeta = [{ field: event.field, order: this.nextSortOrder(sortMeta.order) }];
+                    }
+                    else {
+                        this._multiSortMeta = [{ field: event.field, order: sortMeta.order * -1 }];
+                    }
+                    if (this.resetPageOnSort) {
+                        this._first = 0;
+                        this.firstChange.emit(this._first);
+                        if (this.scrollable) {
+                            this.resetScrollTop();
+                        }
+                    }
+                }
+                else {
+                    if (this.sortType === 'custom') {
+                        sortMeta.order = this.nextSortOrder(sortMeta.order);
+                    }
+                    else {
+                        sortMeta.order = sortMeta.order * -1;
+                    }
+                }
+            }
+            else {
+                if (!metaKey || !this.multiSortMeta) {
+                    this._multiSortMeta = [];
+                    if (this.resetPageOnSort) {
+                        this._first = 0;
+                        this.firstChange.emit(this._first);
+                    }
+                }
+                this._multiSortMeta.push({ field: event.field, order: this.defaultSortOrder });
+            }
+            this._multiSortMeta = this._multiSortMeta.filter((item) => item.order !== 0);
+            this.sortMultiple();
+        }
+        if (this.isStateful()) {
+            this.saveState();
+        }
+        this.anchorRowIndex = null;
+    }
+    sortSingle() {
+        let field = this.sortField || this.groupRowsBy;
+        let order = this.sortField ? this.sortOrder : this.groupRowsByOrder;
+        if (this.groupRowsBy && this.sortField && this.groupRowsBy !== this.sortField) {
+            this._multiSortMeta = [this.getGroupRowsMeta(), { field: this.sortField, order: this.sortOrder }];
+            this.sortMultiple();
+            return;
+        }
+        if (this.sortType === 'custom') {
+            let sortMeta = {
+                field: field,
+                order: order
+            };
+            this.onSort.emit(sortMeta);
+            this.tableService.onSort(sortMeta);
+        }
+        else {
+            if (field && order) {
+                if (this.restoringSort) {
+                    this.restoringSort = false;
+                }
+                if (this.lazy) {
+                    this.onLazyLoad.emit(this.createLazyLoadMetadata());
+                }
+                else if (this.value) {
+                    if (this.customSort) {
+                        this.sortFunction.emit({
+                            data: this.value,
+                            mode: this.sortMode,
+                            field: field,
+                            order: order
+                        });
+                    }
+                    else {
+                        this.value.sort((data1, data2) => {
+                            let value1 = ObjectUtils.resolveFieldData(data1, field);
+                            let value2 = ObjectUtils.resolveFieldData(data2, field);
+                            let result = null;
+                            if (value1 == null && value2 != null)
+                                result = -1;
+                            else if (value1 != null && value2 == null)
+                                result = 1;
+                            else if (value1 == null && value2 == null)
+                                result = 0;
+                            else if (typeof value1 === 'string' && typeof value2 === 'string')
+                                result = value1.localeCompare(value2);
+                            else
+                                result = value1 < value2 ? -1 : value1 > value2 ? 1 : 0;
+                            return order * result;
+                        });
+                        this._value = [...this.value];
+                    }
+                    if (this.hasFilter()) {
+                        this._filter();
+                    }
+                }
+                let sortMeta = {
+                    field: field,
+                    order: order
+                };
+                this.onSort.emit(sortMeta);
+                this.tableService.onSort(sortMeta);
+            }
+        }
+    }
+    sortMultiple() {
+        if (this.groupRowsBy) {
+            if (!this._multiSortMeta)
+                this._multiSortMeta = [this.getGroupRowsMeta()];
+            else if (this.multiSortMeta[0].field !== this.groupRowsBy)
+                this._multiSortMeta = [this.getGroupRowsMeta(), ...this._multiSortMeta];
+        }
+        if (this.sortType === 'custom') {
+            this.onSort.emit({
+                multisortmeta: this.multiSortMeta
+            });
+            this.tableService.onSort(this.multiSortMeta);
+        }
+        else {
+            if (this.multiSortMeta) {
+                if (this.lazy) {
+                    this.onLazyLoad.emit(this.createLazyLoadMetadata());
+                }
+                else if (this.value) {
+                    if (this.customSort) {
+                        this.sortFunction.emit({
+                            data: this.value,
+                            mode: this.sortMode,
+                            multiSortMeta: this.multiSortMeta
+                        });
+                    }
+                    else {
+                        this.value.sort((data1, data2) => {
+                            return this.multisortField(data1, data2, this.multiSortMeta, 0);
+                        });
+                        this._value = [...this.value];
+                    }
+                    if (this.hasFilter()) {
+                        this._filter();
+                    }
+                }
+                this.onSort.emit({
+                    multisortmeta: this.multiSortMeta
+                });
+                this.tableService.onSort(this.multiSortMeta);
+            }
+        }
+    }
+    multisortField(data1, data2, multiSortMeta, index) {
+        const value1 = ObjectUtils.resolveFieldData(data1, multiSortMeta[index].field);
+        const value2 = ObjectUtils.resolveFieldData(data2, multiSortMeta[index].field);
+        if (ObjectUtils.compare(value1, value2, this.filterLocale) === 0) {
+            return multiSortMeta.length - 1 > index ? this.multisortField(data1, data2, multiSortMeta, index + 1) : 0;
+        }
+        return this.compareValuesOnSort(value1, value2, multiSortMeta[index].order);
+    }
+    compareValuesOnSort(value1, value2, order) {
+        return ObjectUtils.sort(value1, value2, order, this.filterLocale, this.sortOrder);
+    }
+    getSortMeta(field) {
+        if (this.multiSortMeta && this.multiSortMeta.length) {
+            for (let i = 0; i < this.multiSortMeta.length; i++) {
+                if (this.multiSortMeta[i].field === field) {
+                    return this.multiSortMeta[i];
+                }
+            }
+        }
+        return null;
+    }
+    isSorted(field) {
+        if (this.sortMode === 'single') {
+            return this.sortField && this.sortField === field;
+        }
+        else if (this.sortMode === 'multiple') {
+            let sorted = false;
+            if (this.multiSortMeta) {
+                for (let i = 0; i < this.multiSortMeta.length; i++) {
+                    if (this.multiSortMeta[i].field == field) {
+                        sorted = true;
+                        break;
+                    }
+                }
+            }
+            return sorted;
+        }
+        else if (this.sortMode === 'custom') {
+            return this.sortField && this.sortField === field;
+        }
+    }
+    handleRowClick(event) {
+        let target = event.originalEvent.target;
+        let targetNode = target.nodeName;
+        let parentNode = target.parentElement && target.parentElement.nodeName;
+        if (targetNode == 'INPUT' || targetNode == 'BUTTON' || targetNode == 'A' || parentNode == 'INPUT' || parentNode == 'BUTTON' || parentNode == 'A' || DomHandler.hasClass(event.originalEvent.target, 'cax-clickable')) {
+            return;
+        }
+        if (this.selectionMode) {
+            let rowData = event.rowData;
+            let rowIndex = event.rowIndex;
+            this.preventSelectionSetterPropagation = true;
+            if (this.isMultipleSelectionMode() && event.originalEvent.shiftKey && this.anchorRowIndex != null) {
+                DomHandler.clearSelection();
+                if (this.rangeRowIndex != null) {
+                    this.clearSelectionRange(event.originalEvent);
+                }
+                this.rangeRowIndex = rowIndex;
+                this.selectRange(event.originalEvent, rowIndex);
+            }
+            else {
+                let selected = this.isSelected(rowData);
+                if (!selected && !this.isRowSelectable(rowData, rowIndex)) {
+                    return;
+                }
+                let metaSelection = this.rowTouched ? false : this.metaKeySelection;
+                let dataKeyValue = this.dataKey ? String(ObjectUtils.resolveFieldData(rowData, this.dataKey)) : null;
+                this.anchorRowIndex = rowIndex;
+                this.rangeRowIndex = rowIndex;
+                if (metaSelection) {
+                    let metaKey = event.originalEvent.metaKey || event.originalEvent.ctrlKey;
+                    if (selected && metaKey) {
+                        if (this.isSingleSelectionMode()) {
+                            this._selection = null;
+                            this.selectionKeys = {};
+                            this.selectionChange.emit(null);
+                        }
+                        else {
+                            let selectionIndex = this.findIndexInSelection(rowData);
+                            this._selection = this.selection.filter((val, i) => i != selectionIndex);
+                            this.selectionChange.emit(this.selection);
+                            if (dataKeyValue) {
+                                delete this.selectionKeys[dataKeyValue];
+                            }
+                        }
+                        this.onRowUnselect.emit({ originalEvent: event.originalEvent, data: rowData, type: 'row' });
+                    }
+                    else {
+                        if (this.isSingleSelectionMode()) {
+                            this._selection = rowData;
+                            this.selectionChange.emit(rowData);
+                            if (dataKeyValue) {
+                                this.selectionKeys = {};
+                                this.selectionKeys[dataKeyValue] = 1;
+                            }
+                        }
+                        else if (this.isMultipleSelectionMode()) {
+                            if (metaKey) {
+                                this._selection = this.selection || [];
+                            }
+                            else {
+                                this._selection = [];
+                                this.selectionKeys = {};
+                            }
+                            this._selection = [...this.selection, rowData];
+                            this.selectionChange.emit(this.selection);
+                            if (dataKeyValue) {
+                                this.selectionKeys[dataKeyValue] = 1;
+                            }
+                        }
+                        this.onRowSelect.emit({ originalEvent: event.originalEvent, data: rowData, type: 'row', index: rowIndex });
+                    }
+                }
+                else {
+                    if (this.selectionMode === 'single') {
+                        if (selected) {
+                            this._selection = null;
+                            this.selectionKeys = {};
+                            this.selectionChange.emit(this.selection);
+                            this.onRowUnselect.emit({ originalEvent: event.originalEvent, data: rowData, type: 'row', index: rowIndex });
+                        }
+                        else {
+                            this._selection = rowData;
+                            this.selectionChange.emit(this.selection);
+                            this.onRowSelect.emit({ originalEvent: event.originalEvent, data: rowData, type: 'row', index: rowIndex });
+                            if (dataKeyValue) {
+                                this.selectionKeys = {};
+                                this.selectionKeys[dataKeyValue] = 1;
+                            }
+                        }
+                    }
+                    else if (this.selectionMode === 'multiple') {
+                        if (selected) {
+                            let selectionIndex = this.findIndexInSelection(rowData);
+                            this._selection = this.selection.filter((val, i) => i != selectionIndex);
+                            this.selectionChange.emit(this.selection);
+                            this.onRowUnselect.emit({ originalEvent: event.originalEvent, data: rowData, type: 'row', index: rowIndex });
+                            if (dataKeyValue) {
+                                delete this.selectionKeys[dataKeyValue];
+                            }
+                        }
+                        else {
+                            this._selection = this.selection ? [...this.selection, rowData] : [rowData];
+                            this.selectionChange.emit(this.selection);
+                            this.onRowSelect.emit({ originalEvent: event.originalEvent, data: rowData, type: 'row', index: rowIndex });
+                            if (dataKeyValue) {
+                                this.selectionKeys[dataKeyValue] = 1;
+                            }
+                        }
+                    }
+                }
+            }
+            this.tableService.onSelectionChange();
+            if (this.isStateful()) {
+                this.saveState();
+            }
+        }
+        this.rowTouched = false;
+    }
+    handleRowTouchEnd(event) {
+        this.rowTouched = true;
+    }
+    handleRowRightClick(event) {
+        if (this.contextMenu) {
+            const rowData = event.rowData;
+            const rowIndex = event.rowIndex;
+            if (this.contextMenuSelectionMode === 'separate') {
+                this.contextMenuSelection = rowData;
+                this.contextMenuSelectionChange.emit(rowData);
+                this.onContextMenuSelect.emit({ originalEvent: event.originalEvent, data: rowData, index: event.rowIndex });
+                this.contextMenu.show(event.originalEvent);
+                this.tableService.onContextMenu(rowData);
+            }
+            else if (this.contextMenuSelectionMode === 'joint') {
+                this.preventSelectionSetterPropagation = true;
+                let selected = this.isSelected(rowData);
+                let dataKeyValue = this.dataKey ? String(ObjectUtils.resolveFieldData(rowData, this.dataKey)) : null;
+                if (!selected) {
+                    if (!this.isRowSelectable(rowData, rowIndex)) {
+                        return;
+                    }
+                    if (this.isSingleSelectionMode()) {
+                        this.selection = rowData;
+                        this.selectionChange.emit(rowData);
+                        if (dataKeyValue) {
+                            this.selectionKeys = {};
+                            this.selectionKeys[dataKeyValue] = 1;
+                        }
+                    }
+                    else if (this.isMultipleSelectionMode()) {
+                        this._selection = this.selection ? [...this.selection, rowData] : [rowData];
+                        this.selectionChange.emit(this.selection);
+                        if (dataKeyValue) {
+                            this.selectionKeys[dataKeyValue] = 1;
+                        }
+                    }
+                }
+                this.tableService.onSelectionChange();
+                this.contextMenu.show(event.originalEvent);
+                this.onContextMenuSelect.emit({ originalEvent: event, data: rowData, index: event.rowIndex });
+            }
+        }
+    }
+    selectRange(event, rowIndex, isMetaKeySelection) {
+        let rangeStart, rangeEnd;
+        if (this.anchorRowIndex > rowIndex) {
+            rangeStart = rowIndex;
+            rangeEnd = this.anchorRowIndex;
+        }
+        else if (this.anchorRowIndex < rowIndex) {
+            rangeStart = this.anchorRowIndex;
+            rangeEnd = rowIndex;
+        }
+        else {
+            rangeStart = rowIndex;
+            rangeEnd = rowIndex;
+        }
+        if (this.lazy && this.paginator) {
+            rangeStart -= this.first;
+            rangeEnd -= this.first;
+        }
+        let rangeRowsData = [];
+        for (let i = rangeStart; i <= rangeEnd; i++) {
+            let rangeRowData = this.filteredValue ? this.filteredValue[i] : this.value[i];
+            if (!this.isSelected(rangeRowData) && !isMetaKeySelection) {
+                if (!this.isRowSelectable(rangeRowData, rowIndex)) {
+                    continue;
+                }
+                rangeRowsData.push(rangeRowData);
+                this._selection = [...this.selection, rangeRowData];
+                let dataKeyValue = this.dataKey ? String(ObjectUtils.resolveFieldData(rangeRowData, this.dataKey)) : null;
+                if (dataKeyValue) {
+                    this.selectionKeys[dataKeyValue] = 1;
+                }
+            }
+        }
+        this.selectionChange.emit(this.selection);
+        this.onRowSelect.emit({ originalEvent: event, data: rangeRowsData, type: 'row' });
+    }
+    clearSelectionRange(event) {
+        let rangeStart, rangeEnd;
+        let rangeRowIndex = this.rangeRowIndex;
+        let anchorRowIndex = this.anchorRowIndex;
+        if (rangeRowIndex > anchorRowIndex) {
+            rangeStart = this.anchorRowIndex;
+            rangeEnd = this.rangeRowIndex;
+        }
+        else if (rangeRowIndex < anchorRowIndex) {
+            rangeStart = this.rangeRowIndex;
+            rangeEnd = this.anchorRowIndex;
+        }
+        else {
+            rangeStart = this.rangeRowIndex;
+            rangeEnd = this.rangeRowIndex;
+        }
+        for (let i = rangeStart; i <= rangeEnd; i++) {
+            let rangeRowData = this.value[i];
+            let selectionIndex = this.findIndexInSelection(rangeRowData);
+            this._selection = this.selection.filter((val, i) => i != selectionIndex);
+            let dataKeyValue = this.dataKey ? String(ObjectUtils.resolveFieldData(rangeRowData, this.dataKey)) : null;
+            if (dataKeyValue) {
+                delete this.selectionKeys[dataKeyValue];
+            }
+            this.onRowUnselect.emit({ originalEvent: event, data: rangeRowData, type: 'row' });
+        }
+    }
+    isSelected(rowData) {
+        if (rowData && this.selection) {
+            if (this.dataKey) {
+                return this.selectionKeys[ObjectUtils.resolveFieldData(rowData, this.dataKey)] !== undefined;
+            }
+            else {
+                if (Array.isArray(this.selection))
+                    return this.findIndexInSelection(rowData) > -1;
+                else
+                    return this.equals(rowData, this.selection);
+            }
+        }
+        return false;
+    }
+    findIndexInSelection(rowData) {
+        let index = -1;
+        if (this.selection && this.selection.length) {
+            for (let i = 0; i < this.selection.length; i++) {
+                if (this.equals(rowData, this.selection[i])) {
+                    index = i;
+                    break;
+                }
+            }
+        }
+        return index;
+    }
+    isRowSelectable(data, index) {
+        if (this.rowSelectable && !this.rowSelectable({ data, index })) {
+            return false;
+        }
+        return true;
+    }
+    toggleRowWithRadio(event, rowData) {
+        this.preventSelectionSetterPropagation = true;
+        if (this.selection != rowData) {
+            if (!this.isRowSelectable(rowData, event.rowIndex)) {
+                return;
+            }
+            this._selection = rowData;
+            this.selectionChange.emit(this.selection);
+            this.onRowSelect.emit({ originalEvent: event.originalEvent, index: event.rowIndex, data: rowData, type: 'radiobutton' });
+            if (this.dataKey) {
+                this.selectionKeys = {};
+                this.selectionKeys[String(ObjectUtils.resolveFieldData(rowData, this.dataKey))] = 1;
+            }
+        }
+        else {
+            this._selection = null;
+            this.selectionChange.emit(this.selection);
+            this.onRowUnselect.emit({ originalEvent: event.originalEvent, index: event.rowIndex, data: rowData, type: 'radiobutton' });
+        }
+        this.tableService.onSelectionChange();
+        if (this.isStateful()) {
+            this.saveState();
+        }
+    }
+    toggleRowWithCheckbox(event, rowData) {
+        this.selection = this.selection || [];
+        let selected = this.isSelected(rowData);
+        let dataKeyValue = this.dataKey ? String(ObjectUtils.resolveFieldData(rowData, this.dataKey)) : null;
+        this.preventSelectionSetterPropagation = true;
+        if (selected) {
+            let selectionIndex = this.findIndexInSelection(rowData);
+            this._selection = this.selection.filter((val, i) => i != selectionIndex);
+            this.selectionChange.emit(this.selection);
+            this.onRowUnselect.emit({ originalEvent: event.originalEvent, index: event.rowIndex, data: rowData, type: 'checkbox' });
+            if (dataKeyValue) {
+                delete this.selectionKeys[dataKeyValue];
+            }
+        }
+        else {
+            if (!this.isRowSelectable(rowData, event.rowIndex)) {
+                return;
+            }
+            this._selection = this.selection ? [...this.selection, rowData] : [rowData];
+            this.selectionChange.emit(this.selection);
+            this.onRowSelect.emit({ originalEvent: event.originalEvent, index: event.rowIndex, data: rowData, type: 'checkbox' });
+            if (dataKeyValue) {
+                this.selectionKeys[dataKeyValue] = 1;
+            }
+        }
+        this.tableService.onSelectionChange();
+        if (this.isStateful()) {
+            this.saveState();
+        }
+    }
+    toggleRowsWithCheckbox(event, check) {
+        if (this._selectAll !== null) {
+            this.selectAllChange.emit({ originalEvent: event, checked: check });
+        }
+        else {
+            const data = this.selectionPageOnly ? this.dataToRender(this.processedData) : this.processedData;
+            let selection = this.selectionPageOnly && this._selection ? this._selection.filter((s) => !data.some((d) => this.equals(s, d))) : [];
+            if (check) {
+                selection = this.frozenValue ? [...selection, ...this.frozenValue, ...data] : [...selection, ...data];
+                selection = this.rowSelectable ? selection.filter((data, index) => this.rowSelectable({ data, index })) : selection;
+            }
+            this._selection = selection;
+            this.preventSelectionSetterPropagation = true;
+            this.updateSelectionKeys();
+            this.selectionChange.emit(this._selection);
+            this.tableService.onSelectionChange();
+            this.onHeaderCheckboxToggle.emit({ originalEvent: event, checked: check });
+            if (this.isStateful()) {
+                this.saveState();
+            }
+        }
+    }
+    equals(data1, data2) {
+        return this.compareSelectionBy === 'equals' ? data1 === data2 : ObjectUtils.equals(data1, data2, this.dataKey);
+    }
+    /* Legacy Filtering for custom elements */
+    filter(value, field, matchMode) {
+        if (this.filterTimeout) {
+            clearTimeout(this.filterTimeout);
+        }
+        if (!this.isFilterBlank(value)) {
+            this.filters[field] = { value: value, matchMode: matchMode };
+        }
+        else if (this.filters[field]) {
+            delete this.filters[field];
+        }
+        this.filterTimeout = setTimeout(() => {
+            this._filter();
+            this.filterTimeout = null;
+        }, this.filterDelay);
+        this.anchorRowIndex = null;
+    }
+    filterGlobal(value, matchMode) {
+        this.filter(value, 'global', matchMode);
+    }
+    isFilterBlank(filter) {
+        if (filter !== null && filter !== undefined) {
+            if ((typeof filter === 'string' && filter.trim().length == 0) || (Array.isArray(filter) && filter.length == 0))
+                return true;
+            else
+                return false;
+        }
+        return true;
+    }
+    _filter() {
+        if (this.filterType === 'custom') {
+            this.onFilter.emit({
+                filters: Object.fromEntries(Object.entries(this.filters).filter(([_, value]) => value && value?.matchMode !== null))
+            });
+        }
+        else {
+            if (!this.restoringFilter) {
+                this.first = 0;
+                this.firstChange.emit(this.first);
+            }
+            if (this.lazy) {
+                this.onLazyLoad.emit(this.createLazyLoadMetadata());
+            }
+            else {
+                if (!this.value) {
+                    return;
+                }
+                if (!this.hasFilter()) {
+                    this.filteredValue = null;
+                    if (this.paginator) {
+                        this.totalRecords = this.value ? this.value.length : 0;
+                    }
+                }
+                else {
+                    let globalFilterFieldsArray;
+                    if (this.filters['global']) {
+                        if (!this.columns && !this.globalFilterFields)
+                            throw new Error('Global filtering requires dynamic columns or globalFilterFields to be defined.');
+                        else
+                            globalFilterFieldsArray = this.globalFilterFields || this.columns;
+                    }
+                    this.filteredValue = [];
+                    for (let i = 0; i < this.value.length; i++) {
+                        let localMatch = true;
+                        let globalMatch = false;
+                        let localFiltered = false;
+                        for (let prop in this.filters) {
+                            if (this.filters.hasOwnProperty(prop) && prop !== 'global') {
+                                localFiltered = true;
+                                let filterField = prop;
+                                let filterMeta = this.filters[filterField];
+                                if (Array.isArray(filterMeta)) {
+                                    for (let meta of filterMeta) {
+                                        localMatch = this.executeLocalFilter(filterField, this.value[i], meta);
+                                        if ((meta.operator === FilterOperator.OR && localMatch) || (meta.operator === FilterOperator.AND && !localMatch)) {
+                                            break;
+                                        }
+                                    }
+                                }
+                                else {
+                                    localMatch = this.executeLocalFilter(filterField, this.value[i], filterMeta);
+                                }
+                                if (!localMatch) {
+                                    break;
+                                }
+                            }
+                        }
+                        if (this.filters['global'] && !globalMatch && globalFilterFieldsArray) {
+                            for (let j = 0; j < globalFilterFieldsArray.length; j++) {
+                                let globalFilterField = globalFilterFieldsArray[j].field || globalFilterFieldsArray[j];
+                                globalMatch = this.filterService.filters[this.filters['global'].matchMode](ObjectUtils.resolveFieldData(this.value[i], globalFilterField), this.filters['global'].value, this.filterLocale);
+                                if (globalMatch) {
+                                    break;
+                                }
+                            }
+                        }
+                        let matches;
+                        if (this.filters['global']) {
+                            matches = localFiltered ? localFiltered && localMatch && globalMatch : globalMatch;
+                        }
+                        else {
+                            matches = localFiltered && localMatch;
+                        }
+                        if (matches) {
+                            this.filteredValue.push(this.value[i]);
+                        }
+                    }
+                    if (this.filteredValue.length === this.value.length) {
+                        this.filteredValue = null;
+                    }
+                    if (this.paginator) {
+                        this.totalRecords = this.filteredValue ? this.filteredValue.length : this.value ? this.value.length : 0;
+                    }
+                }
+            }
+            this.onFilter.emit({
+                filters: this.filters,
+                filteredValue: this.filteredValue || this.value
+            });
+            this.tableService.onValueChange(this.value);
+            if (this.isStateful() && !this.restoringFilter) {
+                this.saveState();
+            }
+            if (this.restoringFilter) {
+                this.restoringFilter = false;
+            }
+        }
+        this.cd.markForCheck();
+        if (this.scrollable) {
+            this.resetScrollTop();
+        }
+    }
+    executeLocalFilter(field, rowData, filterMeta) {
+        let filterValue = filterMeta.value;
+        let filterMatchMode = filterMeta.matchMode || FilterMatchMode.STARTS_WITH;
+        let dataFieldValue = ObjectUtils.resolveFieldData(rowData, field);
+        let filterConstraint = this.filterService.filters[filterMatchMode];
+        return filterConstraint(dataFieldValue, filterValue, this.filterLocale);
+    }
+    hasFilter() {
+        let empty = true;
+        for (let prop in this.filters) {
+            if (this.filters.hasOwnProperty(prop)) {
+                empty = false;
+                break;
+            }
+        }
+        return !empty;
+    }
+    createLazyLoadMetadata() {
+        return {
+            first: this.first,
+            rows: this.rows,
+            sortField: this.sortField,
+            sortOrder: this.sortOrder,
+            filters: this.filters,
+            globalFilter: this.filters && this.filters['global'] ? this.filters['global'].value : null,
+            multiSortMeta: this.multiSortMeta,
+            forceUpdate: () => this.cd.detectChanges()
+        };
+    }
+    clear() {
+        this._sortField = null;
+        this._sortOrder = this.defaultSortOrder;
+        this._multiSortMeta = null;
+        this.tableService.onSort(null);
+        this.clearFilterValues();
+        this.filteredValue = null;
+        this.first = 0;
+        this.firstChange.emit(this.first);
+        if (this.lazy) {
+            this.onLazyLoad.emit(this.createLazyLoadMetadata());
+        }
+        else {
+            this.totalRecords = this._value ? this._value.length : 0;
+        }
+    }
+    clearFilterValues() {
+        for (const [, filterMetadata] of Object.entries(this.filters)) {
+            if (Array.isArray(filterMetadata)) {
+                for (let filter of filterMetadata) {
+                    filter.value = null;
+                }
+            }
+            else if (filterMetadata) {
+                filterMetadata.value = null;
+            }
+        }
+    }
+    reset() {
+        this.clear();
+    }
+    getExportHeader(column) {
+        return column[this.exportHeader] || column.header || column.field;
+    }
+    /**
+     * Data export method.
+     * @param {ExportCSVOptions} object - Export options.
+     * @group Method
+     */
+    exportCSV(options) {
+        let data;
+        let csv = '';
+        let columns = this.columns;
+        if (options && options.selectionOnly) {
+            data = this.selection || [];
+        }
+        else if (options && options.allValues) {
+            data = this.value || [];
+        }
+        else {
+            data = this.filteredValue || this.value;
+            if (this.frozenValue) {
+                data = data ? [...this.frozenValue, ...data] : this.frozenValue;
+            }
+        }
+        const exportableColumns = columns.filter((column) => column.exportable !== false && column.field);
+        //headers
+        csv += exportableColumns.map((column) => '"' + this.getExportHeader(column) + '"').join(this.csvSeparator);
+        //body
+        const body = data
+            .map((record) => exportableColumns
+            .map((column) => {
+            let cellData = ObjectUtils.resolveFieldData(record, column.field);
+            if (cellData != null) {
+                if (this.exportFunction) {
+                    cellData = this.exportFunction({
+                        data: cellData,
+                        field: column.field
+                    });
+                }
+                else
+                    cellData = String(cellData).replace(/"/g, '""');
+            }
+            else
+                cellData = '';
+            return '"' + cellData + '"';
+        })
+            .join(this.csvSeparator))
+            .join('\n');
+        if (body.length) {
+            csv += '\n' + body;
+        }
+        let blob = new Blob([new Uint8Array([0xef, 0xbb, 0xbf]), csv], {
+            type: 'text/csv;charset=utf-8;'
+        });
+        let link = this.renderer.createElement('a');
+        link.style.display = 'none';
+        this.renderer.appendChild(this.document.body, link);
+        if (link.download !== undefined) {
+            link.setAttribute('href', URL.createObjectURL(blob));
+            link.setAttribute('download', this.exportFilename + '.csv');
+            link.click();
+        }
+        else {
+            csv = 'data:text/csv;charset=utf-8,' + csv;
+            this.window.open(encodeURI(csv));
+        }
+        this.renderer.removeChild(this.document.body, link);
+    }
+    onLazyItemLoad(event) {
+        this.onLazyLoad.emit({
+            ...this.createLazyLoadMetadata(),
+            ...event,
+            rows: event.last - event.first
+        });
+    }
+    /**
+     * Resets scroll to top.
+     * @group Method
+     */
+    resetScrollTop() {
+        if (this.virtualScroll)
+            this.scrollToVirtualIndex(0);
+        else
+            this.scrollTo({ top: 0 });
+    }
+    /**
+     * Scrolls to given index when using virtual scroll.
+     * @param {number} index - index of the element.
+     * @group Method
+     */
+    scrollToVirtualIndex(index) {
+        this.scroller && this.scroller.scrollToIndex(index);
+    }
+    /**
+     * Scrolls to given index.
+     * @param {ScrollToOptions} options - scroll options.
+     * @group Method
+     */
+    scrollTo(options) {
+        if (this.virtualScroll) {
+            this.scroller?.scrollTo(options);
+        }
+        else if (this.wrapperViewChild && this.wrapperViewChild.nativeElement) {
+            if (this.wrapperViewChild.nativeElement.scrollTo) {
+                this.wrapperViewChild.nativeElement.scrollTo(options);
+            }
+            else {
+                this.wrapperViewChild.nativeElement.scrollLeft = options.left;
+                this.wrapperViewChild.nativeElement.scrollTop = options.top;
+            }
+        }
+    }
+    updateEditingCell(cell, data, field, index) {
+        this.editingCell = cell;
+        this.editingCellData = data;
+        this.editingCellField = field;
+        this.editingCellRowIndex = index;
+        this.bindDocumentEditListener();
+    }
+    isEditingCellValid() {
+        return this.editingCell && DomHandler.find(this.editingCell, '.ng-invalid.ng-dirty').length === 0;
+    }
+    bindDocumentEditListener() {
+        if (!this.documentEditListener) {
+            this.documentEditListener = this.renderer.listen(this.document, 'click', (event) => {
+                if (this.editingCell && !this.selfClick && this.isEditingCellValid()) {
+                    DomHandler.removeClass(this.editingCell, 'cax-cell-editing');
+                    this.editingCell = null;
+                    this.onEditComplete.emit({ field: this.editingCellField, data: this.editingCellData, originalEvent: event, index: this.editingCellRowIndex });
+                    this.editingCellField = null;
+                    this.editingCellData = null;
+                    this.editingCellRowIndex = null;
+                    this.unbindDocumentEditListener();
+                    this.cd.markForCheck();
+                    if (this.overlaySubscription) {
+                        this.overlaySubscription.unsubscribe();
+                    }
+                }
+                this.selfClick = false;
+            });
+        }
+    }
+    unbindDocumentEditListener() {
+        if (this.documentEditListener) {
+            this.documentEditListener();
+            this.documentEditListener = null;
+        }
+    }
+    initRowEdit(rowData) {
+        let dataKeyValue = String(ObjectUtils.resolveFieldData(rowData, this.dataKey));
+        this.editingRowKeys[dataKeyValue] = true;
+    }
+    saveRowEdit(rowData, rowElement) {
+        if (DomHandler.find(rowElement, '.ng-invalid.ng-dirty').length === 0) {
+            let dataKeyValue = String(ObjectUtils.resolveFieldData(rowData, this.dataKey));
+            delete this.editingRowKeys[dataKeyValue];
+        }
+    }
+    cancelRowEdit(rowData) {
+        let dataKeyValue = String(ObjectUtils.resolveFieldData(rowData, this.dataKey));
+        delete this.editingRowKeys[dataKeyValue];
+    }
+    toggleRow(rowData, event) {
+        if (!this.dataKey && !this.groupRowsBy) {
+            throw new Error('dataKey or groupRowsBy must be defined to use row expansion');
+        }
+        let dataKeyValue = this.groupRowsBy ? String(ObjectUtils.resolveFieldData(rowData, this.groupRowsBy)) : String(ObjectUtils.resolveFieldData(rowData, this.dataKey));
+        if (this.expandedRowKeys[dataKeyValue] != null) {
+            delete this.expandedRowKeys[dataKeyValue];
+            this.onRowCollapse.emit({
+                originalEvent: event,
+                data: rowData
+            });
+        }
+        else {
+            if (this.rowExpandMode === 'single') {
+                this.expandedRowKeys = {};
+            }
+            this.expandedRowKeys[dataKeyValue] = true;
+            this.onRowExpand.emit({
+                originalEvent: event,
+                data: rowData
+            });
+        }
+        if (event) {
+            event.preventDefault();
+        }
+        if (this.isStateful()) {
+            this.saveState();
+        }
+    }
+    isRowExpanded(rowData) {
+        return this.groupRowsBy ? this.expandedRowKeys[String(ObjectUtils.resolveFieldData(rowData, this.groupRowsBy))] === true : this.expandedRowKeys[String(ObjectUtils.resolveFieldData(rowData, this.dataKey))] === true;
+    }
+    isRowEditing(rowData) {
+        return this.editingRowKeys[String(ObjectUtils.resolveFieldData(rowData, this.dataKey))] === true;
+    }
+    isSingleSelectionMode() {
+        return this.selectionMode === 'single';
+    }
+    isMultipleSelectionMode() {
+        return this.selectionMode === 'multiple';
+    }
+    onColumnResizeBegin(event) {
+        let containerLeft = DomHandler.getOffset(this.containerViewChild?.nativeElement).left;
+        this.resizeColumnElement = event.target.parentElement;
+        this.columnResizing = true;
+        if (event.type == 'touchstart') {
+            this.lastResizerHelperX = event.changedTouches[0].clientX - containerLeft + this.containerViewChild?.nativeElement.scrollLeft;
+        }
+        else {
+            this.lastResizerHelperX = event.pageX - containerLeft + this.containerViewChild?.nativeElement.scrollLeft;
+        }
+        this.onColumnResize(event);
+        event.preventDefault();
+    }
+    onColumnResize(event) {
+        let containerLeft = DomHandler.getOffset(this.containerViewChild?.nativeElement).left;
+        DomHandler.addClass(this.containerViewChild?.nativeElement, 'cax-unselectable-text');
+        this.resizeHelperViewChild.nativeElement.style.height = this.containerViewChild?.nativeElement.offsetHeight + 'px';
+        this.resizeHelperViewChild.nativeElement.style.top = 0 + 'px';
+        if (event.type == 'touchmove') {
+            this.resizeHelperViewChild.nativeElement.style.left = event.changedTouches[0].clientX - containerLeft + this.containerViewChild?.nativeElement.scrollLeft + 'px';
+        }
+        else {
+            this.resizeHelperViewChild.nativeElement.style.left = event.pageX - containerLeft + this.containerViewChild?.nativeElement.scrollLeft + 'px';
+        }
+        this.resizeHelperViewChild.nativeElement.style.display = 'block';
+    }
+    onColumnResizeEnd() {
+        let delta = this.resizeHelperViewChild?.nativeElement.offsetLeft - this.lastResizerHelperX;
+        let columnWidth = this.resizeColumnElement.offsetWidth;
+        let newColumnWidth = columnWidth + delta;
+        let minWidth = this.resizeColumnElement.style.minWidth.replace(/[^\d.]/g, '') || 15;
+        if (newColumnWidth >= minWidth) {
+            if (this.columnResizeMode === 'fit') {
+                let nextColumn = this.resizeColumnElement.nextElementSibling;
+                let nextColumnWidth = nextColumn.offsetWidth - delta;
+                if (newColumnWidth > 15 && nextColumnWidth > 15) {
+                    this.resizeTableCells(newColumnWidth, nextColumnWidth);
+                }
+            }
+            else if (this.columnResizeMode === 'expand') {
+                this._initialColWidths = this._totalTableWidth();
+                let tableWidth = this.tableViewChild?.nativeElement.offsetWidth + delta;
+                this.setResizeTableWidth(tableWidth + 'px');
+                this.resizeTableCells(newColumnWidth, null);
+            }
+            this.onColResize.emit({
+                element: this.resizeColumnElement,
+                delta: delta
+            });
+            if (this.isStateful()) {
+                this.saveState();
+            }
+        }
+        this.resizeHelperViewChild.nativeElement.style.display = 'none';
+        DomHandler.removeClass(this.containerViewChild?.nativeElement, 'cax-unselectable-text');
+    }
+    _totalTableWidth() {
+        let widths = [];
+        const tableHead = DomHandler.findSingle(this.containerViewChild.nativeElement, '.cax-datatable-thead');
+        let headers = DomHandler.find(tableHead, 'tr > th');
+        headers.forEach((header) => widths.push(DomHandler.getOuterWidth(header)));
+        return widths;
+    }
+    onColumnDragStart(event, columnElement) {
+        this.reorderIconWidth = DomHandler.getHiddenElementOuterWidth(this.reorderIndicatorUpViewChild?.nativeElement);
+        this.reorderIconHeight = DomHandler.getHiddenElementOuterHeight(this.reorderIndicatorDownViewChild?.nativeElement);
+        this.draggedColumn = columnElement;
+        event.dataTransfer.setData('text', 'b'); // For firefox
+    }
+    onColumnDragEnter(event, dropHeader) {
+        if (this.reorderableColumns && this.draggedColumn && dropHeader) {
+            event.preventDefault();
+            let containerOffset = DomHandler.getOffset(this.containerViewChild?.nativeElement);
+            let dropHeaderOffset = DomHandler.getOffset(dropHeader);
+            if (this.draggedColumn != dropHeader) {
+                let dragIndex = DomHandler.indexWithinGroup(this.draggedColumn, 'caxreorderablecolumn');
+                let dropIndex = DomHandler.indexWithinGroup(dropHeader, 'caxreorderablecolumn');
+                let targetLeft = dropHeaderOffset.left - containerOffset.left;
+                let targetTop = containerOffset.top - dropHeaderOffset.top;
+                let columnCenter = dropHeaderOffset.left + dropHeader.offsetWidth / 2;
+                this.reorderIndicatorUpViewChild.nativeElement.style.top = dropHeaderOffset.top - containerOffset.top - (this.reorderIconHeight - 1) + 'px';
+                this.reorderIndicatorDownViewChild.nativeElement.style.top = dropHeaderOffset.top - containerOffset.top + dropHeader.offsetHeight + 'px';
+                if (event.pageX > columnCenter) {
+                    this.reorderIndicatorUpViewChild.nativeElement.style.left = targetLeft + dropHeader.offsetWidth - Math.ceil(this.reorderIconWidth / 2) + 'px';
+                    this.reorderIndicatorDownViewChild.nativeElement.style.left = targetLeft + dropHeader.offsetWidth - Math.ceil(this.reorderIconWidth / 2) + 'px';
+                    this.dropPosition = 1;
+                }
+                else {
+                    this.reorderIndicatorUpViewChild.nativeElement.style.left = targetLeft - Math.ceil(this.reorderIconWidth / 2) + 'px';
+                    this.reorderIndicatorDownViewChild.nativeElement.style.left = targetLeft - Math.ceil(this.reorderIconWidth / 2) + 'px';
+                    this.dropPosition = -1;
+                }
+                this.reorderIndicatorUpViewChild.nativeElement.style.display = 'block';
+                this.reorderIndicatorDownViewChild.nativeElement.style.display = 'block';
+            }
+            else {
+                event.dataTransfer.dropEffect = 'none';
+            }
+        }
+    }
+    onColumnDragLeave(event) {
+        if (this.reorderableColumns && this.draggedColumn) {
+            event.preventDefault();
+        }
+    }
+    onColumnDrop(event, dropColumn) {
+        event.preventDefault();
+        if (this.draggedColumn) {
+            let dragIndex = DomHandler.indexWithinGroup(this.draggedColumn, 'caxreorderablecolumn');
+            let dropIndex = DomHandler.indexWithinGroup(dropColumn, 'caxreorderablecolumn');
+            let allowDrop = dragIndex != dropIndex;
+            if (allowDrop && ((dropIndex - dragIndex == 1 && this.dropPosition === -1) || (dragIndex - dropIndex == 1 && this.dropPosition === 1))) {
+                allowDrop = false;
+            }
+            if (allowDrop && dropIndex < dragIndex && this.dropPosition === 1) {
+                dropIndex = dropIndex + 1;
+            }
+            if (allowDrop && dropIndex > dragIndex && this.dropPosition === -1) {
+                dropIndex = dropIndex - 1;
+            }
+            if (allowDrop) {
+                ObjectUtils.reorderArray(this.columns, dragIndex, dropIndex);
+                this.onColReorder.emit({
+                    dragIndex: dragIndex,
+                    dropIndex: dropIndex,
+                    columns: this.columns
+                });
+                if (this.isStateful()) {
+                    this.zone.runOutsideAngular(() => {
+                        setTimeout(() => {
+                            this.saveState();
+                        });
+                    });
+                }
+            }
+            if (this.resizableColumns && this.resizeColumnElement) {
+                let width = this.columnResizeMode === 'expand' ? this._initialColWidths : this._totalTableWidth();
+                ObjectUtils.reorderArray(width, dragIndex + 1, dropIndex + 1);
+                this.updateStyleElement(width, dragIndex, null, null);
+            }
+            this.reorderIndicatorUpViewChild.nativeElement.style.display = 'none';
+            this.reorderIndicatorDownViewChild.nativeElement.style.display = 'none';
+            this.draggedColumn.draggable = false;
+            this.draggedColumn = null;
+            this.dropPosition = null;
+        }
+    }
+    resizeTableCells(newColumnWidth, nextColumnWidth) {
+        let colIndex = DomHandler.index(this.resizeColumnElement);
+        let width = this.columnResizeMode === 'expand' ? this._initialColWidths : this._totalTableWidth();
+        this.updateStyleElement(width, colIndex, newColumnWidth, nextColumnWidth);
+    }
+    updateStyleElement(width, colIndex, newColumnWidth, nextColumnWidth) {
+        this.destroyStyleElement();
+        this.createStyleElement();
+        let innerHTML = '';
+        width.forEach((width, index) => {
+            let colWidth = index === colIndex ? newColumnWidth : nextColumnWidth && index === colIndex + 1 ? nextColumnWidth : width;
+            let style = `width: ${colWidth}px !important; max-width: ${colWidth}px !important;`;
+            innerHTML += `
+                #${this.id}-table > .cax-datatable-thead > tr > th:nth-child(${index + 1}),
+                #${this.id}-table > .cax-datatable-tbody > tr > td:nth-child(${index + 1}),
+                #${this.id}-table > .cax-datatable-tfoot > tr > td:nth-child(${index + 1}) {
+                    ${style}
+                }
+            `;
+        });
+        this.renderer.setProperty(this.styleElement, 'innerHTML', this.domSanitizer.bypassSecurityTrustStyle(innerHTML));
+    }
+    onRowDragStart(event, index) {
+        this.rowDragging = true;
+        this.draggedRowIndex = index;
+        event.dataTransfer.setData('text', 'b'); // For firefox
+    }
+    onRowDragOver(event, index, rowElement) {
+        if (this.rowDragging && this.draggedRowIndex !== index) {
+            let rowY = DomHandler.getOffset(rowElement).top;
+            let pageY = event.pageY;
+            let rowMidY = rowY + DomHandler.getOuterHeight(rowElement) / 2;
+            let prevRowElement = rowElement.previousElementSibling;
+            if (pageY < rowMidY) {
+                DomHandler.removeClass(rowElement, 'cax-datatable-dragpoint-bottom');
+                this.droppedRowIndex = index;
+                if (prevRowElement)
+                    DomHandler.addClass(prevRowElement, 'cax-datatable-dragpoint-bottom');
+                else
+                    DomHandler.addClass(rowElement, 'cax-datatable-dragpoint-top');
+            }
+            else {
+                if (prevRowElement)
+                    DomHandler.removeClass(prevRowElement, 'cax-datatable-dragpoint-bottom');
+                else
+                    DomHandler.addClass(rowElement, 'cax-datatable-dragpoint-top');
+                this.droppedRowIndex = index + 1;
+                DomHandler.addClass(rowElement, 'cax-datatable-dragpoint-bottom');
+            }
+        }
+    }
+    onRowDragLeave(event, rowElement) {
+        let prevRowElement = rowElement.previousElementSibling;
+        if (prevRowElement) {
+            DomHandler.removeClass(prevRowElement, 'cax-datatable-dragpoint-bottom');
+        }
+        DomHandler.removeClass(rowElement, 'cax-datatable-dragpoint-bottom');
+        DomHandler.removeClass(rowElement, 'cax-datatable-dragpoint-top');
+    }
+    onRowDragEnd(event) {
+        this.rowDragging = false;
+        this.draggedRowIndex = null;
+        this.droppedRowIndex = null;
+    }
+    onRowDrop(event, rowElement) {
+        if (this.droppedRowIndex != null) {
+            let dropIndex = this.draggedRowIndex > this.droppedRowIndex ? this.droppedRowIndex : this.droppedRowIndex === 0 ? 0 : this.droppedRowIndex - 1;
+            ObjectUtils.reorderArray(this.value, this.draggedRowIndex, dropIndex);
+            if (this.virtualScroll) {
+                // TODO: Check
+                this._value = [...this._value];
+            }
+            this.onRowReorder.emit({
+                dragIndex: this.draggedRowIndex,
+                dropIndex: dropIndex
+            });
+        }
+        //cleanup
+        this.onRowDragLeave(event, rowElement);
+        this.onRowDragEnd(event);
+    }
+    isEmpty() {
+        let data = this.filteredValue || this.value;
+        return data == null || data.length == 0;
+    }
+    getBlockableElement() {
+        return this.el.nativeElement.children[0];
+    }
+    getStorage() {
+        if (isPlatformBrowser(this.platformId)) {
+            switch (this.stateStorage) {
+                case 'local':
+                    return window.localStorage;
+                case 'session':
+                    return window.sessionStorage;
+                default:
+                    throw new Error(this.stateStorage + ' is not a valid value for the state storage, supported values are "local" and "session".');
+            }
+        }
+        else {
+            throw new Error('Browser storage is not available in the server side.');
+        }
+    }
+    isStateful() {
+        return this.stateKey != null;
+    }
+    saveState() {
+        const storage = this.getStorage();
+        let state = {};
+        if (this.paginator) {
+            state.first = this.first;
+            state.rows = this.rows;
+        }
+        if (this.sortField) {
+            state.sortField = this.sortField;
+            state.sortOrder = this.sortOrder;
+        }
+        if (this.multiSortMeta) {
+            state.multiSortMeta = this.multiSortMeta;
+        }
+        if (this.hasFilter()) {
+            state.filters = this.filters;
+        }
+        if (this.resizableColumns) {
+            this.saveColumnWidths(state);
+        }
+        if (this.reorderableColumns) {
+            this.saveColumnOrder(state);
+        }
+        if (this.selection) {
+            state.selection = this.selection;
+        }
+        if (Object.keys(this.expandedRowKeys).length) {
+            state.expandedRowKeys = this.expandedRowKeys;
+        }
+        storage.setItem(this.stateKey, JSON.stringify(state));
+        this.onStateSave.emit(state);
+    }
+    clearState() {
+        const storage = this.getStorage();
+        if (this.stateKey) {
+            storage.removeItem(this.stateKey);
+        }
+    }
+    restoreState() {
+        const storage = this.getStorage();
+        const stateString = storage.getItem(this.stateKey);
+        const dateFormat = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z/;
+        const reviver = function (key, value) {
+            if (typeof value === 'string' && dateFormat.test(value)) {
+                return new Date(value);
+            }
+            return value;
+        };
+        if (stateString) {
+            let state = JSON.parse(stateString, reviver);
+            if (this.paginator) {
+                if (this.first !== undefined) {
+                    this.first = state.first;
+                    this.firstChange.emit(this.first);
+                }
+                if (this.rows !== undefined) {
+                    this.rows = state.rows;
+                    this.rowsChange.emit(this.rows);
+                }
+            }
+            if (state.sortField) {
+                this.restoringSort = true;
+                this._sortField = state.sortField;
+                this._sortOrder = state.sortOrder;
+            }
+            if (state.multiSortMeta) {
+                this.restoringSort = true;
+                this._multiSortMeta = state.multiSortMeta;
+            }
+            if (state.filters) {
+                this.restoringFilter = true;
+                this.filters = state.filters;
+            }
+            if (this.resizableColumns) {
+                this.columnWidthsState = state.columnWidths;
+                this.tableWidthState = state.tableWidth;
+            }
+            // if (this.reorderableColumns) {
+            //     this.restoreColumnOrder();
+            // }
+            if (state.expandedRowKeys) {
+                this.expandedRowKeys = state.expandedRowKeys;
+            }
+            if (state.selection) {
+                Promise.resolve(null).then(() => this.selectionChange.emit(state.selection));
+            }
+            this.stateRestored = true;
+            this.onStateRestore.emit(state);
+        }
+    }
+    saveColumnWidths(state) {
+        let widths = [];
+        let headers = [];
+        const container = this.containerViewChild?.nativeElement;
+        if (container) {
+            headers = DomHandler.find(container, '.cax-datatable-thead > tr > th');
+        }
+        headers.forEach((header) => widths.push(DomHandler.getOuterWidth(header)));
+        state.columnWidths = widths.join(',');
+        if (this.columnResizeMode === 'expand') {
+            state.tableWidth = DomHandler.getOuterWidth(this.tableViewChild?.nativeElement);
+        }
+    }
+    setResizeTableWidth(width) {
+        this.tableViewChild.nativeElement.style.width = width;
+        this.tableViewChild.nativeElement.style.minWidth = width;
+    }
+    restoreColumnWidths() {
+        if (this.columnWidthsState) {
+            let widths = this.columnWidthsState.split(',');
+            if (this.columnResizeMode === 'expand' && this.tableWidthState) {
+                this.setResizeTableWidth(this.tableWidthState + 'px');
+            }
+            if (ObjectUtils.isNotEmpty(widths)) {
+                this.createStyleElement();
+                let innerHTML = '';
+                widths.forEach((width, index) => {
+                    let style = `width: ${width}px !important; max-width: ${width}px !important`;
+                    innerHTML += `
+                        #${this.id}-table > .cax-datatable-thead > tr > th:nth-child(${index + 1}),
+                        #${this.id}-table > .cax-datatable-tbody > tr > td:nth-child(${index + 1}),
+                        #${this.id}-table > .cax-datatable-tfoot > tr > td:nth-child(${index + 1}) {
+                            ${style}
+                        }
+                    `;
+                });
+                this.styleElement.textContent = innerHTML;
+            }
+        }
+    }
+    saveColumnOrder(state) {
+        if (this.columns) {
+            let columnOrder = [];
+            this.columns.map((column) => {
+                columnOrder.push(column.field || column.key);
+            });
+            state.columnOrder = columnOrder;
+        }
+    }
+    restoreColumnOrder() {
+        const storage = this.getStorage();
+        const stateString = storage.getItem(this.stateKey);
+        if (stateString) {
+            let state = JSON.parse(stateString);
+            let columnOrder = state.columnOrder;
+            if (columnOrder) {
+                let reorderedColumns = [];
+                columnOrder.map((key) => {
+                    let col = this.findColumnByKey(key);
+                    if (col) {
+                        reorderedColumns.push(col);
+                    }
+                });
+                this.columnOrderStateRestored = true;
+                this.columns = reorderedColumns;
+            }
+        }
+    }
+    findColumnByKey(key) {
+        if (this.columns) {
+            for (let col of this.columns) {
+                if (col.key === key || col.field === key)
+                    return col;
+                else
+                    continue;
+            }
+        }
+        else {
+            return null;
+        }
+    }
+    createStyleElement() {
+        this.styleElement = this.renderer.createElement('style');
+        this.styleElement.type = 'text/css';
+        DomHandler.setAttribute(this.styleElement, 'nonce', this.config?.csp()?.nonce);
+        this.renderer.appendChild(this.document.head, this.styleElement);
+    }
+    getGroupRowsMeta() {
+        return { field: this.groupRowsBy, order: this.groupRowsByOrder };
+    }
+    getTableClasses() {
+        return {
+            'cax-datatable cax-component': true,
+            'cax-datatable-hoverable-rows': this.rowHover || this.selectionMode,
+            'cax-datatable-scrollable': this.scrollable,
+            'cax-datatable-flex-scrollable': this.scrollable && this.scrollHeight === 'flex',
+            ['cax-datatable-font-' + this.fontSize]: true,
+            ['cax-datatable-row-' + this.rowSize]: true
+        };
+    }
+    createResponsiveStyle() {
+        if (isPlatformBrowser(this.platformId)) {
+            if (!this.responsiveStyleElement) {
+                this.responsiveStyleElement = this.renderer.createElement('style');
+                this.responsiveStyleElement.type = 'text/css';
+                DomHandler.setAttribute(this.responsiveStyleElement, 'nonce', this.config?.csp()?.nonce);
+                this.renderer.appendChild(this.document.head, this.responsiveStyleElement);
+                let innerHTML = `
+    @media screen and (max-width: ${this.breakpoint}) {
+        #${this.id}-table > .cax-datatable-thead > tr > th,
+        #${this.id}-table > .cax-datatable-tfoot > tr > td {
+            display: none !important;
+        }
+
+        #${this.id}-table > .cax-datatable-tbody > tr > td {
+            display: flex;
+            width: 100% !important;
+            align-items: center;
+            justify-content: space-between;
+        }
+
+        #${this.id}-table > .cax-datatable-tbody > tr > td:not(:last-child) {
+            border: 0 none;
+        }
+
+        #${this.id}.cax-datatable-gridlines > .cax-datatable-wrapper > .cax-datatable-table > .cax-datatable-tbody > tr > td:last-child {
+            border-top: 0;
+            border-right: 0;
+            border-left: 0;
+        }
+
+        #${this.id}-table > .cax-datatable-tbody > tr > td > .cax-column-title {
+            display: block;
+        }
+    }
+    `;
+                this.renderer.setProperty(this.responsiveStyleElement, 'innerHTML', this.domSanitizer.bypassSecurityTrustStyle(innerHTML));
+            }
+        }
+    }
+    destroyResponsiveStyle() {
+        if (this.responsiveStyleElement) {
+            this.renderer.removeChild(this.document.head, this.responsiveStyleElement);
+            this.responsiveStyleElement = null;
+        }
+    }
+    destroyStyleElement() {
+        if (this.styleElement) {
+            this.renderer.removeChild(this.document.head, this.styleElement);
+            this.styleElement = null;
+        }
+    }
+    ngOnDestroy() {
+        this.unbindDocumentEditListener();
+        this.editingCell = null;
+        this.initialized = null;
+        this.destroyStyleElement();
+        this.destroyResponsiveStyle();
+    }
+    getPaginatorStyleClasses(className) {
+        return [this.paginatorStyleClass, className]
+            .filter((c) => !!c)
+            .join(' ')
+            .trim();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: Table, deps: [{ token: DOCUMENT }, { token: PLATFORM_ID }, { token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i0.NgZone }, { token: i1.TableService }, { token: i0.ChangeDetectorRef }, { token: i2.FilterService }, { token: i2.OverlayService }, { token: i2.caxConfig }, { token: i3.DomSanitizer }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "18.2.9", type: Table, isStandalone: true, selector: "cax-table", inputs: { fontSize: "fontSize", rowSize: "rowSize", frozenColumns: "frozenColumns", frozenValue: "frozenValue", style: "style", styleClass: "styleClass", tableStyle: "tableStyle", tableStyleClass: "tableStyleClass", paginator: ["paginator", "paginator", booleanAttribute], pageLinks: ["pageLinks", "pageLinks", numberAttribute], rowsPerPageOptions: "rowsPerPageOptions", alwaysShowPaginator: ["alwaysShowPaginator", "alwaysShowPaginator", booleanAttribute], paginatorPosition: "paginatorPosition", paginatorStyleClass: "paginatorStyleClass", paginatorDropdownAppendTo: "paginatorDropdownAppendTo", paginatorDropdownScrollHeight: "paginatorDropdownScrollHeight", currentPageReportTemplate: "currentPageReportTemplate", showCurrentPageReport: ["showCurrentPageReport", "showCurrentPageReport", booleanAttribute], showJumpToPageDropdown: ["showJumpToPageDropdown", "showJumpToPageDropdown", booleanAttribute], showJumpToPageInput: ["showJumpToPageInput", "showJumpToPageInput", booleanAttribute], showFirstLastIcon: ["showFirstLastIcon", "showFirstLastIcon", booleanAttribute], showPageLinks: ["showPageLinks", "showPageLinks", booleanAttribute], defaultSortOrder: ["defaultSortOrder", "defaultSortOrder", numberAttribute], filterType: "filterType", sortType: "sortType", sortMode: "sortMode", resetPageOnSort: ["resetPageOnSort", "resetPageOnSort", booleanAttribute], selectionMode: "selectionMode", selectionPageOnly: ["selectionPageOnly", "selectionPageOnly", booleanAttribute], contextMenuSelection: "contextMenuSelection", contextMenuSelectionMode: "contextMenuSelectionMode", dataKey: "dataKey", metaKeySelection: ["metaKeySelection", "metaKeySelection", booleanAttribute], rowSelectable: "rowSelectable", rowTrackBy: "rowTrackBy", lazy: ["lazy", "lazy", booleanAttribute], lazyLoadOnInit: ["lazyLoadOnInit", "lazyLoadOnInit", booleanAttribute], compareSelectionBy: "compareSelectionBy", csvSeparator: "csvSeparator", exportFilename: "exportFilename", filters: "filters", globalFilterFields: "globalFilterFields", filterDelay: ["filterDelay", "filterDelay", numberAttribute], filterLocale: "filterLocale", expandedRowKeys: "expandedRowKeys", editingRowKeys: "editingRowKeys", rowExpandMode: "rowExpandMode", scrollable: ["scrollable", "scrollable", booleanAttribute], scrollDirection: "scrollDirection", rowGroupMode: "rowGroupMode", scrollHeight: "scrollHeight", virtualScroll: ["virtualScroll", "virtualScroll", booleanAttribute], virtualScrollItemSize: ["virtualScrollItemSize", "virtualScrollItemSize", numberAttribute], virtualScrollOptions: "virtualScrollOptions", virtualScrollDelay: ["virtualScrollDelay", "virtualScrollDelay", numberAttribute], frozenWidth: "frozenWidth", responsive: "responsive", contextMenu: "contextMenu", resizableColumns: ["resizableColumns", "resizableColumns", booleanAttribute], columnResizeMode: "columnResizeMode", reorderableColumns: ["reorderableColumns", "reorderableColumns", booleanAttribute], loading: ["loading", "loading", booleanAttribute], loadingIcon: "loadingIcon", showLoader: ["showLoader", "showLoader", booleanAttribute], rowHover: ["rowHover", "rowHover", booleanAttribute], customSort: ["customSort", "customSort", booleanAttribute], showInitialSortBadge: ["showInitialSortBadge", "showInitialSortBadge", booleanAttribute], autoLayout: ["autoLayout", "autoLayout", booleanAttribute], exportFunction: "exportFunction", exportHeader: "exportHeader", stateKey: "stateKey", stateStorage: "stateStorage", editMode: "editMode", groupRowsBy: "groupRowsBy", groupRowsByOrder: ["groupRowsByOrder", "groupRowsByOrder", numberAttribute], responsiveLayout: "responsiveLayout", breakpoint: "breakpoint", paginatorLocale: "paginatorLocale", value: "value", columns: "columns", first: "first", rows: "rows", totalRecords: "totalRecords", sortField: "sortField", sortOrder: "sortOrder", multiSortMeta: "multiSortMeta", selection: "selection", selectAll: "selectAll", virtualRowHeight: "virtualRowHeight" }, outputs: { contextMenuSelectionChange: "contextMenuSelectionChange", selectAllChange: "selectAllChange", selectionChange: "selectionChange", onRowSelect: "onRowSelect", onRowUnselect: "onRowUnselect", onPage: "onPage", onSort: "onSort", onFilter: "onFilter", onLazyLoad: "onLazyLoad", onRowExpand: "onRowExpand", onRowCollapse: "onRowCollapse", onContextMenuSelect: "onContextMenuSelect", onColResize: "onColResize", onColReorder: "onColReorder", onRowReorder: "onRowReorder", onEditInit: "onEditInit", onEditComplete: "onEditComplete", onEditCancel: "onEditCancel", onHeaderCheckboxToggle: "onHeaderCheckboxToggle", sortFunction: "sortFunction", firstChange: "firstChange", rowsChange: "rowsChange", onStateSave: "onStateSave", onStateRestore: "onStateRestore" }, host: { classAttribute: "cax-element" }, queries: [{ propertyName: "templates", predicate: CaxTemplate }], viewQueries: [{ propertyName: "containerViewChild", first: true, predicate: ["container"], descendants: true }, { propertyName: "resizeHelperViewChild", first: true, predicate: ["resizeHelper"], descendants: true }, { propertyName: "reorderIndicatorUpViewChild", first: true, predicate: ["reorderIndicatorUp"], descendants: true }, { propertyName: "reorderIndicatorDownViewChild", first: true, predicate: ["reorderIndicatorDown"], descendants: true }, { propertyName: "wrapperViewChild", first: true, predicate: ["wrapper"], descendants: true }, { propertyName: "tableViewChild", first: true, predicate: ["table"], descendants: true }, { propertyName: "tableHeaderViewChild", first: true, predicate: ["thead"], descendants: true }, { propertyName: "tableFooterViewChild", first: true, predicate: ["tfoot"], descendants: true }, { propertyName: "scroller", first: true, predicate: ["scroller"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div #container [ngStyle]=\"style\" [class]=\"styleClass\" [ngClass]=\"getTableClasses()\" [attr.id]=\"id\">\r\n    <div class=\"cax-datatable-loading-overlay cax-component-overlay\" *ngIf=\"loading && showLoader\">\r\n        <i *ngIf=\"loadingIcon\" [class]=\"'cax-datatable-loading-icon ' + loadingIcon\"></i>\r\n        <ng-container *ngIf=\"!loadingIcon\">\r\n            <SpinnerIcon *ngIf=\"!loadingIconTemplate\" [spin]=\"true\" [styleClass]=\"'cax-datatable-loading-icon'\" />\r\n            <span *ngIf=\"loadingIconTemplate\" class=\"cax-datatable-loading-icon\">\r\n                <ng-template *ngTemplateOutlet=\"loadingIconTemplate\"></ng-template>\r\n            </span>\r\n        </ng-container>\r\n    </div>\r\n    <div *ngIf=\"captionTemplate\" class=\"cax-datatable-header\">\r\n        <ng-container *ngTemplateOutlet=\"captionTemplate\"></ng-container>\r\n    </div>\r\n    <cax-paginator\r\n        [rows]=\"rows\"\r\n        [first]=\"first\"\r\n        [totalRecords]=\"totalRecords\"\r\n        [pageLinkSize]=\"pageLinks\"\r\n        [alwaysShow]=\"alwaysShowPaginator\"\r\n        (onPageChange)=\"onPageChange($event)\"\r\n        [rowsPerPageOptions]=\"rowsPerPageOptions\"\r\n        *ngIf=\"paginator && (paginatorPosition === 'top' || paginatorPosition == 'both')\"\r\n        [templateLeft]=\"paginatorLeftTemplate\"\r\n        [templateRight]=\"paginatorRightTemplate\"\r\n        [dropdownAppendTo]=\"paginatorDropdownAppendTo\"\r\n        [dropdownScrollHeight]=\"paginatorDropdownScrollHeight\"\r\n        [currentPageReportTemplate]=\"currentPageReportTemplate\"\r\n        [showFirstLastIcon]=\"showFirstLastIcon\"\r\n        [dropdownItemTemplate]=\"paginatorDropdownItemTemplate\"\r\n        [showCurrentPageReport]=\"showCurrentPageReport\"\r\n        [showJumpToPageDropdown]=\"showJumpToPageDropdown\"\r\n        [showJumpToPageInput]=\"showJumpToPageInput\"\r\n        [showPageLinks]=\"showPageLinks\"\r\n        [styleClass]=\"getPaginatorStyleClasses('cax-paginator-top')\"\r\n        [locale]=\"paginatorLocale\"\r\n    >\r\n        <ng-template caxTemplate=\"dropdownicon\" *ngIf=\"paginatorDropdownIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorDropdownIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"firstpagelinkicon\" *ngIf=\"paginatorFirstPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorFirstPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"previouspagelinkicon\" *ngIf=\"paginatorPreviousPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorPreviousPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"lastpagelinkicon\" *ngIf=\"paginatorLastPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorLastPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"nextpagelinkicon\" *ngIf=\"paginatorNextPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorNextPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n    </cax-paginator>\r\n\r\n    <div #wrapper class=\"cax-datatable-wrapper\" [ngStyle]=\"{ maxHeight: virtualScroll ? '' : scrollHeight }\">\r\n        <cax-scroller\r\n            #scroller\r\n            *ngIf=\"virtualScroll\"\r\n            [items]=\"processedData\"\r\n            [columns]=\"columns\"\r\n            [style]=\"{ height: scrollHeight !== 'flex' ? scrollHeight : undefined }\"\r\n            [scrollHeight]=\"scrollHeight !== 'flex' ? undefined : '100%'\"\r\n            [itemSize]=\"virtualScrollItemSize || _virtualRowHeight\"\r\n            [step]=\"rows\"\r\n            [delay]=\"lazy ? virtualScrollDelay : 0\"\r\n            [inline]=\"true\"\r\n            [autoSize]=\"true\"\r\n            [lazy]=\"lazy\"\r\n            (onLazyLoad)=\"onLazyItemLoad($event)\"\r\n            [loaderDisabled]=\"true\"\r\n            [showSpacer]=\"false\"\r\n            [showLoader]=\"loadingBodyTemplate\"\r\n            [options]=\"virtualScrollOptions\"\r\n        >\r\n            <ng-template caxTemplate=\"content\" let-items let-scrollerOptions=\"options\">\r\n                <ng-container *ngTemplateOutlet=\"buildInTable; context: { $implicit: items, options: scrollerOptions }\"></ng-container>\r\n            </ng-template>\r\n        </cax-scroller>\r\n        <ng-container *ngIf=\"!virtualScroll\">\r\n            <ng-container *ngTemplateOutlet=\"buildInTable; context: { $implicit: processedData, options: { columns } }\"></ng-container>\r\n        </ng-container>\r\n\r\n        <ng-template #buildInTable let-items let-scrollerOptions=\"options\">\r\n            <table\r\n                #table\r\n                role=\"table\"\r\n                [ngClass]=\"{ 'cax-datatable-table': true, 'cax-datatable-scrollable-table': scrollable, 'cax-datatable-resizable-table': resizableColumns, 'cax-datatable-resizable-table-fit': resizableColumns && columnResizeMode === 'fit' }\"\r\n                [class]=\"tableStyleClass\"\r\n                [ngStyle]=\"tableStyle\"\r\n                [attr.id]=\"id + '-table'\"\r\n            >\r\n                <ng-container *ngTemplateOutlet=\"colGroupTemplate; context: { $implicit: scrollerOptions.columns }\"></ng-container>\r\n                <thead role=\"rowgroup\" #thead class=\"cax-datatable-thead\">\r\n                    <ng-container *ngTemplateOutlet=\"headerGroupedTemplate || headerTemplate; context: { $implicit: scrollerOptions.columns }\"></ng-container>\r\n                </thead>\r\n                <tbody\r\n                    role=\"rowgroup\"\r\n                    class=\"cax-datatable-tbody cax-datatable-frozen-tbody\"\r\n                    *ngIf=\"frozenValue || frozenBodyTemplate\"\r\n                    [value]=\"frozenValue\"\r\n                    [frozenRows]=\"true\"\r\n                    [caxTableBody]=\"scrollerOptions.columns\"\r\n                    [caxTableBodyTemplate]=\"frozenBodyTemplate\"\r\n                    [frozen]=\"true\"\r\n                ></tbody>\r\n                <tbody\r\n                    role=\"rowgroup\"\r\n                    class=\"cax-datatable-tbody\"\r\n                    [ngClass]=\"scrollerOptions.contentStyleClass\"\r\n                    [ngStyle]=\"scrollerOptions.contentStyle\"\r\n                    [value]=\"dataToRender(scrollerOptions.rows)\"\r\n                    [caxTableBody]=\"scrollerOptions.columns\"\r\n                    [caxTableBodyTemplate]=\"bodyTemplate\"\r\n                    [scrollerOptions]=\"scrollerOptions\"\r\n                ></tbody>\r\n                <tbody\r\n                    role=\"rowgroup\"\r\n                    *ngIf=\"scrollerOptions.spacerStyle\"\r\n                    [ngStyle]=\"{ height: 'calc(' + scrollerOptions.spacerStyle.height + ' - ' + scrollerOptions.rows.length * scrollerOptions.itemSize + 'px)' }\"\r\n                    class=\"cax-datatable-scroller-spacer\"\r\n                ></tbody>\r\n                <tfoot role=\"rowgroup\" *ngIf=\"footerGroupedTemplate || footerTemplate\" #tfoot class=\"cax-datatable-tfoot\">\r\n                    <ng-container *ngTemplateOutlet=\"footerGroupedTemplate || footerTemplate; context: { $implicit: scrollerOptions.columns }\"></ng-container>\r\n                </tfoot>\r\n            </table>\r\n        </ng-template>\r\n    </div>\r\n\r\n    <cax-paginator\r\n        [rows]=\"rows\"\r\n        [first]=\"first\"\r\n        [totalRecords]=\"totalRecords\"\r\n        [pageLinkSize]=\"pageLinks\"\r\n        [alwaysShow]=\"alwaysShowPaginator\"\r\n        (onPageChange)=\"onPageChange($event)\"\r\n        [rowsPerPageOptions]=\"rowsPerPageOptions\"\r\n        *ngIf=\"paginator && (paginatorPosition === 'bottom' || paginatorPosition == 'both')\"\r\n        [templateLeft]=\"paginatorLeftTemplate\"\r\n        [templateRight]=\"paginatorRightTemplate\"\r\n        [dropdownAppendTo]=\"paginatorDropdownAppendTo\"\r\n        [dropdownScrollHeight]=\"paginatorDropdownScrollHeight\"\r\n        [currentPageReportTemplate]=\"currentPageReportTemplate\"\r\n        [showFirstLastIcon]=\"showFirstLastIcon\"\r\n        [dropdownItemTemplate]=\"paginatorDropdownItemTemplate\"\r\n        [showCurrentPageReport]=\"showCurrentPageReport\"\r\n        [showJumpToPageDropdown]=\"showJumpToPageDropdown\"\r\n        [showJumpToPageInput]=\"showJumpToPageInput\"\r\n        [showPageLinks]=\"showPageLinks\"\r\n        [styleClass]=\"getPaginatorStyleClasses('cax-paginator-bottom')\"\r\n        [locale]=\"paginatorLocale\"\r\n    >\r\n        <ng-template caxTemplate=\"dropdownicon\" *ngIf=\"paginatorDropdownIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorDropdownIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"firstpagelinkicon\" *ngIf=\"paginatorFirstPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorFirstPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"previouspagelinkicon\" *ngIf=\"paginatorPreviousPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorPreviousPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"lastpagelinkicon\" *ngIf=\"paginatorLastPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorLastPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"nextpagelinkicon\" *ngIf=\"paginatorNextPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorNextPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n    </cax-paginator>\r\n\r\n    <div *ngIf=\"summaryTemplate\" class=\"cax-datatable-footer\">\r\n        <ng-container *ngTemplateOutlet=\"summaryTemplate\"></ng-container>\r\n    </div>\r\n\r\n    <div\r\n        #resizeHelper\r\n        class=\"cax-column-resizer-helper\"\r\n        [ngStyle]=\"{\r\n                    display: 'none'\r\n                }\"\r\n        *ngIf=\"resizableColumns\"\r\n    ></div>\r\n    <span\r\n        #reorderIndicatorUp\r\n        class=\"cax-datatable-reorder-indicator-up\"\r\n        [ngStyle]=\"{\r\n                    display: 'none'\r\n                }\"\r\n        *ngIf=\"reorderableColumns\"\r\n    >\r\n        <ArrowDownIcon *ngIf=\"!reorderIndicatorUpIconTemplate\" />\r\n        <ng-template *ngTemplateOutlet=\"reorderIndicatorUpIconTemplate\"></ng-template>\r\n    </span>\r\n    <span\r\n        #reorderIndicatorDown\r\n        class=\"cax-datatable-reorder-indicator-down\"\r\n        [ngStyle]=\"{\r\n                    display: 'none'\r\n                }\"\r\n        *ngIf=\"reorderableColumns\"\r\n    >\r\n        <ArrowUpIcon *ngIf=\"!reorderIndicatorDownIconTemplate\" />\r\n        <ng-template *ngTemplateOutlet=\"reorderIndicatorDownIconTemplate\"></ng-template>\r\n    </span>\r\n</div>\r\n", styles: ["@layer cax{.cax-datatable{position:relative}.cax-datatable>.cax-datatable-wrapper{overflow:auto;border-radius:12px}.cax-datatable-wrapper::-webkit-scrollbar{width:8px;height:8px}.cax-datatable-wrapper::-webkit-scrollbar-track{background:#f0f0f0;border-radius:10px}.cax-datatable-wrapper::-webkit-scrollbar-thumb{background:#888;border-radius:10px}.cax-datatable-table{border-spacing:0px;width:100%}.cax-datatable .cax-sortable-column{-webkit-user-select:none;user-select:none}.cax-datatable .cax-sortable-column .cax-column-title,.cax-datatable .cax-sortable-column .cax-sortable-column-icon,.cax-datatable .cax-sortable-column .cax-sortable-column-badge{vertical-align:middle}.cax-datatable .cax-sortable-column .cax-icon-wrapper{display:inline}.cax-datatable .cax-sortable-column .cax-sortable-column-badge{display:inline-flex;align-items:center;justify-content:center}.cax-datatable-hoverable-rows .cax-selectable-row{cursor:pointer}.cax-datatable-scrollable>.cax-datatable-wrapper{position:relative}.cax-datatable-scrollable-table>.cax-datatable-thead{position:sticky;top:0;z-index:2}.cax-datatable-scrollable-table>.cax-datatable-frozen-tbody{position:sticky;z-index:1}.cax-datatable-scrollable-table>.cax-datatable-tfoot{position:sticky;bottom:0;z-index:1}.cax-datatable-scrollable .cax-frozen-column{position:sticky;z-index:1}.cax-datatable-scrollable th.cax-frozen-column{z-index:2;background:var(--neutral-75)}.cax-datatable-scrollable td.cax-frozen-column{z-index:1;background:transparent;-webkit-backdrop-filter:blur(80px);backdrop-filter:blur(80px)}.cax-datatable-flex-scrollable{display:flex;flex-direction:column;height:100%}.cax-datatable-flex-scrollable>.cax-datatable-wrapper{display:flex;flex-direction:column;flex:1;height:100%}.cax-datatable-scrollable-table>.cax-datatable-tbody>.cax-rowgroucax-header{position:sticky;z-index:2}.cax-datatable-resizable-table>.cax-datatable-thead>tr>th,.cax-datatable-resizable-table>.cax-datatable-tfoot>tr>td,.cax-datatable-resizable-table>.cax-datatable-tbody>tr>td{overflow:hidden;white-space:nowrap}.cax-datatable-resizable-table>.cax-datatable-thead>tr>th.cax-resizable-column:not(.cax-frozen-column){background-clip:padding-box;position:relative}.cax-datatable-resizable-table-fit>.cax-datatable-thead>tr>th.cax-resizable-column:last-child .cax-column-resizer{display:none}.cax-datatable .cax-column-resizer{display:block;position:absolute!important;top:0;right:0;margin:0;width:.5rem;height:100%;padding:0;cursor:col-resize;border:1px solid transparent}.cax-datatable .cax-column-resizer-helper{width:1px;position:absolute;z-index:10;display:none}.cax-datatable .cax-row-editor-init,.cax-datatable .cax-row-editor-save,.cax-datatable .cax-row-editor-cancel,.cax-datatable .cax-row-toggler{display:inline-flex;align-items:center;justify-content:center;overflow:hidden;position:relative}.cax-datatable-reorder-indicator-up,.cax-datatable-reorder-indicator-down{position:absolute}.cax-datatable-reorderablerow-handle,[caxReorderableColumn]{cursor:move}.cax-datatable .cax-datatable-loading-overlay{position:absolute;display:flex;align-items:center;justify-content:center;z-index:3}.cax-column-filter-row{display:flex;align-items:center;width:100%}.cax-column-filter-row i{font-size:20px}.cax-column-filter-menu,.cax-column-filter-custom{display:inline-flex;position:relative;float:right;margin-left:4px}.cax-column-filter-menu i,.cax-column-filter-custom i{font-size:20px}.cax-column-filter-custom-container{padding:16px;display:flex;gap:16px;flex-direction:column}.cax-column-filter-custom-container .cax-column-filter-custom-buttons{display:flex;gap:12px}.cax-column-filter-custom-container .cax-column-filter-custom-buttons cax-button{flex:1}.cax-column-filter-overlay-custom{width:248px}.cax-column-filter-row cax-columnfilterformelement{flex:1 1 auto;width:1%}.cax-column-filter-menu-button,.cax-column-filter-clear-button{display:inline-flex;justify-content:center;align-items:center;cursor:pointer;text-decoration:none;overflow:hidden;position:relative}.cax-column-filter-menu-button:disabled{opacity:.5}.cax-column-filter-overlay{position:absolute;top:0;left:0}.cax-column-filter-row-items{margin:0;padding:0;list-style:none}.cax-column-filter-row-item{cursor:pointer}.cax-column-filter-add-button,.cax-column-filter-remove-button{justify-content:center}.cax-column-filter-add-button .cax-button-label,.cax-column-filter-remove-button .cax-button-label{flex-grow:0}.cax-column-filter-buttonbar{display:flex;align-items:center;justify-content:space-between;gap:12px}.cax-column-filter-buttonbar .cax-button{width:auto}.cax-datatable-tbody>tr>td>.cax-column-title{display:none}.cax-datatable-scroller-spacer{display:flex}.cax-datatable .cax-scroller .cax-scroller-loading{transform:none!important;min-height:0;position:sticky;top:0;left:0}}.cax-datatable .cax-editable-column .cax-inputtext{width:100%;box-shadow:none;border:0;padding:0;line-height:normal}.cax-datatable.cax-datatable-font-sm .cax-datatable-tbody>tr>td{font-size:12px}.cax-datatable.cax-datatable-font-sm .cax-datatable-tbody>tr>td .cax-inputtext{font-size:12px}.cax-datatable.cax-datatable-font-sm .cax-datatable-tbody>tr>td cax-tablecheckbox .cax-checkbox .cax-checkbox-box{width:16px;height:16px}.cax-datatable.cax-datatable-font-md .cax-datatable-tbody>tr>td{font-size:14px}.cax-datatable.cax-datatable-font-md .cax-datatable-tbody>tr>td .cax-inputtext{font-size:14px}.cax-datatable.cax-datatable-font-md .cax-datatable-tbody>tr>td cax-tablecheckbox .cax-checkbox .cax-checkbox-box{width:18px;height:18px}.cax-datatable.cax-datatable-font-lg .cax-datatable-tbody>tr>td{font-size:16px}.cax-datatable.cax-datatable-font-lg .cax-datatable-tbody>tr>td .cax-inputtext{font-size:16px}.cax-datatable.cax-datatable-font-lg .cax-datatable-tbody>tr>td cax-tablecheckbox.cax-checkbox .cax-checkbox-box{width:20px;height:20px}.cax-datatable.cax-datatable-font-xl .cax-datatable-tbody>tr>td{font-size:18px}.cax-datatable.cax-datatable-font-xl .cax-datatable-tbody>tr>td .cax-inputtext{font-size:18px}.cax-datatable.cax-datatable-font-xl .cax-datatable-tbody>tr>td cax-tablecheckbox.cax-checkbox .cax-checkbox-box{width:22px;height:22px}.cax-datatable.cax-datatable-font-sm.cax-datatable-row-sm .cax-datatable-tbody>tr>td{height:42px}.cax-datatable.cax-datatable-font-sm.cax-datatable-row-md .cax-datatable-tbody>tr>td{height:56px}.cax-datatable.cax-datatable-font-sm.cax-datatable-row-lg .cax-datatable-tbody>tr>td{height:72px}.cax-datatable.cax-datatable-font-sm.cax-datatable-row-xl .cax-datatable-tbody>tr>td{height:88px}.cax-datatable.cax-datatable-font-md.cax-datatable-row-sm .cax-datatable-tbody>tr>td{height:44px}.cax-datatable.cax-datatable-font-md.cax-datatable-row-md .cax-datatable-tbody>tr>td{height:60px}.cax-datatable.cax-datatable-font-md.cax-datatable-row-lg .cax-datatable-tbody>tr>td{height:78px}.cax-datatable.cax-datatable-font-md.cax-datatable-row-xl .cax-datatable-tbody>tr>td{height:96px}.cax-datatable.cax-datatable-font-lg.cax-datatable-row-sm .cax-datatable-tbody>tr>td{height:54px}.cax-datatable.cax-datatable-font-lg.cax-datatable-row-md .cax-datatable-tbody>tr>td{height:66px}.cax-datatable.cax-datatable-font-lg.cax-datatable-row-lg .cax-datatable-tbody>tr>td{height:86px}.cax-datatable.cax-datatable-font-lg.cax-datatable-row-xl .cax-datatable-tbody>tr>td{height:108px}.cax-datatable.cax-datatable-font-xl.cax-datatable-row-sm .cax-datatable-tbody>tr>td{height:56px}.cax-datatable.cax-datatable-font-xl.cax-datatable-row-md .cax-datatable-tbody>tr>td{height:70px}.cax-datatable.cax-datatable-font-xl.cax-datatable-row-lg .cax-datatable-tbody>tr>td{height:94px}.cax-datatable.cax-datatable-font-xl.cax-datatable-row-xl .cax-datatable-tbody>tr>td{height:116px}.cax-cell-highlight-default{border:1px solid var(--primary-500)!important}.cax-cell-highlight-error{border:1px solid var(--error-600)!important}.cax-cell-background-error{background:var(--error-50)}.cax-sort-icon-button{border:0;width:28px;height:28px!important;display:flex;background:transparent;cursor:pointer;padding:0!important;align-items:center;justify-content:center}.cax-sort-icon-button i{font-size:20px}.cax-sort-icon-button:disabled{opacity:.5;cursor:context-menu}cax-sorticon{position:absolute;margin-left:4px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i4.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i4.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "ngmodule", type: PaginatorModule }, { kind: "component", type: i5.Paginator, selector: "cax-paginator", inputs: ["pageLinkSize", "style", "styleClass", "alwaysShow", "dropdownAppendTo", "templateLeft", "templateRight", "appendTo", "dropdownScrollHeight", "currentPageReportTemplate", "showCurrentPageReport", "showFirstLastIcon", "totalRecords", "rows", "rowsPerPageOptions", "showJumpToPageDropdown", "showJumpToPageInput", "jumpToPageItemTemplate", "showPageLinks", "locale", "dropdownItemTemplate", "first", "rightAligned"], outputs: ["onPageChange"] }, { kind: "directive", type: i2.CaxTemplate, selector: "[caxTemplate]", inputs: ["type", "caxTemplate"] }, { kind: "component", type: i6.Scroller, selector: "cax-scroller", inputs: ["id", "style", "styleClass", "tabindex", "items", "itemSize", "scrollHeight", "scrollWidth", "orientation", "step", "delay", "resizeDelay", "appendOnly", "inline", "lazy", "disabled", "loaderDisabled", "columns", "showSpacer", "showLoader", "numToleratedItems", "loading", "autoSize", "trackBy", "options"], outputs: ["onLazyLoad", "onScroll", "onScrollIndexChange"] }, { kind: "ngmodule", type: ScrollerModule }, { kind: "component", type: ArrowDownIcon, selector: "ArrowDownIcon" }, { kind: "component", type: ArrowUpIcon, selector: "ArrowUpIcon" }, { kind: "component", type: SpinnerIcon, selector: "SpinnerIcon" }, { kind: "component", type: TableBody, selector: "[caxTableBody]", inputs: ["caxTableBody", "caxTableBodyTemplate", "value", "frozen", "frozenRows", "scrollerOptions"] }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: Table, decorators: [{
+            type: Component,
+            args: [{ selector: 'cax-table', changeDetection: ChangeDetectionStrategy.Default, encapsulation: ViewEncapsulation.None, standalone: true, imports: [CommonModule, PaginatorModule, ScrollerModule, ArrowDownIcon, ArrowUpIcon, SpinnerIcon, TableBody], host: {
+                        class: 'cax-element'
+                    }, template: "<div #container [ngStyle]=\"style\" [class]=\"styleClass\" [ngClass]=\"getTableClasses()\" [attr.id]=\"id\">\r\n    <div class=\"cax-datatable-loading-overlay cax-component-overlay\" *ngIf=\"loading && showLoader\">\r\n        <i *ngIf=\"loadingIcon\" [class]=\"'cax-datatable-loading-icon ' + loadingIcon\"></i>\r\n        <ng-container *ngIf=\"!loadingIcon\">\r\n            <SpinnerIcon *ngIf=\"!loadingIconTemplate\" [spin]=\"true\" [styleClass]=\"'cax-datatable-loading-icon'\" />\r\n            <span *ngIf=\"loadingIconTemplate\" class=\"cax-datatable-loading-icon\">\r\n                <ng-template *ngTemplateOutlet=\"loadingIconTemplate\"></ng-template>\r\n            </span>\r\n        </ng-container>\r\n    </div>\r\n    <div *ngIf=\"captionTemplate\" class=\"cax-datatable-header\">\r\n        <ng-container *ngTemplateOutlet=\"captionTemplate\"></ng-container>\r\n    </div>\r\n    <cax-paginator\r\n        [rows]=\"rows\"\r\n        [first]=\"first\"\r\n        [totalRecords]=\"totalRecords\"\r\n        [pageLinkSize]=\"pageLinks\"\r\n        [alwaysShow]=\"alwaysShowPaginator\"\r\n        (onPageChange)=\"onPageChange($event)\"\r\n        [rowsPerPageOptions]=\"rowsPerPageOptions\"\r\n        *ngIf=\"paginator && (paginatorPosition === 'top' || paginatorPosition == 'both')\"\r\n        [templateLeft]=\"paginatorLeftTemplate\"\r\n        [templateRight]=\"paginatorRightTemplate\"\r\n        [dropdownAppendTo]=\"paginatorDropdownAppendTo\"\r\n        [dropdownScrollHeight]=\"paginatorDropdownScrollHeight\"\r\n        [currentPageReportTemplate]=\"currentPageReportTemplate\"\r\n        [showFirstLastIcon]=\"showFirstLastIcon\"\r\n        [dropdownItemTemplate]=\"paginatorDropdownItemTemplate\"\r\n        [showCurrentPageReport]=\"showCurrentPageReport\"\r\n        [showJumpToPageDropdown]=\"showJumpToPageDropdown\"\r\n        [showJumpToPageInput]=\"showJumpToPageInput\"\r\n        [showPageLinks]=\"showPageLinks\"\r\n        [styleClass]=\"getPaginatorStyleClasses('cax-paginator-top')\"\r\n        [locale]=\"paginatorLocale\"\r\n    >\r\n        <ng-template caxTemplate=\"dropdownicon\" *ngIf=\"paginatorDropdownIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorDropdownIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"firstpagelinkicon\" *ngIf=\"paginatorFirstPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorFirstPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"previouspagelinkicon\" *ngIf=\"paginatorPreviousPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorPreviousPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"lastpagelinkicon\" *ngIf=\"paginatorLastPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorLastPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"nextpagelinkicon\" *ngIf=\"paginatorNextPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorNextPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n    </cax-paginator>\r\n\r\n    <div #wrapper class=\"cax-datatable-wrapper\" [ngStyle]=\"{ maxHeight: virtualScroll ? '' : scrollHeight }\">\r\n        <cax-scroller\r\n            #scroller\r\n            *ngIf=\"virtualScroll\"\r\n            [items]=\"processedData\"\r\n            [columns]=\"columns\"\r\n            [style]=\"{ height: scrollHeight !== 'flex' ? scrollHeight : undefined }\"\r\n            [scrollHeight]=\"scrollHeight !== 'flex' ? undefined : '100%'\"\r\n            [itemSize]=\"virtualScrollItemSize || _virtualRowHeight\"\r\n            [step]=\"rows\"\r\n            [delay]=\"lazy ? virtualScrollDelay : 0\"\r\n            [inline]=\"true\"\r\n            [autoSize]=\"true\"\r\n            [lazy]=\"lazy\"\r\n            (onLazyLoad)=\"onLazyItemLoad($event)\"\r\n            [loaderDisabled]=\"true\"\r\n            [showSpacer]=\"false\"\r\n            [showLoader]=\"loadingBodyTemplate\"\r\n            [options]=\"virtualScrollOptions\"\r\n        >\r\n            <ng-template caxTemplate=\"content\" let-items let-scrollerOptions=\"options\">\r\n                <ng-container *ngTemplateOutlet=\"buildInTable; context: { $implicit: items, options: scrollerOptions }\"></ng-container>\r\n            </ng-template>\r\n        </cax-scroller>\r\n        <ng-container *ngIf=\"!virtualScroll\">\r\n            <ng-container *ngTemplateOutlet=\"buildInTable; context: { $implicit: processedData, options: { columns } }\"></ng-container>\r\n        </ng-container>\r\n\r\n        <ng-template #buildInTable let-items let-scrollerOptions=\"options\">\r\n            <table\r\n                #table\r\n                role=\"table\"\r\n                [ngClass]=\"{ 'cax-datatable-table': true, 'cax-datatable-scrollable-table': scrollable, 'cax-datatable-resizable-table': resizableColumns, 'cax-datatable-resizable-table-fit': resizableColumns && columnResizeMode === 'fit' }\"\r\n                [class]=\"tableStyleClass\"\r\n                [ngStyle]=\"tableStyle\"\r\n                [attr.id]=\"id + '-table'\"\r\n            >\r\n                <ng-container *ngTemplateOutlet=\"colGroupTemplate; context: { $implicit: scrollerOptions.columns }\"></ng-container>\r\n                <thead role=\"rowgroup\" #thead class=\"cax-datatable-thead\">\r\n                    <ng-container *ngTemplateOutlet=\"headerGroupedTemplate || headerTemplate; context: { $implicit: scrollerOptions.columns }\"></ng-container>\r\n                </thead>\r\n                <tbody\r\n                    role=\"rowgroup\"\r\n                    class=\"cax-datatable-tbody cax-datatable-frozen-tbody\"\r\n                    *ngIf=\"frozenValue || frozenBodyTemplate\"\r\n                    [value]=\"frozenValue\"\r\n                    [frozenRows]=\"true\"\r\n                    [caxTableBody]=\"scrollerOptions.columns\"\r\n                    [caxTableBodyTemplate]=\"frozenBodyTemplate\"\r\n                    [frozen]=\"true\"\r\n                ></tbody>\r\n                <tbody\r\n                    role=\"rowgroup\"\r\n                    class=\"cax-datatable-tbody\"\r\n                    [ngClass]=\"scrollerOptions.contentStyleClass\"\r\n                    [ngStyle]=\"scrollerOptions.contentStyle\"\r\n                    [value]=\"dataToRender(scrollerOptions.rows)\"\r\n                    [caxTableBody]=\"scrollerOptions.columns\"\r\n                    [caxTableBodyTemplate]=\"bodyTemplate\"\r\n                    [scrollerOptions]=\"scrollerOptions\"\r\n                ></tbody>\r\n                <tbody\r\n                    role=\"rowgroup\"\r\n                    *ngIf=\"scrollerOptions.spacerStyle\"\r\n                    [ngStyle]=\"{ height: 'calc(' + scrollerOptions.spacerStyle.height + ' - ' + scrollerOptions.rows.length * scrollerOptions.itemSize + 'px)' }\"\r\n                    class=\"cax-datatable-scroller-spacer\"\r\n                ></tbody>\r\n                <tfoot role=\"rowgroup\" *ngIf=\"footerGroupedTemplate || footerTemplate\" #tfoot class=\"cax-datatable-tfoot\">\r\n                    <ng-container *ngTemplateOutlet=\"footerGroupedTemplate || footerTemplate; context: { $implicit: scrollerOptions.columns }\"></ng-container>\r\n                </tfoot>\r\n            </table>\r\n        </ng-template>\r\n    </div>\r\n\r\n    <cax-paginator\r\n        [rows]=\"rows\"\r\n        [first]=\"first\"\r\n        [totalRecords]=\"totalRecords\"\r\n        [pageLinkSize]=\"pageLinks\"\r\n        [alwaysShow]=\"alwaysShowPaginator\"\r\n        (onPageChange)=\"onPageChange($event)\"\r\n        [rowsPerPageOptions]=\"rowsPerPageOptions\"\r\n        *ngIf=\"paginator && (paginatorPosition === 'bottom' || paginatorPosition == 'both')\"\r\n        [templateLeft]=\"paginatorLeftTemplate\"\r\n        [templateRight]=\"paginatorRightTemplate\"\r\n        [dropdownAppendTo]=\"paginatorDropdownAppendTo\"\r\n        [dropdownScrollHeight]=\"paginatorDropdownScrollHeight\"\r\n        [currentPageReportTemplate]=\"currentPageReportTemplate\"\r\n        [showFirstLastIcon]=\"showFirstLastIcon\"\r\n        [dropdownItemTemplate]=\"paginatorDropdownItemTemplate\"\r\n        [showCurrentPageReport]=\"showCurrentPageReport\"\r\n        [showJumpToPageDropdown]=\"showJumpToPageDropdown\"\r\n        [showJumpToPageInput]=\"showJumpToPageInput\"\r\n        [showPageLinks]=\"showPageLinks\"\r\n        [styleClass]=\"getPaginatorStyleClasses('cax-paginator-bottom')\"\r\n        [locale]=\"paginatorLocale\"\r\n    >\r\n        <ng-template caxTemplate=\"dropdownicon\" *ngIf=\"paginatorDropdownIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorDropdownIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"firstpagelinkicon\" *ngIf=\"paginatorFirstPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorFirstPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"previouspagelinkicon\" *ngIf=\"paginatorPreviousPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorPreviousPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"lastpagelinkicon\" *ngIf=\"paginatorLastPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorLastPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"nextpagelinkicon\" *ngIf=\"paginatorNextPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorNextPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n    </cax-paginator>\r\n\r\n    <div *ngIf=\"summaryTemplate\" class=\"cax-datatable-footer\">\r\n        <ng-container *ngTemplateOutlet=\"summaryTemplate\"></ng-container>\r\n    </div>\r\n\r\n    <div\r\n        #resizeHelper\r\n        class=\"cax-column-resizer-helper\"\r\n        [ngStyle]=\"{\r\n                    display: 'none'\r\n                }\"\r\n        *ngIf=\"resizableColumns\"\r\n    ></div>\r\n    <span\r\n        #reorderIndicatorUp\r\n        class=\"cax-datatable-reorder-indicator-up\"\r\n        [ngStyle]=\"{\r\n                    display: 'none'\r\n                }\"\r\n        *ngIf=\"reorderableColumns\"\r\n    >\r\n        <ArrowDownIcon *ngIf=\"!reorderIndicatorUpIconTemplate\" />\r\n        <ng-template *ngTemplateOutlet=\"reorderIndicatorUpIconTemplate\"></ng-template>\r\n    </span>\r\n    <span\r\n        #reorderIndicatorDown\r\n        class=\"cax-datatable-reorder-indicator-down\"\r\n        [ngStyle]=\"{\r\n                    display: 'none'\r\n                }\"\r\n        *ngIf=\"reorderableColumns\"\r\n    >\r\n        <ArrowUpIcon *ngIf=\"!reorderIndicatorDownIconTemplate\" />\r\n        <ng-template *ngTemplateOutlet=\"reorderIndicatorDownIconTemplate\"></ng-template>\r\n    </span>\r\n</div>\r\n", styles: ["@layer cax{.cax-datatable{position:relative}.cax-datatable>.cax-datatable-wrapper{overflow:auto;border-radius:12px}.cax-datatable-wrapper::-webkit-scrollbar{width:8px;height:8px}.cax-datatable-wrapper::-webkit-scrollbar-track{background:#f0f0f0;border-radius:10px}.cax-datatable-wrapper::-webkit-scrollbar-thumb{background:#888;border-radius:10px}.cax-datatable-table{border-spacing:0px;width:100%}.cax-datatable .cax-sortable-column{-webkit-user-select:none;user-select:none}.cax-datatable .cax-sortable-column .cax-column-title,.cax-datatable .cax-sortable-column .cax-sortable-column-icon,.cax-datatable .cax-sortable-column .cax-sortable-column-badge{vertical-align:middle}.cax-datatable .cax-sortable-column .cax-icon-wrapper{display:inline}.cax-datatable .cax-sortable-column .cax-sortable-column-badge{display:inline-flex;align-items:center;justify-content:center}.cax-datatable-hoverable-rows .cax-selectable-row{cursor:pointer}.cax-datatable-scrollable>.cax-datatable-wrapper{position:relative}.cax-datatable-scrollable-table>.cax-datatable-thead{position:sticky;top:0;z-index:2}.cax-datatable-scrollable-table>.cax-datatable-frozen-tbody{position:sticky;z-index:1}.cax-datatable-scrollable-table>.cax-datatable-tfoot{position:sticky;bottom:0;z-index:1}.cax-datatable-scrollable .cax-frozen-column{position:sticky;z-index:1}.cax-datatable-scrollable th.cax-frozen-column{z-index:2;background:var(--neutral-75)}.cax-datatable-scrollable td.cax-frozen-column{z-index:1;background:transparent;-webkit-backdrop-filter:blur(80px);backdrop-filter:blur(80px)}.cax-datatable-flex-scrollable{display:flex;flex-direction:column;height:100%}.cax-datatable-flex-scrollable>.cax-datatable-wrapper{display:flex;flex-direction:column;flex:1;height:100%}.cax-datatable-scrollable-table>.cax-datatable-tbody>.cax-rowgroucax-header{position:sticky;z-index:2}.cax-datatable-resizable-table>.cax-datatable-thead>tr>th,.cax-datatable-resizable-table>.cax-datatable-tfoot>tr>td,.cax-datatable-resizable-table>.cax-datatable-tbody>tr>td{overflow:hidden;white-space:nowrap}.cax-datatable-resizable-table>.cax-datatable-thead>tr>th.cax-resizable-column:not(.cax-frozen-column){background-clip:padding-box;position:relative}.cax-datatable-resizable-table-fit>.cax-datatable-thead>tr>th.cax-resizable-column:last-child .cax-column-resizer{display:none}.cax-datatable .cax-column-resizer{display:block;position:absolute!important;top:0;right:0;margin:0;width:.5rem;height:100%;padding:0;cursor:col-resize;border:1px solid transparent}.cax-datatable .cax-column-resizer-helper{width:1px;position:absolute;z-index:10;display:none}.cax-datatable .cax-row-editor-init,.cax-datatable .cax-row-editor-save,.cax-datatable .cax-row-editor-cancel,.cax-datatable .cax-row-toggler{display:inline-flex;align-items:center;justify-content:center;overflow:hidden;position:relative}.cax-datatable-reorder-indicator-up,.cax-datatable-reorder-indicator-down{position:absolute}.cax-datatable-reorderablerow-handle,[caxReorderableColumn]{cursor:move}.cax-datatable .cax-datatable-loading-overlay{position:absolute;display:flex;align-items:center;justify-content:center;z-index:3}.cax-column-filter-row{display:flex;align-items:center;width:100%}.cax-column-filter-row i{font-size:20px}.cax-column-filter-menu,.cax-column-filter-custom{display:inline-flex;position:relative;float:right;margin-left:4px}.cax-column-filter-menu i,.cax-column-filter-custom i{font-size:20px}.cax-column-filter-custom-container{padding:16px;display:flex;gap:16px;flex-direction:column}.cax-column-filter-custom-container .cax-column-filter-custom-buttons{display:flex;gap:12px}.cax-column-filter-custom-container .cax-column-filter-custom-buttons cax-button{flex:1}.cax-column-filter-overlay-custom{width:248px}.cax-column-filter-row cax-columnfilterformelement{flex:1 1 auto;width:1%}.cax-column-filter-menu-button,.cax-column-filter-clear-button{display:inline-flex;justify-content:center;align-items:center;cursor:pointer;text-decoration:none;overflow:hidden;position:relative}.cax-column-filter-menu-button:disabled{opacity:.5}.cax-column-filter-overlay{position:absolute;top:0;left:0}.cax-column-filter-row-items{margin:0;padding:0;list-style:none}.cax-column-filter-row-item{cursor:pointer}.cax-column-filter-add-button,.cax-column-filter-remove-button{justify-content:center}.cax-column-filter-add-button .cax-button-label,.cax-column-filter-remove-button .cax-button-label{flex-grow:0}.cax-column-filter-buttonbar{display:flex;align-items:center;justify-content:space-between;gap:12px}.cax-column-filter-buttonbar .cax-button{width:auto}.cax-datatable-tbody>tr>td>.cax-column-title{display:none}.cax-datatable-scroller-spacer{display:flex}.cax-datatable .cax-scroller .cax-scroller-loading{transform:none!important;min-height:0;position:sticky;top:0;left:0}}.cax-datatable .cax-editable-column .cax-inputtext{width:100%;box-shadow:none;border:0;padding:0;line-height:normal}.cax-datatable.cax-datatable-font-sm .cax-datatable-tbody>tr>td{font-size:12px}.cax-datatable.cax-datatable-font-sm .cax-datatable-tbody>tr>td .cax-inputtext{font-size:12px}.cax-datatable.cax-datatable-font-sm .cax-datatable-tbody>tr>td cax-tablecheckbox .cax-checkbox .cax-checkbox-box{width:16px;height:16px}.cax-datatable.cax-datatable-font-md .cax-datatable-tbody>tr>td{font-size:14px}.cax-datatable.cax-datatable-font-md .cax-datatable-tbody>tr>td .cax-inputtext{font-size:14px}.cax-datatable.cax-datatable-font-md .cax-datatable-tbody>tr>td cax-tablecheckbox .cax-checkbox .cax-checkbox-box{width:18px;height:18px}.cax-datatable.cax-datatable-font-lg .cax-datatable-tbody>tr>td{font-size:16px}.cax-datatable.cax-datatable-font-lg .cax-datatable-tbody>tr>td .cax-inputtext{font-size:16px}.cax-datatable.cax-datatable-font-lg .cax-datatable-tbody>tr>td cax-tablecheckbox.cax-checkbox .cax-checkbox-box{width:20px;height:20px}.cax-datatable.cax-datatable-font-xl .cax-datatable-tbody>tr>td{font-size:18px}.cax-datatable.cax-datatable-font-xl .cax-datatable-tbody>tr>td .cax-inputtext{font-size:18px}.cax-datatable.cax-datatable-font-xl .cax-datatable-tbody>tr>td cax-tablecheckbox.cax-checkbox .cax-checkbox-box{width:22px;height:22px}.cax-datatable.cax-datatable-font-sm.cax-datatable-row-sm .cax-datatable-tbody>tr>td{height:42px}.cax-datatable.cax-datatable-font-sm.cax-datatable-row-md .cax-datatable-tbody>tr>td{height:56px}.cax-datatable.cax-datatable-font-sm.cax-datatable-row-lg .cax-datatable-tbody>tr>td{height:72px}.cax-datatable.cax-datatable-font-sm.cax-datatable-row-xl .cax-datatable-tbody>tr>td{height:88px}.cax-datatable.cax-datatable-font-md.cax-datatable-row-sm .cax-datatable-tbody>tr>td{height:44px}.cax-datatable.cax-datatable-font-md.cax-datatable-row-md .cax-datatable-tbody>tr>td{height:60px}.cax-datatable.cax-datatable-font-md.cax-datatable-row-lg .cax-datatable-tbody>tr>td{height:78px}.cax-datatable.cax-datatable-font-md.cax-datatable-row-xl .cax-datatable-tbody>tr>td{height:96px}.cax-datatable.cax-datatable-font-lg.cax-datatable-row-sm .cax-datatable-tbody>tr>td{height:54px}.cax-datatable.cax-datatable-font-lg.cax-datatable-row-md .cax-datatable-tbody>tr>td{height:66px}.cax-datatable.cax-datatable-font-lg.cax-datatable-row-lg .cax-datatable-tbody>tr>td{height:86px}.cax-datatable.cax-datatable-font-lg.cax-datatable-row-xl .cax-datatable-tbody>tr>td{height:108px}.cax-datatable.cax-datatable-font-xl.cax-datatable-row-sm .cax-datatable-tbody>tr>td{height:56px}.cax-datatable.cax-datatable-font-xl.cax-datatable-row-md .cax-datatable-tbody>tr>td{height:70px}.cax-datatable.cax-datatable-font-xl.cax-datatable-row-lg .cax-datatable-tbody>tr>td{height:94px}.cax-datatable.cax-datatable-font-xl.cax-datatable-row-xl .cax-datatable-tbody>tr>td{height:116px}.cax-cell-highlight-default{border:1px solid var(--primary-500)!important}.cax-cell-highlight-error{border:1px solid var(--error-600)!important}.cax-cell-background-error{background:var(--error-50)}.cax-sort-icon-button{border:0;width:28px;height:28px!important;display:flex;background:transparent;cursor:pointer;padding:0!important;align-items:center;justify-content:center}.cax-sort-icon-button i{font-size:20px}.cax-sort-icon-button:disabled{opacity:.5;cursor:context-menu}cax-sorticon{position:absolute;margin-left:4px}\n"] }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: i1.TableService }, { type: i0.ChangeDetectorRef }, { type: i2.FilterService }, { type: i2.OverlayService }, { type: i2.caxConfig }, { type: i3.DomSanitizer }], propDecorators: { fontSize: [{
+                type: Input
+            }], rowSize: [{
+                type: Input
+            }], frozenColumns: [{
+                type: Input
+            }], frozenValue: [{
+                type: Input
+            }], style: [{
+                type: Input
+            }], styleClass: [{
+                type: Input
+            }], tableStyle: [{
+                type: Input
+            }], tableStyleClass: [{
+                type: Input
+            }], paginator: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], pageLinks: [{
+                type: Input,
+                args: [{ transform: numberAttribute }]
+            }], rowsPerPageOptions: [{
+                type: Input
+            }], alwaysShowPaginator: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], paginatorPosition: [{
+                type: Input
+            }], paginatorStyleClass: [{
+                type: Input
+            }], paginatorDropdownAppendTo: [{
+                type: Input
+            }], paginatorDropdownScrollHeight: [{
+                type: Input
+            }], currentPageReportTemplate: [{
+                type: Input
+            }], showCurrentPageReport: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showJumpToPageDropdown: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showJumpToPageInput: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showFirstLastIcon: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showPageLinks: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], defaultSortOrder: [{
+                type: Input,
+                args: [{ transform: numberAttribute }]
+            }], filterType: [{
+                type: Input
+            }], sortType: [{
+                type: Input
+            }], sortMode: [{
+                type: Input
+            }], resetPageOnSort: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], selectionMode: [{
+                type: Input
+            }], selectionPageOnly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], contextMenuSelection: [{
+                type: Input
+            }], contextMenuSelectionChange: [{
+                type: Output
+            }], contextMenuSelectionMode: [{
+                type: Input
+            }], dataKey: [{
+                type: Input
+            }], metaKeySelection: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], rowSelectable: [{
+                type: Input
+            }], rowTrackBy: [{
+                type: Input
+            }], lazy: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], lazyLoadOnInit: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], compareSelectionBy: [{
+                type: Input
+            }], csvSeparator: [{
+                type: Input
+            }], exportFilename: [{
+                type: Input
+            }], filters: [{
+                type: Input
+            }], globalFilterFields: [{
+                type: Input
+            }], filterDelay: [{
+                type: Input,
+                args: [{ transform: numberAttribute }]
+            }], filterLocale: [{
+                type: Input
+            }], expandedRowKeys: [{
+                type: Input
+            }], editingRowKeys: [{
+                type: Input
+            }], rowExpandMode: [{
+                type: Input
+            }], scrollable: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], scrollDirection: [{
+                type: Input
+            }], rowGroupMode: [{
+                type: Input
+            }], scrollHeight: [{
+                type: Input
+            }], virtualScroll: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], virtualScrollItemSize: [{
+                type: Input,
+                args: [{ transform: numberAttribute }]
+            }], virtualScrollOptions: [{
+                type: Input
+            }], virtualScrollDelay: [{
+                type: Input,
+                args: [{ transform: numberAttribute }]
+            }], frozenWidth: [{
+                type: Input
+            }], responsive: [{
+                type: Input
+            }], contextMenu: [{
+                type: Input
+            }], resizableColumns: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], columnResizeMode: [{
+                type: Input
+            }], reorderableColumns: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], loading: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], loadingIcon: [{
+                type: Input
+            }], showLoader: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], rowHover: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], customSort: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showInitialSortBadge: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], autoLayout: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], exportFunction: [{
+                type: Input
+            }], exportHeader: [{
+                type: Input
+            }], stateKey: [{
+                type: Input
+            }], stateStorage: [{
+                type: Input
+            }], editMode: [{
+                type: Input
+            }], groupRowsBy: [{
+                type: Input
+            }], groupRowsByOrder: [{
+                type: Input,
+                args: [{ transform: numberAttribute }]
+            }], responsiveLayout: [{
+                type: Input
+            }], breakpoint: [{
+                type: Input
+            }], paginatorLocale: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], first: [{
+                type: Input
+            }], rows: [{
+                type: Input
+            }], totalRecords: [{
+                type: Input
+            }], sortField: [{
+                type: Input
+            }], sortOrder: [{
+                type: Input
+            }], multiSortMeta: [{
+                type: Input
+            }], selection: [{
+                type: Input
+            }], selectAll: [{
+                type: Input
+            }], selectAllChange: [{
+                type: Output
+            }], selectionChange: [{
+                type: Output
+            }], onRowSelect: [{
+                type: Output
+            }], onRowUnselect: [{
+                type: Output
+            }], onPage: [{
+                type: Output
+            }], onSort: [{
+                type: Output
+            }], onFilter: [{
+                type: Output
+            }], onLazyLoad: [{
+                type: Output
+            }], onRowExpand: [{
+                type: Output
+            }], onRowCollapse: [{
+                type: Output
+            }], onContextMenuSelect: [{
+                type: Output
+            }], onColResize: [{
+                type: Output
+            }], onColReorder: [{
+                type: Output
+            }], onRowReorder: [{
+                type: Output
+            }], onEditInit: [{
+                type: Output
+            }], onEditComplete: [{
+                type: Output
+            }], onEditCancel: [{
+                type: Output
+            }], onHeaderCheckboxToggle: [{
+                type: Output
+            }], sortFunction: [{
+                type: Output
+            }], firstChange: [{
+                type: Output
+            }], rowsChange: [{
+                type: Output
+            }], onStateSave: [{
+                type: Output
+            }], onStateRestore: [{
+                type: Output
+            }], containerViewChild: [{
+                type: ViewChild,
+                args: ['container']
+            }], resizeHelperViewChild: [{
+                type: ViewChild,
+                args: ['resizeHelper']
+            }], reorderIndicatorUpViewChild: [{
+                type: ViewChild,
+                args: ['reorderIndicatorUp']
+            }], reorderIndicatorDownViewChild: [{
+                type: ViewChild,
+                args: ['reorderIndicatorDown']
+            }], wrapperViewChild: [{
+                type: ViewChild,
+                args: ['wrapper']
+            }], tableViewChild: [{
+                type: ViewChild,
+                args: ['table']
+            }], tableHeaderViewChild: [{
+                type: ViewChild,
+                args: ['thead']
+            }], tableFooterViewChild: [{
+                type: ViewChild,
+                args: ['tfoot']
+            }], scroller: [{
+                type: ViewChild,
+                args: ['scroller']
+            }], templates: [{
+                type: ContentChildren,
+                args: [CaxTemplate]
+            }], virtualRowHeight: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.js","sourceRoot":"","sources":["../../../src/app/components/table/table.ts","../../../src/app/components/table/table.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAC5E,OAAO,EAGH,gBAAgB,EAChB,uBAAuB,EAEvB,SAAS,EACT,eAAe,EAEf,YAAY,EACZ,MAAM,EACN,KAAK,EAEL,eAAe,EAGf,MAAM,EACN,WAAW,EAKX,SAAS,EACT,iBAAiB,EACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAe,eAAe,EAAkB,cAAc,EAA0D,WAAW,EAAyC,MAAM,uBAAuB,CAAC;AACjN,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAY,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEtE,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAuBzE,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAC;;;;;;;;AAE/D;;;GAGG;AAaH,MAAM,OAAO,KAAK;IAozBgB;IACG;IACrB;IACD;IACA;IACA;IACA;IACA;IACA;IACA;IACU;IA7zBZ,QAAQ,GAA8B,IAAI,CAAC;IAC3C,OAAO,GAA8B,IAAI,CAAC;IACnD;;;OAGG;IACM,aAAa,CAAoB;IAC1C;;;OAGG;IACM,WAAW,CAAoB;IACxC;;;OAGG;IACM,KAAK,CAA8C;IAC5D;;;OAGG;IACM,UAAU,CAAqB;IACxC;;;OAGG;IACM,UAAU,CAA8C;IACjE;;;OAGG;IACM,eAAe,CAAqB;IAC7C;;;OAGG;IACqC,SAAS,CAAsB;IACvE;;;OAGG;IACoC,SAAS,GAAW,CAAC,CAAC;IAC7D;;;OAGG;IACM,kBAAkB,CAAoB;IAC/C;;;OAGG;IACqC,mBAAmB,GAAY,IAAI,CAAC;IAC5E;;;OAGG;IACM,iBAAiB,GAA8B,QAAQ,CAAC;IACjE;;;OAGG;IACM,mBAAmB,CAAqB;IACjD;;;OAGG;IACM,yBAAyB,CAAgF;IAClH;;;OAGG;IACM,6BAA6B,GAAW,OAAO,CAAC;IACzD;;;OAGG;IACM,yBAAyB,GAAW,+BAA+B,CAAC;IAC7E;;;OAGG;IACqC,qBAAqB,CAAsB;IACnF;;;OAGG;IACqC,sBAAsB,CAAsB;IACpF;;;OAGG;IACqC,mBAAmB,CAAsB;IACjF;;;OAGG;IACqC,iBAAiB,GAAY,IAAI,CAAC;IAC1E;;;OAGG;IACqC,aAAa,GAAY,IAAI,CAAC;IACtE;;;OAGG;IACoC,gBAAgB,GAAW,CAAC,CAAC;IACpE;;;OAGG;IACM,UAAU,GAAyB,SAAS,CAAC;IAC7C,QAAQ,GAAyB,SAAS,CAAC;IAC3C,QAAQ,GAA0B,QAAQ,CAAC;IACpD;;;OAGG;IACqC,eAAe,GAAY,IAAI,CAAC;IACxE;;;OAGG;IACM,aAAa,CAA2C;IACjE;;;OAGG;IACqC,iBAAiB,CAAsB;IAC/E;;;OAGG;IACM,oBAAoB,CAAM;IACnC;;;;OAIG;IACO,0BAA0B,GAAsB,IAAI,YAAY,EAAE,CAAC;IAC7E;;;OAGG;IACM,wBAAwB,GAAW,UAAU,CAAC;IACvD;;;OAGG;IACM,OAAO,CAAqB;IACrC;;;OAGG;IACqC,gBAAgB,GAAwB,KAAK,CAAC;IACtF;;;OAGG;IACM,aAAa,CAA6D;IACnF;;;OAGG;IACM,UAAU,GAAa,CAAC,KAAa,EAAE,IAAS,EAAE,EAAE,CAAC,IAAI,CAAC;IACnE;;;OAGG;IACqC,IAAI,GAAY,KAAK,CAAC;IAC9D;;;OAGG;IACqC,cAAc,GAAY,IAAI,CAAC;IACvE;;;OAGG;IACM,kBAAkB,GAA4B,YAAY,CAAC;IACpE;;;OAGG;IACM,YAAY,GAAW,GAAG,CAAC;IACpC;;;OAGG;IACM,cAAc,GAAW,UAAU,CAAC;IAC7C;;;OAGG;IACM,OAAO,GAAuD,EAAE,CAAC;IAC1E;;;OAGG;IACM,kBAAkB,CAAuB;IAClD;;;OAGG;IACoC,WAAW,GAAW,GAAG,CAAC;IACjE;;;OAGG;IACM,YAAY,CAAqB;IAC1C;;;OAGG;IACM,eAAe,GAA6B,EAAE,CAAC;IACxD;;;OAGG;IACM,cAAc,GAA6B,EAAE,CAAC;IACvD;;;OAGG;IACM,aAAa,GAA0B,UAAU,CAAC;IAC3D;;;OAGG;IACqC,UAAU,CAAsB;IACxE;;;;OAIG;IACM,eAAe,GAAuC,UAAU,CAAC;IAC1E;;;OAGG;IACM,YAAY,CAAsC;IAC3D;;;OAGG;IACM,YAAY,CAAqB;IAC1C;;;OAGG;IACqC,aAAa,CAAsB;IAC3E;;;OAGG;IACoC,qBAAqB,CAAqB;IACjF;;;OAGG;IACM,oBAAoB,CAA8B;IAC3D;;;OAGG;IACoC,kBAAkB,GAAW,GAAG,CAAC;IACxE;;;OAGG;IACM,WAAW,CAAqB;IACzC;;;;OAIG;IACH,IAAa,UAAU;QACnB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IACD,IAAI,UAAU,CAAC,GAA+B;QAC1C,IAAI,CAAC,WAAW,GAAG,GAAG,CAAC;QACvB,OAAO,CAAC,IAAI,CAAC,2FAA2F,CAAC,CAAC;IAC9G,CAAC;IACD,WAAW,CAA6B;IACxC;;;OAGG;IACM,WAAW,CAAM;IAC1B;;;OAGG;IACqC,gBAAgB,CAAsB;IAC9E;;;OAGG;IACM,gBAAgB,GAAW,KAAK,CAAC;IAC1C;;;OAGG;IACqC,kBAAkB,CAAsB;IAChF;;;OAGG;IACqC,OAAO,CAAsB;IACrE;;;OAGG;IACM,WAAW,CAAqB;IACzC;;;OAGG;IACqC,UAAU,GAAY,IAAI,CAAC;IACnE;;;OAGG;IACqC,QAAQ,CAAsB;IACtE;;;OAGG;IACqC,UAAU,CAAsB;IACxE;;;OAGG;IACqC,oBAAoB,GAAY,IAAI,CAAC;IAC7E;;;OAGG;IACqC,UAAU,CAAsB;IACxE;;;OAGG;IACM,cAAc,CAAuB;IAC9C;;;OAGG;IACM,YAAY,CAAqB;IAC1C;;;OAGG;IACM,QAAQ,CAAqB;IACtC;;;OAGG;IACM,YAAY,GAAwB,SAAS,CAAC;IACvD;;;OAGG;IACM,QAAQ,GAAmB,MAAM,CAAC;IAC3C;;;OAGG;IACM,WAAW,CAAM;IAC1B;;;OAGG;IACoC,gBAAgB,GAAW,CAAC,CAAC;IACpE;;;OAGG;IACM,gBAAgB,GAAW,QAAQ,CAAC;IAC7C;;;OAGG;IACM,UAAU,GAAW,OAAO,CAAC;IACtC;;;OAGG;IACM,eAAe,CAAqB;IAC7C;;;OAGG;IACH,IAAa,KAAK;QACd,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IACD,IAAI,KAAK,CAAC,GAAU;QAChB,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC;IACtB,CAAC;IACD;;;OAGG;IACH,IAAa,OAAO;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IACD,IAAI,OAAO,CAAC,IAAuB;QAC/B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;IACzB,CAAC;IACD;;;OAGG;IACH,IAAa,KAAK;QACd,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IACD,IAAI,KAAK,CAAC,GAA8B;QACpC,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC;IACtB,CAAC;IACD;;;OAGG;IACH,IAAa,IAAI;QACb,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IACD,IAAI,IAAI,CAAC,GAAuB;QAC5B,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC;IACrB,CAAC;IACD;;;OAGG;IACH,IAAa,YAAY;QACrB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC9B,CAAC;IACD,IAAI,YAAY,CAAC,GAAW;QACxB,IAAI,CAAC,aAAa,GAAG,GAAG,CAAC;QACzB,IAAI,CAAC,YAAY,CAAC,oBAAoB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC/D,CAAC;IACD;;;OAGG;IACH,IAAa,SAAS;QAClB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IACD,IAAI,SAAS,CAAC,GAA8B;QACxC,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC;IAC1B,CAAC;IACD;;;OAGG;IACH,IAAa,SAAS;QAClB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IACD,IAAI,SAAS,CAAC,GAAW;QACrB,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC;IAC1B,CAAC;IACD;;;OAGG;IACH,IAAa,aAAa;QACtB,OAAO,IAAI,CAAC,cAAc,CAAC;IAC/B,CAAC;IACD,IAAI,aAAa,CAAC,GAAkC;QAChD,IAAI,CAAC,cAAc,GAAG,GAAG,CAAC;IAC9B,CAAC;IACD;;;OAGG;IACH,IAAa,SAAS;QAClB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IACD,IAAI,SAAS,CAAC,GAAQ;QAClB,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC;IAC1B,CAAC;IACD;;;OAGG;IACH,IAAa,SAAS;QAClB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IACD,IAAI,SAAS,CAAC,GAAmB;QAC7B,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC;IAC1B,CAAC;IACD;;;;OAIG;IACO,eAAe,GAA4C,IAAI,YAAY,EAA6B,CAAC;IACnH;;;;OAIG;IACO,eAAe,GAA6B,IAAI,YAAY,EAAc,CAAC;IACrF;;;;OAIG;IACO,WAAW,GAAsC,IAAI,YAAY,EAAuB,CAAC;IACnG;;;;OAIG;IACO,aAAa,GAAwC,IAAI,YAAY,EAAyB,CAAC;IACzG;;;;OAIG;IACO,MAAM,GAAiC,IAAI,YAAY,EAAkB,CAAC;IACpF;;;;OAIG;IACO,MAAM,GAAsD,IAAI,YAAY,EAAuC,CAAC;IAC9H;;;;OAIG;IACO,QAAQ,GAAmC,IAAI,YAAY,EAAoB,CAAC;IAC1F;;;;OAIG;IACO,UAAU,GAAqC,IAAI,YAAY,EAAsB,CAAC;IAChG;;;;OAIG;IACO,WAAW,GAAsC,IAAI,YAAY,EAAuB,CAAC;IACnG;;;;OAIG;IACO,aAAa,GAAwC,IAAI,YAAY,EAAyB,CAAC;IACzG;;;;OAIG;IACO,mBAAmB,GAA8C,IAAI,YAAY,EAA+B,CAAC;IAC3H;;;;OAIG;IACO,WAAW,GAAsC,IAAI,YAAY,EAAuB,CAAC;IACnG;;;;OAIG;IACO,YAAY,GAA0C,IAAI,YAAY,EAA2B,CAAC;IAC5G;;;;OAIG;IACO,YAAY,GAAuC,IAAI,YAAY,EAAwB,CAAC;IACtG;;;;OAIG;IACO,UAAU,GAAqC,IAAI,YAAY,EAAsB,CAAC;IAChG;;;;OAIG;IACO,cAAc,GAAyC,IAAI,YAAY,EAA0B,CAAC;IAC5G;;;;OAIG;IACO,YAAY,GAAuC,IAAI,YAAY,EAAwB,CAAC;IACtG;;;;OAIG;IACO,sBAAsB,GAAiD,IAAI,YAAY,EAAkC,CAAC;IACpI;;;;OAIG;IACO,YAAY,GAAsB,IAAI,YAAY,EAAO,CAAC;IACpE;;;;OAIG;IACO,WAAW,GAAyB,IAAI,YAAY,EAAU,CAAC;IACzE;;;;OAIG;IACO,UAAU,GAAyB,IAAI,YAAY,EAAU,CAAC;IACxE;;;;OAIG;IACO,WAAW,GAA6B,IAAI,YAAY,EAAc,CAAC;IACjF;;;;OAIG;IACO,cAAc,GAA6B,IAAI,YAAY,EAAc,CAAC;IAE5D,kBAAkB,CAAuB;IAEtC,qBAAqB,CAAuB;IAEtC,2BAA2B,CAAuB;IAEhD,6BAA6B,CAAuB;IAEjE,gBAAgB,CAAuB;IAEzC,cAAc,CAAuB;IAErC,oBAAoB,CAAuB;IAE3C,oBAAoB,CAAuB;IAExC,QAAQ,CAAqB;IAEtB,SAAS,CAAmC;IAC1E;;;;OAIG;IACH,IAAa,gBAAgB;QACzB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAClC,CAAC;IACD,IAAI,gBAAgB,CAAC,GAAW;QAC5B,IAAI,CAAC,iBAAiB,GAAG,GAAG,CAAC;QAC7B,OAAO,CAAC,IAAI,CAAC,8CAA8C,CAAC,CAAC;IACjE,CAAC;IACD,iBAAiB,GAAW,EAAE,CAAC;IAE/B,MAAM,GAAU,EAAE,CAAC;IAEnB,QAAQ,CAAoB;IAE5B,aAAa,GAAW,CAAC,CAAC;IAE1B,MAAM,GAA8B,CAAC,CAAC;IAEtC,KAAK,CAAqB;IAE1B,aAAa,CAA2B;IAExC,cAAc,CAA6B;IAE3C,qBAAqB,CAA6B;IAElD,YAAY,CAA6B;IAEzC,mBAAmB,CAA6B;IAEhD,eAAe,CAA6B;IAE5C,cAAc,CAA6B;IAE3C,qBAAqB,CAA6B;IAElD,eAAe,CAA6B;IAE5C,gBAAgB,CAA6B;IAE7C,mBAAmB,CAA6B;IAEhD,mBAAmB,CAA6B;IAEhD,mBAAmB,CAA6B;IAEhD,yBAAyB,CAA6B;IAEtD,oBAAoB,CAA6B;IAEjD,kBAAkB,CAA6B;IAE/C,oBAAoB,CAA6B;IAEjD,sBAAsB,CAA6B;IAEnD,oBAAoB,CAA6B;IAEjD,qBAAqB,CAA6B;IAElD,sBAAsB,CAA6B;IAEnD,6BAA6B,CAA6B;IAE1D,mBAAmB,CAA6B;IAEhD,8BAA8B,CAA6B;IAE3D,gCAAgC,CAA6B;IAE7D,gBAAgB,CAA6B;IAE7C,oBAAoB,CAA6B;IAEjD,0BAA0B,CAA6B;IAEvD,6BAA6B,CAA6B;IAE1D,kCAAkC,CAA6B;IAE/D,iCAAiC,CAA6B;IAE9D,qCAAqC,CAA6B;IAElE,iCAAiC,CAA6B;IAE9D,aAAa,GAAQ,EAAE,CAAC;IAExB,kBAAkB,CAAqB;IAEvC,gBAAgB,CAAqB;IAErC,iBAAiB,CAAqB;IAEtC,aAAa,CAAM;IAEnB,eAAe,CAA4B;IAE3C,eAAe,CAA4B;IAE3C,WAAW,CAA6B;IAExC,YAAY,CAA4B;IAExC,WAAW,CAA6B;IAExC,eAAe,CAAM;IAErB,gBAAgB,CAAM;IAEtB,mBAAmB,CAA4B;IAE/C,SAAS,CAA6B;IAEtC,oBAAoB,CAAM;IAE1B,cAAc,CAAgC;IAE9C,UAAU,CAA4B;IAEtC,UAAU,GAAW,CAAC,CAAC;IAEvB,iCAAiC,CAAsB;IAEvD,UAAU,CAAM;IAEhB,UAAU,GAAmB,IAAI,CAAC;IAElC,cAAc,CAA4B;IAE1C,aAAa,CAAqB;IAElC,aAAa,CAAM;IAEnB,WAAW,CAA6B;IAExC,UAAU,CAAsB;IAEhC,aAAa,CAAsB;IAEnC,eAAe,CAAsB;IAErC,aAAa,CAAsB;IAEnC,wBAAwB,CAAsB;IAE9C,iBAAiB,CAAqB;IAEtC,eAAe,CAAqB;IAEpC,mBAAmB,CAA2B;IAE9C,mBAAmB,CAAM;IAEzB,cAAc,GAAY,KAAK,CAAC;IAEhC,yBAAyB,GAAQ,EAAE,CAAC;IAEpC,EAAE,GAAW,iBAAiB,EAAE,CAAC;IAEjC,YAAY,CAAM;IAElB,sBAAsB,CAAM;IAEpB,MAAM,CAAS;IAEvB,YAC8B,QAAkB,EACf,UAAe,EACpC,QAAmB,EACpB,EAAc,EACd,IAAY,EACZ,YAA0B,EAC1B,EAAqB,EACrB,aAA4B,EAC5B,cAA8B,EAC9B,MAAiB,EACP,YAA0B;QAVjB,aAAQ,GAAR,QAAQ,CAAU;QACf,eAAU,GAAV,UAAU,CAAK;QACpC,aAAQ,GAAR,QAAQ,CAAW;QACpB,OAAE,GAAF,EAAE,CAAY;QACd,SAAI,GAAJ,IAAI,CAAQ;QACZ,iBAAY,GAAZ,YAAY,CAAc;QAC1B,OAAE,GAAF,EAAE,CAAmB;QACrB,kBAAa,GAAb,aAAa,CAAe;QAC5B,mBAAc,GAAd,cAAc,CAAgB;QAC9B,WAAM,GAAN,MAAM,CAAW;QACP,iBAAY,GAAZ,YAAY,CAAc;QAE3C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAqB,CAAC;IACtD,CAAC;IAED,QAAQ;QACJ,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACnC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;gBACtB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC,CAAC;YACxD,CAAC;YAED,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;gBACvB,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;YACjC,CAAC;QACL,CAAC;QAED,IAAI,IAAI,CAAC,gBAAgB,KAAK,OAAO,EAAE,CAAC;YACpC,IAAI,CAAC,qBAAqB,EAAE,CAAC;QACjC,CAAC;QAED,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;IAC5B,CAAC;IAED,kBAAkB;QACb,IAAI,CAAC,SAAoC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YACxD,QAAQ,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;gBACrB,KAAK,SAAS;oBACV,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACrC,MAAM;gBAEV,KAAK,QAAQ;oBACT,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACpC,MAAM;gBAEV,KAAK,eAAe;oBAChB,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBAC3C,MAAM;gBAEV,KAAK,MAAM;oBACP,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC;oBAClC,MAAM;gBAEV,KAAK,aAAa;oBACd,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACzC,MAAM;gBAEV,KAAK,QAAQ;oBACT,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACpC,MAAM;gBAEV,KAAK,eAAe;oBAChB,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBAC3C,MAAM;gBAEV,KAAK,SAAS;oBACV,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACrC,MAAM;gBAEV,KAAK,UAAU;oBACX,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACtC,MAAM;gBAEV,KAAK,cAAc;oBACf,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACzC,MAAM;gBAEV,KAAK,aAAa;oBACd,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACzC,MAAM;gBAEV,KAAK,aAAa;oBACd,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACzC,MAAM;gBAEV,KAAK,cAAc;oBACf,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBAC1C,MAAM;gBAEV,KAAK,YAAY;oBACb,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACxC,MAAM;gBAEV,KAAK,cAAc;oBACf,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBAC1C,MAAM;gBAEV,KAAK,gBAAgB;oBACjB,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBAC5C,MAAM;gBAEV,KAAK,oBAAoB;oBACrB,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBAC/C,MAAM;gBAEV,KAAK,cAAc;oBACf,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBAC1C,MAAM;gBAEV,KAAK,eAAe;oBAChB,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBAC3C,MAAM;gBAEV,KAAK,gBAAgB;oBACjB,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBAC5C,MAAM;gBAEV,KAAK,uBAAuB;oBACxB,IAAI,CAAC,6BAA6B,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACnD,MAAM;gBAEV,KAAK,uBAAuB;oBACxB,IAAI,CAAC,6BAA6B,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACnD,MAAM;gBAEV,KAAK,4BAA4B;oBAC7B,IAAI,CAAC,kCAAkC,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACxD,MAAM;gBAEV,KAAK,2BAA2B;oBAC5B,IAAI,CAAC,iCAAiC,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACvD,MAAM;gBAEV,KAAK,+BAA+B;oBAChC,IAAI,CAAC,qCAAqC,GAAG,IAAI,CAAC,QAAQ,CAAC;oBAC3D,MAAM;gBAEV,KAAK,2BAA2B;oBAC5B,IAAI,CAAC,iCAAiC,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACvD,MAAM;gBAEV,KAAK,aAAa;oBACd,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACzC,MAAM;gBAEV,KAAK,wBAAwB;oBACzB,IAAI,CAAC,8BAA8B,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACpD,MAAM;gBAEV,KAAK,0BAA0B;oBAC3B,IAAI,CAAC,gCAAgC,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACtD,MAAM;gBAEV,KAAK,UAAU;oBACX,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACtC,MAAM;gBAEV,KAAK,cAAc;oBACf,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBAC1C,MAAM;gBAEV,KAAK,oBAAoB;oBACrB,IAAI,CAAC,0BAA0B,GAAG,IAAI,CAAC,QAAQ,CAAC;oBAChD,MAAM;YACd,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAED,eAAe;QACX,IAAI,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACrC,IAAI,IAAI,CAAC,UAAU,EAAE,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBAC7C,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC/B,CAAC;QACL,CAAC;IACL,CAAC;IAED,WAAW,CAAC,YAA2B;QACnC,IAAI,YAAY,CAAC,KAAK,EAAE,CAAC;YACrB,IAAI,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;gBACjF,IAAI,CAAC,YAAY,EAAE,CAAC;YACxB,CAAC;YAED,IAAI,CAAC,MAAM,GAAG,YAAY,CAAC,KAAK,CAAC,YAAY,CAAC;YAE9C,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;gBACb,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;gBAEzD,IAAI,IAAI,CAAC,QAAQ,IAAI,QAAQ,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,WAAW,CAAC;oBAAE,IAAI,CAAC,UAAU,EAAE,CAAC;qBACpF,IAAI,IAAI,CAAC,QAAQ,IAAI,UAAU,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,WAAW,CAAC;oBAAE,IAAI,CAAC,YAAY,EAAE,CAAC;qBACjG,IAAI,IAAI,CAAC,SAAS,EAAE;oBACrB,sBAAsB;oBACtB,IAAI,CAAC,OAAO,EAAE,CAAC;YACvB,CAAC;YAED,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,YAAY,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QACrE,CAAC;QAED,IAAI,YAAY,CAAC,OAAO,EAAE,CAAC;YACvB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;gBACrB,IAAI,CAAC,QAAQ,GAAG,YAAY,CAAC,OAAO,CAAC,YAAY,CAAC;gBAClD,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,YAAY,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;YACzE,CAAC;YAED,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,UAAU,EAAE,IAAI,IAAI,CAAC,kBAAkB,IAAI,CAAC,IAAI,CAAC,wBAAwB,EAAE,CAAC;gBAClG,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBAE1B,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACrD,CAAC;QACL,CAAC;QAED,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC;YACzB,IAAI,CAAC,UAAU,GAAG,YAAY,CAAC,SAAS,CAAC,YAAY,CAAC;YAEtD,mEAAmE;YACnE,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjC,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;oBAC7B,IAAI,CAAC,UAAU,EAAE,CAAC;gBACtB,CAAC;YACL,CAAC;QACL,CAAC;QAED,IAAI,YAAY,CAAC,WAAW,EAAE,CAAC;YAC3B,mEAAmE;YACnE,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjC,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;oBAC7B,IAAI,CAAC,UAAU,EAAE,CAAC;gBACtB,CAAC;YACL,CAAC;QACL,CAAC;QAED,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC;YACzB,IAAI,CAAC,UAAU,GAAG,YAAY,CAAC,SAAS,CAAC,YAAY,CAAC;YAEtD,mEAAmE;YACnE,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjC,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;oBAC7B,IAAI,CAAC,UAAU,EAAE,CAAC;gBACtB,CAAC;YACL,CAAC;QACL,CAAC;QAED,IAAI,YAAY,CAAC,gBAAgB,EAAE,CAAC;YAChC,mEAAmE;YACnE,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjC,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;oBAC7B,IAAI,CAAC,UAAU,EAAE,CAAC;gBACtB,CAAC;YACL,CAAC;QACL,CAAC;QAED,IAAI,YAAY,CAAC,aAAa,EAAE,CAAC;YAC7B,IAAI,CAAC,cAAc,GAAG,YAAY,CAAC,aAAa,CAAC,YAAY,CAAC;YAC9D,IAAI,IAAI,CAAC,QAAQ,KAAK,UAAU,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC;gBAC5F,IAAI,CAAC,YAAY,EAAE,CAAC;YACxB,CAAC;QACL,CAAC;QAED,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC;YACzB,IAAI,CAAC,UAAU,GAAG,YAAY,CAAC,SAAS,CAAC,YAAY,CAAC;YAEtD,IAAI,CAAC,IAAI,CAAC,iCAAiC,EAAE,CAAC;gBAC1C,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBAC3B,IAAI,CAAC,YAAY,CAAC,iBAAiB,EAAE,CAAC;YAC1C,CAAC;YACD,IAAI,CAAC,iCAAiC,GAAG,KAAK,CAAC;QACnD,CAAC;QAED,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC;YACzB,IAAI,CAAC,UAAU,GAAG,YAAY,CAAC,SAAS,CAAC,YAAY,CAAC;YAEtD,IAAI,CAAC,IAAI,CAAC,iCAAiC,EAAE,CAAC;gBAC1C,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBAC3B,IAAI,CAAC,YAAY,CAAC,iBAAiB,EAAE,CAAC;gBAEtC,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;oBACpB,IAAI,CAAC,SAAS,EAAE,CAAC;gBACrB,CAAC;YACL,CAAC;YACD,IAAI,CAAC,iCAAiC,GAAG,KAAK,CAAC;QACnD,CAAC;IACL,CAAC;IAED,IAAI,aAAa;QACb,OAAO,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;IAClD,CAAC;IAEO,iBAAiB,CAAW;IAEpC,YAAY,CAAC,IAAS;QAClB,MAAM,KAAK,GAAG,IAAI,IAAI,IAAI,CAAC,aAAa,CAAC;QAEzC,IAAI,KAAK,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;YACzC,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,EAAU,KAAK,GAAW,IAAI,CAAC,IAAI,CAAC,CAAC;QACjE,CAAC;QAED,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,mBAAmB;QACf,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAClC,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;YACxB,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;gBACjC,KAAK,IAAI,IAAI,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;oBAC/B,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;gBACrF,CAAC;YACL,CAAC;iBAAM,CAAC;gBACJ,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;YAChG,CAAC;QACL,CAAC;IACL,CAAC;IAED,YAAY,CAAC,KAAqB;QAC9B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QACzB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;QAEvB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;YACb,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,IAAI,EAAU,IAAI,CAAC,IAAI;SAC1B,CAAC,CAAC;QAEH,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACZ,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC,CAAC;QACxD,CAAC;QAED,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAClC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAE5C,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;YACpB,IAAI,CAAC,SAAS,EAAE,CAAC;QACrB,CAAC;QAED,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAE3B,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,IAAI,CAAC,cAAc,EAAE,CAAC;QAC1B,CAAC;IACL,CAAC;IAED,aAAa,GAAG,CAAC,OAAe,EAAU,EAAE;QACxC,QAAQ,OAAO,EAAE,CAAC;YACd,KAAK,CAAC;gBACF,OAAO,CAAC,CAAC;YACb,KAAK,CAAC;gBACF,OAAO,CAAC,CAAC,CAAC;YACd,KAAK,CAAC,CAAC;gBACH,OAAO,CAAC,CAAC;YACb;gBACI,OAAO,CAAC,CAAC,CAAC,yCAAyC;QAC3D,CAAC;IACL,CAAC,CAAC;IAEF,IAAI,CAAC,KAAU;QACX,IAAI,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;QAExC,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;YAC7B,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;gBAC7B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC;YACnH,CAAC;iBAAM,CAAC;gBACJ,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC;YACnG,CAAC;YACD,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC;YAE9B,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;gBACvB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;gBAChB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBAEnC,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;oBAClB,IAAI,CAAC,cAAc,EAAE,CAAC;gBAC1B,CAAC;YACL,CAAC;YAED,IAAI,CAAC,UAAU,EAAE,CAAC;QACtB,CAAC;QACD,IAAI,IAAI,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;YAC/B,IAAI,OAAO,GAAmB,aAAc,CAAC,OAAO,IAAoB,aAAc,CAAC,OAAO,CAAC;YAC/F,IAAI,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAS,KAAK,CAAC,KAAK,CAAC,CAAC;YAErD,IAAI,QAAQ,EAAE,CAAC;gBACX,IAAI,CAAC,OAAO,EAAE,CAAC;oBACX,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;wBAC7B,IAAI,CAAC,cAAc,GAAG,CAAC,EAAE,KAAK,EAAU,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;oBACtG,CAAC;yBAAM,CAAC;wBACJ,IAAI,CAAC,cAAc,GAAG,CAAC,EAAE,KAAK,EAAU,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;oBACvF,CAAC;oBAED,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;wBACvB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;wBAChB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;wBAEnC,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;4BAClB,IAAI,CAAC,cAAc,EAAE,CAAC;wBAC1B,CAAC;oBACL,CAAC;gBACL,CAAC;qBAAM,CAAC;oBACJ,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;wBAC7B,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;oBACxD,CAAC;yBAAM,CAAC;wBACJ,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;oBACzC,CAAC;gBACL,CAAC;YACL,CAAC;iBAAM,CAAC;gBACJ,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;oBAClC,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC;oBAEzB,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;wBACvB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;wBAChB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;oBACvC,CAAC;gBACL,CAAC;gBACY,IAAI,CAAC,cAAe,CAAC,IAAI,CAAC,EAAE,KAAK,EAAU,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;YACzG,CAAC;YAED,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC;YAE7E,IAAI,CAAC,YAAY,EAAE,CAAC;QACxB,CAAC;QAED,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;YACpB,IAAI,CAAC,SAAS,EAAE,CAAC;QACrB,CAAC;QAED,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;IAC/B,CAAC;IAED,UAAU;QACN,IAAI,KAAK,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,WAAW,CAAC;QAC/C,IAAI,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC;QACpE,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI,CAAC,SAAS,EAAE,CAAC;YAC5E,IAAI,CAAC,cAAc,GAAG,CAAC,IAAI,CAAC,gBAAgB,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;YAClG,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,OAAO;QACX,CAAC;QAED,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;YAC7B,IAAI,QAAQ,GAAa;gBACrB,KAAK,EAAE,KAAK;gBACZ,KAAK,EAAE,KAAK;aACf,CAAC;YAEF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC3B,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACvC,CAAC;aAAM,CAAC;YACJ,IAAI,KAAK,IAAI,KAAK,EAAE,CAAC;gBACjB,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;oBACrB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;gBAC/B,CAAC;gBAED,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;oBACZ,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC,CAAC;gBACxD,CAAC;qBAAM,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;oBACpB,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;wBAClB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC;4BACnB,IAAI,EAAE,IAAI,CAAC,KAAK;4BAChB,IAAI,EAAE,IAAI,CAAC,QAAQ;4BACnB,KAAK,EAAE,KAAK;4BACZ,KAAK,EAAE,KAAK;yBACf,CAAC,CAAC;oBACP,CAAC;yBAAM,CAAC;wBACJ,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;4BAC7B,IAAI,MAAM,GAAG,WAAW,CAAC,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;4BACxD,IAAI,MAAM,GAAG,WAAW,CAAC,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;4BACxD,IAAI,MAAM,GAAG,IAAI,CAAC;4BAElB,IAAI,MAAM,IAAI,IAAI,IAAI,MAAM,IAAI,IAAI;gCAAE,MAAM,GAAG,CAAC,CAAC,CAAC;iCAC7C,IAAI,MAAM,IAAI,IAAI,IAAI,MAAM,IAAI,IAAI;gCAAE,MAAM,GAAG,CAAC,CAAC;iCACjD,IAAI,MAAM,IAAI,IAAI,IAAI,MAAM,IAAI,IAAI;gCAAE,MAAM,GAAG,CAAC,CAAC;iCACjD,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,OAAO,MAAM,KAAK,QAAQ;gCAAE,MAAM,GAAG,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;;gCACpG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;4BAE7D,OAAO,KAAK,GAAG,MAAM,CAAC;wBAC1B,CAAC,CAAC,CAAC;wBAEH,IAAI,CAAC,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;oBAClC,CAAC;oBAED,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;wBACnB,IAAI,CAAC,OAAO,EAAE,CAAC;oBACnB,CAAC;gBACL,CAAC;gBAED,IAAI,QAAQ,GAAa;oBACrB,KAAK,EAAE,KAAK;oBACZ,KAAK,EAAE,KAAK;iBACf,CAAC;gBAEF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBAC3B,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YACvC,CAAC;QACL,CAAC;IACL,CAAC;IAED,YAAY;QACR,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,IAAI,CAAC,IAAI,CAAC,cAAc;gBAAE,IAAI,CAAC,cAAc,GAAG,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;iBACrE,IAAiB,IAAI,CAAC,aAAc,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,WAAW;gBAAE,IAAI,CAAC,cAAc,GAAG,CAAC,IAAI,CAAC,gBAAgB,EAAE,EAAE,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC;QACrJ,CAAC;QAED,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;YAC7B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;gBACb,aAAa,EAAc,IAAI,CAAC,aAAa;aAChD,CAAC,CAAC;YACH,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACjD,CAAC;aAAM,CAAC;YACJ,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;gBACrB,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;oBACZ,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC,CAAC;gBACxD,CAAC;qBAAM,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;oBACpB,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;wBAClB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC;4BACnB,IAAI,EAAE,IAAI,CAAC,KAAK;4BAChB,IAAI,EAAE,IAAI,CAAC,QAAQ;4BACnB,aAAa,EAAE,IAAI,CAAC,aAAa;yBACpC,CAAC,CAAC;oBACP,CAAC;yBAAM,CAAC;wBACJ,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;4BAC7B,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,EAAc,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;wBAChF,CAAC,CAAC,CAAC;wBAEH,IAAI,CAAC,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;oBAClC,CAAC;oBAED,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;wBACnB,IAAI,CAAC,OAAO,EAAE,CAAC;oBACnB,CAAC;gBACL,CAAC;gBAED,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;oBACb,aAAa,EAAc,IAAI,CAAC,aAAa;iBAChD,CAAC,CAAC;gBACH,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACjD,CAAC;QACL,CAAC;IACL,CAAC;IAED,cAAc,CAAC,KAAU,EAAE,KAAU,EAAE,aAAyB,EAAE,KAAa;QAC3E,MAAM,MAAM,GAAG,WAAW,CAAC,gBAAgB,CAAC,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;QAC/E,MAAM,MAAM,GAAG,WAAW,CAAC,gBAAgB,CAAC,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;QAC/E,IAAI,WAAW,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;YAC/D,OAAO,aAAa,CAAC,MAAM,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9G,CAAC;QACD,OAAO,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;IAChF,CAAC;IAED,mBAAmB,CAAC,MAAW,EAAE,MAAW,EAAE,KAAU;QACpD,OAAO,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;IACtF,CAAC;IAED,WAAW,CAAC,KAAa;QACrB,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC;YAClD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACjD,IAAI,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;oBACxC,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;gBACjC,CAAC;YACL,CAAC;QACL,CAAC;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,QAAQ,CAAC,KAAa;QAClB,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC;QACtD,CAAC;aAAM,IAAI,IAAI,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;YACtC,IAAI,MAAM,GAAG,KAAK,CAAC;YACnB,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;gBACrB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBACjD,IAAI,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,KAAK,EAAE,CAAC;wBACvC,MAAM,GAAG,IAAI,CAAC;wBACd,MAAM;oBACV,CAAC;gBACL,CAAC;YACL,CAAC;YACD,OAAO,MAAM,CAAC;QAClB,CAAC;aAAM,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;YACpC,OAAO,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC;QACtD,CAAC;IACL,CAAC;IAED,cAAc,CAAC,KAAU;QACrB,IAAI,MAAM,GAAgB,KAAK,CAAC,aAAa,CAAC,MAAM,CAAC;QACrD,IAAI,UAAU,GAAG,MAAM,CAAC,QAAQ,CAAC;QACjC,IAAI,UAAU,GAAG,MAAM,CAAC,aAAa,IAAI,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC;QACvE,IAAI,UAAU,IAAI,OAAO,IAAI,UAAU,IAAI,QAAQ,IAAI,UAAU,IAAI,GAAG,IAAI,UAAU,IAAI,OAAO,IAAI,UAAU,IAAI,QAAQ,IAAI,UAAU,IAAI,GAAG,IAAI,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,aAAa,CAAC,MAAM,EAAE,eAAe,CAAC,EAAE,CAAC;YACnN,OAAO;QACX,CAAC;QAED,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACrB,IAAI,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;YAC5B,IAAI,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;YAE9B,IAAI,CAAC,iCAAiC,GAAG,IAAI,CAAC;YAC9C,IAAI,IAAI,CAAC,uBAAuB,EAAE,IAAI,KAAK,CAAC,aAAa,CAAC,QAAQ,IAAI,IAAI,CAAC,cAAc,IAAI,IAAI,EAAE,CAAC;gBAChG,UAAU,CAAC,cAAc,EAAE,CAAC;gBAC5B,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,EAAE,CAAC;oBAC7B,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;gBAClD,CAAC;gBAED,IAAI,CAAC,aAAa,GAAG,QAAQ,CAAC;gBAC9B,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;YACpD,CAAC;iBAAM,CAAC;gBACJ,IAAI,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;gBAExC,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC;oBACxD,OAAO;gBACX,CAAC;gBAED,IAAI,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC;gBACpE,IAAI,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;gBACrG,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC;gBAC/B,IAAI,CAAC,aAAa,GAAG,QAAQ,CAAC;gBAE9B,IAAI,aAAa,EAAE,CAAC;oBAChB,IAAI,OAAO,GAAG,KAAK,CAAC,aAAa,CAAC,OAAO,IAAI,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC;oBAEzE,IAAI,QAAQ,IAAI,OAAO,EAAE,CAAC;wBACtB,IAAI,IAAI,CAAC,qBAAqB,EAAE,EAAE,CAAC;4BAC/B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;4BACvB,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;4BACxB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;wBACpC,CAAC;6BAAM,CAAC;4BACJ,IAAI,cAAc,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;4BACxD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,GAAQ,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC;4BACtF,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;4BAC1C,IAAI,YAAY,EAAE,CAAC;gCACf,OAAO,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;4BAC5C,CAAC;wBACL,CAAC;wBAED,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;oBAChG,CAAC;yBAAM,CAAC;wBACJ,IAAI,IAAI,CAAC,qBAAqB,EAAE,EAAE,CAAC;4BAC/B,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC;4BAC1B,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;4BACnC,IAAI,YAAY,EAAE,CAAC;gCACf,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;gCACxB,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;4BACzC,CAAC;wBACL,CAAC;6BAAM,IAAI,IAAI,CAAC,uBAAuB,EAAE,EAAE,CAAC;4BACxC,IAAI,OAAO,EAAE,CAAC;gCACV,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC;4BAC3C,CAAC;iCAAM,CAAC;gCACJ,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;gCACrB,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;4BAC5B,CAAC;4BAED,IAAI,CAAC,UAAU,GAAG,CAAC,GAAG,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;4BAC/C,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;4BAC1C,IAAI,YAAY,EAAE,CAAC;gCACf,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;4BACzC,CAAC;wBACL,CAAC;wBAED,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;oBAC/G,CAAC;gBACL,CAAC;qBAAM,CAAC;oBACJ,IAAI,IAAI,CAAC,aAAa,KAAK,QAAQ,EAAE,CAAC;wBAClC,IAAI,QAAQ,EAAE,CAAC;4BACX,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;4BACvB,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;4BACxB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;4BAC1C,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;wBACjH,CAAC;6BAAM,CAAC;4BACJ,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC;4BAC1B,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;4BAC1C,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;4BAC3G,IAAI,YAAY,EAAE,CAAC;gCACf,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;gCACxB,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;4BACzC,CAAC;wBACL,CAAC;oBACL,CAAC;yBAAM,IAAI,IAAI,CAAC,aAAa,KAAK,UAAU,EAAE,CAAC;wBAC3C,IAAI,QAAQ,EAAE,CAAC;4BACX,IAAI,cAAc,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;4BACxD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,GAAQ,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC;4BACtF,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;4BAC1C,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;4BAC7G,IAAI,YAAY,EAAE,CAAC;gCACf,OAAO,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;4BAC5C,CAAC;wBACL,CAAC;6BAAM,CAAC;4BACJ,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;4BAC5E,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;4BAC1C,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;4BAC3G,IAAI,YAAY,EAAE,CAAC;gCACf,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;4BACzC,CAAC;wBACL,CAAC;oBACL,CAAC;gBACL,CAAC;YACL,CAAC;YAED,IAAI,CAAC,YAAY,CAAC,iBAAiB,EAAE,CAAC;YAEtC,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;gBACpB,IAAI,CAAC,SAAS,EAAE,CAAC;YACrB,CAAC;QACL,CAAC;QAED,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC5B,CAAC;IAED,iBAAiB,CAAC,KAAY;QAC1B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;IAC3B,CAAC;IAED,mBAAmB,CAAC,KAAU;QAC1B,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;YAC9B,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;YAEhC,IAAI,IAAI,CAAC,wBAAwB,KAAK,UAAU,EAAE,CAAC;gBAC/C,IAAI,CAAC,oBAAoB,GAAG,OAAO,CAAC;gBACpC,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBAC9C,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC5G,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;gBAC3C,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;YAC7C,CAAC;iBAAM,IAAI,IAAI,CAAC,wBAAwB,KAAK,OAAO,EAAE,CAAC;gBACnD,IAAI,CAAC,iCAAiC,GAAG,IAAI,CAAC;gBAC9C,IAAI,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;gBACxC,IAAI,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;gBAErG,IAAI,CAAC,QAAQ,EAAE,CAAC;oBACZ,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC;wBAC3C,OAAO;oBACX,CAAC;oBAED,IAAI,IAAI,CAAC,qBAAqB,EAAE,EAAE,CAAC;wBAC/B,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC;wBACzB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;wBAEnC,IAAI,YAAY,EAAE,CAAC;4BACf,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;4BACxB,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;wBACzC,CAAC;oBACL,CAAC;yBAAM,IAAI,IAAI,CAAC,uBAAuB,EAAE,EAAE,CAAC;wBACxC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;wBAC5E,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;wBAE1C,IAAI,YAAY,EAAE,CAAC;4BACf,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;wBACzC,CAAC;oBACL,CAAC;gBACL,CAAC;gBAED,IAAI,CAAC,YAAY,CAAC,iBAAiB,EAAE,CAAC;gBACtC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;gBAC3C,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;YAClG,CAAC;QACL,CAAC;IACL,CAAC;IAED,WAAW,CAAC,KAAiC,EAAE,QAAgB,EAAE,kBAAwC;QACrG,IAAI,UAAU,EAAE,QAAQ,CAAC;QAEzB,IAAY,IAAI,CAAC,cAAc,GAAG,QAAQ,EAAE,CAAC;YACzC,UAAU,GAAG,QAAQ,CAAC;YACtB,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC;QACnC,CAAC;aAAM,IAAY,IAAI,CAAC,cAAc,GAAG,QAAQ,EAAE,CAAC;YAChD,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC;YACjC,QAAQ,GAAG,QAAQ,CAAC;QACxB,CAAC;aAAM,CAAC;YACJ,UAAU,GAAG,QAAQ,CAAC;YACtB,QAAQ,GAAG,QAAQ,CAAC;QACxB,CAAC;QAED,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAC7B,UAAqB,IAAY,IAAI,CAAC,KAAK,CAAC;YAC5C,QAAmB,IAAY,IAAI,CAAC,KAAK,CAAC;QAC/C,CAAC;QAED,IAAI,aAAa,GAAG,EAAE,CAAC;QACvB,KAAK,IAAI,CAAC,GAAW,UAAU,EAAE,CAAC,IAAY,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC;YAC1D,IAAI,YAAY,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAC9E,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBACxD,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,QAAQ,CAAC,EAAE,CAAC;oBAChD,SAAS;gBACb,CAAC;gBAED,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;gBACjC,IAAI,CAAC,UAAU,GAAG,CAAC,GAAG,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;gBACpD,IAAI,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;gBAC1G,IAAI,YAAY,EAAE,CAAC;oBACf,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;gBACzC,CAAC;YACL,CAAC;QACL,CAAC;QACD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC1C,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IACtF,CAAC;IAED,mBAAmB,CAAC,KAAiC;QACjD,IAAI,UAAU,EAAE,QAAQ,CAAC;QACzB,IAAI,aAAa,GAAW,IAAI,CAAC,aAAa,CAAC;QAC/C,IAAI,cAAc,GAAW,IAAI,CAAC,cAAc,CAAC;QAEjD,IAAI,aAAa,GAAG,cAAc,EAAE,CAAC;YACjC,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC;YACjC,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC;QAClC,CAAC;aAAM,IAAI,aAAa,GAAG,cAAc,EAAE,CAAC;YACxC,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC;YAChC,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC;QACnC,CAAC;aAAM,CAAC;YACJ,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC;YAChC,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC;QAClC,CAAC;QAED,KAAK,IAAI,CAAC,GAAW,UAAU,EAAE,CAAC,IAAY,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC;YAC1D,IAAI,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACjC,IAAI,cAAc,GAAG,IAAI,CAAC,oBAAoB,CAAC,YAAY,CAAC,CAAC;YAC7D,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,GAAQ,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC;YACtF,IAAI,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YAC1G,IAAI,YAAY,EAAE,CAAC;gBACf,OAAO,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;YAC5C,CAAC;YACD,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACvF,CAAC;IACL,CAAC;IAED,UAAU,CAAC,OAAY;QACnB,IAAI,OAAO,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAC5B,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBACf,OAAO,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,KAAK,SAAS,CAAC;YACjG,CAAC;iBAAM,CAAC;gBACJ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC;oBAAE,OAAO,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;;oBAC7E,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;YACrD,CAAC;QACL,CAAC;QAED,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,oBAAoB,CAAC,OAAY;QAC7B,IAAI,KAAK,GAAW,CAAC,CAAC,CAAC;QACvB,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;YAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC7C,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;oBAC1C,KAAK,GAAG,CAAC,CAAC;oBACV,MAAM;gBACV,CAAC;YACL,CAAC;QACL,CAAC;QAED,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,eAAe,CAAC,IAAS,EAAE,KAAa;QACpC,IAAI,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;YAC7D,OAAO,KAAK,CAAC;QACjB,CAAC;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,kBAAkB,CAAC,KAAU,EAAE,OAAY;QACvC,IAAI,CAAC,iCAAiC,GAAG,IAAI,CAAC;QAE9C,IAAI,IAAI,CAAC,SAAS,IAAI,OAAO,EAAE,CAAC;YAC5B,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACjD,OAAO;YACX,CAAC;YAED,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC;YAC1B,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC1C,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,CAAC;YAEzH,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBACf,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;gBACxB,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;YACxF,CAAC;QACL,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;YACvB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC1C,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,CAAC;QAC/H,CAAC;QAED,IAAI,CAAC,YAAY,CAAC,iBAAiB,EAAE,CAAC;QAEtC,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;YACpB,IAAI,CAAC,SAAS,EAAE,CAAC;QACrB,CAAC;IACL,CAAC;IAED,qBAAqB,CAAC,KAAU,EAAE,OAAY;QAC1C,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC;QACtC,IAAI,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACxC,IAAI,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACrG,IAAI,CAAC,iCAAiC,GAAG,IAAI,CAAC;QAE9C,IAAI,QAAQ,EAAE,CAAC;YACX,IAAI,cAAc,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;YACxD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,GAAQ,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC;YACtF,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC1C,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;YACxH,IAAI,YAAY,EAAE,CAAC;gBACf,OAAO,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;YAC5C,CAAC;QACL,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACjD,OAAO;YACX,CAAC;YAED,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YAC5E,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC1C,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;YACtH,IAAI,YAAY,EAAE,CAAC;gBACf,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;YACzC,CAAC;QACL,CAAC;QAED,IAAI,CAAC,YAAY,CAAC,iBAAiB,EAAE,CAAC;QAEtC,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;YACpB,IAAI,CAAC,SAAS,EAAE,CAAC;QACrB,CAAC;IACL,CAAC;IAED,sBAAsB,CAAC,KAAY,EAAE,KAAc;QAC/C,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC;YAC3B,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;QACxE,CAAC;aAAM,CAAC;YACJ,MAAM,IAAI,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC;YACjG,IAAI,SAAS,GAAG,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAE/I,IAAI,KAAK,EAAE,CAAC;gBACR,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,GAAG,IAAI,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,GAAG,IAAI,CAAC,CAAC;gBACtG,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,IAAS,EAAE,KAAa,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YACrI,CAAC;YAED,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;YAC5B,IAAI,CAAC,iCAAiC,GAAG,IAAI,CAAC;YAC9C,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC3B,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC3C,IAAI,CAAC,YAAY,CAAC,iBAAiB,EAAE,CAAC;YACtC,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;YAE3E,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;gBACpB,IAAI,CAAC,SAAS,EAAE,CAAC;YACrB,CAAC;QACL,CAAC;IACL,CAAC;IAED,MAAM,CAAC,KAAU,EAAE,KAAU;QACzB,OAAO,IAAI,CAAC,kBAAkB,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,KAAK,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACnH,CAAC;IAED,0CAA0C;IAC1C,MAAM,CAAC,KAAU,EAAE,KAAa,EAAE,SAAiB;QAC/C,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACrB,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACrC,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;YAC7B,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC;QACjE,CAAC;aAAM,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;QAED,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,GAAG,EAAE;YACjC,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC9B,CAAC,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAErB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;IAC/B,CAAC;IAED,YAAY,CAAC,KAAU,EAAE,SAAiB;QACtC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IAC5C,CAAC;IAED,aAAa,CAAC,MAAW;QACrB,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YAC1C,IAAI,CAAC,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC,MAAM,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC;gBAAE,OAAO,IAAI,CAAC;;gBACvH,OAAO,KAAK,CAAC;QACtB,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,OAAO;QACH,IAAI,IAAI,CAAC,UAAU,KAAK,QAAQ,EAAE,CAAC;YAC/B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;gBACf,OAAO,EAAE,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAA8C,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,IAAI,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC,CAAC;aACpK,CAAC,CAAC;QACP,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;gBACxB,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;gBACf,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACtC,CAAC;YAED,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;gBACZ,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC,CAAC;YACxD,CAAC;iBAAM,CAAC;gBACJ,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;oBACd,OAAO;gBACX,CAAC;gBAED,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;oBACpB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;oBAC1B,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;wBACjB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC3D,CAAC;gBACL,CAAC;qBAAM,CAAC;oBACJ,IAAI,uBAAuB,CAAC;oBAC5B,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;wBACzB,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,kBAAkB;4BAAE,MAAM,IAAI,KAAK,CAAC,gFAAgF,CAAC,CAAC;;4BAC5I,uBAAuB,GAAG,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,OAAO,CAAC;oBAC3E,CAAC;oBAED,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;oBAExB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;wBACzC,IAAI,UAAU,GAAG,IAAI,CAAC;wBACtB,IAAI,WAAW,GAAG,KAAK,CAAC;wBACxB,IAAI,aAAa,GAAG,KAAK,CAAC;wBAE1B,KAAK,IAAI,IAAI,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;4BAC5B,IAAI,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;gCACzD,aAAa,GAAG,IAAI,CAAC;gCACrB,IAAI,WAAW,GAAG,IAAI,CAAC;gCACvB,IAAI,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;gCAE3C,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;oCAC5B,KAAK,IAAI,IAAI,IAAI,UAAU,EAAE,CAAC;wCAC1B,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;wCAEvE,IAAI,CAAC,IAAI,CAAC,QAAQ,KAAK,cAAc,CAAC,EAAE,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,KAAK,cAAc,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;4CAC/G,MAAM;wCACV,CAAC;oCACL,CAAC;gCACL,CAAC;qCAAM,CAAC;oCACJ,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAO,UAAU,CAAC,CAAC;gCACtF,CAAC;gCAED,IAAI,CAAC,UAAU,EAAE,CAAC;oCACd,MAAM;gCACV,CAAC;4BACL,CAAC;wBACL,CAAC;wBAED,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,IAAI,uBAAuB,EAAE,CAAC;4BACpE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,uBAAuB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gCACtD,IAAI,iBAAiB,GAAG,uBAAuB,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,uBAAuB,CAAC,CAAC,CAAC,CAAC;gCACvF,WAAW,GAAS,IAAI,CAAC,aAAc,CAAC,OAAO,CAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAE,CAAC,SAAS,CAAC,CACpF,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,iBAAiB,CAAC,EAC7C,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAE,CAAC,KAAK,EAC9C,IAAI,CAAC,YAAY,CACpB,CAAC;gCAEF,IAAI,WAAW,EAAE,CAAC;oCACd,MAAM;gCACV,CAAC;4BACL,CAAC;wBACL,CAAC;wBAED,IAAI,OAAgB,CAAC;wBACrB,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;4BACzB,OAAO,GAAG,aAAa,CAAC,CAAC,CAAC,aAAa,IAAI,UAAU,IAAI,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC;wBACvF,CAAC;6BAAM,CAAC;4BACJ,OAAO,GAAG,aAAa,IAAI,UAAU,CAAC;wBAC1C,CAAC;wBAED,IAAI,OAAO,EAAE,CAAC;4BACV,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;wBAC3C,CAAC;oBACL,CAAC;oBAED,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,KAAK,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;wBAClD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;oBAC9B,CAAC;oBAED,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;wBACjB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC5G,CAAC;gBACL,CAAC;YACL,CAAC;YAED,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;gBACf,OAAO,EAA+C,IAAI,CAAC,OAAO;gBAClE,aAAa,EAAE,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,KAAK;aAClD,CAAC,CAAC;YAEH,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAE5C,IAAI,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;gBAC7C,IAAI,CAAC,SAAS,EAAE,CAAC;YACrB,CAAC;YAED,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;gBACvB,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;YACjC,CAAC;QACL,CAAC;QAED,IAAI,CAAC,EAAE,CAAC,YAAY,EAAE,CAAC;QAEvB,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,IAAI,CAAC,cAAc,EAAE,CAAC;QAC1B,CAAC;IACL,CAAC;IAED,kBAAkB,CAAC,KAAa,EAAE,OAAY,EAAE,UAA0B;QACtE,IAAI,WAAW,GAAG,UAAU,CAAC,KAAK,CAAC;QACnC,IAAI,eAAe,GAAG,UAAU,CAAC,SAAS,IAAI,eAAe,CAAC,WAAW,CAAC;QAC1E,IAAI,cAAc,GAAG,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAClE,IAAI,gBAAgB,GAAS,IAAI,CAAC,aAAc,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;QAE1E,OAAO,gBAAgB,CAAC,cAAc,EAAE,WAAW,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;IAC5E,CAAC;IAED,SAAS;QACL,IAAI,KAAK,GAAG,IAAI,CAAC;QACjB,KAAK,IAAI,IAAI,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAC5B,IAAI,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;gBACpC,KAAK,GAAG,KAAK,CAAC;gBACd,MAAM;YACV,CAAC;QACL,CAAC;QAED,OAAO,CAAC,KAAK,CAAC;IAClB,CAAC;IAED,sBAAsB;QAClB,OAAO;YACH,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,YAAY,EAAE,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAkB,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAE,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI;YAC5G,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,WAAW,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,EAAE;SAC7C,CAAC;IACN,CAAC;IAEM,KAAK;QACR,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC;QACxC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAE/B,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAEzB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAE1B,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;QACf,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAElC,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACZ,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC,CAAC;QACxD,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7D,CAAC;IACL,CAAC;IAED,iBAAiB;QACb,KAAK,MAAM,CAAC,EAAE,cAAc,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5D,IAAI,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC;gBAChC,KAAK,IAAI,MAAM,IAAI,cAAc,EAAE,CAAC;oBAChC,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC;gBACxB,CAAC;YACL,CAAC;iBAAM,IAAI,cAAc,EAAE,CAAC;gBACxB,cAAc,CAAC,KAAK,GAAG,IAAI,CAAC;YAChC,CAAC;QACL,CAAC;IACL,CAAC;IAED,KAAK;QACD,IAAI,CAAC,KAAK,EAAE,CAAC;IACjB,CAAC;IAED,eAAe,CAAC,MAAW;QACvB,OAAO,MAAM,CAAS,IAAI,CAAC,YAAY,CAAC,IAAI,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,KAAK,CAAC;IAC9E,CAAC;IACD;;;;OAIG;IACI,SAAS,CAAC,OAA0B;QACvC,IAAI,IAAI,CAAC;QACT,IAAI,GAAG,GAAG,EAAE,CAAC;QACb,IAAI,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAE3B,IAAI,OAAO,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;YACnC,IAAI,GAAG,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC;QAChC,CAAC;aAAM,IAAI,OAAO,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;YACtC,IAAI,GAAG,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;QAC5B,CAAC;aAAM,CAAC;YACJ,IAAI,GAAG,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,KAAK,CAAC;YAExC,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;gBACnB,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC;YACpE,CAAC;QACL,CAAC;QAED,MAAM,iBAAiB,GAAkB,OAAQ,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,KAAK,KAAK,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC;QAElH,SAAS;QACT,GAAG,IAAI,iBAAiB,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAE3G,MAAM;QACN,MAAM,IAAI,GAAG,IAAI;aACZ,GAAG,CAAC,CAAC,MAAW,EAAE,EAAE,CACjB,iBAAiB;aACZ,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;YACZ,IAAI,QAAQ,GAAG,WAAW,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;YAElE,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;gBACnB,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;oBACtB,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC;wBAC3B,IAAI,EAAE,QAAQ;wBACd,KAAK,EAAE,MAAM,CAAC,KAAK;qBACtB,CAAC,CAAC;gBACP,CAAC;;oBAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YAC3D,CAAC;;gBAAM,QAAQ,GAAG,EAAE,CAAC;YAErB,OAAO,GAAG,GAAG,QAAQ,GAAG,GAAG,CAAC;QAChC,CAAC,CAAC;aACD,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAC/B;aACA,IAAI,CAAC,IAAI,CAAC,CAAC;QAEhB,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YACd,GAAG,IAAI,IAAI,GAAG,IAAI,CAAC;QACvB,CAAC;QAED,IAAI,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE;YAC3D,IAAI,EAAE,yBAAyB;SAClC,CAAC,CAAC;QAEH,IAAI,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;QAC5C,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;QAC5B,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACpD,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC9B,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC;YACrD,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,CAAC;YAC5D,IAAI,CAAC,KAAK,EAAE,CAAC;QACjB,CAAC;aAAM,CAAC;YACJ,GAAG,GAAG,8BAA8B,GAAG,GAAG,CAAC;YAC3C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;QACrC,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACxD,CAAC;IAED,cAAc,CAAC,KAAmB;QAC9B,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;YACjB,GAAG,IAAI,CAAC,sBAAsB,EAAE;YAChC,GAAG,KAAK;YACR,IAAI,EAAU,KAAK,CAAC,IAAI,GAAW,KAAK,CAAC,KAAK;SACjD,CAAC,CAAC;IACP,CAAC;IACD;;;OAGG;IACI,cAAc;QACjB,IAAI,IAAI,CAAC,aAAa;YAAE,IAAI,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;;YAChD,IAAI,CAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;IACnC,CAAC;IACD;;;;OAIG;IACI,oBAAoB,CAAC,KAAa;QACrC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IACxD,CAAC;IACD;;;;OAIG;IACI,QAAQ,CAAC,OAAY;QACxB,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACrB,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;QACrC,CAAC;aAAM,IAAI,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,gBAAgB,CAAC,aAAa,EAAE,CAAC;YACtE,IAAI,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;gBAC/C,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YAC1D,CAAC;iBAAM,CAAC;gBACJ,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;gBAC9D,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC;YAChE,CAAC;QACL,CAAC;IACL,CAAC;IAED,iBAAiB,CAAC,IAAS,EAAE,IAAS,EAAE,KAAa,EAAE,KAAa;QAChE,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAC9B,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;QACjC,IAAI,CAAC,wBAAwB,EAAE,CAAC;IACpC,CAAC;IAED,kBAAkB;QACd,OAAO,IAAI,CAAC,WAAW,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,sBAAsB,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC;IACtG,CAAC;IAED,wBAAwB;QACpB,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC7B,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;gBAC/E,IAAI,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,kBAAkB,EAAE,EAAE,CAAC;oBACnE,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,EAAE,kBAAkB,CAAC,CAAC;oBAC7D,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;oBACxB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,gBAAgB,EAAE,IAAI,EAAE,IAAI,CAAC,eAAe,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK,EAAU,IAAI,CAAC,mBAAmB,EAAE,CAAC,CAAC;oBACtJ,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;oBAC7B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;oBAC5B,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;oBAChC,IAAI,CAAC,0BAA0B,EAAE,CAAC;oBAClC,IAAI,CAAC,EAAE,CAAC,YAAY,EAAE,CAAC;oBAEvB,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;wBAC3B,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,CAAC;oBAC3C,CAAC;gBACL,CAAC;gBAED,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;YAC3B,CAAC,CAAC,CAAC;QACP,CAAC;IACL,CAAC;IAED,0BAA0B;QACtB,IAAI,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;QACrC,CAAC;IACL,CAAC;IAED,WAAW,CAAC,OAAY;QACpB,IAAI,YAAY,GAAG,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QAC/E,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;IAC7C,CAAC;IAED,WAAW,CAAC,OAAY,EAAE,UAA+B;QACrD,IAAI,UAAU,CAAC,IAAI,CAAC,UAAU,EAAE,sBAAsB,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACnE,IAAI,YAAY,GAAG,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;YAC/E,OAAO,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;QAC7C,CAAC;IACL,CAAC;IAED,aAAa,CAAC,OAAY;QACtB,IAAI,YAAY,GAAG,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QAC/E,OAAO,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;IAC7C,CAAC;IAED,SAAS,CAAC,OAAY,EAAE,KAAa;QACjC,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,6DAA6D,CAAC,CAAC;QACnF,CAAC;QAED,IAAI,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QAEpK,IAAI,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,IAAI,IAAI,EAAE,CAAC;YAC7C,OAAO,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC;YAC1C,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;gBACpB,aAAa,EAAS,KAAK;gBAC3B,IAAI,EAAE,OAAO;aAChB,CAAC,CAAC;QACP,CAAC;aAAM,CAAC;YACJ,IAAI,IAAI,CAAC,aAAa,KAAK,QAAQ,EAAE,CAAC;gBAClC,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;YAC9B,CAAC;YAED,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;YAC1C,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;gBAClB,aAAa,EAAS,KAAK;gBAC3B,IAAI,EAAE,OAAO;aAChB,CAAC,CAAC;QACP,CAAC;QAED,IAAI,KAAK,EAAE,CAAC;YACR,KAAK,CAAC,cAAc,EAAE,CAAC;QAC3B,CAAC;QAED,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;YACpB,IAAI,CAAC,SAAS,EAAE,CAAC;QACrB,CAAC;IACL,CAAC;IAED,aAAa,CAAC,OAAY;QACtB,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IAC1N,CAAC;IAED,YAAY,CAAC,OAAY;QACrB,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IACrG,CAAC;IAED,qBAAqB;QACjB,OAAO,IAAI,CAAC,aAAa,KAAK,QAAQ,CAAC;IAC3C,CAAC;IAED,uBAAuB;QACnB,OAAO,IAAI,CAAC,aAAa,KAAK,UAAU,CAAC;IAC7C,CAAC;IAED,mBAAmB,CAAC,KAAU;QAC1B,IAAI,aAAa,GAAG,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,CAAC,IAAI,CAAC;QACtF,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC,MAAM,CAAC,aAAa,CAAC;QACtD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,IAAI,KAAK,CAAC,IAAI,IAAI,YAAY,EAAE,CAAC;YAC7B,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,aAAa,GAAG,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,UAAU,CAAC;QAClI,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,KAAK,GAAG,aAAa,GAAG,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,UAAU,CAAC;QAC9G,CAAC;QACD,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QAC3B,KAAK,CAAC,cAAc,EAAE,CAAC;IAC3B,CAAC;IAED,cAAc,CAAC,KAAU;QACrB,IAAI,aAAa,GAAG,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,CAAC,IAAI,CAAC;QACtF,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,kBAAkB,EAAE,aAAa,EAAE,uBAAuB,CAAC,CAAC;QACxE,IAAI,CAAC,qBAAsB,CAAC,aAAa,CAAC,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,YAAY,GAAG,IAAI,CAAC;QACpH,IAAI,CAAC,qBAAsB,CAAC,aAAa,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC;QAC5E,IAAI,KAAK,CAAC,IAAI,IAAI,WAAW,EAAE,CAAC;YACf,IAAI,CAAC,qBAAsB,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,aAAa,GAAG,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,UAAU,GAAG,IAAI,CAAC;QACnL,CAAC;aAAM,CAAC;YACS,IAAI,CAAC,qBAAsB,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC,KAAK,GAAG,aAAa,GAAG,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,UAAU,GAAG,IAAI,CAAC;QAC/J,CAAC;QACY,IAAI,CAAC,qBAAsB,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC;IACnF,CAAC;IAED,iBAAiB;QACb,IAAI,KAAK,GAAG,IAAI,CAAC,qBAAqB,EAAE,aAAa,CAAC,UAAU,GAAW,IAAI,CAAC,kBAAkB,CAAC;QACnG,IAAI,WAAW,GAAG,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC;QACvD,IAAI,cAAc,GAAG,WAAW,GAAG,KAAK,CAAC;QACzC,IAAI,QAAQ,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC;QAEpF,IAAI,cAAc,IAAI,QAAQ,EAAE,CAAC;YAC7B,IAAI,IAAI,CAAC,gBAAgB,KAAK,KAAK,EAAE,CAAC;gBAClC,IAAI,UAAU,GAAG,IAAI,CAAC,mBAAmB,CAAC,kBAAkB,CAAC;gBAC7D,IAAI,eAAe,GAAG,UAAU,CAAC,WAAW,GAAG,KAAK,CAAC;gBAErD,IAAI,cAAc,GAAG,EAAE,IAAI,eAAe,GAAG,EAAE,EAAE,CAAC;oBAC9C,IAAI,CAAC,gBAAgB,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC;gBAC3D,CAAC;YACL,CAAC;iBAAM,IAAI,IAAI,CAAC,gBAAgB,KAAK,QAAQ,EAAE,CAAC;gBAC5C,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBACjD,IAAI,UAAU,GAAG,IAAI,CAAC,cAAc,EAAE,aAAa,CAAC,WAAW,GAAG,KAAK,CAAC;gBAExE,IAAI,CAAC,mBAAmB,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;gBAC5C,IAAI,CAAC,gBAAgB,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;YAChD,CAAC;YAED,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;gBAClB,OAAO,EAAE,IAAI,CAAC,mBAAmB;gBACjC,KAAK,EAAE,KAAK;aACf,CAAC,CAAC;YAEH,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;gBACpB,IAAI,CAAC,SAAS,EAAE,CAAC;YACrB,CAAC;QACL,CAAC;QAEY,IAAI,CAAC,qBAAsB,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;QAC9E,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,kBAAkB,EAAE,aAAa,EAAE,uBAAuB,CAAC,CAAC;IAC5F,CAAC;IAEO,gBAAgB;QACpB,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,MAAM,SAAS,GAAG,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAE,sBAAsB,CAAC,CAAC;QACvG,IAAI,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QACpD,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QAE3E,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,iBAAiB,CAAC,KAAU,EAAE,aAAkB;QAC5C,IAAI,CAAC,gBAAgB,GAAG,UAAU,CAAC,0BAA0B,CAAC,IAAI,CAAC,2BAA2B,EAAE,aAAa,CAAC,CAAC;QAC/G,IAAI,CAAC,iBAAiB,GAAG,UAAU,CAAC,2BAA2B,CAAC,IAAI,CAAC,6BAA6B,EAAE,aAAa,CAAC,CAAC;QACnH,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,cAAc;IAC3D,CAAC;IAED,iBAAiB,CAAC,KAAU,EAAE,UAAe;QACzC,IAAI,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,aAAa,IAAI,UAAU,EAAE,CAAC;YAC9D,KAAK,CAAC,cAAc,EAAE,CAAC;YACvB,IAAI,eAAe,GAAG,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,CAAC;YACnF,IAAI,gBAAgB,GAAG,UAAU,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;YAExD,IAAI,IAAI,CAAC,aAAa,IAAI,UAAU,EAAE,CAAC;gBACnC,IAAI,SAAS,GAAG,UAAU,CAAC,gBAAgB,CAAC,IAAI,CAAC,aAAa,EAAE,sBAAsB,CAAC,CAAC;gBACxF,IAAI,SAAS,GAAG,UAAU,CAAC,gBAAgB,CAAC,UAAU,EAAE,sBAAsB,CAAC,CAAC;gBAChF,IAAI,UAAU,GAAG,gBAAgB,CAAC,IAAI,GAAG,eAAe,CAAC,IAAI,CAAC;gBAC9D,IAAI,SAAS,GAAG,eAAe,CAAC,GAAG,GAAG,gBAAgB,CAAC,GAAG,CAAC;gBAC3D,IAAI,YAAY,GAAG,gBAAgB,CAAC,IAAI,GAAG,UAAU,CAAC,WAAW,GAAG,CAAC,CAAC;gBAEzD,IAAI,CAAC,2BAA4B,CAAC,aAAa,CAAC,KAAK,CAAC,GAAG,GAAG,gBAAgB,CAAC,GAAG,GAAG,eAAe,CAAC,GAAG,GAAG,CAAS,IAAI,CAAC,iBAAiB,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;gBACrJ,IAAI,CAAC,6BAA8B,CAAC,aAAa,CAAC,KAAK,CAAC,GAAG,GAAG,gBAAgB,CAAC,GAAG,GAAG,eAAe,CAAC,GAAG,GAAG,UAAU,CAAC,YAAY,GAAG,IAAI,CAAC;gBAEvJ,IAAI,KAAK,CAAC,KAAK,GAAG,YAAY,EAAE,CAAC;oBAChB,IAAI,CAAC,2BAA4B,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,GAAG,UAAU,GAAG,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAS,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;oBACvJ,IAAI,CAAC,6BAA8B,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,GAAG,UAAU,GAAG,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAS,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;oBACtK,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;gBAC1B,CAAC;qBAAM,CAAC;oBACS,IAAI,CAAC,2BAA4B,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,GAAG,UAAU,GAAG,IAAI,CAAC,IAAI,CAAS,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;oBAC9H,IAAI,CAAC,6BAA8B,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,GAAG,UAAU,GAAG,IAAI,CAAC,IAAI,CAAS,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;oBAC7I,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC;gBAC3B,CAAC;gBACY,IAAI,CAAC,2BAA4B,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC;gBACxE,IAAI,CAAC,6BAA8B,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC;YAC3F,CAAC;iBAAM,CAAC;gBACJ,KAAK,CAAC,YAAY,CAAC,UAAU,GAAG,MAAM,CAAC;YAC3C,CAAC;QACL,CAAC;IACL,CAAC;IAED,iBAAiB,CAAC,KAAY;QAC1B,IAAI,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YAChD,KAAK,CAAC,cAAc,EAAE,CAAC;QAC3B,CAAC;IACL,CAAC;IAED,YAAY,CAAC,KAAY,EAAE,UAAe;QACtC,KAAK,CAAC,cAAc,EAAE,CAAC;QACvB,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACrB,IAAI,SAAS,GAAG,UAAU,CAAC,gBAAgB,CAAC,IAAI,CAAC,aAAa,EAAE,sBAAsB,CAAC,CAAC;YACxF,IAAI,SAAS,GAAG,UAAU,CAAC,gBAAgB,CAAC,UAAU,EAAE,sBAAsB,CAAC,CAAC;YAChF,IAAI,SAAS,GAAG,SAAS,IAAI,SAAS,CAAC;YACvC,IAAI,SAAS,IAAI,CAAC,CAAC,SAAS,GAAG,SAAS,IAAI,CAAC,IAAI,IAAI,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,SAAS,IAAI,CAAC,IAAI,IAAI,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;gBACrI,SAAS,GAAG,KAAK,CAAC;YACtB,CAAC;YAED,IAAI,SAAS,IAAI,SAAS,GAAG,SAAS,IAAI,IAAI,CAAC,YAAY,KAAK,CAAC,EAAE,CAAC;gBAChE,SAAS,GAAG,SAAS,GAAG,CAAC,CAAC;YAC9B,CAAC;YAED,IAAI,SAAS,IAAI,SAAS,GAAG,SAAS,IAAI,IAAI,CAAC,YAAY,KAAK,CAAC,CAAC,EAAE,CAAC;gBACjE,SAAS,GAAG,SAAS,GAAG,CAAC,CAAC;YAC9B,CAAC;YAED,IAAI,SAAS,EAAE,CAAC;gBACZ,WAAW,CAAC,YAAY,CAAQ,IAAI,CAAC,OAAO,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;gBAEpE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC;oBACnB,SAAS,EAAE,SAAS;oBACpB,SAAS,EAAE,SAAS;oBACpB,OAAO,EAAE,IAAI,CAAC,OAAO;iBACxB,CAAC,CAAC;gBAEH,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;oBACpB,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE;wBAC7B,UAAU,CAAC,GAAG,EAAE;4BACZ,IAAI,CAAC,SAAS,EAAE,CAAC;wBACrB,CAAC,CAAC,CAAC;oBACP,CAAC,CAAC,CAAC;gBACP,CAAC;YACL,CAAC;YAED,IAAI,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBACpD,IAAI,KAAK,GAAG,IAAI,CAAC,gBAAgB,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBAClG,WAAW,CAAC,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC,CAAC;gBAC9D,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;YAC1D,CAAC;YAEY,IAAI,CAAC,2BAA4B,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;YACvE,IAAI,CAAC,6BAA8B,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;YACtF,IAAI,CAAC,aAAa,CAAC,SAAS,GAAG,KAAK,CAAC;YACrC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;YAC1B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QAC7B,CAAC;IACL,CAAC;IAED,gBAAgB,CAAC,cAAsB,EAAE,eAA8B;QACnE,IAAI,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QAC1D,IAAI,KAAK,GAAG,IAAI,CAAC,gBAAgB,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAClG,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,eAAe,CAAC,CAAC;IAC9E,CAAC;IAED,kBAAkB,CAAC,KAAe,EAAE,QAAgB,EAAE,cAAsB,EAAE,eAA8B;QACxG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAE1B,IAAI,SAAS,GAAG,EAAE,CAAC;QACnB,KAAK,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;YAC3B,IAAI,QAAQ,GAAG,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,eAAe,IAAI,KAAK,KAAK,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,CAAC;YACzH,IAAI,KAAK,GAAG,UAAU,QAAQ,6BAA6B,QAAQ,gBAAgB,CAAC;YACpF,SAAS,IAAI;mBACN,IAAI,CAAC,EAAE,qDAAqD,KAAK,GAAG,CAAC;mBACrE,IAAI,CAAC,EAAE,qDAAqD,KAAK,GAAG,CAAC;mBACrE,IAAI,CAAC,EAAE,qDAAqD,KAAK,GAAG,CAAC;sBAClE,KAAK;;aAEd,CAAC;QACN,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,EAAE,WAAW,EAAE,IAAI,CAAC,YAAY,CAAC,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAAC;IACrH,CAAC;IAED,cAAc,CAAC,KAAU,EAAE,KAAa;QACpC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;QAC7B,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,cAAc;IAC3D,CAAC;IAED,aAAa,CAAC,KAAiB,EAAE,KAAa,EAAE,UAAe;QAC3D,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,eAAe,KAAK,KAAK,EAAE,CAAC;YACrD,IAAI,IAAI,GAAG,UAAU,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC;YAChD,IAAI,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;YACxB,IAAI,OAAO,GAAG,IAAI,GAAG,UAAU,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YAC/D,IAAI,cAAc,GAAG,UAAU,CAAC,sBAAsB,CAAC;YAEvD,IAAI,KAAK,GAAG,OAAO,EAAE,CAAC;gBAClB,UAAU,CAAC,WAAW,CAAC,UAAU,EAAE,gCAAgC,CAAC,CAAC;gBAErE,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;gBAC7B,IAAI,cAAc;oBAAE,UAAU,CAAC,QAAQ,CAAC,cAAc,EAAE,gCAAgC,CAAC,CAAC;;oBACrF,UAAU,CAAC,QAAQ,CAAC,UAAU,EAAE,6BAA6B,CAAC,CAAC;YACxE,CAAC;iBAAM,CAAC;gBACJ,IAAI,cAAc;oBAAE,UAAU,CAAC,WAAW,CAAC,cAAc,EAAE,gCAAgC,CAAC,CAAC;;oBACxF,UAAU,CAAC,QAAQ,CAAC,UAAU,EAAE,6BAA6B,CAAC,CAAC;gBAEpE,IAAI,CAAC,eAAe,GAAG,KAAK,GAAG,CAAC,CAAC;gBACjC,UAAU,CAAC,QAAQ,CAAC,UAAU,EAAE,gCAAgC,CAAC,CAAC;YACtE,CAAC;QACL,CAAC;IACL,CAAC;IAED,cAAc,CAAC,KAAY,EAAE,UAAe;QACxC,IAAI,cAAc,GAAG,UAAU,CAAC,sBAAsB,CAAC;QACvD,IAAI,cAAc,EAAE,CAAC;YACjB,UAAU,CAAC,WAAW,CAAC,cAAc,EAAE,gCAAgC,CAAC,CAAC;QAC7E,CAAC;QAED,UAAU,CAAC,WAAW,CAAC,UAAU,EAAE,gCAAgC,CAAC,CAAC;QACrE,UAAU,CAAC,WAAW,CAAC,UAAU,EAAE,6BAA6B,CAAC,CAAC;IACtE,CAAC;IAED,YAAY,CAAC,KAAY;QACrB,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;IAChC,CAAC;IAED,SAAS,CAAC,KAAY,EAAE,UAAe;QACnC,IAAI,IAAI,CAAC,eAAe,IAAI,IAAI,EAAE,CAAC;YAC/B,IAAI,SAAS,GAAW,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,GAAG,CAAC,CAAC;YACvJ,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,EAAU,IAAI,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC;YAE9E,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;gBACrB,cAAc;gBACd,IAAI,CAAC,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;YACnC,CAAC;YAED,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC;gBACnB,SAAS,EAAU,IAAI,CAAC,eAAe;gBACvC,SAAS,EAAE,SAAS;aACvB,CAAC,CAAC;QACP,CAAC;QACD,SAAS;QACT,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;QACvC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;IAED,OAAO;QACH,IAAI,IAAI,GAAG,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,KAAK,CAAC;QAC5C,OAAO,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC;IAC5C,CAAC;IAED,mBAAmB;QACf,OAAO,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC7C,CAAC;IAED,UAAU;QACN,IAAI,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACrC,QAAQ,IAAI,CAAC,YAAY,EAAE,CAAC;gBACxB,KAAK,OAAO;oBACR,OAAO,MAAM,CAAC,YAAY,CAAC;gBAE/B,KAAK,SAAS;oBACV,OAAO,MAAM,CAAC,cAAc,CAAC;gBAEjC;oBACI,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,YAAY,GAAG,0FAA0F,CAAC,CAAC;YACxI,CAAC;QACL,CAAC;aAAM,CAAC;YACJ,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;QAC5E,CAAC;IACL,CAAC;IAED,UAAU;QACN,OAAO,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC;IACjC,CAAC;IAED,SAAS;QACL,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAClC,IAAI,KAAK,GAAe,EAAE,CAAC;QAE3B,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACjB,KAAK,CAAC,KAAK,GAAW,IAAI,CAAC,KAAK,CAAC;YACjC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QAC3B,CAAC;QAED,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACjB,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;YACjC,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QACrC,CAAC;QAED,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACrB,KAAK,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QAC7C,CAAC;QAED,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YACnB,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QACjC,CAAC;QAED,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACxB,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC;QAED,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC1B,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;QAChC,CAAC;QAED,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACjB,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QACrC,CAAC;QAED,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,MAAM,EAAE,CAAC;YAC3C,KAAK,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;QACjD,CAAC;QAED,OAAO,CAAC,OAAO,CAAS,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;QAC9D,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAED,UAAU;QACN,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAElC,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAChB,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACtC,CAAC;IACL,CAAC;IAED,YAAY;QACR,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAClC,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAS,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC3D,MAAM,UAAU,GAAG,4CAA4C,CAAC;QAChE,MAAM,OAAO,GAAG,UAAU,GAAQ,EAAE,KAAU;YAC1C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;gBACtD,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;YAC3B,CAAC;YAED,OAAO,KAAK,CAAC;QACjB,CAAC,CAAC;QAEF,IAAI,WAAW,EAAE,CAAC;YACd,IAAI,KAAK,GAAe,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;YAEzD,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;gBACjB,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;oBAC3B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;oBACzB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACtC,CAAC;gBAED,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;oBAC1B,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;oBACvB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACpC,CAAC;YACL,CAAC;YAED,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;gBAClB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;gBAC1B,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,SAAS,CAAC;gBAClC,IAAI,CAAC,UAAU,GAAW,KAAK,CAAC,SAAS,CAAC;YAC9C,CAAC;YAED,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;gBACtB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;gBAC1B,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,aAAa,CAAC;YAC9C,CAAC;YAED,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;gBAChB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;gBAC5B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;YACjC,CAAC;YAED,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBACxB,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC,YAAY,CAAC;gBAC5C,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,UAAU,CAAC;YAC5C,CAAC;YAED,iCAAiC;YACjC,iCAAiC;YACjC,IAAI;YAEJ,IAAI,KAAK,CAAC,eAAe,EAAE,CAAC;gBACxB,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,eAAe,CAAC;YACjD,CAAC;YAED,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;gBAClB,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;YACjF,CAAC;YAED,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;YAE1B,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACpC,CAAC;IACL,CAAC;IAED,gBAAgB,CAAC,KAAU;QACvB,IAAI,MAAM,GAAU,EAAE,CAAC;QACvB,IAAI,OAAO,GAAG,EAAE,CAAC;QACjB,MAAM,SAAS,GAAG,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC;QAEzD,IAAI,SAAS,EAAE,CAAC;YACZ,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,SAAS,EAAE,gCAAgC,CAAC,CAAC;QAC3E,CAAC;QAED,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QAC3E,KAAK,CAAC,YAAY,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAEtC,IAAI,IAAI,CAAC,gBAAgB,KAAK,QAAQ,EAAE,CAAC;YACrC,KAAK,CAAC,UAAU,GAAG,UAAU,CAAC,aAAa,CAAC,IAAI,CAAC,cAAc,EAAE,aAAa,CAAC,CAAC;QACpF,CAAC;IACL,CAAC;IAED,mBAAmB,CAAC,KAAa;QAChB,IAAI,CAAC,cAAe,CAAC,aAAa,CAAC,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC;QACvD,IAAI,CAAC,cAAe,CAAC,aAAa,CAAC,KAAK,CAAC,QAAQ,GAAG,KAAK,CAAC;IAC3E,CAAC;IAED,mBAAmB;QACf,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzB,IAAI,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAE/C,IAAI,IAAI,CAAC,gBAAgB,KAAK,QAAQ,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;gBAC7D,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;YAC1D,CAAC;YAED,IAAI,WAAW,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;gBACjC,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBAE1B,IAAI,SAAS,GAAG,EAAE,CAAC;gBACnB,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;oBAC5B,IAAI,KAAK,GAAG,UAAU,KAAK,6BAA6B,KAAK,eAAe,CAAC;oBAE7E,SAAS,IAAI;2BACN,IAAI,CAAC,EAAE,qDAAqD,KAAK,GAAG,CAAC;2BACrE,IAAI,CAAC,EAAE,qDAAqD,KAAK,GAAG,CAAC;2BACrE,IAAI,CAAC,EAAE,qDAAqD,KAAK,GAAG,CAAC;8BAClE,KAAK;;qBAEd,CAAC;gBACN,CAAC,CAAC,CAAC;gBAEH,IAAI,CAAC,YAAY,CAAC,WAAW,GAAG,SAAS,CAAC;YAC9C,CAAC;QACL,CAAC;IACL,CAAC;IAED,eAAe,CAAC,KAAU;QACtB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,IAAI,WAAW,GAAa,EAAE,CAAC;YAC/B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;gBACxB,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC;YACjD,CAAC,CAAC,CAAC;YAEH,KAAK,CAAC,WAAW,GAAG,WAAW,CAAC;QACpC,CAAC;IACL,CAAC;IAED,kBAAkB;QACd,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAClC,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAS,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC3D,IAAI,WAAW,EAAE,CAAC;YACd,IAAI,KAAK,GAAe,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;YAChD,IAAI,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;YAEpC,IAAI,WAAW,EAAE,CAAC;gBACd,IAAI,gBAAgB,GAAU,EAAE,CAAC;gBAEjC,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;oBACpB,IAAI,GAAG,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;oBACpC,IAAI,GAAG,EAAE,CAAC;wBACN,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oBAC/B,CAAC;gBACL,CAAC,CAAC,CAAC;gBACH,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC;gBACrC,IAAI,CAAC,OAAO,GAAG,gBAAgB,CAAC;YACpC,CAAC;QACL,CAAC;IACL,CAAC;IAED,eAAe,CAAC,GAAQ;QACpB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,KAAK,IAAI,GAAG,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBAC3B,IAAI,GAAG,CAAC,GAAG,KAAK,GAAG,IAAI,GAAG,CAAC,KAAK,KAAK,GAAG;oBAAE,OAAO,GAAG,CAAC;;oBAChD,SAAS;YAClB,CAAC;QACL,CAAC;aAAM,CAAC;YACJ,OAAO,IAAI,CAAC;QAChB,CAAC;IACL,CAAC;IAED,kBAAkB;QACd,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QACzD,IAAI,CAAC,YAAY,CAAC,IAAI,GAAG,UAAU,CAAC;QACpC,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,KAAK,CAAC,CAAC;QAC/E,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;IACrE,CAAC;IAED,gBAAgB;QACZ,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACrE,CAAC;IAED,eAAe;QACX,OAAO;YACH,6BAA6B,EAAE,IAAI;YACnC,8BAA8B,EAAE,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,aAAa;YACnE,0BAA0B,EAAE,IAAI,CAAC,UAAU;YAC3C,+BAA+B,EAAE,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,YAAY,KAAK,MAAM;YAChF,CAAC,qBAAqB,GAAG,IAAI,CAAC,QAAQ,CAAC,EAAE,IAAI;YAC7C,CAAC,oBAAoB,GAAG,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI;SAC9C,CAAC;IACN,CAAC;IAED,qBAAqB;QACjB,IAAI,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACrC,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC;gBAC/B,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;gBACnE,IAAI,CAAC,sBAAsB,CAAC,IAAI,GAAG,UAAU,CAAC;gBAC9C,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,sBAAsB,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,KAAK,CAAC,CAAC;gBACzF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,sBAAsB,CAAC,CAAC;gBAE3E,IAAI,SAAS,GAAG;oCACI,IAAI,CAAC,UAAU;WACxC,IAAI,CAAC,EAAE;WACP,IAAI,CAAC,EAAE;;;;WAIP,IAAI,CAAC,EAAE;;;;;;;WAOP,IAAI,CAAC,EAAE;;;;WAIP,IAAI,CAAC,EAAE;;;;;;WAMP,IAAI,CAAC,EAAE;;;;KAIb,CAAC;gBACU,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,sBAAsB,EAAE,WAAW,EAAE,IAAI,CAAC,YAAY,CAAC,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAAC;YAC/H,CAAC;QACL,CAAC;IACL,CAAC;IAED,sBAAsB;QAClB,IAAI,IAAI,CAAC,sBAAsB,EAAE,CAAC;YAC9B,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,sBAAsB,CAAC,CAAC;YAC3E,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;QACvC,CAAC;IACL,CAAC;IAED,mBAAmB;QACf,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;YACjE,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QAC7B,CAAC;IACL,CAAC;IAED,WAAW;QACP,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAClC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QAExB,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAClC,CAAC;IAED,wBAAwB,CAAC,SAAkB;QACvC,OAAO,CAAC,IAAI,CAAC,mBAAmB,EAAE,SAAS,CAAC;aACvC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;aAClB,IAAI,CAAC,GAAG,CAAC;aACT,IAAI,EAAE,CAAC;IAChB,CAAC;uGAlvFQ,KAAK,kBAozBF,QAAQ,aACR,WAAW;2FArzBd,KAAK,2SAqCM,gBAAgB,yCAKhB,eAAe,iHAUf,gBAAgB,iVA8BhB,gBAAgB,gFAKhB,gBAAgB,uEAKhB,gBAAgB,iEAKhB,gBAAgB,qDAKhB,gBAAgB,8DAKhB,eAAe,iIAYf,gBAAgB,iGAUhB,gBAAgB,sLA0BhB,gBAAgB,oFAehB,gBAAgB,wDAKhB,gBAAgB,uNA8BhB,eAAe,gLAyBf,gBAAgB,qJAqBhB,gBAAgB,6EAKhB,eAAe,kHAUf,eAAe,gJA4Bf,gBAAgB,0GAUhB,gBAAgB,mCAKhB,gBAAgB,wEAUhB,gBAAgB,sCAKhB,gBAAgB,4CAKhB,gBAAgB,0EAKhB,gBAAgB,4CAKhB,gBAAgB,oOAmChB,eAAe,usCAkRlB,WAAW,s8BCntBhC,y6VAkNA,umQD5Ic,YAAY,4dAAE,eAAe,6kCAAE,cAAc,+BAAE,aAAa,0DAAE,WAAW,wDAAE,WAAW,wDAAE,SAAS;;2FAKlG,KAAK;kBAZjB,SAAS;+BACI,WAAW,mBAEJ,uBAAuB,CAAC,OAAO,iBACjC,iBAAiB,CAAC,IAAI,cAEzB,IAAI,WACP,CAAC,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,CAAC,QACtG;wBACF,KAAK,EAAE,aAAa;qBACvB;;0BAszBI,MAAM;2BAAC,QAAQ;;0BACf,MAAM;2BAAC,WAAW;sRApzBd,QAAQ;sBAAhB,KAAK;gBACG,OAAO;sBAAf,KAAK;gBAKG,aAAa;sBAArB,KAAK;gBAKG,WAAW;sBAAnB,KAAK;gBAKG,KAAK;sBAAb,KAAK;gBAKG,UAAU;sBAAlB,KAAK;gBAKG,UAAU;sBAAlB,KAAK;gBAKG,eAAe;sBAAvB,KAAK;gBAKkC,SAAS;sBAAhD,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAKC,SAAS;sBAA/C,KAAK;uBAAC,EAAE,SAAS,EAAE,eAAe,EAAE;gBAK5B,kBAAkB;sBAA1B,KAAK;gBAKkC,mBAAmB;sBAA1D,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAK7B,iBAAiB;sBAAzB,KAAK;gBAKG,mBAAmB;sBAA3B,KAAK;gBAKG,yBAAyB;sBAAjC,KAAK;gBAKG,6BAA6B;sBAArC,KAAK;gBAKG,yBAAyB;sBAAjC,KAAK;gBAKkC,qBAAqB;sBAA5D,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAKE,sBAAsB;sBAA7D,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAKE,mBAAmB;sBAA1D,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAKE,iBAAiB;sBAAxD,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAKE,aAAa;sBAApD,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAKC,gBAAgB;sBAAtD,KAAK;uBAAC,EAAE,SAAS,EAAE,eAAe,EAAE;gBAK5B,UAAU;sBAAlB,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBAKkC,eAAe;sBAAtD,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAK7B,aAAa;sBAArB,KAAK;gBAKkC,iBAAiB;sBAAxD,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAK7B,oBAAoB;sBAA5B,KAAK;gBAMI,0BAA0B;sBAAnC,MAAM;gBAKE,wBAAwB;sBAAhC,KAAK;gBAKG,OAAO;sBAAf,KAAK;gBAKkC,gBAAgB;sBAAvD,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAK7B,aAAa;sBAArB,KAAK;gBAKG,UAAU;sBAAlB,KAAK;gBAKkC,IAAI;sBAA3C,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAKE,cAAc;sBAArD,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAK7B,kBAAkB;sBAA1B,KAAK;gBAKG,YAAY;sBAApB,KAAK;gBAKG,cAAc;sBAAtB,KAAK;gBAKG,OAAO;sBAAf,KAAK;gBAKG,kBAAkB;sBAA1B,KAAK;gBAKiC,WAAW;sBAAjD,KAAK;uBAAC,EAAE,SAAS,EAAE,eAAe,EAAE;gBAK5B,YAAY;sBAApB,KAAK;gBAKG,eAAe;sBAAvB,KAAK;gBAKG,cAAc;sBAAtB,KAAK;gBAKG,aAAa;sBAArB,KAAK;gBAKkC,UAAU;sBAAjD,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAM7B,eAAe;sBAAvB,KAAK;gBAKG,YAAY;sBAApB,KAAK;gBAKG,YAAY;sBAApB,KAAK;gBAKkC,aAAa;sBAApD,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAKC,qBAAqB;sBAA3D,KAAK;uBAAC,EAAE,SAAS,EAAE,eAAe,EAAE;gBAK5B,oBAAoB;sBAA5B,KAAK;gBAKiC,kBAAkB;sBAAxD,KAAK;uBAAC,EAAE,SAAS,EAAE,eAAe,EAAE;gBAK5B,WAAW;sBAAnB,KAAK;gBAMO,UAAU;sBAAtB,KAAK;gBAYG,WAAW;sBAAnB,KAAK;gBAKkC,gBAAgB;sBAAvD,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAK7B,gBAAgB;sBAAxB,KAAK;gBAKkC,kBAAkB;sBAAzD,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAKE,OAAO;sBAA9C,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAK7B,WAAW;sBAAnB,KAAK;gBAKkC,UAAU;sBAAjD,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAKE,QAAQ;sBAA/C,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAKE,UAAU;sBAAjD,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAKE,oBAAoB;sBAA3D,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAKE,UAAU;sBAAjD,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAK7B,cAAc;sBAAtB,KAAK;gBAKG,YAAY;sBAApB,KAAK;gBAKG,QAAQ;sBAAhB,KAAK;gBAKG,YAAY;sBAApB,KAAK;gBAKG,QAAQ;sBAAhB,KAAK;gBAKG,WAAW;sBAAnB,KAAK;gBAKiC,gBAAgB;sBAAtD,KAAK;uBAAC,EAAE,SAAS,EAAE,eAAe,EAAE;gBAK5B,gBAAgB;sBAAxB,KAAK;gBAKG,UAAU;sBAAlB,KAAK;gBAKG,eAAe;sBAAvB,KAAK;gBAKO,KAAK;sBAAjB,KAAK;gBAUO,OAAO;sBAAnB,KAAK;gBAUO,KAAK;sBAAjB,KAAK;gBAUO,IAAI;sBAAhB,KAAK;gBAUO,YAAY;sBAAxB,KAAK;gBAWO,SAAS;sBAArB,KAAK;gBAUO,SAAS;sBAArB,KAAK;gBAUO,aAAa;sBAAzB,KAAK;gBAUO,SAAS;sBAArB,KAAK;gBAUO,SAAS;sBAArB,KAAK;gBAWI,eAAe;sBAAxB,MAAM;gBAMG,eAAe;sBAAxB,MAAM;gBAMG,WAAW;sBAApB,MAAM;gBAMG,aAAa;sBAAtB,MAAM;gBAMG,MAAM;sBAAf,MAAM;gBAMG,MAAM;sBAAf,MAAM;gBAMG,QAAQ;sBAAjB,MAAM;gBAMG,UAAU;sBAAnB,MAAM;gBAMG,WAAW;sBAApB,MAAM;gBAMG,aAAa;sBAAtB,MAAM;gBAMG,mBAAmB;sBAA5B,MAAM;gBAMG,WAAW;sBAApB,MAAM;gBAMG,YAAY;sBAArB,MAAM;gBAMG,YAAY;sBAArB,MAAM;gBAMG,UAAU;sBAAnB,MAAM;gBAMG,cAAc;sBAAvB,MAAM;gBAMG,YAAY;sBAArB,MAAM;gBAMG,sBAAsB;sBAA/B,MAAM;gBAMG,YAAY;sBAArB,MAAM;gBAMG,WAAW;sBAApB,MAAM;gBAMG,UAAU;sBAAnB,MAAM;gBAMG,WAAW;sBAApB,MAAM;gBAMG,cAAc;sBAAvB,MAAM;gBAEiB,kBAAkB;sBAAzC,SAAS;uBAAC,WAAW;gBAEK,qBAAqB;sBAA/C,SAAS;uBAAC,cAAc;gBAEQ,2BAA2B;sBAA3D,SAAS;uBAAC,oBAAoB;gBAEI,6BAA6B;sBAA/D,SAAS;uBAAC,sBAAsB;gBAEX,gBAAgB;sBAArC,SAAS;uBAAC,SAAS;gBAEA,cAAc;sBAAjC,SAAS;uBAAC,OAAO;gBAEE,oBAAoB;sBAAvC,SAAS;uBAAC,OAAO;gBAEE,oBAAoB;sBAAvC,SAAS;uBAAC,OAAO;gBAEK,QAAQ;sBAA9B,SAAS;uBAAC,UAAU;gBAES,SAAS;sBAAtC,eAAe;uBAAC,WAAW;gBAMf,gBAAgB;sBAA5B,KAAK","sourcesContent":["import { CommonModule, DOCUMENT, isPlatformBrowser } from '@angular/common';\nimport {\n    AfterContentInit,\n    AfterViewInit,\n    booleanAttribute,\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ContentChildren,\n    ElementRef,\n    EventEmitter,\n    Inject,\n    Input,\n    NgZone,\n    numberAttribute,\n    OnChanges,\n    OnInit,\n    Output,\n    PLATFORM_ID,\n    QueryList,\n    Renderer2,\n    SimpleChanges,\n    TemplateRef,\n    ViewChild,\n    ViewEncapsulation\n} from '@angular/core';\nimport { BlockableUI, FilterMatchMode, FilterMetadata, FilterOperator, FilterService, LazyLoadMeta, OverlayService, caxConfig, CaxTemplate, ScrollerOptions, SortMeta, TableState } from 'cax-design-system/api';\nimport { DomHandler } from 'cax-design-system/dom';\nimport { Scroller, ScrollerModule } from 'cax-design-system/scroller';\nimport { Nullable } from 'cax-design-system/ts-helpers';\nimport { ObjectUtils, UniqueComponentId } from 'cax-design-system/utils';\nimport { Subscription } from 'rxjs';\nimport {\n    ExportCSVOptions,\n    TableColResizeEvent,\n    TableColumnReorderEvent,\n    TableContextMenuSelectEvent,\n    TableEditCancelEvent,\n    TableEditCompleteEvent,\n    TableEditInitEvent,\n    TableFilterEvent,\n    TableHeaderCheckboxToggleEvent,\n    TableLazyLoadEvent,\n    TablePageEvent,\n    TableRowCollapseEvent,\n    TableRowExpandEvent,\n    TableRowReorderEvent,\n    TableRowSelectEvent,\n    TableRowUnSelectEvent,\n    TableSelectAllChangeEvent\n} from './table.interface';\nimport { DomSanitizer } from '@angular/platform-browser';\nimport { TableService } from './table.service';\nimport { ArrowDownIcon } from 'cax-design-system/icons/arrowdown';\nimport { ArrowUpIcon } from 'cax-design-system/icons/arrowup';\nimport { SpinnerIcon } from 'cax-design-system/icons/spinner';\nimport { PaginatorModule } from 'cax-design-system/paginator';\nimport { TableBody } from './components/table-body/table-body';\n\n/**\n * Table displays data in tabular format.\n * @group Components\n */\n@Component({\n    selector: 'cax-table',\n    templateUrl: './table.html',\n    changeDetection: ChangeDetectionStrategy.Default,\n    encapsulation: ViewEncapsulation.None,\n    styleUrls: ['./table.scss'],\n    standalone: true,\n    imports: [CommonModule, PaginatorModule, ScrollerModule, ArrowDownIcon, ArrowUpIcon, SpinnerIcon, TableBody],\n    host: {\n        class: 'cax-element'\n    }\n})\nexport class Table implements OnInit, AfterViewInit, AfterContentInit, BlockableUI, OnChanges {\n    @Input() fontSize: 'sm' | 'md' | 'lg' | 'xl' = 'md';\n    @Input() rowSize: 'sm' | 'md' | 'lg' | 'xl' = 'md';\n    /**\n     * An array of objects to represent dynamic columns that are frozen.\n     * @group Props\n     */\n    @Input() frozenColumns: any[] | undefined;\n    /**\n     * An array of objects to display as frozen.\n     * @group Props\n     */\n    @Input() frozenValue: any[] | undefined;\n    /**\n     * Inline style of the component.\n     * @group Props\n     */\n    @Input() style: { [klass: string]: any } | null | undefined;\n    /**\n     * Style class of the component.\n     * @group Props\n     */\n    @Input() styleClass: string | undefined;\n    /**\n     * Inline style of the table.\n     * @group Props\n     */\n    @Input() tableStyle: { [klass: string]: any } | null | undefined;\n    /**\n     * Style class of the table.\n     * @group Props\n     */\n    @Input() tableStyleClass: string | undefined;\n    /**\n     * When specified as true, enables the pagination.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) paginator: boolean | undefined;\n    /**\n     * Number of page links to display in paginator.\n     * @group Props\n     */\n    @Input({ transform: numberAttribute }) pageLinks: number = 5;\n    /**\n     * Array of integer/object values to display inside rows per page dropdown of paginator\n     * @group Props\n     */\n    @Input() rowsPerPageOptions: any[] | undefined;\n    /**\n     * Whether to show it even there is only one page.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) alwaysShowPaginator: boolean = true;\n    /**\n     * Position of the paginator, options are \"top\", \"bottom\" or \"both\".\n     * @group Props\n     */\n    @Input() paginatorPosition: 'top' | 'bottom' | 'both' = 'bottom';\n    /**\n     * Custom style class for paginator\n     * @group Props\n     */\n    @Input() paginatorStyleClass: string | undefined;\n    /**\n     * Target element to attach the paginator dropdown overlay, valid values are \"body\" or a local ng-template variable of another element (note: use binding with brackets for template variables, e.g. [appendTo]=\"mydiv\" for a div element having #mydiv as variable name).\n     * @group Props\n     */\n    @Input() paginatorDropdownAppendTo: HTMLElement | ElementRef | TemplateRef<any> | string | null | undefined | any;\n    /**\n     * Paginator dropdown height of the viewport in pixels, a scrollbar is defined if height of list exceeds this value.\n     * @group Props\n     */\n    @Input() paginatorDropdownScrollHeight: string = '200px';\n    /**\n     * Template of the current page report element. Available placeholders are {currentPage},{totalPages},{rows},{first},{last} and {totalRecords}\n     * @group Props\n     */\n    @Input() currentPageReportTemplate: string = '{currentPage} of {totalPages}';\n    /**\n     * Whether to display current page report.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) showCurrentPageReport: boolean | undefined;\n    /**\n     * Whether to display a dropdown to navigate to any page.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) showJumpToPageDropdown: boolean | undefined;\n    /**\n     * Whether to display a input to navigate to any page.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) showJumpToPageInput: boolean | undefined;\n    /**\n     * When enabled, icons are displayed on paginator to go first and last page.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) showFirstLastIcon: boolean = true;\n    /**\n     * Whether to show page links.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) showPageLinks: boolean = true;\n    /**\n     * Sort order to use when an unsorted column gets sorted by user interaction.\n     * @group Props\n     */\n    @Input({ transform: numberAttribute }) defaultSortOrder: number = 1;\n    /**\n     * Defines whether sorting works on single column or on multiple columns.\n     * @group Props\n     */\n    @Input() filterType: 'default' | 'custom' = 'default';\n    @Input() sortType: 'default' | 'custom' = 'default';\n    @Input() sortMode: 'single' | 'multiple' = 'single';\n    /**\n     * When true, resets paginator to first page after sorting. Available only when sortMode is set to single.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) resetPageOnSort: boolean = true;\n    /**\n     * Specifies the selection mode, valid values are \"single\" and \"multiple\".\n     * @group Props\n     */\n    @Input() selectionMode: 'single' | 'multiple' | undefined | null;\n    /**\n     * When enabled with paginator and checkbox selection mode, the select all checkbox in the header will select all rows on the current page.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) selectionPageOnly: boolean | undefined;\n    /**\n     * Selected row with a context menu.\n     * @group Props\n     */\n    @Input() contextMenuSelection: any;\n    /**\n     * Callback to invoke on context menu selection change.\n     * @param {*} object - row data.\n     * @group Emits\n     */\n    @Output() contextMenuSelectionChange: EventEmitter<any> = new EventEmitter();\n    /**\n     *  Defines the behavior of context menu selection, in \"separate\" mode context menu updates contextMenuSelection property whereas in joint mode selection property is used instead so that when row selection is enabled, both row selection and context menu selection use the same property.\n     * @group Props\n     */\n    @Input() contextMenuSelectionMode: string = 'separate';\n    /**\n     * A property to uniquely identify a record in data.\n     * @group Props\n     */\n    @Input() dataKey: string | undefined;\n    /**\n     * Defines whether metaKey should be considered for the selection. On touch enabled devices, metaKeySelection is turned off automatically.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) metaKeySelection: boolean | undefined = false;\n    /**\n     * Defines if the row is selectable.\n     * @group Props\n     */\n    @Input() rowSelectable: (row: { data: any; index: number }) => boolean | undefined;\n    /**\n     * Function to optimize the dom operations by delegating to ngForTrackBy, default algorithm checks for object identity.\n     * @group Props\n     */\n    @Input() rowTrackBy: Function = (index: number, item: any) => item;\n    /**\n     * Defines if data is loaded and interacted with in lazy manner.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) lazy: boolean = false;\n    /**\n     * Whether to call lazy loading on initialization.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) lazyLoadOnInit: boolean = true;\n    /**\n     * Algorithm to define if a row is selected, valid values are \"equals\" that compares by reference and \"deepEquals\" that compares all fields.\n     * @group Props\n     */\n    @Input() compareSelectionBy: 'equals' | 'deepEquals' = 'deepEquals';\n    /**\n     * Character to use as the csv separator.\n     * @group Props\n     */\n    @Input() csvSeparator: string = ',';\n    /**\n     * Name of the exported file.\n     * @group Props\n     */\n    @Input() exportFilename: string = 'download';\n    /**\n     * An array of FilterMetadata objects to provide external filters.\n     * @group Props\n     */\n    @Input() filters: { [s: string]: FilterMetadata | FilterMetadata[] } = {};\n    /**\n     * An array of fields as string to use in global filtering.\n     * @group Props\n     */\n    @Input() globalFilterFields: string[] | undefined;\n    /**\n     * Delay in milliseconds before filtering the data.\n     * @group Props\n     */\n    @Input({ transform: numberAttribute }) filterDelay: number = 300;\n    /**\n     * Locale to use in filtering. The default locale is the host environment's current locale.\n     * @group Props\n     */\n    @Input() filterLocale: string | undefined;\n    /**\n     * Map instance to keep the expanded rows where key of the map is the data key of the row.\n     * @group Props\n     */\n    @Input() expandedRowKeys: { [s: string]: boolean } = {};\n    /**\n     * Map instance to keep the rows being edited where key of the map is the data key of the row.\n     * @group Props\n     */\n    @Input() editingRowKeys: { [s: string]: boolean } = {};\n    /**\n     * Whether multiple rows can be expanded at any time. Valid values are \"multiple\" and \"single\".\n     * @group Props\n     */\n    @Input() rowExpandMode: 'multiple' | 'single' = 'multiple';\n    /**\n     * Enables scrollable tables.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) scrollable: boolean | undefined;\n    /**\n     * Orientation of the scrolling, options are \"vertical\", \"horizontal\" and \"both\".\n     * @group Props\n     * @deprecated Property is obselete since v14.2.0.\n     */\n    @Input() scrollDirection: 'vertical' | 'horizontal' | 'both' = 'vertical';\n    /**\n     * Type of the row grouping, valid values are \"subheader\" and \"rowspan\".\n     * @group Props\n     */\n    @Input() rowGroupMode: 'subheader' | 'rowspan' | undefined;\n    /**\n     * Height of the scroll viewport in fixed pixels or the \"flex\" keyword for a dynamic size.\n     * @group Props\n     */\n    @Input() scrollHeight: string | undefined;\n    /**\n     * Whether the data should be loaded on demand during scroll.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) virtualScroll: boolean | undefined;\n    /**\n     * Height of a row to use in calculations of virtual scrolling.\n     * @group Props\n     */\n    @Input({ transform: numberAttribute }) virtualScrollItemSize: number | undefined;\n    /**\n     * Whether to use the scroller feature. The properties of scroller component can be used like an object in it.\n     * @group Props\n     */\n    @Input() virtualScrollOptions: ScrollerOptions | undefined;\n    /**\n     * Threshold in milliseconds to delay lazy loading during scrolling.\n     * @group Props\n     */\n    @Input({ transform: numberAttribute }) virtualScrollDelay: number = 250;\n    /**\n     * Width of the frozen columns container.\n     * @group Props\n     */\n    @Input() frozenWidth: string | undefined;\n    /**\n     * Defines if the table is responsive.\n     * @group Props\n     * @deprecated table is always responsive with scrollable behavior.\n     */\n    @Input() get responsive(): boolean | undefined | null {\n        return this._responsive;\n    }\n    set responsive(val: boolean | undefined | null) {\n        this._responsive = val;\n        console.warn('responsive property is deprecated as table is always responsive with scrollable behavior.');\n    }\n    _responsive: boolean | undefined | null;\n    /**\n     * Local ng-template varilable of a ContextMenu.\n     * @group Props\n     */\n    @Input() contextMenu: any;\n    /**\n     * When enabled, columns can be resized using drag and drop.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) resizableColumns: boolean | undefined;\n    /**\n     * Defines whether the overall table width should change on column resize, valid values are \"fit\" and \"expand\".\n     * @group Props\n     */\n    @Input() columnResizeMode: string = 'fit';\n    /**\n     * When enabled, columns can be reordered using drag and drop.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) reorderableColumns: boolean | undefined;\n    /**\n     * Displays a loader to indicate data load is in progress.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) loading: boolean | undefined;\n    /**\n     * The icon to show while indicating data load is in progress.\n     * @group Props\n     */\n    @Input() loadingIcon: string | undefined;\n    /**\n     * Whether to show the loading mask when loading property is true.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) showLoader: boolean = true;\n    /**\n     * Adds hover effect to rows without the need for selectionMode. Note that tr elements that can be hovered need to have \"cax-selectable-row\" class for rowHover to work.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) rowHover: boolean | undefined;\n    /**\n     * Whether to use the default sorting or a custom one using sortFunction.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) customSort: boolean | undefined;\n    /**\n     * Whether to use the initial sort badge or not.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) showInitialSortBadge: boolean = true;\n    /**\n     * Whether the cell widths scale according to their content or not.  Deprecated:  Table layout is always \"auto\".\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) autoLayout: boolean | undefined;\n    /**\n     * Export function.\n     * @group Props\n     */\n    @Input() exportFunction: Function | undefined;\n    /**\n     * Custom export header of the column to be exported as CSV.\n     * @group Props\n     */\n    @Input() exportHeader: string | undefined;\n    /**\n     * Unique identifier of a stateful table to use in state storage.\n     * @group Props\n     */\n    @Input() stateKey: string | undefined;\n    /**\n     * Defines where a stateful table keeps its state, valid values are \"session\" for sessionStorage and \"local\" for localStorage.\n     * @group Props\n     */\n    @Input() stateStorage: 'session' | 'local' = 'session';\n    /**\n     * Defines the editing mode, valid values are \"cell\" and \"row\".\n     * @group Props\n     */\n    @Input() editMode: 'cell' | 'row' = 'cell';\n    /**\n     * Field name to use in row grouping.\n     * @group Props\n     */\n    @Input() groupRowsBy: any;\n    /**\n     * Order to sort when default row grouping is enabled.\n     * @group Props\n     */\n    @Input({ transform: numberAttribute }) groupRowsByOrder: number = 1;\n    /**\n     * Defines the responsive mode, valid options are \"stack\" and \"scroll\".\n     * @group Props\n     */\n    @Input() responsiveLayout: string = 'scroll';\n    /**\n     * The breakpoint to define the maximum width boundary when using stack responsive layout.\n     * @group Props\n     */\n    @Input() breakpoint: string = '960px';\n    /**\n     * Locale to be used in paginator formatting.\n     * @group Props\n     */\n    @Input() paginatorLocale: string | undefined;\n    /**\n     * An array of objects to display.\n     * @group Props\n     */\n    @Input() get value(): any[] {\n        return this._value;\n    }\n    set value(val: any[]) {\n        this._value = val;\n    }\n    /**\n     * An array of objects to represent dynamic columns.\n     * @group Props\n     */\n    @Input() get columns(): any[] | undefined {\n        return this._columns;\n    }\n    set columns(cols: any[] | undefined) {\n        this._columns = cols;\n    }\n    /**\n     * Index of the first row to be displayed.\n     * @group Props\n     */\n    @Input() get first(): number | null | undefined {\n        return this._first;\n    }\n    set first(val: number | null | undefined) {\n        this._first = val;\n    }\n    /**\n     * Number of rows to display per page.\n     * @group Props\n     */\n    @Input() get rows(): number | undefined {\n        return this._rows;\n    }\n    set rows(val: number | undefined) {\n        this._rows = val;\n    }\n    /**\n     * Number of total records, defaults to length of value when not defined.\n     * @group Props\n     */\n    @Input() get totalRecords(): number {\n        return this._totalRecords;\n    }\n    set totalRecords(val: number) {\n        this._totalRecords = val;\n        this.tableService.onTotalRecordsChange(this._totalRecords);\n    }\n    /**\n     * Name of the field to sort data by default.\n     * @group Props\n     */\n    @Input() get sortField(): string | undefined | null {\n        return this._sortField;\n    }\n    set sortField(val: string | undefined | null) {\n        this._sortField = val;\n    }\n    /**\n     * Order to sort when default sorting is enabled.\n     * @group Props\n     */\n    @Input() get sortOrder(): number {\n        return this._sortOrder;\n    }\n    set sortOrder(val: number) {\n        this._sortOrder = val;\n    }\n    /**\n     * An array of SortMeta objects to sort the data by default in multiple sort mode.\n     * @group Props\n     */\n    @Input() get multiSortMeta(): SortMeta[] | undefined | null {\n        return this._multiSortMeta;\n    }\n    set multiSortMeta(val: SortMeta[] | undefined | null) {\n        this._multiSortMeta = val;\n    }\n    /**\n     * Selected row in single mode or an array of values in multiple mode.\n     * @group Props\n     */\n    @Input() get selection(): any {\n        return this._selection;\n    }\n    set selection(val: any) {\n        this._selection = val;\n    }\n    /**\n     * Whether all data is selected.\n     * @group Props\n     */\n    @Input() get selectAll(): boolean | null {\n        return this._selection;\n    }\n    set selectAll(val: boolean | null) {\n        this._selection = val;\n    }\n    /**\n     * Emits when the all of the items selected or unselected.\n     * @param {TableSelectAllChangeEvent} event - custom  all selection change event.\n     * @group Emits\n     */\n    @Output() selectAllChange: EventEmitter<TableSelectAllChangeEvent> = new EventEmitter<TableSelectAllChangeEvent>();\n    /**\n     * Callback to invoke on selection changed.\n     * @param {any | null} value - selected data.\n     * @group Emits\n     */\n    @Output() selectionChange: EventEmitter<any | null> = new EventEmitter<any | null>();\n    /**\n     * Callback to invoke when a row is selected.\n     * @param {TableRowSelectEvent} event - custom select event.\n     * @group Emits\n     */\n    @Output() onRowSelect: EventEmitter<TableRowSelectEvent> = new EventEmitter<TableRowSelectEvent>();\n    /**\n     * Callback to invoke when a row is unselected.\n     * @param {TableRowUnSelectEvent} event - custom unselect event.\n     * @group Emits\n     */\n    @Output() onRowUnselect: EventEmitter<TableRowUnSelectEvent> = new EventEmitter<TableRowUnSelectEvent>();\n    /**\n     * Callback to invoke when pagination occurs.\n     * @param {TablePageEvent} event - custom pagination event.\n     * @group Emits\n     */\n    @Output() onPage: EventEmitter<TablePageEvent> = new EventEmitter<TablePageEvent>();\n    /**\n     * Callback to invoke when a column gets sorted.\n     * @param {Object} object - sort meta.\n     * @group Emits\n     */\n    @Output() onSort: EventEmitter<{ multisortmeta: SortMeta[] } | any> = new EventEmitter<{ multisortmeta: SortMeta[] } | any>();\n    /**\n     * Callback to invoke when data is filtered.\n     * @param {TableFilterEvent} event - custom filtering event.\n     * @group Emits\n     */\n    @Output() onFilter: EventEmitter<TableFilterEvent> = new EventEmitter<TableFilterEvent>();\n    /**\n     * Callback to invoke when paging, sorting or filtering happens in lazy mode.\n     * @param {TableLazyLoadEvent} event - custom lazy loading event.\n     * @group Emits\n     */\n    @Output() onLazyLoad: EventEmitter<TableLazyLoadEvent> = new EventEmitter<TableLazyLoadEvent>();\n    /**\n     * Callback to invoke when a row is expanded.\n     * @param {TableRowExpandEvent} event - custom row expand event.\n     * @group Emits\n     */\n    @Output() onRowExpand: EventEmitter<TableRowExpandEvent> = new EventEmitter<TableRowExpandEvent>();\n    /**\n     * Callback to invoke when a row is collapsed.\n     * @param {TableRowCollapseEvent} event - custom row collapse event.\n     * @group Emits\n     */\n    @Output() onRowCollapse: EventEmitter<TableRowCollapseEvent> = new EventEmitter<TableRowCollapseEvent>();\n    /**\n     * Callback to invoke when a row is selected with right click.\n     * @param {TableContextMenuSelectEvent} event - custom context menu select event.\n     * @group Emits\n     */\n    @Output() onContextMenuSelect: EventEmitter<TableContextMenuSelectEvent> = new EventEmitter<TableContextMenuSelectEvent>();\n    /**\n     * Callback to invoke when a column is resized.\n     * @param {TableColResizeEvent} event - custom column resize event.\n     * @group Emits\n     */\n    @Output() onColResize: EventEmitter<TableColResizeEvent> = new EventEmitter<TableColResizeEvent>();\n    /**\n     * Callback to invoke when a column is reordered.\n     * @param {TableColumnReorderEvent} event - custom column reorder event.\n     * @group Emits\n     */\n    @Output() onColReorder: EventEmitter<TableColumnReorderEvent> = new EventEmitter<TableColumnReorderEvent>();\n    /**\n     * Callback to invoke when a row is reordered.\n     * @param {TableRowReorderEvent} event - custom row reorder event.\n     * @group Emits\n     */\n    @Output() onRowReorder: EventEmitter<TableRowReorderEvent> = new EventEmitter<TableRowReorderEvent>();\n    /**\n     * Callback to invoke when a cell switches to edit mode.\n     * @param {TableEditInitEvent} event - custom edit init event.\n     * @group Emits\n     */\n    @Output() onEditInit: EventEmitter<TableEditInitEvent> = new EventEmitter<TableEditInitEvent>();\n    /**\n     * Callback to invoke when cell edit is completed.\n     * @param {TableEditCompleteEvent} event - custom edit complete event.\n     * @group Emits\n     */\n    @Output() onEditComplete: EventEmitter<TableEditCompleteEvent> = new EventEmitter<TableEditCompleteEvent>();\n    /**\n     * Callback to invoke when cell edit is cancelled with escape key.\n     * @param {TableEditCancelEvent} event - custom edit cancel event.\n     * @group Emits\n     */\n    @Output() onEditCancel: EventEmitter<TableEditCancelEvent> = new EventEmitter<TableEditCancelEvent>();\n    /**\n     * Callback to invoke when state of header checkbox changes.\n     * @param {TableHeaderCheckboxToggleEvent} event - custom header checkbox event.\n     * @group Emits\n     */\n    @Output() onHeaderCheckboxToggle: EventEmitter<TableHeaderCheckboxToggleEvent> = new EventEmitter<TableHeaderCheckboxToggleEvent>();\n    /**\n     * A function to implement custom sorting, refer to sorting section for details.\n     * @param {any} any - sort meta.\n     * @group Emits\n     */\n    @Output() sortFunction: EventEmitter<any> = new EventEmitter<any>();\n    /**\n     * Callback to invoke on pagination.\n     * @param {number} number - first element.\n     * @group Emits\n     */\n    @Output() firstChange: EventEmitter<number> = new EventEmitter<number>();\n    /**\n     * Callback to invoke on rows change.\n     * @param {number} number - Row count.\n     * @group Emits\n     */\n    @Output() rowsChange: EventEmitter<number> = new EventEmitter<number>();\n    /**\n     * Callback to invoke table state is saved.\n     * @param {TableState} object - table state.\n     * @group Emits\n     */\n    @Output() onStateSave: EventEmitter<TableState> = new EventEmitter<TableState>();\n    /**\n     * Callback to invoke table state is restored.\n     * @param {TableState} object - table state.\n     * @group Emits\n     */\n    @Output() onStateRestore: EventEmitter<TableState> = new EventEmitter<TableState>();\n\n    @ViewChild('container') containerViewChild: Nullable<ElementRef>;\n\n    @ViewChild('resizeHelper') resizeHelperViewChild: Nullable<ElementRef>;\n\n    @ViewChild('reorderIndicatorUp') reorderIndicatorUpViewChild: Nullable<ElementRef>;\n\n    @ViewChild('reorderIndicatorDown') reorderIndicatorDownViewChild: Nullable<ElementRef>;\n\n    @ViewChild('wrapper') wrapperViewChild: Nullable<ElementRef>;\n\n    @ViewChild('table') tableViewChild: Nullable<ElementRef>;\n\n    @ViewChild('thead') tableHeaderViewChild: Nullable<ElementRef>;\n\n    @ViewChild('tfoot') tableFooterViewChild: Nullable<ElementRef>;\n\n    @ViewChild('scroller') scroller: Nullable<Scroller>;\n\n    @ContentChildren(CaxTemplate) templates: Nullable<QueryList<CaxTemplate>>;\n    /**\n     * Indicates the height of rows to be scrolled.\n     * @group Props\n     * @deprecated use virtualScrollItemSize property instead.\n     */\n    @Input() get virtualRowHeight(): number {\n        return this._virtualRowHeight;\n    }\n    set virtualRowHeight(val: number) {\n        this._virtualRowHeight = val;\n        console.warn('The virtualRowHeight property is deprecated.');\n    }\n    _virtualRowHeight: number = 28;\n\n    _value: any[] = [];\n\n    _columns: any[] | undefined;\n\n    _totalRecords: number = 0;\n\n    _first: number | null | undefined = 0;\n\n    _rows: number | undefined;\n\n    filteredValue: any[] | undefined | null;\n\n    headerTemplate: Nullable<TemplateRef<any>>;\n\n    headerGroupedTemplate: Nullable<TemplateRef<any>>;\n\n    bodyTemplate: Nullable<TemplateRef<any>>;\n\n    loadingBodyTemplate: Nullable<TemplateRef<any>>;\n\n    captionTemplate: Nullable<TemplateRef<any>>;\n\n    footerTemplate: Nullable<TemplateRef<any>>;\n\n    footerGroupedTemplate: Nullable<TemplateRef<any>>;\n\n    summaryTemplate: Nullable<TemplateRef<any>>;\n\n    colGroupTemplate: Nullable<TemplateRef<any>>;\n\n    expandedRowTemplate: Nullable<TemplateRef<any>>;\n\n    groupHeaderTemplate: Nullable<TemplateRef<any>>;\n\n    groupFooterTemplate: Nullable<TemplateRef<any>>;\n\n    frozenExpandedRowTemplate: Nullable<TemplateRef<any>>;\n\n    frozenHeaderTemplate: Nullable<TemplateRef<any>>;\n\n    frozenBodyTemplate: Nullable<TemplateRef<any>>;\n\n    frozenFooterTemplate: Nullable<TemplateRef<any>>;\n\n    frozenColGroupTemplate: Nullable<TemplateRef<any>>;\n\n    emptyMessageTemplate: Nullable<TemplateRef<any>>;\n\n    paginatorLeftTemplate: Nullable<TemplateRef<any>>;\n\n    paginatorRightTemplate: Nullable<TemplateRef<any>>;\n\n    paginatorDropdownItemTemplate: Nullable<TemplateRef<any>>;\n\n    loadingIconTemplate: Nullable<TemplateRef<any>>;\n\n    reorderIndicatorUpIconTemplate: Nullable<TemplateRef<any>>;\n\n    reorderIndicatorDownIconTemplate: Nullable<TemplateRef<any>>;\n\n    sortIconTemplate: Nullable<TemplateRef<any>>;\n\n    checkboxIconTemplate: Nullable<TemplateRef<any>>;\n\n    headerCheckboxIconTemplate: Nullable<TemplateRef<any>>;\n\n    paginatorDropdownIconTemplate: Nullable<TemplateRef<any>>;\n\n    paginatorFirstPageLinkIconTemplate: Nullable<TemplateRef<any>>;\n\n    paginatorLastPageLinkIconTemplate: Nullable<TemplateRef<any>>;\n\n    paginatorPreviousPageLinkIconTemplate: Nullable<TemplateRef<any>>;\n\n    paginatorNextPageLinkIconTemplate: Nullable<TemplateRef<any>>;\n\n    selectionKeys: any = {};\n\n    lastResizerHelperX: number | undefined;\n\n    reorderIconWidth: number | undefined;\n\n    reorderIconHeight: number | undefined;\n\n    draggedColumn: any;\n\n    draggedRowIndex: number | undefined | null;\n\n    droppedRowIndex: number | undefined | null;\n\n    rowDragging: boolean | undefined | null;\n\n    dropPosition: number | undefined | null;\n\n    editingCell: Element | undefined | null;\n\n    editingCellData: any;\n\n    editingCellField: any;\n\n    editingCellRowIndex: number | undefined | null;\n\n    selfClick: boolean | undefined | null;\n\n    documentEditListener: any;\n\n    _multiSortMeta: SortMeta[] | undefined | null;\n\n    _sortField: string | undefined | null;\n\n    _sortOrder: number = 1;\n\n    preventSelectionSetterPropagation: boolean | undefined;\n\n    _selection: any;\n\n    _selectAll: boolean | null = null;\n\n    anchorRowIndex: number | undefined | null;\n\n    rangeRowIndex: number | undefined;\n\n    filterTimeout: any;\n\n    initialized: boolean | undefined | null;\n\n    rowTouched: boolean | undefined;\n\n    restoringSort: boolean | undefined;\n\n    restoringFilter: boolean | undefined;\n\n    stateRestored: boolean | undefined;\n\n    columnOrderStateRestored: boolean | undefined;\n\n    columnWidthsState: string | undefined;\n\n    tableWidthState: string | undefined;\n\n    overlaySubscription: Subscription | undefined;\n\n    resizeColumnElement: any;\n\n    columnResizing: boolean = false;\n\n    rowGroupHeaderStyleObject: any = {};\n\n    id: string = UniqueComponentId();\n\n    styleElement: any;\n\n    responsiveStyleElement: any;\n\n    private window: Window;\n\n    constructor(\n        @Inject(DOCUMENT) private document: Document,\n        @Inject(PLATFORM_ID) private platformId: any,\n        private renderer: Renderer2,\n        public el: ElementRef,\n        public zone: NgZone,\n        public tableService: TableService,\n        public cd: ChangeDetectorRef,\n        public filterService: FilterService,\n        public overlayService: OverlayService,\n        public config: caxConfig,\n        private readonly domSanitizer: DomSanitizer\n    ) {\n        this.window = this.document.defaultView as Window;\n    }\n\n    ngOnInit() {\n        if (this.lazy && this.lazyLoadOnInit) {\n            if (!this.virtualScroll) {\n                this.onLazyLoad.emit(this.createLazyLoadMetadata());\n            }\n\n            if (this.restoringFilter) {\n                this.restoringFilter = false;\n            }\n        }\n\n        if (this.responsiveLayout === 'stack') {\n            this.createResponsiveStyle();\n        }\n\n        this.initialized = true;\n    }\n\n    ngAfterContentInit() {\n        (this.templates as QueryList<CaxTemplate>).forEach((item) => {\n            switch (item.getType()) {\n                case 'caption':\n                    this.captionTemplate = item.template;\n                    break;\n\n                case 'header':\n                    this.headerTemplate = item.template;\n                    break;\n\n                case 'headergrouped':\n                    this.headerGroupedTemplate = item.template;\n                    break;\n\n                case 'body':\n                    this.bodyTemplate = item.template;\n                    break;\n\n                case 'loadingbody':\n                    this.loadingBodyTemplate = item.template;\n                    break;\n\n                case 'footer':\n                    this.footerTemplate = item.template;\n                    break;\n\n                case 'footergrouped':\n                    this.footerGroupedTemplate = item.template;\n                    break;\n\n                case 'summary':\n                    this.summaryTemplate = item.template;\n                    break;\n\n                case 'colgroup':\n                    this.colGroupTemplate = item.template;\n                    break;\n\n                case 'rowexpansion':\n                    this.expandedRowTemplate = item.template;\n                    break;\n\n                case 'groupheader':\n                    this.groupHeaderTemplate = item.template;\n                    break;\n\n                case 'groupfooter':\n                    this.groupFooterTemplate = item.template;\n                    break;\n\n                case 'frozenheader':\n                    this.frozenHeaderTemplate = item.template;\n                    break;\n\n                case 'frozenbody':\n                    this.frozenBodyTemplate = item.template;\n                    break;\n\n                case 'frozenfooter':\n                    this.frozenFooterTemplate = item.template;\n                    break;\n\n                case 'frozencolgroup':\n                    this.frozenColGroupTemplate = item.template;\n                    break;\n\n                case 'frozenrowexpansion':\n                    this.frozenExpandedRowTemplate = item.template;\n                    break;\n\n                case 'emptymessage':\n                    this.emptyMessageTemplate = item.template;\n                    break;\n\n                case 'paginatorleft':\n                    this.paginatorLeftTemplate = item.template;\n                    break;\n\n                case 'paginatorright':\n                    this.paginatorRightTemplate = item.template;\n                    break;\n\n                case 'paginatordropdownicon':\n                    this.paginatorDropdownIconTemplate = item.template;\n                    break;\n\n                case 'paginatordropdownitem':\n                    this.paginatorDropdownItemTemplate = item.template;\n                    break;\n\n                case 'paginatorfirstpagelinkicon':\n                    this.paginatorFirstPageLinkIconTemplate = item.template;\n                    break;\n\n                case 'paginatorlastpagelinkicon':\n                    this.paginatorLastPageLinkIconTemplate = item.template;\n                    break;\n\n                case 'paginatorpreviouspagelinkicon':\n                    this.paginatorPreviousPageLinkIconTemplate = item.template;\n                    break;\n\n                case 'paginatornextpagelinkicon':\n                    this.paginatorNextPageLinkIconTemplate = item.template;\n                    break;\n\n                case 'loadingicon':\n                    this.loadingIconTemplate = item.template;\n                    break;\n\n                case 'reorderindicatorupicon':\n                    this.reorderIndicatorUpIconTemplate = item.template;\n                    break;\n\n                case 'reorderindicatordownicon':\n                    this.reorderIndicatorDownIconTemplate = item.template;\n                    break;\n\n                case 'sorticon':\n                    this.sortIconTemplate = item.template;\n                    break;\n\n                case 'checkboxicon':\n                    this.checkboxIconTemplate = item.template;\n                    break;\n\n                case 'headercheckboxicon':\n                    this.headerCheckboxIconTemplate = item.template;\n                    break;\n            }\n        });\n    }\n\n    ngAfterViewInit() {\n        if (isPlatformBrowser(this.platformId)) {\n            if (this.isStateful() && this.resizableColumns) {\n                this.restoreColumnWidths();\n            }\n        }\n    }\n\n    ngOnChanges(simpleChange: SimpleChanges) {\n        if (simpleChange.value) {\n            if (this.isStateful() && !this.stateRestored && isPlatformBrowser(this.platformId)) {\n                this.restoreState();\n            }\n\n            this._value = simpleChange.value.currentValue;\n\n            if (!this.lazy) {\n                this.totalRecords = this._value ? this._value.length : 0;\n\n                if (this.sortMode == 'single' && (this.sortField || this.groupRowsBy)) this.sortSingle();\n                else if (this.sortMode == 'multiple' && (this.multiSortMeta || this.groupRowsBy)) this.sortMultiple();\n                else if (this.hasFilter())\n                    //sort already filters\n                    this._filter();\n            }\n\n            this.tableService.onValueChange(simpleChange.value.currentValue);\n        }\n\n        if (simpleChange.columns) {\n            if (!this.isStateful()) {\n                this._columns = simpleChange.columns.currentValue;\n                this.tableService.onColumnsChange(simpleChange.columns.currentValue);\n            }\n\n            if (this._columns && this.isStateful() && this.reorderableColumns && !this.columnOrderStateRestored) {\n                this.restoreColumnOrder();\n\n                this.tableService.onColumnsChange(this._columns);\n            }\n        }\n\n        if (simpleChange.sortField) {\n            this._sortField = simpleChange.sortField.currentValue;\n\n            //avoid triggering lazy load prior to lazy initialization at onInit\n            if (!this.lazy || this.initialized) {\n                if (this.sortMode === 'single') {\n                    this.sortSingle();\n                }\n            }\n        }\n\n        if (simpleChange.groupRowsBy) {\n            //avoid triggering lazy load prior to lazy initialization at onInit\n            if (!this.lazy || this.initialized) {\n                if (this.sortMode === 'single') {\n                    this.sortSingle();\n                }\n            }\n        }\n\n        if (simpleChange.sortOrder) {\n            this._sortOrder = simpleChange.sortOrder.currentValue;\n\n            //avoid triggering lazy load prior to lazy initialization at onInit\n            if (!this.lazy || this.initialized) {\n                if (this.sortMode === 'single') {\n                    this.sortSingle();\n                }\n            }\n        }\n\n        if (simpleChange.groupRowsByOrder) {\n            //avoid triggering lazy load prior to lazy initialization at onInit\n            if (!this.lazy || this.initialized) {\n                if (this.sortMode === 'single') {\n                    this.sortSingle();\n                }\n            }\n        }\n\n        if (simpleChange.multiSortMeta) {\n            this._multiSortMeta = simpleChange.multiSortMeta.currentValue;\n            if (this.sortMode === 'multiple' && (this.initialized || (!this.lazy && !this.virtualScroll))) {\n                this.sortMultiple();\n            }\n        }\n\n        if (simpleChange.selection) {\n            this._selection = simpleChange.selection.currentValue;\n\n            if (!this.preventSelectionSetterPropagation) {\n                this.updateSelectionKeys();\n                this.tableService.onSelectionChange();\n            }\n            this.preventSelectionSetterPropagation = false;\n        }\n\n        if (simpleChange.selectAll) {\n            this._selectAll = simpleChange.selectAll.currentValue;\n\n            if (!this.preventSelectionSetterPropagation) {\n                this.updateSelectionKeys();\n                this.tableService.onSelectionChange();\n\n                if (this.isStateful()) {\n                    this.saveState();\n                }\n            }\n            this.preventSelectionSetterPropagation = false;\n        }\n    }\n\n    get processedData() {\n        return this.filteredValue || this.value || [];\n    }\n\n    private _initialColWidths: number[];\n\n    dataToRender(data: any) {\n        const _data = data || this.processedData;\n\n        if (_data && this.paginator) {\n            const first = this.lazy ? 0 : this.first;\n            return _data.slice(first, <number>first + <number>this.rows);\n        }\n\n        return _data;\n    }\n\n    updateSelectionKeys() {\n        if (this.dataKey && this._selection) {\n            this.selectionKeys = {};\n            if (Array.isArray(this._selection)) {\n                for (let data of this._selection) {\n                    this.selectionKeys[String(ObjectUtils.resolveFieldData(data, this.dataKey))] = 1;\n                }\n            } else {\n                this.selectionKeys[String(ObjectUtils.resolveFieldData(this._selection, this.dataKey))] = 1;\n            }\n        }\n    }\n\n    onPageChange(event: TablePageEvent) {\n        this.first = event.first;\n        this.rows = event.rows;\n\n        this.onPage.emit({\n            first: this.first,\n            rows: <number>this.rows\n        });\n\n        if (this.lazy) {\n            this.onLazyLoad.emit(this.createLazyLoadMetadata());\n        }\n\n        this.firstChange.emit(this.first);\n        this.rowsChange.emit(this.rows);\n        this.tableService.onValueChange(this.value);\n\n        if (this.isStateful()) {\n            this.saveState();\n        }\n\n        this.anchorRowIndex = null;\n\n        if (this.scrollable) {\n            this.resetScrollTop();\n        }\n    }\n\n    nextSortOrder = (current: number): number => {\n        switch (current) {\n            case 0:\n                return 1;\n            case 1:\n                return -1;\n            case -1:\n                return 0;\n            default:\n                return 1; // fallback to default if somehow invalid\n        }\n    };\n\n    sort(event: any) {\n        let originalEvent = event.originalEvent;\n\n        if (this.sortMode === 'single') {\n            if (this.sortType === 'custom') {\n                this._sortOrder = this.sortField === event.field ? this.nextSortOrder(this._sortOrder) : this.defaultSortOrder;\n            } else {\n                this._sortOrder = this.sortField === event.field ? this.sortOrder * -1 : this.defaultSortOrder;\n            }\n            this._sortField = event.field;\n\n            if (this.resetPageOnSort) {\n                this._first = 0;\n                this.firstChange.emit(this._first);\n\n                if (this.scrollable) {\n                    this.resetScrollTop();\n                }\n            }\n\n            this.sortSingle();\n        }\n        if (this.sortMode === 'multiple') {\n            let metaKey = (<KeyboardEvent>originalEvent).metaKey || (<KeyboardEvent>originalEvent).ctrlKey;\n            let sortMeta = this.getSortMeta(<string>event.field);\n\n            if (sortMeta) {\n                if (!metaKey) {\n                    if (this.sortType === 'custom') {\n                        this._multiSortMeta = [{ field: <string>event.field, order: this.nextSortOrder(sortMeta.order) }];\n                    } else {\n                        this._multiSortMeta = [{ field: <string>event.field, order: sortMeta.order * -1 }];\n                    }\n\n                    if (this.resetPageOnSort) {\n                        this._first = 0;\n                        this.firstChange.emit(this._first);\n\n                        if (this.scrollable) {\n                            this.resetScrollTop();\n                        }\n                    }\n                } else {\n                    if (this.sortType === 'custom') {\n                        sortMeta.order = this.nextSortOrder(sortMeta.order);\n                    } else {\n                        sortMeta.order = sortMeta.order * -1;\n                    }\n                }\n            } else {\n                if (!metaKey || !this.multiSortMeta) {\n                    this._multiSortMeta = [];\n\n                    if (this.resetPageOnSort) {\n                        this._first = 0;\n                        this.firstChange.emit(this._first);\n                    }\n                }\n                (<SortMeta[]>this._multiSortMeta).push({ field: <string>event.field, order: this.defaultSortOrder });\n            }\n\n            this._multiSortMeta = this._multiSortMeta.filter((item) => item.order !== 0);\n\n            this.sortMultiple();\n        }\n\n        if (this.isStateful()) {\n            this.saveState();\n        }\n\n        this.anchorRowIndex = null;\n    }\n\n    sortSingle() {\n        let field = this.sortField || this.groupRowsBy;\n        let order = this.sortField ? this.sortOrder : this.groupRowsByOrder;\n        if (this.groupRowsBy && this.sortField && this.groupRowsBy !== this.sortField) {\n            this._multiSortMeta = [this.getGroupRowsMeta(), { field: this.sortField, order: this.sortOrder }];\n            this.sortMultiple();\n            return;\n        }\n\n        if (this.sortType === 'custom') {\n            let sortMeta: SortMeta = {\n                field: field,\n                order: order\n            };\n\n            this.onSort.emit(sortMeta);\n            this.tableService.onSort(sortMeta);\n        } else {\n            if (field && order) {\n                if (this.restoringSort) {\n                    this.restoringSort = false;\n                }\n\n                if (this.lazy) {\n                    this.onLazyLoad.emit(this.createLazyLoadMetadata());\n                } else if (this.value) {\n                    if (this.customSort) {\n                        this.sortFunction.emit({\n                            data: this.value,\n                            mode: this.sortMode,\n                            field: field,\n                            order: order\n                        });\n                    } else {\n                        this.value.sort((data1, data2) => {\n                            let value1 = ObjectUtils.resolveFieldData(data1, field);\n                            let value2 = ObjectUtils.resolveFieldData(data2, field);\n                            let result = null;\n\n                            if (value1 == null && value2 != null) result = -1;\n                            else if (value1 != null && value2 == null) result = 1;\n                            else if (value1 == null && value2 == null) result = 0;\n                            else if (typeof value1 === 'string' && typeof value2 === 'string') result = value1.localeCompare(value2);\n                            else result = value1 < value2 ? -1 : value1 > value2 ? 1 : 0;\n\n                            return order * result;\n                        });\n\n                        this._value = [...this.value];\n                    }\n\n                    if (this.hasFilter()) {\n                        this._filter();\n                    }\n                }\n\n                let sortMeta: SortMeta = {\n                    field: field,\n                    order: order\n                };\n\n                this.onSort.emit(sortMeta);\n                this.tableService.onSort(sortMeta);\n            }\n        }\n    }\n\n    sortMultiple() {\n        if (this.groupRowsBy) {\n            if (!this._multiSortMeta) this._multiSortMeta = [this.getGroupRowsMeta()];\n            else if ((<SortMeta[]>this.multiSortMeta)[0].field !== this.groupRowsBy) this._multiSortMeta = [this.getGroupRowsMeta(), ...this._multiSortMeta];\n        }\n\n        if (this.sortType === 'custom') {\n            this.onSort.emit({\n                multisortmeta: <SortMeta[]>this.multiSortMeta\n            });\n            this.tableService.onSort(this.multiSortMeta);\n        } else {\n            if (this.multiSortMeta) {\n                if (this.lazy) {\n                    this.onLazyLoad.emit(this.createLazyLoadMetadata());\n                } else if (this.value) {\n                    if (this.customSort) {\n                        this.sortFunction.emit({\n                            data: this.value,\n                            mode: this.sortMode,\n                            multiSortMeta: this.multiSortMeta\n                        });\n                    } else {\n                        this.value.sort((data1, data2) => {\n                            return this.multisortField(data1, data2, <SortMeta[]>this.multiSortMeta, 0);\n                        });\n\n                        this._value = [...this.value];\n                    }\n\n                    if (this.hasFilter()) {\n                        this._filter();\n                    }\n                }\n\n                this.onSort.emit({\n                    multisortmeta: <SortMeta[]>this.multiSortMeta\n                });\n                this.tableService.onSort(this.multiSortMeta);\n            }\n        }\n    }\n\n    multisortField(data1: any, data2: any, multiSortMeta: SortMeta[], index: number): any {\n        const value1 = ObjectUtils.resolveFieldData(data1, multiSortMeta[index].field);\n        const value2 = ObjectUtils.resolveFieldData(data2, multiSortMeta[index].field);\n        if (ObjectUtils.compare(value1, value2, this.filterLocale) === 0) {\n            return multiSortMeta.length - 1 > index ? this.multisortField(data1, data2, multiSortMeta, index + 1) : 0;\n        }\n        return this.compareValuesOnSort(value1, value2, multiSortMeta[index].order);\n    }\n\n    compareValuesOnSort(value1: any, value2: any, order: any) {\n        return ObjectUtils.sort(value1, value2, order, this.filterLocale, this.sortOrder);\n    }\n\n    getSortMeta(field: string) {\n        if (this.multiSortMeta && this.multiSortMeta.length) {\n            for (let i = 0; i < this.multiSortMeta.length; i++) {\n                if (this.multiSortMeta[i].field === field) {\n                    return this.multiSortMeta[i];\n                }\n            }\n        }\n\n        return null;\n    }\n\n    isSorted(field: string) {\n        if (this.sortMode === 'single') {\n            return this.sortField && this.sortField === field;\n        } else if (this.sortMode === 'multiple') {\n            let sorted = false;\n            if (this.multiSortMeta) {\n                for (let i = 0; i < this.multiSortMeta.length; i++) {\n                    if (this.multiSortMeta[i].field == field) {\n                        sorted = true;\n                        break;\n                    }\n                }\n            }\n            return sorted;\n        } else if (this.sortMode === 'custom') {\n            return this.sortField && this.sortField === field;\n        }\n    }\n\n    handleRowClick(event: any) {\n        let target = <HTMLElement>event.originalEvent.target;\n        let targetNode = target.nodeName;\n        let parentNode = target.parentElement && target.parentElement.nodeName;\n        if (targetNode == 'INPUT' || targetNode == 'BUTTON' || targetNode == 'A' || parentNode == 'INPUT' || parentNode == 'BUTTON' || parentNode == 'A' || DomHandler.hasClass(event.originalEvent.target, 'cax-clickable')) {\n            return;\n        }\n\n        if (this.selectionMode) {\n            let rowData = event.rowData;\n            let rowIndex = event.rowIndex;\n\n            this.preventSelectionSetterPropagation = true;\n            if (this.isMultipleSelectionMode() && event.originalEvent.shiftKey && this.anchorRowIndex != null) {\n                DomHandler.clearSelection();\n                if (this.rangeRowIndex != null) {\n                    this.clearSelectionRange(event.originalEvent);\n                }\n\n                this.rangeRowIndex = rowIndex;\n                this.selectRange(event.originalEvent, rowIndex);\n            } else {\n                let selected = this.isSelected(rowData);\n\n                if (!selected && !this.isRowSelectable(rowData, rowIndex)) {\n                    return;\n                }\n\n                let metaSelection = this.rowTouched ? false : this.metaKeySelection;\n                let dataKeyValue = this.dataKey ? String(ObjectUtils.resolveFieldData(rowData, this.dataKey)) : null;\n                this.anchorRowIndex = rowIndex;\n                this.rangeRowIndex = rowIndex;\n\n                if (metaSelection) {\n                    let metaKey = event.originalEvent.metaKey || event.originalEvent.ctrlKey;\n\n                    if (selected && metaKey) {\n                        if (this.isSingleSelectionMode()) {\n                            this._selection = null;\n                            this.selectionKeys = {};\n                            this.selectionChange.emit(null);\n                        } else {\n                            let selectionIndex = this.findIndexInSelection(rowData);\n                            this._selection = this.selection.filter((val: any, i: number) => i != selectionIndex);\n                            this.selectionChange.emit(this.selection);\n                            if (dataKeyValue) {\n                                delete this.selectionKeys[dataKeyValue];\n                            }\n                        }\n\n                        this.onRowUnselect.emit({ originalEvent: event.originalEvent, data: rowData, type: 'row' });\n                    } else {\n                        if (this.isSingleSelectionMode()) {\n                            this._selection = rowData;\n                            this.selectionChange.emit(rowData);\n                            if (dataKeyValue) {\n                                this.selectionKeys = {};\n                                this.selectionKeys[dataKeyValue] = 1;\n                            }\n                        } else if (this.isMultipleSelectionMode()) {\n                            if (metaKey) {\n                                this._selection = this.selection || [];\n                            } else {\n                                this._selection = [];\n                                this.selectionKeys = {};\n                            }\n\n                            this._selection = [...this.selection, rowData];\n                            this.selectionChange.emit(this.selection);\n                            if (dataKeyValue) {\n                                this.selectionKeys[dataKeyValue] = 1;\n                            }\n                        }\n\n                        this.onRowSelect.emit({ originalEvent: event.originalEvent, data: rowData, type: 'row', index: rowIndex });\n                    }\n                } else {\n                    if (this.selectionMode === 'single') {\n                        if (selected) {\n                            this._selection = null;\n                            this.selectionKeys = {};\n                            this.selectionChange.emit(this.selection);\n                            this.onRowUnselect.emit({ originalEvent: event.originalEvent, data: rowData, type: 'row', index: rowIndex });\n                        } else {\n                            this._selection = rowData;\n                            this.selectionChange.emit(this.selection);\n                            this.onRowSelect.emit({ originalEvent: event.originalEvent, data: rowData, type: 'row', index: rowIndex });\n                            if (dataKeyValue) {\n                                this.selectionKeys = {};\n                                this.selectionKeys[dataKeyValue] = 1;\n                            }\n                        }\n                    } else if (this.selectionMode === 'multiple') {\n                        if (selected) {\n                            let selectionIndex = this.findIndexInSelection(rowData);\n                            this._selection = this.selection.filter((val: any, i: number) => i != selectionIndex);\n                            this.selectionChange.emit(this.selection);\n                            this.onRowUnselect.emit({ originalEvent: event.originalEvent, data: rowData, type: 'row', index: rowIndex });\n                            if (dataKeyValue) {\n                                delete this.selectionKeys[dataKeyValue];\n                            }\n                        } else {\n                            this._selection = this.selection ? [...this.selection, rowData] : [rowData];\n                            this.selectionChange.emit(this.selection);\n                            this.onRowSelect.emit({ originalEvent: event.originalEvent, data: rowData, type: 'row', index: rowIndex });\n                            if (dataKeyValue) {\n                                this.selectionKeys[dataKeyValue] = 1;\n                            }\n                        }\n                    }\n                }\n            }\n\n            this.tableService.onSelectionChange();\n\n            if (this.isStateful()) {\n                this.saveState();\n            }\n        }\n\n        this.rowTouched = false;\n    }\n\n    handleRowTouchEnd(event: Event) {\n        this.rowTouched = true;\n    }\n\n    handleRowRightClick(event: any) {\n        if (this.contextMenu) {\n            const rowData = event.rowData;\n            const rowIndex = event.rowIndex;\n\n            if (this.contextMenuSelectionMode === 'separate') {\n                this.contextMenuSelection = rowData;\n                this.contextMenuSelectionChange.emit(rowData);\n                this.onContextMenuSelect.emit({ originalEvent: event.originalEvent, data: rowData, index: event.rowIndex });\n                this.contextMenu.show(event.originalEvent);\n                this.tableService.onContextMenu(rowData);\n            } else if (this.contextMenuSelectionMode === 'joint') {\n                this.preventSelectionSetterPropagation = true;\n                let selected = this.isSelected(rowData);\n                let dataKeyValue = this.dataKey ? String(ObjectUtils.resolveFieldData(rowData, this.dataKey)) : null;\n\n                if (!selected) {\n                    if (!this.isRowSelectable(rowData, rowIndex)) {\n                        return;\n                    }\n\n                    if (this.isSingleSelectionMode()) {\n                        this.selection = rowData;\n                        this.selectionChange.emit(rowData);\n\n                        if (dataKeyValue) {\n                            this.selectionKeys = {};\n                            this.selectionKeys[dataKeyValue] = 1;\n                        }\n                    } else if (this.isMultipleSelectionMode()) {\n                        this._selection = this.selection ? [...this.selection, rowData] : [rowData];\n                        this.selectionChange.emit(this.selection);\n\n                        if (dataKeyValue) {\n                            this.selectionKeys[dataKeyValue] = 1;\n                        }\n                    }\n                }\n\n                this.tableService.onSelectionChange();\n                this.contextMenu.show(event.originalEvent);\n                this.onContextMenuSelect.emit({ originalEvent: event, data: rowData, index: event.rowIndex });\n            }\n        }\n    }\n\n    selectRange(event: MouseEvent | KeyboardEvent, rowIndex: number, isMetaKeySelection?: boolean | undefined) {\n        let rangeStart, rangeEnd;\n\n        if (<number>this.anchorRowIndex > rowIndex) {\n            rangeStart = rowIndex;\n            rangeEnd = this.anchorRowIndex;\n        } else if (<number>this.anchorRowIndex < rowIndex) {\n            rangeStart = this.anchorRowIndex;\n            rangeEnd = rowIndex;\n        } else {\n            rangeStart = rowIndex;\n            rangeEnd = rowIndex;\n        }\n\n        if (this.lazy && this.paginator) {\n            (rangeStart as number) -= <number>this.first;\n            (rangeEnd as number) -= <number>this.first;\n        }\n\n        let rangeRowsData = [];\n        for (let i = <number>rangeStart; i <= <number>rangeEnd; i++) {\n            let rangeRowData = this.filteredValue ? this.filteredValue[i] : this.value[i];\n            if (!this.isSelected(rangeRowData) && !isMetaKeySelection) {\n                if (!this.isRowSelectable(rangeRowData, rowIndex)) {\n                    continue;\n                }\n\n                rangeRowsData.push(rangeRowData);\n                this._selection = [...this.selection, rangeRowData];\n                let dataKeyValue = this.dataKey ? String(ObjectUtils.resolveFieldData(rangeRowData, this.dataKey)) : null;\n                if (dataKeyValue) {\n                    this.selectionKeys[dataKeyValue] = 1;\n                }\n            }\n        }\n        this.selectionChange.emit(this.selection);\n        this.onRowSelect.emit({ originalEvent: event, data: rangeRowsData, type: 'row' });\n    }\n\n    clearSelectionRange(event: MouseEvent | KeyboardEvent) {\n        let rangeStart, rangeEnd;\n        let rangeRowIndex = <number>this.rangeRowIndex;\n        let anchorRowIndex = <number>this.anchorRowIndex;\n\n        if (rangeRowIndex > anchorRowIndex) {\n            rangeStart = this.anchorRowIndex;\n            rangeEnd = this.rangeRowIndex;\n        } else if (rangeRowIndex < anchorRowIndex) {\n            rangeStart = this.rangeRowIndex;\n            rangeEnd = this.anchorRowIndex;\n        } else {\n            rangeStart = this.rangeRowIndex;\n            rangeEnd = this.rangeRowIndex;\n        }\n\n        for (let i = <number>rangeStart; i <= <number>rangeEnd; i++) {\n            let rangeRowData = this.value[i];\n            let selectionIndex = this.findIndexInSelection(rangeRowData);\n            this._selection = this.selection.filter((val: any, i: number) => i != selectionIndex);\n            let dataKeyValue = this.dataKey ? String(ObjectUtils.resolveFieldData(rangeRowData, this.dataKey)) : null;\n            if (dataKeyValue) {\n                delete this.selectionKeys[dataKeyValue];\n            }\n            this.onRowUnselect.emit({ originalEvent: event, data: rangeRowData, type: 'row' });\n        }\n    }\n\n    isSelected(rowData: any) {\n        if (rowData && this.selection) {\n            if (this.dataKey) {\n                return this.selectionKeys[ObjectUtils.resolveFieldData(rowData, this.dataKey)] !== undefined;\n            } else {\n                if (Array.isArray(this.selection)) return this.findIndexInSelection(rowData) > -1;\n                else return this.equals(rowData, this.selection);\n            }\n        }\n\n        return false;\n    }\n\n    findIndexInSelection(rowData: any) {\n        let index: number = -1;\n        if (this.selection && this.selection.length) {\n            for (let i = 0; i < this.selection.length; i++) {\n                if (this.equals(rowData, this.selection[i])) {\n                    index = i;\n                    break;\n                }\n            }\n        }\n\n        return index;\n    }\n\n    isRowSelectable(data: any, index: number) {\n        if (this.rowSelectable && !this.rowSelectable({ data, index })) {\n            return false;\n        }\n\n        return true;\n    }\n\n    toggleRowWithRadio(event: any, rowData: any) {\n        this.preventSelectionSetterPropagation = true;\n\n        if (this.selection != rowData) {\n            if (!this.isRowSelectable(rowData, event.rowIndex)) {\n                return;\n            }\n\n            this._selection = rowData;\n            this.selectionChange.emit(this.selection);\n            this.onRowSelect.emit({ originalEvent: event.originalEvent, index: event.rowIndex, data: rowData, type: 'radiobutton' });\n\n            if (this.dataKey) {\n                this.selectionKeys = {};\n                this.selectionKeys[String(ObjectUtils.resolveFieldData(rowData, this.dataKey))] = 1;\n            }\n        } else {\n            this._selection = null;\n            this.selectionChange.emit(this.selection);\n            this.onRowUnselect.emit({ originalEvent: event.originalEvent, index: event.rowIndex, data: rowData, type: 'radiobutton' });\n        }\n\n        this.tableService.onSelectionChange();\n\n        if (this.isStateful()) {\n            this.saveState();\n        }\n    }\n\n    toggleRowWithCheckbox(event: any, rowData: any) {\n        this.selection = this.selection || [];\n        let selected = this.isSelected(rowData);\n        let dataKeyValue = this.dataKey ? String(ObjectUtils.resolveFieldData(rowData, this.dataKey)) : null;\n        this.preventSelectionSetterPropagation = true;\n\n        if (selected) {\n            let selectionIndex = this.findIndexInSelection(rowData);\n            this._selection = this.selection.filter((val: any, i: number) => i != selectionIndex);\n            this.selectionChange.emit(this.selection);\n            this.onRowUnselect.emit({ originalEvent: event.originalEvent, index: event.rowIndex, data: rowData, type: 'checkbox' });\n            if (dataKeyValue) {\n                delete this.selectionKeys[dataKeyValue];\n            }\n        } else {\n            if (!this.isRowSelectable(rowData, event.rowIndex)) {\n                return;\n            }\n\n            this._selection = this.selection ? [...this.selection, rowData] : [rowData];\n            this.selectionChange.emit(this.selection);\n            this.onRowSelect.emit({ originalEvent: event.originalEvent, index: event.rowIndex, data: rowData, type: 'checkbox' });\n            if (dataKeyValue) {\n                this.selectionKeys[dataKeyValue] = 1;\n            }\n        }\n\n        this.tableService.onSelectionChange();\n\n        if (this.isStateful()) {\n            this.saveState();\n        }\n    }\n\n    toggleRowsWithCheckbox(event: Event, check: boolean) {\n        if (this._selectAll !== null) {\n            this.selectAllChange.emit({ originalEvent: event, checked: check });\n        } else {\n            const data = this.selectionPageOnly ? this.dataToRender(this.processedData) : this.processedData;\n            let selection = this.selectionPageOnly && this._selection ? this._selection.filter((s: any) => !data.some((d: any) => this.equals(s, d))) : [];\n\n            if (check) {\n                selection = this.frozenValue ? [...selection, ...this.frozenValue, ...data] : [...selection, ...data];\n                selection = this.rowSelectable ? selection.filter((data: any, index: number) => this.rowSelectable({ data, index })) : selection;\n            }\n\n            this._selection = selection;\n            this.preventSelectionSetterPropagation = true;\n            this.updateSelectionKeys();\n            this.selectionChange.emit(this._selection);\n            this.tableService.onSelectionChange();\n            this.onHeaderCheckboxToggle.emit({ originalEvent: event, checked: check });\n\n            if (this.isStateful()) {\n                this.saveState();\n            }\n        }\n    }\n\n    equals(data1: any, data2: any) {\n        return this.compareSelectionBy === 'equals' ? data1 === data2 : ObjectUtils.equals(data1, data2, this.dataKey);\n    }\n\n    /* Legacy Filtering for custom elements */\n    filter(value: any, field: string, matchMode: string) {\n        if (this.filterTimeout) {\n            clearTimeout(this.filterTimeout);\n        }\n        if (!this.isFilterBlank(value)) {\n            this.filters[field] = { value: value, matchMode: matchMode };\n        } else if (this.filters[field]) {\n            delete this.filters[field];\n        }\n\n        this.filterTimeout = setTimeout(() => {\n            this._filter();\n            this.filterTimeout = null;\n        }, this.filterDelay);\n\n        this.anchorRowIndex = null;\n    }\n\n    filterGlobal(value: any, matchMode: string) {\n        this.filter(value, 'global', matchMode);\n    }\n\n    isFilterBlank(filter: any): boolean {\n        if (filter !== null && filter !== undefined) {\n            if ((typeof filter === 'string' && filter.trim().length == 0) || (Array.isArray(filter) && filter.length == 0)) return true;\n            else return false;\n        }\n        return true;\n    }\n\n    _filter() {\n        if (this.filterType === 'custom') {\n            this.onFilter.emit({\n                filters: Object.fromEntries(Object.entries(<{ [s: string]: FilterMetadata | undefined }>this.filters).filter(([_, value]) => value && value?.matchMode !== null))\n            });\n        } else {\n            if (!this.restoringFilter) {\n                this.first = 0;\n                this.firstChange.emit(this.first);\n            }\n\n            if (this.lazy) {\n                this.onLazyLoad.emit(this.createLazyLoadMetadata());\n            } else {\n                if (!this.value) {\n                    return;\n                }\n\n                if (!this.hasFilter()) {\n                    this.filteredValue = null;\n                    if (this.paginator) {\n                        this.totalRecords = this.value ? this.value.length : 0;\n                    }\n                } else {\n                    let globalFilterFieldsArray;\n                    if (this.filters['global']) {\n                        if (!this.columns && !this.globalFilterFields) throw new Error('Global filtering requires dynamic columns or globalFilterFields to be defined.');\n                        else globalFilterFieldsArray = this.globalFilterFields || this.columns;\n                    }\n\n                    this.filteredValue = [];\n\n                    for (let i = 0; i < this.value.length; i++) {\n                        let localMatch = true;\n                        let globalMatch = false;\n                        let localFiltered = false;\n\n                        for (let prop in this.filters) {\n                            if (this.filters.hasOwnProperty(prop) && prop !== 'global') {\n                                localFiltered = true;\n                                let filterField = prop;\n                                let filterMeta = this.filters[filterField];\n\n                                if (Array.isArray(filterMeta)) {\n                                    for (let meta of filterMeta) {\n                                        localMatch = this.executeLocalFilter(filterField, this.value[i], meta);\n\n                                        if ((meta.operator === FilterOperator.OR && localMatch) || (meta.operator === FilterOperator.AND && !localMatch)) {\n                                            break;\n                                        }\n                                    }\n                                } else {\n                                    localMatch = this.executeLocalFilter(filterField, this.value[i], <any>filterMeta);\n                                }\n\n                                if (!localMatch) {\n                                    break;\n                                }\n                            }\n                        }\n\n                        if (this.filters['global'] && !globalMatch && globalFilterFieldsArray) {\n                            for (let j = 0; j < globalFilterFieldsArray.length; j++) {\n                                let globalFilterField = globalFilterFieldsArray[j].field || globalFilterFieldsArray[j];\n                                globalMatch = (<any>this.filterService).filters[(<any>this.filters['global']).matchMode](\n                                    ObjectUtils.resolveFieldData(this.value[i], globalFilterField),\n                                    (<FilterMetadata>this.filters['global']).value,\n                                    this.filterLocale\n                                );\n\n                                if (globalMatch) {\n                                    break;\n                                }\n                            }\n                        }\n\n                        let matches: boolean;\n                        if (this.filters['global']) {\n                            matches = localFiltered ? localFiltered && localMatch && globalMatch : globalMatch;\n                        } else {\n                            matches = localFiltered && localMatch;\n                        }\n\n                        if (matches) {\n                            this.filteredValue.push(this.value[i]);\n                        }\n                    }\n\n                    if (this.filteredValue.length === this.value.length) {\n                        this.filteredValue = null;\n                    }\n\n                    if (this.paginator) {\n                        this.totalRecords = this.filteredValue ? this.filteredValue.length : this.value ? this.value.length : 0;\n                    }\n                }\n            }\n\n            this.onFilter.emit({\n                filters: <{ [s: string]: FilterMetadata | undefined }>this.filters,\n                filteredValue: this.filteredValue || this.value\n            });\n\n            this.tableService.onValueChange(this.value);\n\n            if (this.isStateful() && !this.restoringFilter) {\n                this.saveState();\n            }\n\n            if (this.restoringFilter) {\n                this.restoringFilter = false;\n            }\n        }\n\n        this.cd.markForCheck();\n\n        if (this.scrollable) {\n            this.resetScrollTop();\n        }\n    }\n\n    executeLocalFilter(field: string, rowData: any, filterMeta: FilterMetadata): boolean {\n        let filterValue = filterMeta.value;\n        let filterMatchMode = filterMeta.matchMode || FilterMatchMode.STARTS_WITH;\n        let dataFieldValue = ObjectUtils.resolveFieldData(rowData, field);\n        let filterConstraint = (<any>this.filterService).filters[filterMatchMode];\n\n        return filterConstraint(dataFieldValue, filterValue, this.filterLocale);\n    }\n\n    hasFilter() {\n        let empty = true;\n        for (let prop in this.filters) {\n            if (this.filters.hasOwnProperty(prop)) {\n                empty = false;\n                break;\n            }\n        }\n\n        return !empty;\n    }\n\n    createLazyLoadMetadata(): any {\n        return {\n            first: this.first,\n            rows: this.rows,\n            sortField: this.sortField,\n            sortOrder: this.sortOrder,\n            filters: this.filters,\n            globalFilter: this.filters && this.filters['global'] ? (<FilterMetadata>this.filters['global']).value : null,\n            multiSortMeta: this.multiSortMeta,\n            forceUpdate: () => this.cd.detectChanges()\n        };\n    }\n\n    public clear() {\n        this._sortField = null;\n        this._sortOrder = this.defaultSortOrder;\n        this._multiSortMeta = null;\n        this.tableService.onSort(null);\n\n        this.clearFilterValues();\n\n        this.filteredValue = null;\n\n        this.first = 0;\n        this.firstChange.emit(this.first);\n\n        if (this.lazy) {\n            this.onLazyLoad.emit(this.createLazyLoadMetadata());\n        } else {\n            this.totalRecords = this._value ? this._value.length : 0;\n        }\n    }\n\n    clearFilterValues() {\n        for (const [, filterMetadata] of Object.entries(this.filters)) {\n            if (Array.isArray(filterMetadata)) {\n                for (let filter of filterMetadata) {\n                    filter.value = null;\n                }\n            } else if (filterMetadata) {\n                filterMetadata.value = null;\n            }\n        }\n    }\n\n    reset() {\n        this.clear();\n    }\n\n    getExportHeader(column: any) {\n        return column[<string>this.exportHeader] || column.header || column.field;\n    }\n    /**\n     * Data export method.\n     * @param {ExportCSVOptions} object - Export options.\n     * @group Method\n     */\n    public exportCSV(options?: ExportCSVOptions) {\n        let data;\n        let csv = '';\n        let columns = this.columns;\n\n        if (options && options.selectionOnly) {\n            data = this.selection || [];\n        } else if (options && options.allValues) {\n            data = this.value || [];\n        } else {\n            data = this.filteredValue || this.value;\n\n            if (this.frozenValue) {\n                data = data ? [...this.frozenValue, ...data] : this.frozenValue;\n            }\n        }\n\n        const exportableColumns: any[] = (<any[]>columns).filter((column) => column.exportable !== false && column.field);\n\n        //headers\n        csv += exportableColumns.map((column) => '\"' + this.getExportHeader(column) + '\"').join(this.csvSeparator);\n\n        //body\n        const body = data\n            .map((record: any) =>\n                exportableColumns\n                    .map((column) => {\n                        let cellData = ObjectUtils.resolveFieldData(record, column.field);\n\n                        if (cellData != null) {\n                            if (this.exportFunction) {\n                                cellData = this.exportFunction({\n                                    data: cellData,\n                                    field: column.field\n                                });\n                            } else cellData = String(cellData).replace(/\"/g, '\"\"');\n                        } else cellData = '';\n\n                        return '\"' + cellData + '\"';\n                    })\n                    .join(this.csvSeparator)\n            )\n            .join('\\n');\n\n        if (body.length) {\n            csv += '\\n' + body;\n        }\n\n        let blob = new Blob([new Uint8Array([0xef, 0xbb, 0xbf]), csv], {\n            type: 'text/csv;charset=utf-8;'\n        });\n\n        let link = this.renderer.createElement('a');\n        link.style.display = 'none';\n        this.renderer.appendChild(this.document.body, link);\n        if (link.download !== undefined) {\n            link.setAttribute('href', URL.createObjectURL(blob));\n            link.setAttribute('download', this.exportFilename + '.csv');\n            link.click();\n        } else {\n            csv = 'data:text/csv;charset=utf-8,' + csv;\n            this.window.open(encodeURI(csv));\n        }\n        this.renderer.removeChild(this.document.body, link);\n    }\n\n    onLazyItemLoad(event: LazyLoadMeta) {\n        this.onLazyLoad.emit({\n            ...this.createLazyLoadMetadata(),\n            ...event,\n            rows: <number>event.last - <number>event.first\n        });\n    }\n    /**\n     * Resets scroll to top.\n     * @group Method\n     */\n    public resetScrollTop() {\n        if (this.virtualScroll) this.scrollToVirtualIndex(0);\n        else this.scrollTo({ top: 0 });\n    }\n    /**\n     * Scrolls to given index when using virtual scroll.\n     * @param {number} index - index of the element.\n     * @group Method\n     */\n    public scrollToVirtualIndex(index: number) {\n        this.scroller && this.scroller.scrollToIndex(index);\n    }\n    /**\n     * Scrolls to given index.\n     * @param {ScrollToOptions} options - scroll options.\n     * @group Method\n     */\n    public scrollTo(options: any) {\n        if (this.virtualScroll) {\n            this.scroller?.scrollTo(options);\n        } else if (this.wrapperViewChild && this.wrapperViewChild.nativeElement) {\n            if (this.wrapperViewChild.nativeElement.scrollTo) {\n                this.wrapperViewChild.nativeElement.scrollTo(options);\n            } else {\n                this.wrapperViewChild.nativeElement.scrollLeft = options.left;\n                this.wrapperViewChild.nativeElement.scrollTop = options.top;\n            }\n        }\n    }\n\n    updateEditingCell(cell: any, data: any, field: string, index: number) {\n        this.editingCell = cell;\n        this.editingCellData = data;\n        this.editingCellField = field;\n        this.editingCellRowIndex = index;\n        this.bindDocumentEditListener();\n    }\n\n    isEditingCellValid() {\n        return this.editingCell && DomHandler.find(this.editingCell, '.ng-invalid.ng-dirty').length === 0;\n    }\n\n    bindDocumentEditListener() {\n        if (!this.documentEditListener) {\n            this.documentEditListener = this.renderer.listen(this.document, 'click', (event) => {\n                if (this.editingCell && !this.selfClick && this.isEditingCellValid()) {\n                    DomHandler.removeClass(this.editingCell, 'cax-cell-editing');\n                    this.editingCell = null;\n                    this.onEditComplete.emit({ field: this.editingCellField, data: this.editingCellData, originalEvent: event, index: <number>this.editingCellRowIndex });\n                    this.editingCellField = null;\n                    this.editingCellData = null;\n                    this.editingCellRowIndex = null;\n                    this.unbindDocumentEditListener();\n                    this.cd.markForCheck();\n\n                    if (this.overlaySubscription) {\n                        this.overlaySubscription.unsubscribe();\n                    }\n                }\n\n                this.selfClick = false;\n            });\n        }\n    }\n\n    unbindDocumentEditListener() {\n        if (this.documentEditListener) {\n            this.documentEditListener();\n            this.documentEditListener = null;\n        }\n    }\n\n    initRowEdit(rowData: any) {\n        let dataKeyValue = String(ObjectUtils.resolveFieldData(rowData, this.dataKey));\n        this.editingRowKeys[dataKeyValue] = true;\n    }\n\n    saveRowEdit(rowData: any, rowElement: HTMLTableRowElement) {\n        if (DomHandler.find(rowElement, '.ng-invalid.ng-dirty').length === 0) {\n            let dataKeyValue = String(ObjectUtils.resolveFieldData(rowData, this.dataKey));\n            delete this.editingRowKeys[dataKeyValue];\n        }\n    }\n\n    cancelRowEdit(rowData: any) {\n        let dataKeyValue = String(ObjectUtils.resolveFieldData(rowData, this.dataKey));\n        delete this.editingRowKeys[dataKeyValue];\n    }\n\n    toggleRow(rowData: any, event?: Event) {\n        if (!this.dataKey && !this.groupRowsBy) {\n            throw new Error('dataKey or groupRowsBy must be defined to use row expansion');\n        }\n\n        let dataKeyValue = this.groupRowsBy ? String(ObjectUtils.resolveFieldData(rowData, this.groupRowsBy)) : String(ObjectUtils.resolveFieldData(rowData, this.dataKey));\n\n        if (this.expandedRowKeys[dataKeyValue] != null) {\n            delete this.expandedRowKeys[dataKeyValue];\n            this.onRowCollapse.emit({\n                originalEvent: <Event>event,\n                data: rowData\n            });\n        } else {\n            if (this.rowExpandMode === 'single') {\n                this.expandedRowKeys = {};\n            }\n\n            this.expandedRowKeys[dataKeyValue] = true;\n            this.onRowExpand.emit({\n                originalEvent: <Event>event,\n                data: rowData\n            });\n        }\n\n        if (event) {\n            event.preventDefault();\n        }\n\n        if (this.isStateful()) {\n            this.saveState();\n        }\n    }\n\n    isRowExpanded(rowData: any): boolean {\n        return this.groupRowsBy ? this.expandedRowKeys[String(ObjectUtils.resolveFieldData(rowData, this.groupRowsBy))] === true : this.expandedRowKeys[String(ObjectUtils.resolveFieldData(rowData, this.dataKey))] === true;\n    }\n\n    isRowEditing(rowData: any): boolean {\n        return this.editingRowKeys[String(ObjectUtils.resolveFieldData(rowData, this.dataKey))] === true;\n    }\n\n    isSingleSelectionMode() {\n        return this.selectionMode === 'single';\n    }\n\n    isMultipleSelectionMode() {\n        return this.selectionMode === 'multiple';\n    }\n\n    onColumnResizeBegin(event: any) {\n        let containerLeft = DomHandler.getOffset(this.containerViewChild?.nativeElement).left;\n        this.resizeColumnElement = event.target.parentElement;\n        this.columnResizing = true;\n        if (event.type == 'touchstart') {\n            this.lastResizerHelperX = event.changedTouches[0].clientX - containerLeft + this.containerViewChild?.nativeElement.scrollLeft;\n        } else {\n            this.lastResizerHelperX = event.pageX - containerLeft + this.containerViewChild?.nativeElement.scrollLeft;\n        }\n        this.onColumnResize(event);\n        event.preventDefault();\n    }\n\n    onColumnResize(event: any) {\n        let containerLeft = DomHandler.getOffset(this.containerViewChild?.nativeElement).left;\n        DomHandler.addClass(this.containerViewChild?.nativeElement, 'cax-unselectable-text');\n        (<ElementRef>this.resizeHelperViewChild).nativeElement.style.height = this.containerViewChild?.nativeElement.offsetHeight + 'px';\n        (<ElementRef>this.resizeHelperViewChild).nativeElement.style.top = 0 + 'px';\n        if (event.type == 'touchmove') {\n            (<ElementRef>this.resizeHelperViewChild).nativeElement.style.left = event.changedTouches[0].clientX - containerLeft + this.containerViewChild?.nativeElement.scrollLeft + 'px';\n        } else {\n            (<ElementRef>this.resizeHelperViewChild).nativeElement.style.left = event.pageX - containerLeft + this.containerViewChild?.nativeElement.scrollLeft + 'px';\n        }\n        (<ElementRef>this.resizeHelperViewChild).nativeElement.style.display = 'block';\n    }\n\n    onColumnResizeEnd() {\n        let delta = this.resizeHelperViewChild?.nativeElement.offsetLeft - <number>this.lastResizerHelperX;\n        let columnWidth = this.resizeColumnElement.offsetWidth;\n        let newColumnWidth = columnWidth + delta;\n        let minWidth = this.resizeColumnElement.style.minWidth.replace(/[^\\d.]/g, '') || 15;\n\n        if (newColumnWidth >= minWidth) {\n            if (this.columnResizeMode === 'fit') {\n                let nextColumn = this.resizeColumnElement.nextElementSibling;\n                let nextColumnWidth = nextColumn.offsetWidth - delta;\n\n                if (newColumnWidth > 15 && nextColumnWidth > 15) {\n                    this.resizeTableCells(newColumnWidth, nextColumnWidth);\n                }\n            } else if (this.columnResizeMode === 'expand') {\n                this._initialColWidths = this._totalTableWidth();\n                let tableWidth = this.tableViewChild?.nativeElement.offsetWidth + delta;\n\n                this.setResizeTableWidth(tableWidth + 'px');\n                this.resizeTableCells(newColumnWidth, null);\n            }\n\n            this.onColResize.emit({\n                element: this.resizeColumnElement,\n                delta: delta\n            });\n\n            if (this.isStateful()) {\n                this.saveState();\n            }\n        }\n\n        (<ElementRef>this.resizeHelperViewChild).nativeElement.style.display = 'none';\n        DomHandler.removeClass(this.containerViewChild?.nativeElement, 'cax-unselectable-text');\n    }\n\n    private _totalTableWidth(): number[] {\n        let widths = [];\n        const tableHead = DomHandler.findSingle(this.containerViewChild.nativeElement, '.cax-datatable-thead');\n        let headers = DomHandler.find(tableHead, 'tr > th');\n        headers.forEach((header) => widths.push(DomHandler.getOuterWidth(header)));\n\n        return widths;\n    }\n\n    onColumnDragStart(event: any, columnElement: any) {\n        this.reorderIconWidth = DomHandler.getHiddenElementOuterWidth(this.reorderIndicatorUpViewChild?.nativeElement);\n        this.reorderIconHeight = DomHandler.getHiddenElementOuterHeight(this.reorderIndicatorDownViewChild?.nativeElement);\n        this.draggedColumn = columnElement;\n        event.dataTransfer.setData('text', 'b'); // For firefox\n    }\n\n    onColumnDragEnter(event: any, dropHeader: any) {\n        if (this.reorderableColumns && this.draggedColumn && dropHeader) {\n            event.preventDefault();\n            let containerOffset = DomHandler.getOffset(this.containerViewChild?.nativeElement);\n            let dropHeaderOffset = DomHandler.getOffset(dropHeader);\n\n            if (this.draggedColumn != dropHeader) {\n                let dragIndex = DomHandler.indexWithinGroup(this.draggedColumn, 'caxreorderablecolumn');\n                let dropIndex = DomHandler.indexWithinGroup(dropHeader, 'caxreorderablecolumn');\n                let targetLeft = dropHeaderOffset.left - containerOffset.left;\n                let targetTop = containerOffset.top - dropHeaderOffset.top;\n                let columnCenter = dropHeaderOffset.left + dropHeader.offsetWidth / 2;\n\n                (<ElementRef>this.reorderIndicatorUpViewChild).nativeElement.style.top = dropHeaderOffset.top - containerOffset.top - (<number>this.reorderIconHeight - 1) + 'px';\n                (<ElementRef>this.reorderIndicatorDownViewChild).nativeElement.style.top = dropHeaderOffset.top - containerOffset.top + dropHeader.offsetHeight + 'px';\n\n                if (event.pageX > columnCenter) {\n                    (<ElementRef>this.reorderIndicatorUpViewChild).nativeElement.style.left = targetLeft + dropHeader.offsetWidth - Math.ceil(<number>this.reorderIconWidth / 2) + 'px';\n                    (<ElementRef>this.reorderIndicatorDownViewChild).nativeElement.style.left = targetLeft + dropHeader.offsetWidth - Math.ceil(<number>this.reorderIconWidth / 2) + 'px';\n                    this.dropPosition = 1;\n                } else {\n                    (<ElementRef>this.reorderIndicatorUpViewChild).nativeElement.style.left = targetLeft - Math.ceil(<number>this.reorderIconWidth / 2) + 'px';\n                    (<ElementRef>this.reorderIndicatorDownViewChild).nativeElement.style.left = targetLeft - Math.ceil(<number>this.reorderIconWidth / 2) + 'px';\n                    this.dropPosition = -1;\n                }\n                (<ElementRef>this.reorderIndicatorUpViewChild).nativeElement.style.display = 'block';\n                (<ElementRef>this.reorderIndicatorDownViewChild).nativeElement.style.display = 'block';\n            } else {\n                event.dataTransfer.dropEffect = 'none';\n            }\n        }\n    }\n\n    onColumnDragLeave(event: Event) {\n        if (this.reorderableColumns && this.draggedColumn) {\n            event.preventDefault();\n        }\n    }\n\n    onColumnDrop(event: Event, dropColumn: any) {\n        event.preventDefault();\n        if (this.draggedColumn) {\n            let dragIndex = DomHandler.indexWithinGroup(this.draggedColumn, 'caxreorderablecolumn');\n            let dropIndex = DomHandler.indexWithinGroup(dropColumn, 'caxreorderablecolumn');\n            let allowDrop = dragIndex != dropIndex;\n            if (allowDrop && ((dropIndex - dragIndex == 1 && this.dropPosition === -1) || (dragIndex - dropIndex == 1 && this.dropPosition === 1))) {\n                allowDrop = false;\n            }\n\n            if (allowDrop && dropIndex < dragIndex && this.dropPosition === 1) {\n                dropIndex = dropIndex + 1;\n            }\n\n            if (allowDrop && dropIndex > dragIndex && this.dropPosition === -1) {\n                dropIndex = dropIndex - 1;\n            }\n\n            if (allowDrop) {\n                ObjectUtils.reorderArray(<any[]>this.columns, dragIndex, dropIndex);\n\n                this.onColReorder.emit({\n                    dragIndex: dragIndex,\n                    dropIndex: dropIndex,\n                    columns: this.columns\n                });\n\n                if (this.isStateful()) {\n                    this.zone.runOutsideAngular(() => {\n                        setTimeout(() => {\n                            this.saveState();\n                        });\n                    });\n                }\n            }\n\n            if (this.resizableColumns && this.resizeColumnElement) {\n                let width = this.columnResizeMode === 'expand' ? this._initialColWidths : this._totalTableWidth();\n                ObjectUtils.reorderArray(width, dragIndex + 1, dropIndex + 1);\n                this.updateStyleElement(width, dragIndex, null, null);\n            }\n\n            (<ElementRef>this.reorderIndicatorUpViewChild).nativeElement.style.display = 'none';\n            (<ElementRef>this.reorderIndicatorDownViewChild).nativeElement.style.display = 'none';\n            this.draggedColumn.draggable = false;\n            this.draggedColumn = null;\n            this.dropPosition = null;\n        }\n    }\n\n    resizeTableCells(newColumnWidth: number, nextColumnWidth: number | null) {\n        let colIndex = DomHandler.index(this.resizeColumnElement);\n        let width = this.columnResizeMode === 'expand' ? this._initialColWidths : this._totalTableWidth();\n        this.updateStyleElement(width, colIndex, newColumnWidth, nextColumnWidth);\n    }\n\n    updateStyleElement(width: number[], colIndex: number, newColumnWidth: number, nextColumnWidth: number | null) {\n        this.destroyStyleElement();\n        this.createStyleElement();\n\n        let innerHTML = '';\n        width.forEach((width, index) => {\n            let colWidth = index === colIndex ? newColumnWidth : nextColumnWidth && index === colIndex + 1 ? nextColumnWidth : width;\n            let style = `width: ${colWidth}px !important; max-width: ${colWidth}px !important;`;\n            innerHTML += `\n                #${this.id}-table > .cax-datatable-thead > tr > th:nth-child(${index + 1}),\n                #${this.id}-table > .cax-datatable-tbody > tr > td:nth-child(${index + 1}),\n                #${this.id}-table > .cax-datatable-tfoot > tr > td:nth-child(${index + 1}) {\n                    ${style}\n                }\n            `;\n        });\n        this.renderer.setProperty(this.styleElement, 'innerHTML', this.domSanitizer.bypassSecurityTrustStyle(innerHTML));\n    }\n\n    onRowDragStart(event: any, index: number) {\n        this.rowDragging = true;\n        this.draggedRowIndex = index;\n        event.dataTransfer.setData('text', 'b'); // For firefox\n    }\n\n    onRowDragOver(event: MouseEvent, index: number, rowElement: any) {\n        if (this.rowDragging && this.draggedRowIndex !== index) {\n            let rowY = DomHandler.getOffset(rowElement).top;\n            let pageY = event.pageY;\n            let rowMidY = rowY + DomHandler.getOuterHeight(rowElement) / 2;\n            let prevRowElement = rowElement.previousElementSibling;\n\n            if (pageY < rowMidY) {\n                DomHandler.removeClass(rowElement, 'cax-datatable-dragpoint-bottom');\n\n                this.droppedRowIndex = index;\n                if (prevRowElement) DomHandler.addClass(prevRowElement, 'cax-datatable-dragpoint-bottom');\n                else DomHandler.addClass(rowElement, 'cax-datatable-dragpoint-top');\n            } else {\n                if (prevRowElement) DomHandler.removeClass(prevRowElement, 'cax-datatable-dragpoint-bottom');\n                else DomHandler.addClass(rowElement, 'cax-datatable-dragpoint-top');\n\n                this.droppedRowIndex = index + 1;\n                DomHandler.addClass(rowElement, 'cax-datatable-dragpoint-bottom');\n            }\n        }\n    }\n\n    onRowDragLeave(event: Event, rowElement: any) {\n        let prevRowElement = rowElement.previousElementSibling;\n        if (prevRowElement) {\n            DomHandler.removeClass(prevRowElement, 'cax-datatable-dragpoint-bottom');\n        }\n\n        DomHandler.removeClass(rowElement, 'cax-datatable-dragpoint-bottom');\n        DomHandler.removeClass(rowElement, 'cax-datatable-dragpoint-top');\n    }\n\n    onRowDragEnd(event: Event) {\n        this.rowDragging = false;\n        this.draggedRowIndex = null;\n        this.droppedRowIndex = null;\n    }\n\n    onRowDrop(event: Event, rowElement: any) {\n        if (this.droppedRowIndex != null) {\n            let dropIndex = <number>this.draggedRowIndex > this.droppedRowIndex ? this.droppedRowIndex : this.droppedRowIndex === 0 ? 0 : this.droppedRowIndex - 1;\n            ObjectUtils.reorderArray(this.value, <number>this.draggedRowIndex, dropIndex);\n\n            if (this.virtualScroll) {\n                // TODO: Check\n                this._value = [...this._value];\n            }\n\n            this.onRowReorder.emit({\n                dragIndex: <number>this.draggedRowIndex,\n                dropIndex: dropIndex\n            });\n        }\n        //cleanup\n        this.onRowDragLeave(event, rowElement);\n        this.onRowDragEnd(event);\n    }\n\n    isEmpty() {\n        let data = this.filteredValue || this.value;\n        return data == null || data.length == 0;\n    }\n\n    getBlockableElement(): HTMLElement {\n        return this.el.nativeElement.children[0];\n    }\n\n    getStorage() {\n        if (isPlatformBrowser(this.platformId)) {\n            switch (this.stateStorage) {\n                case 'local':\n                    return window.localStorage;\n\n                case 'session':\n                    return window.sessionStorage;\n\n                default:\n                    throw new Error(this.stateStorage + ' is not a valid value for the state storage, supported values are \"local\" and \"session\".');\n            }\n        } else {\n            throw new Error('Browser storage is not available in the server side.');\n        }\n    }\n\n    isStateful() {\n        return this.stateKey != null;\n    }\n\n    saveState() {\n        const storage = this.getStorage();\n        let state: TableState = {};\n\n        if (this.paginator) {\n            state.first = <number>this.first;\n            state.rows = this.rows;\n        }\n\n        if (this.sortField) {\n            state.sortField = this.sortField;\n            state.sortOrder = this.sortOrder;\n        }\n\n        if (this.multiSortMeta) {\n            state.multiSortMeta = this.multiSortMeta;\n        }\n\n        if (this.hasFilter()) {\n            state.filters = this.filters;\n        }\n\n        if (this.resizableColumns) {\n            this.saveColumnWidths(state);\n        }\n\n        if (this.reorderableColumns) {\n            this.saveColumnOrder(state);\n        }\n\n        if (this.selection) {\n            state.selection = this.selection;\n        }\n\n        if (Object.keys(this.expandedRowKeys).length) {\n            state.expandedRowKeys = this.expandedRowKeys;\n        }\n\n        storage.setItem(<string>this.stateKey, JSON.stringify(state));\n        this.onStateSave.emit(state);\n    }\n\n    clearState() {\n        const storage = this.getStorage();\n\n        if (this.stateKey) {\n            storage.removeItem(this.stateKey);\n        }\n    }\n\n    restoreState() {\n        const storage = this.getStorage();\n        const stateString = storage.getItem(<string>this.stateKey);\n        const dateFormat = /\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}.\\d{3}Z/;\n        const reviver = function (key: any, value: any) {\n            if (typeof value === 'string' && dateFormat.test(value)) {\n                return new Date(value);\n            }\n\n            return value;\n        };\n\n        if (stateString) {\n            let state: TableState = JSON.parse(stateString, reviver);\n\n            if (this.paginator) {\n                if (this.first !== undefined) {\n                    this.first = state.first;\n                    this.firstChange.emit(this.first);\n                }\n\n                if (this.rows !== undefined) {\n                    this.rows = state.rows;\n                    this.rowsChange.emit(this.rows);\n                }\n            }\n\n            if (state.sortField) {\n                this.restoringSort = true;\n                this._sortField = state.sortField;\n                this._sortOrder = <number>state.sortOrder;\n            }\n\n            if (state.multiSortMeta) {\n                this.restoringSort = true;\n                this._multiSortMeta = state.multiSortMeta;\n            }\n\n            if (state.filters) {\n                this.restoringFilter = true;\n                this.filters = state.filters;\n            }\n\n            if (this.resizableColumns) {\n                this.columnWidthsState = state.columnWidths;\n                this.tableWidthState = state.tableWidth;\n            }\n\n            // if (this.reorderableColumns) {\n            //     this.restoreColumnOrder();\n            // }\n\n            if (state.expandedRowKeys) {\n                this.expandedRowKeys = state.expandedRowKeys;\n            }\n\n            if (state.selection) {\n                Promise.resolve(null).then(() => this.selectionChange.emit(state.selection));\n            }\n\n            this.stateRestored = true;\n\n            this.onStateRestore.emit(state);\n        }\n    }\n\n    saveColumnWidths(state: any) {\n        let widths: any[] = [];\n        let headers = [];\n        const container = this.containerViewChild?.nativeElement;\n\n        if (container) {\n            headers = DomHandler.find(container, '.cax-datatable-thead > tr > th');\n        }\n\n        headers.forEach((header) => widths.push(DomHandler.getOuterWidth(header)));\n        state.columnWidths = widths.join(',');\n\n        if (this.columnResizeMode === 'expand') {\n            state.tableWidth = DomHandler.getOuterWidth(this.tableViewChild?.nativeElement);\n        }\n    }\n\n    setResizeTableWidth(width: string) {\n        (<ElementRef>this.tableViewChild).nativeElement.style.width = width;\n        (<ElementRef>this.tableViewChild).nativeElement.style.minWidth = width;\n    }\n\n    restoreColumnWidths() {\n        if (this.columnWidthsState) {\n            let widths = this.columnWidthsState.split(',');\n\n            if (this.columnResizeMode === 'expand' && this.tableWidthState) {\n                this.setResizeTableWidth(this.tableWidthState + 'px');\n            }\n\n            if (ObjectUtils.isNotEmpty(widths)) {\n                this.createStyleElement();\n\n                let innerHTML = '';\n                widths.forEach((width, index) => {\n                    let style = `width: ${width}px !important; max-width: ${width}px !important`;\n\n                    innerHTML += `\n                        #${this.id}-table > .cax-datatable-thead > tr > th:nth-child(${index + 1}),\n                        #${this.id}-table > .cax-datatable-tbody > tr > td:nth-child(${index + 1}),\n                        #${this.id}-table > .cax-datatable-tfoot > tr > td:nth-child(${index + 1}) {\n                            ${style}\n                        }\n                    `;\n                });\n\n                this.styleElement.textContent = innerHTML;\n            }\n        }\n    }\n\n    saveColumnOrder(state: any) {\n        if (this.columns) {\n            let columnOrder: string[] = [];\n            this.columns.map((column) => {\n                columnOrder.push(column.field || column.key);\n            });\n\n            state.columnOrder = columnOrder;\n        }\n    }\n\n    restoreColumnOrder() {\n        const storage = this.getStorage();\n        const stateString = storage.getItem(<string>this.stateKey);\n        if (stateString) {\n            let state: TableState = JSON.parse(stateString);\n            let columnOrder = state.columnOrder;\n\n            if (columnOrder) {\n                let reorderedColumns: any[] = [];\n\n                columnOrder.map((key) => {\n                    let col = this.findColumnByKey(key);\n                    if (col) {\n                        reorderedColumns.push(col);\n                    }\n                });\n                this.columnOrderStateRestored = true;\n                this.columns = reorderedColumns;\n            }\n        }\n    }\n\n    findColumnByKey(key: any) {\n        if (this.columns) {\n            for (let col of this.columns) {\n                if (col.key === key || col.field === key) return col;\n                else continue;\n            }\n        } else {\n            return null;\n        }\n    }\n\n    createStyleElement() {\n        this.styleElement = this.renderer.createElement('style');\n        this.styleElement.type = 'text/css';\n        DomHandler.setAttribute(this.styleElement, 'nonce', this.config?.csp()?.nonce);\n        this.renderer.appendChild(this.document.head, this.styleElement);\n    }\n\n    getGroupRowsMeta() {\n        return { field: this.groupRowsBy, order: this.groupRowsByOrder };\n    }\n\n    getTableClasses() {\n        return {\n            'cax-datatable cax-component': true,\n            'cax-datatable-hoverable-rows': this.rowHover || this.selectionMode,\n            'cax-datatable-scrollable': this.scrollable,\n            'cax-datatable-flex-scrollable': this.scrollable && this.scrollHeight === 'flex',\n            ['cax-datatable-font-' + this.fontSize]: true,\n            ['cax-datatable-row-' + this.rowSize]: true\n        };\n    }\n\n    createResponsiveStyle() {\n        if (isPlatformBrowser(this.platformId)) {\n            if (!this.responsiveStyleElement) {\n                this.responsiveStyleElement = this.renderer.createElement('style');\n                this.responsiveStyleElement.type = 'text/css';\n                DomHandler.setAttribute(this.responsiveStyleElement, 'nonce', this.config?.csp()?.nonce);\n                this.renderer.appendChild(this.document.head, this.responsiveStyleElement);\n\n                let innerHTML = `\n    @media screen and (max-width: ${this.breakpoint}) {\n        #${this.id}-table > .cax-datatable-thead > tr > th,\n        #${this.id}-table > .cax-datatable-tfoot > tr > td {\n            display: none !important;\n        }\n\n        #${this.id}-table > .cax-datatable-tbody > tr > td {\n            display: flex;\n            width: 100% !important;\n            align-items: center;\n            justify-content: space-between;\n        }\n\n        #${this.id}-table > .cax-datatable-tbody > tr > td:not(:last-child) {\n            border: 0 none;\n        }\n\n        #${this.id}.cax-datatable-gridlines > .cax-datatable-wrapper > .cax-datatable-table > .cax-datatable-tbody > tr > td:last-child {\n            border-top: 0;\n            border-right: 0;\n            border-left: 0;\n        }\n\n        #${this.id}-table > .cax-datatable-tbody > tr > td > .cax-column-title {\n            display: block;\n        }\n    }\n    `;\n                this.renderer.setProperty(this.responsiveStyleElement, 'innerHTML', this.domSanitizer.bypassSecurityTrustStyle(innerHTML));\n            }\n        }\n    }\n\n    destroyResponsiveStyle() {\n        if (this.responsiveStyleElement) {\n            this.renderer.removeChild(this.document.head, this.responsiveStyleElement);\n            this.responsiveStyleElement = null;\n        }\n    }\n\n    destroyStyleElement() {\n        if (this.styleElement) {\n            this.renderer.removeChild(this.document.head, this.styleElement);\n            this.styleElement = null;\n        }\n    }\n\n    ngOnDestroy() {\n        this.unbindDocumentEditListener();\n        this.editingCell = null;\n        this.initialized = null;\n\n        this.destroyStyleElement();\n        this.destroyResponsiveStyle();\n    }\n\n    getPaginatorStyleClasses(className?: string) {\n        return [this.paginatorStyleClass, className]\n            .filter((c) => !!c)\n            .join(' ')\n            .trim();\n    }\n}\n","<div #container [ngStyle]=\"style\" [class]=\"styleClass\" [ngClass]=\"getTableClasses()\" [attr.id]=\"id\">\r\n    <div class=\"cax-datatable-loading-overlay cax-component-overlay\" *ngIf=\"loading && showLoader\">\r\n        <i *ngIf=\"loadingIcon\" [class]=\"'cax-datatable-loading-icon ' + loadingIcon\"></i>\r\n        <ng-container *ngIf=\"!loadingIcon\">\r\n            <SpinnerIcon *ngIf=\"!loadingIconTemplate\" [spin]=\"true\" [styleClass]=\"'cax-datatable-loading-icon'\" />\r\n            <span *ngIf=\"loadingIconTemplate\" class=\"cax-datatable-loading-icon\">\r\n                <ng-template *ngTemplateOutlet=\"loadingIconTemplate\"></ng-template>\r\n            </span>\r\n        </ng-container>\r\n    </div>\r\n    <div *ngIf=\"captionTemplate\" class=\"cax-datatable-header\">\r\n        <ng-container *ngTemplateOutlet=\"captionTemplate\"></ng-container>\r\n    </div>\r\n    <cax-paginator\r\n        [rows]=\"rows\"\r\n        [first]=\"first\"\r\n        [totalRecords]=\"totalRecords\"\r\n        [pageLinkSize]=\"pageLinks\"\r\n        [alwaysShow]=\"alwaysShowPaginator\"\r\n        (onPageChange)=\"onPageChange($event)\"\r\n        [rowsPerPageOptions]=\"rowsPerPageOptions\"\r\n        *ngIf=\"paginator && (paginatorPosition === 'top' || paginatorPosition == 'both')\"\r\n        [templateLeft]=\"paginatorLeftTemplate\"\r\n        [templateRight]=\"paginatorRightTemplate\"\r\n        [dropdownAppendTo]=\"paginatorDropdownAppendTo\"\r\n        [dropdownScrollHeight]=\"paginatorDropdownScrollHeight\"\r\n        [currentPageReportTemplate]=\"currentPageReportTemplate\"\r\n        [showFirstLastIcon]=\"showFirstLastIcon\"\r\n        [dropdownItemTemplate]=\"paginatorDropdownItemTemplate\"\r\n        [showCurrentPageReport]=\"showCurrentPageReport\"\r\n        [showJumpToPageDropdown]=\"showJumpToPageDropdown\"\r\n        [showJumpToPageInput]=\"showJumpToPageInput\"\r\n        [showPageLinks]=\"showPageLinks\"\r\n        [styleClass]=\"getPaginatorStyleClasses('cax-paginator-top')\"\r\n        [locale]=\"paginatorLocale\"\r\n    >\r\n        <ng-template caxTemplate=\"dropdownicon\" *ngIf=\"paginatorDropdownIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorDropdownIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"firstpagelinkicon\" *ngIf=\"paginatorFirstPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorFirstPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"previouspagelinkicon\" *ngIf=\"paginatorPreviousPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorPreviousPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"lastpagelinkicon\" *ngIf=\"paginatorLastPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorLastPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"nextpagelinkicon\" *ngIf=\"paginatorNextPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorNextPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n    </cax-paginator>\r\n\r\n    <div #wrapper class=\"cax-datatable-wrapper\" [ngStyle]=\"{ maxHeight: virtualScroll ? '' : scrollHeight }\">\r\n        <cax-scroller\r\n            #scroller\r\n            *ngIf=\"virtualScroll\"\r\n            [items]=\"processedData\"\r\n            [columns]=\"columns\"\r\n            [style]=\"{ height: scrollHeight !== 'flex' ? scrollHeight : undefined }\"\r\n            [scrollHeight]=\"scrollHeight !== 'flex' ? undefined : '100%'\"\r\n            [itemSize]=\"virtualScrollItemSize || _virtualRowHeight\"\r\n            [step]=\"rows\"\r\n            [delay]=\"lazy ? virtualScrollDelay : 0\"\r\n            [inline]=\"true\"\r\n            [autoSize]=\"true\"\r\n            [lazy]=\"lazy\"\r\n            (onLazyLoad)=\"onLazyItemLoad($event)\"\r\n            [loaderDisabled]=\"true\"\r\n            [showSpacer]=\"false\"\r\n            [showLoader]=\"loadingBodyTemplate\"\r\n            [options]=\"virtualScrollOptions\"\r\n        >\r\n            <ng-template caxTemplate=\"content\" let-items let-scrollerOptions=\"options\">\r\n                <ng-container *ngTemplateOutlet=\"buildInTable; context: { $implicit: items, options: scrollerOptions }\"></ng-container>\r\n            </ng-template>\r\n        </cax-scroller>\r\n        <ng-container *ngIf=\"!virtualScroll\">\r\n            <ng-container *ngTemplateOutlet=\"buildInTable; context: { $implicit: processedData, options: { columns } }\"></ng-container>\r\n        </ng-container>\r\n\r\n        <ng-template #buildInTable let-items let-scrollerOptions=\"options\">\r\n            <table\r\n                #table\r\n                role=\"table\"\r\n                [ngClass]=\"{ 'cax-datatable-table': true, 'cax-datatable-scrollable-table': scrollable, 'cax-datatable-resizable-table': resizableColumns, 'cax-datatable-resizable-table-fit': resizableColumns && columnResizeMode === 'fit' }\"\r\n                [class]=\"tableStyleClass\"\r\n                [ngStyle]=\"tableStyle\"\r\n                [attr.id]=\"id + '-table'\"\r\n            >\r\n                <ng-container *ngTemplateOutlet=\"colGroupTemplate; context: { $implicit: scrollerOptions.columns }\"></ng-container>\r\n                <thead role=\"rowgroup\" #thead class=\"cax-datatable-thead\">\r\n                    <ng-container *ngTemplateOutlet=\"headerGroupedTemplate || headerTemplate; context: { $implicit: scrollerOptions.columns }\"></ng-container>\r\n                </thead>\r\n                <tbody\r\n                    role=\"rowgroup\"\r\n                    class=\"cax-datatable-tbody cax-datatable-frozen-tbody\"\r\n                    *ngIf=\"frozenValue || frozenBodyTemplate\"\r\n                    [value]=\"frozenValue\"\r\n                    [frozenRows]=\"true\"\r\n                    [caxTableBody]=\"scrollerOptions.columns\"\r\n                    [caxTableBodyTemplate]=\"frozenBodyTemplate\"\r\n                    [frozen]=\"true\"\r\n                ></tbody>\r\n                <tbody\r\n                    role=\"rowgroup\"\r\n                    class=\"cax-datatable-tbody\"\r\n                    [ngClass]=\"scrollerOptions.contentStyleClass\"\r\n                    [ngStyle]=\"scrollerOptions.contentStyle\"\r\n                    [value]=\"dataToRender(scrollerOptions.rows)\"\r\n                    [caxTableBody]=\"scrollerOptions.columns\"\r\n                    [caxTableBodyTemplate]=\"bodyTemplate\"\r\n                    [scrollerOptions]=\"scrollerOptions\"\r\n                ></tbody>\r\n                <tbody\r\n                    role=\"rowgroup\"\r\n                    *ngIf=\"scrollerOptions.spacerStyle\"\r\n                    [ngStyle]=\"{ height: 'calc(' + scrollerOptions.spacerStyle.height + ' - ' + scrollerOptions.rows.length * scrollerOptions.itemSize + 'px)' }\"\r\n                    class=\"cax-datatable-scroller-spacer\"\r\n                ></tbody>\r\n                <tfoot role=\"rowgroup\" *ngIf=\"footerGroupedTemplate || footerTemplate\" #tfoot class=\"cax-datatable-tfoot\">\r\n                    <ng-container *ngTemplateOutlet=\"footerGroupedTemplate || footerTemplate; context: { $implicit: scrollerOptions.columns }\"></ng-container>\r\n                </tfoot>\r\n            </table>\r\n        </ng-template>\r\n    </div>\r\n\r\n    <cax-paginator\r\n        [rows]=\"rows\"\r\n        [first]=\"first\"\r\n        [totalRecords]=\"totalRecords\"\r\n        [pageLinkSize]=\"pageLinks\"\r\n        [alwaysShow]=\"alwaysShowPaginator\"\r\n        (onPageChange)=\"onPageChange($event)\"\r\n        [rowsPerPageOptions]=\"rowsPerPageOptions\"\r\n        *ngIf=\"paginator && (paginatorPosition === 'bottom' || paginatorPosition == 'both')\"\r\n        [templateLeft]=\"paginatorLeftTemplate\"\r\n        [templateRight]=\"paginatorRightTemplate\"\r\n        [dropdownAppendTo]=\"paginatorDropdownAppendTo\"\r\n        [dropdownScrollHeight]=\"paginatorDropdownScrollHeight\"\r\n        [currentPageReportTemplate]=\"currentPageReportTemplate\"\r\n        [showFirstLastIcon]=\"showFirstLastIcon\"\r\n        [dropdownItemTemplate]=\"paginatorDropdownItemTemplate\"\r\n        [showCurrentPageReport]=\"showCurrentPageReport\"\r\n        [showJumpToPageDropdown]=\"showJumpToPageDropdown\"\r\n        [showJumpToPageInput]=\"showJumpToPageInput\"\r\n        [showPageLinks]=\"showPageLinks\"\r\n        [styleClass]=\"getPaginatorStyleClasses('cax-paginator-bottom')\"\r\n        [locale]=\"paginatorLocale\"\r\n    >\r\n        <ng-template caxTemplate=\"dropdownicon\" *ngIf=\"paginatorDropdownIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorDropdownIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"firstpagelinkicon\" *ngIf=\"paginatorFirstPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorFirstPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"previouspagelinkicon\" *ngIf=\"paginatorPreviousPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorPreviousPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"lastpagelinkicon\" *ngIf=\"paginatorLastPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorLastPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template caxTemplate=\"nextpagelinkicon\" *ngIf=\"paginatorNextPageLinkIconTemplate\">\r\n            <ng-container *ngTemplateOutlet=\"paginatorNextPageLinkIconTemplate\"></ng-container>\r\n        </ng-template>\r\n    </cax-paginator>\r\n\r\n    <div *ngIf=\"summaryTemplate\" class=\"cax-datatable-footer\">\r\n        <ng-container *ngTemplateOutlet=\"summaryTemplate\"></ng-container>\r\n    </div>\r\n\r\n    <div\r\n        #resizeHelper\r\n        class=\"cax-column-resizer-helper\"\r\n        [ngStyle]=\"{\r\n                    display: 'none'\r\n                }\"\r\n        *ngIf=\"resizableColumns\"\r\n    ></div>\r\n    <span\r\n        #reorderIndicatorUp\r\n        class=\"cax-datatable-reorder-indicator-up\"\r\n        [ngStyle]=\"{\r\n                    display: 'none'\r\n                }\"\r\n        *ngIf=\"reorderableColumns\"\r\n    >\r\n        <ArrowDownIcon *ngIf=\"!reorderIndicatorUpIconTemplate\" />\r\n        <ng-template *ngTemplateOutlet=\"reorderIndicatorUpIconTemplate\"></ng-template>\r\n    </span>\r\n    <span\r\n        #reorderIndicatorDown\r\n        class=\"cax-datatable-reorder-indicator-down\"\r\n        [ngStyle]=\"{\r\n                    display: 'none'\r\n                }\"\r\n        *ngIf=\"reorderableColumns\"\r\n    >\r\n        <ArrowUpIcon *ngIf=\"!reorderIndicatorDownIconTemplate\" />\r\n        <ng-template *ngTemplateOutlet=\"reorderIndicatorDownIconTemplate\"></ng-template>\r\n    </span>\r\n</div>\r\n"]}